Memory
## Quality Workstations Have Contracts (Design Confirmation) **Date:** 2026-09-09 **Status:** Design confirmation **Related:** LLM Assigned to Workstation, Not Task; Work Item ↔ Work Engineering Join Design; Work Engineering in the Workspace DO ### Core confirmation > **Quality workstations also have contracts. The same callsign can perform quality steps, but must conform to the quality contract.** This confirms and sharpens the earlier design decision on operator independence. ### Prior decision (from Work Item ↔ Work Engineering Join) **Operator independence rule (v1 decision):** Advisory only, not enforced. [mikesecondbrain:1] Rationale at the time: - Work Engineering Map v0 reference enforces station-level independence (only quality stations own gates), not operator-level independence. [mikesecondbrain:2] - In small teams / solo operation, the same callsign may legitimately perform both production and quality roles. - Can be added later as a contract-governed rule if needed. ### Refined understanding The real governance mechanism is **the contract**, not a hard-coded "different operator required" rule. **Quality workstation contract example:** ```json { "id": "contract-review-notes-v1", "name": "Notes Review Contract", "description": "Human reviewer must verify completeness of notes against transcript", "inputs": ["transcript", "draft-notes"], "outputs": ["approved-notes"], "rules": [ "Reviewer must verify that notes capture every decision from the transcript", "Reviewer must verify that notes capture every action item from the transcript", "Reviewer must cite specific transcript passages as evidence" ], "evidenceRequirements": [ "Record reviewer callsign", "Record timestamp of review", "Cite transcript evidence (passages reviewed)", "Record verdict (pass/fail/rework) with reason" ], "operatorIndependence": "advisory" // or "required" in future } ``` **Key points:** 1. **Contract governs, not operator identity** — The contract specifies what evidence must be recorded, what rules must be followed, what verdicts are valid. 2. **Same callsign allowed (v1)** — The same callsign that did production work (e.g. `@transcribe-op`) can operate the quality workstation (e.g. `@reviewer` or even the same `@transcribe-op`), **as long as the contract is satisfied**. 3. **Evidence trail** — The quality workstation must record: - Who did the review (callsign) - When (timestamp) - What was reviewed (transcript passages cited) - What the verdict was (pass/fail/rework) - Why (reason) 4. **Future enhancement** — If needed, a contract can specify `operatorIndependence: "required"`, which would mean: - The DO rejects `evaluateGate` if `gateEvaluations[].by` matches the callsign that performed the preceding production work. - This becomes a **contract-governed rule**, not a hard-coded system constraint. ### Design implications #### 1. Contract schema enhancement Add an optional `operatorIndependence` field to contract definitions: ```typescript interface Contract { id: string name: string inputs: string[] // work object IDs outputs: string[] // work object IDs rules?: string[] evidenceRequirements: string[] operatorIndependence?: 'advisory' | 'required' // NEW } ``` - **Default:** `'advisory'` (same callsign can do production + quality) - **If `'required'`:** DO enforces that `gateEvaluations[].by` ≠ preceding production operator #### 2. Workstation definition unchanged Workstation definitions already have `kind: 'production' | 'quality'` and `contractId`. No change needed. The **contract** determines whether operator independence is required, not the workstation kind. #### 3. Execution flow When a lot reaches a quality workstation: 1. **DO checks** — Is there an operator callsign assigned? 2. **If contract has `operatorIndependence: 'required'`** — DO verifies that the callsign ≠ preceding production operator. 3. **Callsign operates** — Invokes quality workstation methods (e.g. `read_artifact`, `record_evidence`, `submit_quality_decision`). 4. **DO enforces contract** — Verifies: - Inputs exist (transcript, draft notes) - Evidence is recorded (citations, verdict, reason) - If `operatorIndependence: 'required'`, verifies operator ≠ production operator 5. **DO advances lot** — If verdict is `pass`, lot advances; if `fail`, lot blocks. #### 4. Work item ↔ work engineering join From the Work Item ↔ Work Engineering Join Design: - **Bound work item** = "operate Workstation X in Routing R for Work Object W under Contract C" [mikesecondbrain:1] This now includes quality workstations: - **Quality work item** = "operate Quality Workstation Q in Routing R for Work Object W under Quality Contract C_Q" The same callsign can be assigned to both the production work item and the quality work item, **as long as the quality contract is satisfied**. #### 5. Evidence recording Quality workstation evidence must include: ```json { "lotId": "lot-001", "workstationId": "ws-review-notes", "operatorCallsign": "@transcribe-op", // or "@reviewer" "timestamp": "2026-09-09T00:00:00Z", "verdict": "pass", "reason": "Notes capture all 3 decisions and 5 action items from transcript", "evidenceCitations": [ {"passage": "00:05:23 - 00:06:12", "type": "decision"}, {"passage": "00:12:45 - 00:13:30", "type": "action_item"} ], "contractVersion": "contract-review-notes-v1" } ``` This evidence is what makes the quality step **auditable**, regardless of which callsign performed it. ### Benefits of this model 1. **Flexibility** — Small teams / solo operators can do both production and quality without artificial constraints. 2. **Governance** — The contract is the source of truth, not hard-coded rules. 3. **Auditability** — Every quality step is recorded with evidence, regardless of operator. 4. **Future-proof** — If needed, contracts can require operator independence without changing the system. 5. **Consistency** — Production and quality workstations are governed by the same mechanism (contracts), just with different rules. ### Relationship to prior designs - **Work Item ↔ Work Engineering Join** — This confirms that operator independence is advisory in v1, and can be made required via contract later. [mikesecondbrain:1] - **LLM Assigned to Workstation** — This reinforces that LLMs (and humans) operate workstations under contracts, including quality workstations. [mikesecondbrain:3] - **Work Engineering in the Workspace DO** — This aligns with the principle that workstations are capability projections governed by contracts. [mikesecondbrain:2] ### Example: Same callsign, production + quality **Scenario:** Solo operator `@founder` building a feature. 1. **Production workstation** (Code Changes): - Contract: `contract-code-changes-v1` - Inputs: [working branch] - Outputs: [committed changes] - Operator: `@founder` 2. **Quality workstation** (Code Review): - Contract: `contract-code-review-v1` - `operatorIndependence: 'advisory'` (default) - Inputs: [committed changes, PR] - Outputs: [reviewed PR] - Evidence requirements: [cite PR diff, record verdict + reason] - Operator: `@founder` (same callsign) 3. **Execution:** - `@founder` operates Code Changes workstation → commits changes. - Lot advances to Code Review workstation. - `@founder` operates Code Review workstation → reviews own PR, cites diff, records verdict "pass" with reason "changes match spec". - Contract is satisfied (evidence recorded, rules followed). - Lot advances. **Audit trail:** - Production: `@founder` committed changes at `T1`. - Quality: `@founder` reviewed at `T2`, cited diff, recorded verdict. - Evidence is complete, even though the same callsign did both steps. **Future: If contract requires independence** Change contract to `operatorIndependence: 'required'`: - Now `@founder` cannot review their own PR. - A different callsign (e.g. `@reviewer`) must operate the Code Review workstation. - DO enforces this at `evaluateGate` time. ### Implementation checklist - [ ] Add `operatorIndependence?: 'advisory' | 'required'` to contract schema. - [ ] Default to `'advisory'` if not specified. - [ ] In DO runtime, check `operatorIndependence` at quality gate evaluation. - [ ] If `'required'`, verify `gateEvaluations[].by` ≠ preceding production operator. - [ ] Update MCP tools to expose `operatorIndependence` in contract definitions. - [ ] Document the pattern: "Same callsign can do production + quality if contract allows." --- **Note:** This is a design confirmation, not a change. It clarifies that **quality workstations have contracts, and the same callsign can perform quality steps if the contract allows** — with `operatorIndependence` as an optional future enhancement.
Tags: quality-workstations, contracts, operator-independence, work-engineering, design-confirmation, volatility:durable, kind:semantic, status:canonical — Source: mcp — 2026-09-08 23:07:47 UTC