@mstar-harness/omp 3.6.0-alpha.4

package/harness-skills/mstar-engine-legacy/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: mstar-engine-legacy
+description: Morning Star 条件契约档案（engine-absent fallback）。宿主无 engine 能力（无 `mstar` CLI、无 engine import、engine 约束未激活）时需要被 engine 校验接管的 contract 全文时使用：status v1→v2 字段历史、lease claim 协议全文、各宿主 QC 座次 N=3/N=1 重述、反递归完整清单、Engine-check 样板说明。engine 约束激活（或宿主含 engine 能力）时不加载；运行时 skills 的 engine-check 指针为权威契约。
+---
+
+# mstar-engine-legacy（条件契约档案 / Engine-absent fallback）
+
+## Load Order
+
+- 先 Read **`mstar-harness-core`**（SKILL.md；冲突时以 core 为准）。
+- **条件加载**：仅当宿主**无 engine 能力**时读取本 skill 及其 references —— 无 `mstar` CLI、无 engine import、engine 约束未激活。engine 约束激活（或宿主含 engine 能力）时**不加载**：此时运行时 skills 的 engine-check 指针 + 短契约文本为权威（见 core 索引行）。
+- 本 skill 是**单一条件归档**：承接因 engine 校验而从运行时 skills 中移除的 contract 全文，engine-absent 宿主在此找回完整文本。
+
+## Scope
+
+- 归档**被承接的完整契约散文**（Task 2 displaced prose 的单一收容处）：
+  1. `status.json` v1→v2 字段历史表（字段、severity、lifecycle、jq/flock 示例）
+  2. lease claim 协议全文（claim-before-InProgress、hold/release/override、integration merge、orphan recovery、waiver）
+  3. 各宿主 QC 座次 N=3/N=1 重述（omp / opencode / cursor / codex / kimi / zcode / dsh）
+  4. 反递归完整清单（leaf executor checklist、红线、NEVER 规则）
+  5. Engine-check 样板含义（运行时 skills 中 `Engine check (when available)` blockquote 的语义与 fallback 规则）
+- 运行时 skills 只保留短指针 + engine-check 命令；完整全文一律在本 skill 的 `references/` 中（避免全仓重复）。
+
+## Workflow
+
+1. 确认触发条件：宿主**无 engine**（无 CLI / import；约束未激活）。满足才继续。
+2. 按需打开对应 reference（见下表），把其中的完整契约文本作为 fallback 应用。
+3. engine 恢复后回到运行时 skills 的指针契约，停止使用本文件作为权威。
+
+| 需要 | 打开 |
+|------|------|
+| status 字段 / severity / lifecycle / 迁移 / jq-flock 示例 | `references/status-field-history.md` |
+| lease claim 协议全文（claim / hold / merge / orphan / waiver） | `references/lease-protocol.md` |
+| 各宿主 QC 座次 N=3/N=1 重述 | `references/qc-seat-n-restatements.md` |
+| 反递归完整清单（leaf checklist + 红线） | `references/anti-recursion-checklists.md` |
+| Engine-check 样板含义与 fallback 规则 | `references/engine-check-boilerplate.md` |
+
+## Decision Rules
+
+- **不加载条件**：engine 约束激活，或宿主含 engine 能力（`mstar` CLI / engine import 可用）→ 本 skill 不加载。
+- **归档唯一性**：完整契约文本只存在于本文件；不得同时在运行时 skills 重复维护全文（运行时只放指针 + engine-check）。
+- **权威性**：engine-absent 时，本文件的完整文本是行为权威；engine-present 时，运行时 skills + engine 校验是权威，本文件不是。
+- **不改契约语义**：承接文本必须逐字保留（字段名、severity 枚举、lease 规则、N 规则、反递归清单）；只做整理与归档，不重写规则。
+
+## Evidence
+
+- 正确结果 = references 中的完整文本可独立支撑 engine-absent 宿主操作；`bun run validation:drift` 绿（skill corpus lint 通过）；`mstar skill lint skills/mstar-engine-legacy` 绿。
+- 回归 = grep 验证运行时 skills 已不再携带被承接的全文（原全文位置只剩指针 / engine-check）。
+
+## References
+
+- 本 skill 的 references（见 When Workflow 表）。
+- 权威运行时契约（engine-present 时读）：`mstar-artifacts`（status v2 / register）、`mstar-iteration`、`mstar-dispatch-gates`、`mstar-host`。

package/harness-skills/mstar-engine-legacy/references/anti-recursion-checklists.md

@@ -0,0 +1,58 @@
+# Anti-recursion full checklists (archived)
+
+> Engine-absent fallback: the complete anti-recursion checklists. Engine-present hosts read `mstar-dispatch-gates` (red lines) + `mstar-roles/references/` role NEVER rules; this file is the consolidated full checklist text.
+
+## 1. Leaf executor dispatch checklist (full)
+
+> **First**: read the `**IDENTITY**` and `**CAPABILITY BOUNDARY**` blocks at the top of your Assignment. Those tell you who you ARE and what tools are NOT yours. Then read the `**You are a leaf executor. You MUST NOT:**` prohibitions. Those anti-patterns are customized for your specific role+context and are the authoritative dispatch boundaries for this assignment.
+
+**Preamble — internalize before any action:**
+
+I am a leaf executor. I personally complete all work. Task/subagent is NOT my tool. If I think about dispatching, I stop and return to my direct work or write `Blocked`.
+
+Before any Task/subagent call (if I somehow forget the preamble):
+
+1. What is my **`Execute as`**?
+2. Does the Assignment include **`Delegation: allowed (...)`**? If no → **no** Task/subagent.
+3. Is my next step a Task/subagent invoke? If yes without (2) → **stop**; use Read/Write/Shell/Edit in-session or **`Blocked`**.
+4. Is `subagent_type` equal to my `Execute as`? If yes → **forbidden** (recursive dispatch).
+5. Am I treating plain `role-id` mentions, Handoff, QA gate, Completion Report roles, or multi-plan/multi-track **design text** as invoke commands? If yes → **stop**; deliver in-session.
+6. Am I invoking because the tool exists? **Available ≠ authorized.**
+7. Need parallel work or PM-only dispatch? → **`Blocked`**; PM dispatches on the next round.
+
+If blocked, report: `## Blocked — recursive dispatch refused (<which NEVER or reason>)`.
+
+## 2. 承接方反递归红线 (NEVER / DO NOT; leaf executor 必读)
+
+下列行为易触发递归误派；`project-manager` 之外的角色一旦命中，须立即停止并改为本会话内可交付物，或 **`Blocked`** 回报 PM。**禁止**以「更高效」「Assignment 像 PM 编排」等理由绕开：
+
+- **NEVER** 在本会话内调用 Task / subagent，且其 `subagent_type` **等于**你当前的 **`Execute as`** 角色 id。
+- **NEVER** 把 Assignment 里出现的 **任何** plain `role-id` 提及、反引号 `` `<role-id>` ``、**Handoff**、**QA gate**、**Completion Report** 模板里的角色名、路由表下游角色当成「立刻 invoke」的指令；这些是**叙事 / 路由文档 / 后续 PM 编排意图**，不是命令。
+- **NEVER** 把「分解为多个计划 / 多 phase / 多 track」等**设计产物层面**的并行或拆分读成「应 invoke 与子会话数量对应的多个 subagent」。**纸面产物**由本会话写盘完成；并行**调度**由 PM 在后续轮次决定。
+- **NEVER** 因宿主**暴露**了 `Task` 或若干 `subagent_type` 名称就推断可以调用。**工具可用 ≠ 授权使用**；授权只来自 **`Delegation: allowed (...)`**。
+- **NEVER**（非 PM）主动执行 parallel-agent dispatch 来分派子代理；需要并行时回报 PM。
+- **DO NOT** 在 Assignment 缺少 `Execute as` / `Delegation` / `Who runs this turn` 时自行「补齐」为 PM；缺字段时按 **leaf executor** 解释：亲自完成或 **`Blocked`**。
+- **DO NOT** 用「Assignment 太长 / 像编排稿」当作分派依据；先交付本会话任务再回报，分派由 PM 下一轮决定。
+
+**自检（动手前）**：
+
+1. 我此刻的 **`Execute as`** 是什么？
+2. Assignment 是否写了 **`Delegation: allowed (...)`**？没有 → **禁止**任何 Task / subagent。
+3. 下一动作是不是「Task / subagent_type=…」？是 → 停手，改为 Read / Write / Shell / Edit，或 **`Blocked`**。
+4. 命中任一 NEVER → 写 `## Blocked — recursive dispatch refused (<which NEVER>)` 回报 PM，**不**继续 invoke。
+
+**Assignment 顶部反模式块**：每个 PM Assignment 开头均有 **`**You are a leaf executor. You MUST NOT:**`** 块（含 IDENTITY + CAPABILITY BOUNDARY + prohibitions），PM 按该 Assignment 的角色+上下文定制反模式清单。leaf executor 收到 Assignment 后须 **首先** 阅读该块；命中任一条 → **停止**（亲自完成或 `Blocked`）。
+
+## 3. 身份断言（leaf executor）
+
+- **你就是** `Execute as` 写的那个角色。你**不是 PM**，不是调度者，不是 parallel-agent dispatch 的使用者。
+- Task/subagent 工具即使在你的工具列表里出现，它**不属于你**。把它当作你没见过的工具 —— 不是"不能用"，是"你没有"。
+- 所有工作由你**本人**在当前会话内完成（Read / Write / Edit / Shell / Grep / Glob）。任何"这样做更高效"的想法都不构成 dispatch 的理由。
+- 遇到超出能力范围的需求 → 写 `## Blocked` 回报 PM，**不是**尝试 dispatch。Blocked 是你能发出的正确信号，dispatch 不是。
+
+## 4. Non-recursive dispatch rule (shared shape, all leaf executors)
+
+- Complete assigned work in this session.
+- Do not recursively dispatch sibling roles unless explicitly authorized via `Delegation: allowed (...)`.
+- `Execute as: {role_id}` is identity lock, not orchestration permission.
+- If required inputs are missing or prerequisites unmet, return `Blocked` to PM rather than inventing delegation.

package/harness-skills/mstar-engine-legacy/references/engine-check-boilerplate.md

@@ -0,0 +1,26 @@
+# Engine-check boilerplate explanation (archived)
+
+> Engine-absent fallback: explains what the `Engine check (when available)` blockquotes in runtime skills mean, and how the fallback rule works when the engine is absent.
+
+## What the boilerplate says
+
+Runtime skills carry short contract pointers shaped as blockquote runs that open with a bold marker reading `Engine check (when available)` followed by a colon, then give a runnable verification form, then a fail clause, then the standalone guarantee sentence:
+
+1. **Marker + command form.** The blockquote states a `mstar` CLI command or an engine-import form that validates the contract in that section. The import form references the engine package inside a host hook; the CLI form is `mstar <subcommand> <args>`. Illustrative shape (engine-present hosts only):
+
+```text
+// Engine check (when available) — import form example
+import { validateStatus } from "@mstar-harness/engine";
+```
+2. **Fail clause.** `On fail -> do not proceed; fix and re-run.` A failed engine check means the contract is violated: the operator must fix the underlying state (not paper over the violation) and re-run the check before continuing.
+3. **Standalone guarantee.** The blockquote closes with "Skill text below remains authoritative when the runtime is absent." — i.e. when the engine is not available in the host (no CLI, no import), the skill text itself (including this archive's full prose) is the contract; when the engine is available, the engine check is the authoritative enforcer and the prose is the fallback reference.
+
+## Why the archive exists
+
+When engine validators enforce a contract (status schema, lease fields, QC seat N, role binding, anti-recursion gates, path resolution, …), the runtime skills no longer need to carry the full contract prose — they keep the short pointer + the engine check. `mstar-engine-legacy` is the **single conditional archive** of that displaced full prose: engine-absent hosts read it here; engine-present hosts never load it (`mstar-harness-core` load condition).
+
+## Reading the boilerplate when the engine is absent
+
+- See the marker → read the surrounding runtime-skill text for the short contract, and open this skill's matching reference for the full prose (status fields → `status-field-history.md`; leases → `lease-protocol.md`; QC seats → `qc-seat-n-restatements.md`; anti-recursion → `anti-recursion-checklists.md`).
+- The fail clause means the same discipline applies manually: verify the artifact satisfies the contract before proceeding.
+- The standalone guarantee is why this archive is authoritative for you — the runtime skills deliberately defer the full text here.

package/harness-skills/mstar-engine-legacy/references/lease-protocol.md

@@ -0,0 +1,92 @@
+# Lease claim protocol (full prose, archived)
+
+> Engine-absent fallback: the full lease protocol prose displaced from `mstar-iteration` / `mstar-artifacts` when engine validators (`validateExecutionLease` / `validateIntegrationMergeLease` / CLI `mstar lease verify --workflow <id>`) took over the same contract. Engine-present hosts read the runtime skills' engine-check pointers instead.
+
+## When it applies
+
+**Iteration Phase 2 only** (after control-worktree entry, or primary checkout when `Worktree mode: waived`). Defaults are **hard** unless the current turn explicitly waives via Assignment `Worktree mode: waived` (or equivalent user instruction). `Plan parallelism: serial` is **not** a waiver — it only forces serial cross-plan **implement** scheduling while control worktree + leases remain required. Phase 1 Review & Edit may stay on the primary checkout; the control-worktree gate starts at **Phase 2 entry**. **`Worktree mode: waived` does not waive the cross-plan parallel safety gate**.
+
+## Coordination SSOT and lock discipline
+
+Lease mutations happen on the **control copy** of the coordination file — the v2 workflow snapshot `{WORKFLOW_DIR}/<id>/snapshot.json` (v1: `{HARNESS_DIR}/status.json`, migrated). This is cooperative, not a distributed lock service — non-cooperating processes are out of scope.
+
+**Same-host exclusive write lock** — all control-path lease mutations (claim, release, transfer, plan-status transitions that touch the lease, merge-lease claim/release) MUST run inside a same-host exclusive write lock for the full **read-check-replace-verify** sequence. Hold from first read through post-write verify; release on all exit paths.
+
+- Engine writers acquire the lock automatically: `writeWorkflowSnapshot` / `registerWorkflow` atomic-`mkdir` the lockdir at `<status-file dir>/.status-write.lockdir/` — for the snapshot the lockdir lands **inside `workflows/<id>/`** (next to `snapshot.json`).
+- Manual fallback when no engine writer exists: atomic `mkdir` on `{WORKFLOW_DIR}/<id>/.status-write.lockdir/` — success acquires; existing dir → **Blocked** (another writer holds the lock); `rmdir` the directory only after successful verify or explicit rollback. The dsh notes-ledger writer uses the same lockdir pattern (`{WORKFLOW_DIR}/<id>/.ledger-write.lockdir`). Do **not** invent a distributed CAS CLI.
+
+```bash
+CONTROL_ROOT="<snapshot top-level control_worktree_path>"
+HARNESS=".mstar"   # or resolved {HARNESS_DIR}
+WORKFLOW_ID="<plan-or-iteration-id>"
+SNAPSHOT="$CONTROL_ROOT/$HARNESS/workflows/$WORKFLOW_ID/snapshot.json"
+LOCKDIR="$CONTROL_ROOT/$HARNESS/workflows/$WORKFLOW_ID/.status-write.lockdir"
+(
+  mkdir "$LOCKDIR" || exit 1
+  trap 'rmdir "$LOCKDIR"' EXIT
+  # read → mutate → temp file + atomic replace → re-read verify
+)
+```
+
+**Pre-dispatch re-verify:** immediately before **any** writable implement dispatch, re-read the coordination file and confirm this session still passes verify-held-lease (`holder`, `worktree_path`, `working_branch` match Assignment). Mismatch or absent lease ⇒ **STOP** — do not dispatch.
+
+## Claim-before-`InProgress` (execution lease)
+
+A Phase 2 session **MUST** claim before moving a plan from `Todo`/`Blocked` to `InProgress` and before any writable dispatch for that plan:
+
+1. Re-read the coordination copy; locate exactly one plan row (`id` read compatibility).
+2. **Resume (not steal):** if `execution_lease` exists and `holder` **equals this session** → verify-held: confirm `worktree_path` and `working_branch` match the Assignment; continue (not Blocked, not a new claim).
+3. **Blocked:** if `execution_lease` exists and `holder` **differs** → stop. No timestamp, TTL, or inactivity makes it stealable.
+4. **Orphan:** if `status` is `InProgress` but `execution_lease` is absent → **STOP** (see Orphan recovery). Do not writable-dispatch or invent a lease.
+5. Create or verify the dedicated feature worktree and branch (default `<repoRoot>/.worktrees/<plan-id>-<slug>`; `worktree_path` ≠ `control_worktree_path`).
+6. Acquire the same-host write lock (above); re-read the coordination file; if row/status/lease changed, restart from step 1.
+7. In **one complete-file update** (under lock), set `status: "InProgress"` and write the full `execution_lease` object. Use a temp file in the same directory + atomic replace; never expose partial JSON.
+8. Re-read the stored row; verify `holder`, `worktree_path`, `working_branch` exactly match the attempted claim. Writable dispatch is forbidden until verification succeeds.
+
+V1: **manual release only** — omit `expires_at`; readers **MUST NOT** treat unknown/draft `expires_at` as authority to steal or release.
+
+## Hold, release, and override
+
+- Lease remains active across `InProgress` and `InReview` (including review fix rounds) unless deliberately released or transferred.
+- **Release:** re-read coordination file; stored `holder` must match this session (mismatch ⇒ **Blocked**, not permission to delete). Delete `execution_lease` in the same complete-file update — never `null`.
+- Voluntary abandonment: may set `status: "Blocked"` and delete the lease in one update.
+- **Done authority** deletes `execution_lease` in the **same** complete-file update as `status: "Done"` — **only after** successful integration merge when the lease gate is not waived. After QC/QA pass the plan stays **`InReview`** with lease retained until merge succeeds.
+- Temporary blockage may retain the lease when the same holder remains responsible and the plan record explains the next action.
+- **Override (only exception to no-steal):** explicit **user instruction in the current turn** may remove or replace another holder's lease. Append an audit note (prior holder, new holder/release, user authorized) to `plans[].notes` / `notes.jsonl`. Agents **MUST NOT** infer override from age, inactivity, `Blocked` status, or a failed session.
+- Cooperative handoff: current holder explicitly agrees; receiving worktree/branch verified; one complete-file update — otherwise old holder releases and new holder follows normal claim.
+
+## Integration merge protocol
+
+Feature implementation may run in parallel across plan IDs **only when** the cross-plan parallel hard gate is satisfied (same-host lock on the coordination file, default `Plan parallelism: serial`, or current-turn `Cross-host lease race: accepted` + audit — **not** by `Worktree mode: waived` alone); when the lease gate is active, each plan also needs a verified `execution_lease` and distinct feature worktree. Mutations of `spec_integration_branch` are **serial**. Plan status after QC/QA is `InReview` with `execution_lease` retained until merge succeeds (when lease gate active); `Done` + lease deletion happen **after** the integration merge commit is recorded.
+
+1. From `control_worktree_path`: clean working tree; checked-out branch = resolved `spec_integration_branch`.
+2. Re-read the coordination file under the same-process write lock. If `integration_merge_lease` exists:
+   - **Resume (not steal):** `holder` equals this session → verify `plan_id`, `source_branch`, `target_branch` match the intended merge; confirm control worktree state; continue (not Blocked).
+   - **Blocked:** `holder` differs → stop. No timestamp, TTL, or inactivity makes it stealable.
+3. If unclaimed, claim the merge lease with the same read-check-replace-verify discipline as execution claims. `source_branch`/`plan_id` must match the feature; `target_branch` must match `spec_integration_branch`.
+4. Only the stored merge-lease holder runs integration from `control_worktree_path`.
+5. On success: record merge commit/evidence; **delete** `integration_merge_lease`; in the **same** locked update set plan `status: "Done"` and **delete** `execution_lease`.
+6. On conflict/failure: retain both leases; plan stays `InReview` — do not set `Done`. Release the merge lease only after the control worktree is clean and in a known state.
+
+Execution and merge leases may coexist; the merge lease does not grant execution ownership for the source plan.
+
+## Orphan recovery (`InProgress` without `execution_lease`)
+
+Runtime skills that detect this state **STOP** and defer recovery — they must not silently add a lease or writable-dispatch. **Immediate gate:** no writable dispatch until recovery completes and a verified `execution_lease` exists (or the plan returns to a non-active status). **Resolver:** `@project-manager` (or explicit human/PM ownership resolution after race or corruption).
+
+| Path | When | Actions |
+| ---- | ---- | ------- |
+| **Reset to `Todo`** | Work abandoned, unknown owner, or safe to restart claim | One complete-file update under write lock: `status: "Todo"`; ensure `execution_lease` absent; append audit note (timestamp, reason, actor). |
+| **Recover with claim (same holder)** | Legitimate in-progress work; worktree/branch verified on disk; **this session's stable `holder`** matches the prior owner | Unattended recovery permitted only for the **same** stable `holder`. Follow claim from step 5 under write lock; append audit note (orphan recovery, same holder, paths verified). |
+| **Recover with claim (different holder)** | New session must take over live work | **Blocked** for unattended recovery. Requires verified quiescence of the prior writer (no live writable work on the feature branch/worktree) **and** explicit cooperative handoff from the prior holder, **or** current-turn user override + audit note. Then normal claim under write lock. |
+| **Escalate / `Blocked`** | Ambiguous ownership, conflicting worktrees, or partial/corrupt state | Set `status: "Blocked"` with `metadata.blocked_reason`; do not writable-dispatch until human/PM resolves. Restore coherent state from the latest complete version if needed. |
+
+After any recovery path, the next session must pass verify-held before writable dispatch.
+
+## Lease prohibitions (SSOT)
+
+- **MUST NOT** steal or overwrite an active `execution_lease` or `integration_merge_lease` (no TTL, age, or inactivity authority).
+- **MUST NOT** writable-dispatch without a verified `execution_lease` for that plan (resume counts only when same `holder` passes verify-held).
+- **MUST NOT** write `null` or tombstone objects for lease keys — **delete** the key on release.
+- **PM NEVER** steals an active lease without explicit current-turn user override + audit note (full list → `mstar-roles/references/project-manager.md`).
+- Writers **MUST preserve** unrelated plan rows, root metadata, and residual data on every lease mutation.

package/harness-skills/mstar-engine-legacy/references/qc-seat-n-restatements.md

@@ -0,0 +1,57 @@
+# QC seat N restatements (per-host, archived)
+
+> Engine-absent fallback: the per-host N=3/N=1 restatements that runtime host references (`mstar-host/references/*`) consolidate. Engine-present hosts read `mstar-host` → `parallel-dispatch.md` + `executionModeToN` instead; this file is the consolidated full restatement text.
+
+## Canonical N mapping (any host)
+
+| `Execution mode` | QC seats | N |
+| --- | --- | --- |
+| `sdd` (multi-task plan, single plan, or iteration Phase 2) | `qc-specialist` / `qc-specialist-2` / `qc-specialist-3` in **one** dispatch turn | **N=3** |
+| `inline` (hotfix) / explicit `QC mode: single` override | `qc-specialist` ×1 | **N=1** |
+| Targeted re-review (`QC re-review: targeted — reviewers: <ids>`) | the listed seats only | N = listed count (1–3) |
+
+Rules that never change: tri seats dispatch **in one message** with a branch review-package path (`{SDD_DIR}/review/qc1.md`…`qc3.md` + `qc-consolidated.md`); post-dispatch verify three distinct agent ids; `Execution mode: inline` with `QC mode: full tri-review` still launches the three seats; SDD implement/reviewer dispatches stay **serial** (never parallel implementers for the same plan); each invoke must carry the role-binding field set to `Execute as` even at N=1.
+
+## Per-host restatements (full text)
+
+### omp (`task` tool, `agent` field)
+
+- **`Execution mode: sdd`**: **N=3** task entries — prefer `agent: "qc-specialist"`, `"qc-specialist-2"`, `"qc-specialist-3"` when listed; each body still **Act as** the respective QC role + QC skill load. If a seat is missing from the live schema, fall back per C5 (generic + C5b) for that seat only. N rules → `parallel-dispatch.md`.
+- **`inline`**: **N=1** per `parallel-dispatch.md`.
+- Cannot emit required **N** → **`Blocked`**.
+- SDD implement: one implementer `task` entry per task id with `agent` matching the implementer role when listed; task reviewer = new entry with `agent: "code-reviewer"` (omp L2 review; not qc-specialist*) or `agent: "reviewer"`/`"task"` fallback + C5b; serial rule → `parallel-dispatch.md`.
+
+### opencode (`task` tool, `subagent` field)
+
+- Parallel batch **N** = **N task tool calls** in one assistant message when the host allows (`parallel-dispatch.md`); 1 Assignment ⇒ 1 invoke.
+- Prepare phase serial roles (`explore → product-manager → architect`) still require a real task-tool call per handoff (**N=1** per dispatch turn) — Assignment Markdown alone does not open subagent sessions.
+- SDD task reviewer: new task tool call with `subagent: "code-reviewer"` (OpenCode L2; not qc-specialist*), no sticky resume for reviewers.
+
+### cursor (Task tool, `subagent_type` field)
+
+- **`Execution mode: sdd`**: **N=3** Tasks (`qc-specialist`, `qc-specialist-2`, `qc-specialist-3`) + branch review-package path (N rules → `parallel-dispatch.md`).
+- **`inline`**: **N=1** per `parallel-dispatch.md`.
+- SDD implement/reviewer: serial — implementer Task per task id with `subagent_type` matching the implementer role when listed; task reviewer = new Task with `subagent_type: "code-reviewer"` (Cursor L2; not qc-specialist*) when listed, else generic fallback per C5 — no `resume` for reviewers.
+
+### codex (custom-agent / multi-agent tools only)
+
+- QC: N rules → `parallel-dispatch.md` (**`Execution mode: sdd`** → N=3; **`inline`** → N=1) when a callable invoke tool exists. Cannot emit required **N** → **`Blocked`**.
+- If no invoke tool is present when dispatch is required → **`Blocked`** — report missing invoke capability; do not substitute single-session role execution in the PM thread unless the user explicitly overrides harness dispatch this turn.
+
+### kimi (`Agent` tool, `subagent_type` ∈ {`coder`,`explore`,`plan`})
+
+- **`Execution mode: sdd`**: **N=3** `Agent` calls (`qc-specialist`, `qc-specialist-2`, `qc-specialist-3`) — each prompt **Act as** the respective QC role, all `subagent_type: "coder"` (N rules → `parallel-dispatch.md`).
+- **`inline`**: **N=1** per `parallel-dispatch.md`. Cannot emit required **N** → **`Blocked`**.
+- SDD implement: one implementer `Agent` per task id; task reviewer = new `Agent` with **Act as `code-reviewer`** (Kimi L2; not qc-specialist*), generic fallback `subagent_type: "coder"` per C5 — no sticky resume unless the host adds it later.
+
+### zcode (`Agent` tool, `subagent_type` ∈ {`general-purpose`, …})
+
+- **`Execution mode: sdd`**: **N=3** `Agent` calls (`qc-specialist`, `qc-specialist-2`, `qc-specialist-3`) — each prompt **Act as** the respective QC role, all `subagent_type: "general-purpose"` (N rules → `parallel-dispatch.md`).
+- **`inline`**: **N=1** per `parallel-dispatch.md`. Cannot emit required **N** → **`Blocked`**.
+- SDD implement: one implementer `Agent` per task id; task reviewer = new `Agent` with **Act as `code-reviewer`** (ZCode L2; not qc-specialist*), generic fallback `subagent_type: "general-purpose"` per C5 — no sticky resume unless the host adds it later.
+
+### dsh (`subagent` dispatches)
+
+- **`Execution mode: sdd`**: **N=3** `subagent` dispatches — one per QC seat (`qc-specialist`, `qc-specialist-2`, `qc-specialist-3`), each body **Act as** the respective QC role + QC skill load. **MUST dispatch all three with `run_in_background: true` in one message** → the seats run CONCURRENTLY (background children; wall ≈ single seat); foreground (no `run_in_background`) runs serially (wall ≈ 3× single seat) and does NOT count as parallel tri. Cannot emit required **N** → **`Blocked`**.
+- **`inline`**: **N=1**.
+- SDD implement: one implementer `subagent` dispatch per task id; task reviewer = a separate dispatch (SDD review role) — no sticky resume unless the host's continuable-subagent id is available and recorded.

package/harness-skills/mstar-engine-legacy/references/status-field-history.md

@@ -0,0 +1,186 @@
+# Status v1→v2 field history (archived contract prose)
+
+> Engine-absent fallback: the full field tables displaced from `mstar-artifacts` when engine validators took over the same contract. Engine-present hosts read `mstar-artifacts/references/status-and-residuals.md` (v2) instead; this file is the historical + fallback full text.
+
+## v1 `{HARNESS_DIR}/status.json` — full shape (historical)
+
+`status.json` lived at `{HARNESS_DIR}/status.json` and was the **SSOT** for `plans[]` row status and open residual findings. Closed residuals were archived to `{HARNESS_DIR}/archived/residuals/<plan-id>.json`.
+
+```json
+{
+  "version": 1,
+  "updated_at": "YYYY-MM-DD",
+  "plans": [
+    {
+      "id": "plan-id",
+      "title": "Plan title",
+      "file": "{PLAN_DIR}/plan-id-feature-name.md",
+      "status": "Todo | InProgress | InReview | Blocked | Done",
+      "owner": "@project-manager",
+      "agents": ["@fullstack-dev"],
+      "progress": 0,
+      "tags": [],
+      "created_at": "YYYY-MM-DD",
+      "updated_at": "YYYY-MM-DD",
+      "done_at": null,
+      "notes": "",
+      "metadata": {}
+    }
+  ],
+  "residual_findings": {
+    "plan-id": [
+      {
+        "id": "R1",
+        "title": "Finding title",
+        "severity": "critical | high | medium | low | nit",
+        "source": "QC-#1 qc1.md F-001 @ <review-range>, QA qa.md, review, …",
+        "scope": "Affected file or component",
+        "decision": "defer | accept | risk-accepted",
+        "owner": "@fullstack-dev",
+        "target": "Before plan 02 / YYYY-MM-DD / milestone",
+        "tracking": "Issue URL or null",
+        "detail_doc": "{PLAN_DIR}/residuals/plan-id/R1-short-label.md"
+      }
+    ]
+  },
+  "metadata": {}
+}
+```
+
+Closed residual entries added: `lifecycle`, `closed_at`, `closure_note`; optional `closure_evidence`, `superseded_by`.
+
+## v1 `plans[]` row fields
+
+| Field | Meaning |
+| --- | --- |
+| `id` | Plan id (legacy alias `plan_id` read-compatible). |
+| `title` / `file` | Display title / main plan path (`{PLAN_DIR}/…`). |
+| `status` | `Todo \| InProgress \| InReview \| Blocked \| Done` (Done only by `@project-manager` / `@qa-engineer`). |
+| `owner` / `agents` / `progress` / `tags` | PM ownership, role agents, progress 0–100, tags. |
+| `created_at` / `updated_at` / `done_at` | `YYYY-MM-DD`; `done_at` set at Done. |
+| `notes` | Per-plan timeline (string array recommended; legacy string OK). |
+| `metadata` | Optional object (see below). |
+
+## v1 `plans[].metadata` standard optional fields
+
+| Key | Type | Purpose |
+| --- | --- | --- |
+| `findings_cleanup` | `zero-residual` \| `allow-residual` | Mirror of Assignment `Findings cleanup`. |
+| `working_branch` | string | Implementation branch; aligns with Assignment `Working branch` (SSOT). |
+| `spec_integration_branch` | string | (Multi-plan same Spec) integration branch; created from root `metadata.iteration_base_branch`. |
+| `merge_target` | string | Next merge target; final PR target is root `metadata.target_branch`. |
+| `branch_policy` | string | One-line policy per `mstar-harness-core`. |
+| `phase` / `priority` / `description` / `scope` | string | Program label; `high\|medium\|low`; one-line scope (pick one key per repo). |
+| `gates` | object | Gate summary (`qc`, `qa`, `typecheck`, `tests`, `lint`, …). |
+| `blocked_since` / `blocked_reason` / `blocked_by_plan_id` / `dependency` / `next_action` | string | Block bookkeeping + deps + next step. |
+| `primary_spec` / `iteration_compass` / `iteration_refs` | string / string[] | Spec / compass pointers. |
+| `qc_status` / `tests` / `commits` | string | InReview/Done snapshots — not a substitute for durable gate summaries or root `residual_findings`. |
+| `sdd_dir` / `sdd_progress` / `review_bundle` / `task_commits` | string / array | SDD scratch path, progress ledger pointer, review bundle pointer, `{task_id,base,head}[]`. |
+
+### v1 `plans[].execution_lease` (iteration Phase 2)
+
+| Field | Type | Required | Semantics |
+| --- | --- | --- | --- |
+| `holder` | non-empty string | Yes | Opaque cooperative owner identity (recommended `<host>:<stable-session-id>`, e.g. `cursor:bc-1234`); stable for claim lifetime; **no credentials**; used for ownership comparison — not `session_label`. |
+| `claimed_at` | RFC 3339 UTC (`Z`) | Yes | Acquisition time (audit only; **not** an expiry clock). |
+| `worktree_path` | absolute path string | Yes | Dedicated feature-worktree root; **MUST** differ from `metadata.control_worktree_path`. |
+| `working_branch` | non-empty string | Yes | Feature branch at `worktree_path`; MUST agree with Assignment `Working branch`. |
+| `session_label` | string | No | Human display only — **MUST NOT** authorize or compare ownership. |
+
+Writers **delete** `execution_lease` on release; `null` and tombstone objects are invalid.
+
+## v1 root `metadata` standard optional fields
+
+| Key | Type | Purpose |
+| --- | --- | --- |
+| `versioning` | object | Cross-plan conventions (team-defined). |
+| `iteration_base_branch` | string | Branch/ref used to create `spec_integration_branch`; required for formal iterations. |
+| `target_branch` | string | Final PR target after iteration-close; required for formal iterations. |
+| `notes` | array | **Legacy** — prefer `{HARNESS_DIR}/notes.json`. |
+| `residual_findings_history` | object | **Legacy** — prefer `archived/residuals/<plan-id>.json`. |
+| `tech_debt_summary` | object | Optional rollup over open R# (engine `techDebtRollup`). |
+| `control_worktree_path` | absolute path string | Iteration Phase 2: canonical repository root checked out to active `spec_integration_branch`; coordination + serial merge cwd. |
+| `integration_merge_lease` | object | While one integration merge is owned; **absent** = unclaimed. Writers **delete** the key on release — never `null`/tombstones. |
+
+## v1 residual entry contract (9 required fields + severity/lifecycle)
+
+Entry keys mirroring engine `RESIDUAL_REQUIRED_FIELDS`: `id`, `title`, `severity`, `source`, `scope`, `decision`, `owner`, `target`, `tracking` (+ optional `detail_doc`). Malformed entries (non-object, missing any required field, or severity outside enum) were rejected fail-loud by `validateResidual` / `validateStatus` — never silent pass-through.
+
+### Severity (machine enum, lowercase English only)
+
+`critical` > `high` > `medium` > `low` > `nit`. `nit` is always lighter than `low`. Forbidden in JSON: `warning`, `Major`, non-English. Legacy `"severity": "warning"` read+rolled up as `low`. QC report **Critical / Warning / Suggestion** are section titles — never copied verbatim into JSON.
+
+### Lifecycle states
+
+`open` (default; omit field) · `resolved` · `waived` · `superseded` · `duplicate`. On close set `closed_at` (`YYYY-MM-DD`) + `closure_note`; recommend `closure_evidence` (PR/commit/test/doc anchor). Owners: fix → implementer; verify → QA (when `QA gate: mandatory`) else PM; write SSOT → PM or QA.
+
+## v1 archive shapes (historical)
+
+**`archived/residuals/<plan-id>.json`** (append to `entries`):
+
+```json
+{
+  "plan_id": "01-data-infrastructure",
+  "schema_version": 1,
+  "entries": [
+    {
+      "id": "R1",
+      "severity": "medium",
+      "lifecycle": "resolved",
+      "closed_at": "2026-04-06",
+      "closure_note": "…",
+      "closure_evidence": "PR #42 / commit …",
+      "archived_at": "2026-04-07"
+    }
+  ]
+}
+```
+
+**`{HARNESS_DIR}/notes.json`** (append-only program timeline):
+
+```json
+{ "schema_version": 1, "updated_at": "YYYY-MM-DD",
+  "entries": [{ "at": "2026-04-08", "message": "Short milestone", "plan_id": "01-data-infrastructure" }] }
+```
+
+`plans[].notes` = per-plan timeline; `notes.json` = cross-plan milestones.
+
+## v1 jq / flock examples (legacy read paths)
+
+```bash
+# Replace .mstar with your resolved {HARNESS_DIR}; legacy projects may use .agents.
+jq '.plans[] | select(.id == "01-data-infrastructure")' .mstar/status.json
+jq '.residual_findings["01-data-infrastructure"] // .metadata.residual_findings["01-data-infrastructure"]' .mstar/status.json
+jq '.entries[] | select(.id == "R1")' .mstar/archived/residuals/01-data-infrastructure.json
+```
+
+Legacy read paths (root `residual_findings` / `metadata.residual_findings` / `archived/residuals/<plan-id>.json`) were **legacy read-only**; `mstar migrate` moved open entries into the register.
+
+## v2 destinations (where each v1 surface landed)
+
+| v1 surface | v2 home |
+| --- | --- |
+| root `plans[]` rows | `{WORKFLOW_DIR}/<id>/snapshot.json` → `plans[]` (legacy PlanRow shape verbatim) |
+| root `plans[].execution_lease` | snapshot plan row `execution_lease` |
+| root `metadata.integration_merge_lease` | snapshot top-level `integration_merge_lease` |
+| root `metadata.control_worktree_path` | snapshot top-level `control_worktree_path` |
+| root `metadata.iteration_base_branch` / `target_branch` / `spec_integration_branch` / `merge_target` | snapshot top-level `branch.{base,integration,target}` |
+| root `metadata.plan_parallelism` / `worktree_mode` / `push_policy` | snapshot `execution_policy` |
+| root `metadata.notes` / legacy row `notes` | `{WORKFLOW_DIR}/<id>/notes.jsonl` (runtime ledger; row `notes` kept verbatim as legacy copy) |
+| root `residual_findings` | `{PROJECT_DIR}/<id>/residuals.json` → `entries[<plan-id>]` (array semantics preserved) |
+| `archived/residuals/<plan-id>.json` | register **close in place** (lifecycle/closed_at/closure_note on the entry) |
+| `metadata.tech_debt_summary` | derived `mstar status tech-debt <project-dir>` rollup (v1 stored drift path dead) |
+| root `version: 1` | root `version: 2` + `workflows[]` (active-only registry; terminal rows removed after snapshot write) |
+| v1 root `plans[]`/`residual_findings` trees | migrated first via `mstar migrate [--dry-run] [--path <root>]` |
+
+Root v2 shape:
+
+```json
+{ "version": 2, "updated_at": "YYYY-MM-DD",
+  "workflows": [{ "id": "<plan-or-iteration-id>", "type": "plan | iteration", "started_at": "YYYY-MM-DD", "dir": "workflows/<id>" }] }
+```
+
+## Compatibility
+
+- Read: accept `id` or `plan_id`; write: one canonical key (prefer `id`).
+- Document the canonical key in `{HARNESS_DIR}/AGENTS.md` if migrating.