@mstar-harness/opencode 1.0.0 → 1.0.2

package/harness-skills/mstar-sdd/references/implementer-continuation-prompt.md

@@ -0,0 +1,44 @@
+# Implementer continuation prompt (sticky session)
+
+Use when PM continues **`SDD implementer session: sticky`** for Task N>1. Host: **resume** same agent when supported (`sticky-implementer-session.md`).
+
+```
+Task / subagent:
+  resume: [HOST_AGENT_ID from implementer-session.json]
+  description: "SDD continue Task N: <name>"
+  model: [same tier as session start unless PM upgrades]
+  prompt: |
+    <SUBAGENT-STOP> Skip PM orchestration skills. You are a leaf implementer continuing a sticky SDD session.</SUBAGENT-STOP>
+
+    Continue as the same implementer on plan <plan-id>, Working branch: <branch>.
+
+    ## Completed (do not redo)
+
+    Read: [SDD_DIR]/progress.md and [SDD_DIR]/implementer-session.json
+
+    ## This task
+
+    Task N: <name>
+
+    Read first — your spec (verbatim): [BRIEF_FILE]
+
+    ## Context not in the brief
+
+    [Interfaces from earlier tasks only if not already in your session]
+
+    ## Report file
+
+    Write your full report to: [REPORT_FILE]
+
+    ## Your job
+
+    1. Implement exactly what this brief specifies (prior tasks are done)
+    2. Run tests; commit on Working branch
+    3. Write report file; return short summary only
+
+    ## When stuck
+
+    Report BLOCKED or NEEDS_CONTEXT — PM may reset session to fresh.
+```
+
+First task on a plan uses **`implementer-prompt.md`** (not this file).

package/harness-skills/mstar-sdd/references/implementer-prompt.md

@@ -1,6 +1,8 @@
 # Implementer subagent prompt template
 
-Use when PM dispatches an SDD implementer (`mstar-sdd`).
+Use when PM dispatches an SDD implementer (`mstar-sdd`) — **first task** or **`SDD implementer session: fresh`**.
+
+For **sticky** continuation (task 2+), use **`implementer-continuation-prompt.md`** instead.
 
 ```
 Task / subagent:

package/harness-skills/mstar-sdd/references/sticky-implementer-session.md

@@ -0,0 +1,103 @@
+# Sticky implementer session (SDD token optimization)
+
+Reuse the **same implementer subagent** across multiple tasks in one plan when tasks are tightly coupled, same `Execute as` role, and same `Working branch`. **L2 task reviewers stay fresh per task** — do not sticky reviewers.
+
+SSOT for mode selection and host resume → this file. Per-task artifacts → **`file-handoffs.md`**.
+
+## When to use
+
+| `SDD implementer session` | Use |
+|---------------------------|-----|
+| **`fresh`** (default) | Independent tasks, module boundaries, different dev tracks, or first task on a plan |
+| **`sticky`** | Same `fullstack-dev` (or same role id), sequential tasks on one branch, strong file/context continuity (e.g. T3+T4 daemon stderr + DB reset) |
+
+**Prefer `sticky`** on iteration-drive Phase 2 when PM will dispatch many tasks to the same dev on one plan feature branch.
+
+## Assignment fields (implement dispatch)
+
+```markdown
+**Execution mode**: sdd
+**SDD implementer session**: sticky | fresh
+**SDD dir**: `{HARNESS_DIR}/sdd/<plan-id>/`
+**Model tier**: standard
+**Execute as**: fullstack-dev
+**Working branch**: <branch>
+**Covers task**: N | N–M   # single task id for this dispatch turn
+```
+
+- **Task 1** (or first task after `fresh` reset): `SDD implementer session: fresh` or `sticky` (starts sticky ledger).
+- **Task 2+** with sticky: `SDD implementer session: sticky` + host **resume** (Cursor) or continuation prompt (fallback).
+
+## Session ledger: `implementer-session.json`
+
+PM writes/updates at `{SDD_DIR}/implementer-session.json` when starting or continuing sticky mode:
+
+```json
+{
+  "plan_id": "<plan-id>",
+  "execute_as": "fullstack-dev",
+  "session_mode": "sticky",
+  "host": "cursor",
+  "host_agent_id": "<agent-id from first Task return — required for resume>",
+  "working_branch": "feature/...",
+  "started_task": 1,
+  "last_task": 1,
+  "started_at": "2026-07-07T00:00:00Z"
+}
+```
+
+After each completed task review, PM sets `last_task` to N. **Do not** resume if `host_agent_id` is missing — fall back to `fresh` for that task.
+
+## Per-task loop (sticky implementer)
+
+Same as default SDD for artifacts and L2 review; only implementer dispatch differs:
+
+1. `task-brief` → `{SDD_DIR}/task-N-brief.md`
+2. Record `BASE_SHA`
+3. **Implementer dispatch**
+   - **First task** (`fresh` or sticky start): normal Task/subagent invoke → save `host_agent_id` to ledger
+   - **Next tasks** (`sticky`): host **resume** with same `host_agent_id` + continuation prompt (`implementer-prompt.md` § Continuation)
+4. On `DONE` → `review-package` → **fresh** task reviewer (never resume reviewer)
+5. Append `progress.md`; update ledger `last_task`
+6. Next task
+
+**Still required per task:** commit, `task-N-report.md`, task-level diff, task reviewer, `progress.md` line.
+
+## When to reset to `fresh`
+
+Start a **new** implementer session (`session_mode: fresh` or new ledger) when any:
+
+- `BLOCKED` / `NEEDS_CONTEXT` not resolved in one continuation turn
+- `Execute as` role changes (`fullstack-dev` → `fullstack-dev-2`)
+- `Working branch` changes
+- Host does not support resume (OpenCode without resume → use **micro-batch** or `fresh`)
+- Context clearly degraded (implementer confuses prior tasks) — PM judgment
+- Switching from another dev track mid-plan
+
+Delete or archive `implementer-session.json` when resetting.
+
+## Micro-batch fallback (no host resume)
+
+When resume is unavailable, PM may dispatch **one** implementer for **2–3** tightly coupled tasks:
+
+- Prompt lists `task-N-brief.md` … `task-M-brief.md` and matching report paths only
+- Implementer completes tasks **in order** in one session
+- PM still runs **per-task** `review-package` + **fresh** task reviewer after each task (or after batch if PM documents per-task SHAs in Assignment)
+
+Max **3** tasks per micro-batch without user override. See `project-manager.md` batch sizing.
+
+## Host mapping
+
+| Host | Sticky implementer |
+|------|-------------------|
+| **Cursor** | `Task` with `resume: <host_agent_id>` — **`mstar-host/references/cursor.md`** § SDD sticky |
+| **OpenCode** | Resume only if task tool supports it; else micro-batch or `fresh` per task |
+| **Codex** | Thread resume only when callable multi-agent tool documents agent id; else micro-batch or `fresh` |
+
+## PM NEVER (sticky)
+
+- Resume task **reviewer** sessions — reviewers stay fresh per task
+- Parallel sticky implementers on the same branch
+- Resume without updating `implementer-session.json` / `progress.md`
+- Skip per-task review because implementer "remembers" prior tasks
+- Paste full plan into continuation prompt — only new brief path + report path

package/harness-skills/pm/SKILL.md

@@ -1,59 +1,34 @@
 ---
 name: pm
-description: "Morning Star PM orchestration entry. On Cursor/Codex, /pm launches project-manager. On OpenCode, switch to project-manager when the active agent is not PM. The autonomous Execute flow (per-plan dispatch, iteration management, compound) lives in mstar-iteration — this skill covers PM role identity, host entry, dispatch-first rules, and host-specific concerns."
+description: "PM entry shim — force project-manager orchestration when user invokes /pm or this skill (Codex and Cursor). General per-plan PM work: this skill + project-manager.md. Formal iteration lifecycle on Cursor/OpenCode: commands (iteration-start, iteration-drive, mstar-bootstrap). Boot, routing, dispatch SSOT → mstar-roles/references/project-manager.md and topic mstar-* skills — not here."
 ---
 
-# PM — Morning Star orchestration entry
+# PM (entry shim)
 
-**PM role launcher and host adapter.** Iteration flow (start → Execute → close) → **`mstar-iteration`** (canonical SSOT). This skill handles: PM role identity per host, boot order, dispatch-first rules, Cursor Plan mode.
+**Thin launcher only.** Boot lists, iteration phases, Assignment templates, and SDD loops are **not** maintained in this file.
 
-## Host entry (read `mstar-host` first)
+## Host entry
 
-| Host | Entry | PM role |
-| --- | --- | --- |
-| **Cursor / Codex** | User invokes **`/pm`** (or explicit "run as PM") | Force **`project-manager`** for the session |
-| **OpenCode** | User may already be on a configured agent | **If active role ≠ `project-manager`**: operate **only** as PM — load `mstar-roles` → `references/project-manager.md`; do **not** stay in dev/QC/architect voice for orchestration. Host invoke: task tool **`subagent`** matching Assignment `Execute as` (see `mstar-host` → `opencode.md`); Assignment body uses **plain role ids** |
+| Host | Use |
+|------|-----|
+| **Codex** | **`/pm`** or this skill → **`project-manager`** for the session |
+| **Cursor** | **`/pm`** or this skill → general PM orchestration (single-plan, hotfix, QC waves, dispatch) **without** starting an iteration. Formal iteration → **`commands/`** below |
+| **OpenCode** | Same as Cursor when no command: **`project-manager`** via `mstar-roles` → `references/project-manager.md` |
 
-Detect host → Read `mstar-host` → `references/cursor.md` | `opencode.md` | `codex.md`.
+**Iteration commands** (optional; carry their own Boot): `iteration-start`, `iteration-drive`, `mstar-bootstrap` — use when running Phase 1–5 iteration lifecycle, not required for ordinary PM work.
 
-## Boot (order)
+Detect host → **`mstar-host`** → `references/codex.md` | `cursor.md` | `opencode.md`.
 
-1. `mstar-harness-core`
-2. `mstar-roles` → `references/project-manager.md`
-3. Before first **implement** dispatch: `mstar-dispatch-gates` + host reference
-4. Before **QC**: `mstar-review-qc`
-5. **SDD implement** (`Execution mode: sdd`): `mstar-sdd` before first implement dispatch
-6. **Iteration flow** (start / Execute / close): **`mstar-iteration`** — canonical SSOT for per-plan dispatch loop, integration branch, compound round. Do **not** re-describe the flow in this skill.
-7. **On demand:** `mstar-phase-gates`, `mstar-plan-conventions`, `mstar-plan-artifacts`, `mstar-branch-worktree`, `mstar-skill-authoring` for skill work
-
-Prepare/Execute gates, routing, Assignment templates, Task Board, QC (SDD → tri; inline → single), residuals, compound → topic skills + PM references (not repeated here).
-
-## Dispatch-first (`implement`)
-
-| Do | Don't |
-| --- | --- |
-| **Loop:** `## Assignment` → invoke → Completion Report v2 → report-to-status → next batch | Parent **Write/Edit/Shell** on product code to "move faster" |
-| **1 Assignment ⇒ 1 invoke** when host supports Task/subagent (`mstar-dispatch-gates`) | Assignment markdown only, no matching invoke |
-| Put merge/branch/handoff from **this thread** into Assignment | Skip subagent because context is "already here" |
-
-- **NEVER** implement while staying PM — SDD ends with **plan QC tri** (N=3); **implement still delegates** dev + task reviewer subagents.
-- **Delegate scope / PM whitelist:** `mstar-roles` → PM Execution Boundary.
+## Read next (in order)
 
-**Exceptions:** user explicitly asks PM thread to implement; hotfix per `mstar-phase-gates`.
-
-## Iteration
-
-Formal iteration（Phase 1 → Phase 2 → Phase 3）→ **`mstar-iteration`** only. Do not duplicate phase gates, branch policy, or close checklists here.
-
-## Cursor Plan mode
-
-CreatePlan / SwitchMode: Read **`mstar-host/references/cursor-plan-mode-bridge.md`**. Bootstrap todos `harness-init` → `spec-register` → `mirror-plan` before implement todos; evidence on **subagent** work.
+1. `mstar-harness-core`
+2. `mstar-roles` → **`references/project-manager.md`** — required reading list, routing, dispatch-first, iteration branch policy
+3. Topic skills **on demand** per that file and the active workflow (`mstar-dispatch-gates`, `mstar-iteration`, `mstar-sdd`, `mstar-review-qc`, …)
 
-## Conflict order
+## Three rules (everything else is a pointer)
 
-1. User explicit instructions  
-2. Project `AGENTS.md` / `CLAUDE.md`  
-3. `mstar-harness-core` + runtime `mstar-*`  
-4. This skill  
+1. **Delegate** — PM does not implement, QC, or QA in-thread (`project-manager.md` Execution Boundary; hotfix → `mstar-phase-gates`).
+2. **Dispatch** — when host has invoke/Task tools: **1 Assignment ⇒ 1 invoke** (`mstar-dispatch-gates`). Markdown alone is not dispatch.
+3. **SSOT** — iteration lifecycle → **`mstar-iteration`** (or **`commands/`** on Cursor/OpenCode); Cursor Plan mode → **`mstar-host/references/cursor-plan-mode-bridge.md`**.
 
-**Dispatch-first + `mstar-dispatch-gates`** win over "fast parent agent" unless user overrides.
+Conflict: user instructions → project `AGENTS.md` / `CLAUDE.md` → `mstar-harness-core` → this file.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mstar-harness/opencode",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Morning Star harness OpenCode plugin (skills bootstrap and agent loading).",
   "license": "MIT",
   "repository": {
@@ -16,7 +16,9 @@
     "harness-agents",
     "harness-commands",
     "AGENTS.md",
-    "INSTALL.md"
+    "INSTALL.md",
+    "README.md",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "bundle-assets": "bun run scripts/bundle-harness-assets.ts",