cowork-flow 0.0.28 → 0.0.30

package/README.md

@@ -99,7 +99,7 @@ OpenCode 项目级固定 agent、slash command 和系统上下文注入插件。
 npx cowork-flow init ./my-project --platform codex
 ```
 
-`init` 会显式要求平台和开发者身份。平台可选 `codex`、`opencode`、`claude-code`、`all`，其中 `both` 仍作为兼容别名表示 `codex,opencode`。交互式终端会提示输入；脚本或 CI 请传入：
+`init` 会显式要求平台和开发者身份。平台可选 `codex`、`opencode`、`claude-code`、`all`。交互式终端会提示输入；脚本或 CI 请传入：
 
 ```bash
 npx cowork-flow init ./my-project --platform codex --developer <your-name>
@@ -134,7 +134,7 @@ npx cowork-flow --help
 cowork-flow init ./my-project --platform codex
 ```
 
-`init` 会直接复制模板中的通用 `.cowork-flow/`，并按 `--platform` 只复制对应 host 资产：`codex` 复制 `.codex/`、`.agents/skills/` 与 `.cowork-flow/adapters/codex/`，`opencode` 复制 `.opencode/`、`.agents/skills/` 与 `.cowork-flow/adapters/opencode/`，`claude-code` 复制 `CLAUDE.md`、`.claude/`（含 `.claude/settings.json`、`.claude/hooks/`、`.claude/skills/`）与 `.cowork-flow/adapters/claude-code/`，不复制 `.agents/skills/`。`all` 或 `--platform codex,opencode,claude-code` 同时复制三者和 `.agents/skills/`。`both` 保持兼容，只复制 Codex 和 OpenCode。它还会初始化 `.cowork-flow/.developer` 与 `.cowork-flow/workspace/<developer>/`。交互式终端会先显示 checkbox 多选界面选择平台，再提示开发者名称；非交互式环境必须传入 `--platform <codex|opencode|claude-code|all>` 与 `--developer <name>`。`init` 不会复制额外技能包。
+`init` 会直接复制模板中的通用 `.cowork-flow/`，并按 `--platform` 只复制对应 host 资产：`codex` 复制 `.codex/`、`.agents/skills/` 与 `.cowork-flow/adapters/codex/`，`opencode` 复制 `.opencode/`、`.agents/skills/` 与 `.cowork-flow/adapters/opencode/`，`claude-code` 复制 `CLAUDE.md`、`.claude/`（含 `.claude/settings.json`、`.claude/hooks/`、`.claude/skills/`）与 `.cowork-flow/adapters/claude-code/`，不复制 `.agents/skills/`。`all` 或 `--platform codex,opencode,claude-code` 同时复制三者和 `.agents/skills/`。它还会初始化 `.cowork-flow/.developer` 与 `.cowork-flow/workspace/<developer>/`。交互式终端会先显示 checkbox 多选界面选择平台，再提示开发者名称；非交互式环境必须传入 `--platform <codex|opencode|claude-code|all>` 与 `--developer <name>`。`init` 不会复制额外技能包。
 
 初始化到当前项目：
 
@@ -185,6 +185,16 @@ cowork-flow sync . --dry-run
 下面示例使用 macOS / Linux 写法；Windows 原生命令行中把
 `./.cowork-flow/run` 替换为 `.\.cowork-flow\run.cmd`。
 
+当前主流程以 `.cowork-flow/workflow.md` 为准。默认路径是：
+
+```text
+changes -> brainstorming -> read spec -> plan -> tasks -> implement -> check -> complete
+```
+
+L0 文档、格式、小范围重构或测试补充可简化为
+`brainstorming -> read spec -> implement -> check -> complete`；L1/L2 在完成后继续
+`archive -> add session`。
+
 初始化或查看开发者身份：
 
 ```bash
@@ -196,7 +206,6 @@ cowork-flow sync . --dry-run
 
 ```bash
 ./.cowork-flow/run get-context
-./.cowork-flow/run project-context refresh
 ./.cowork-flow/run task list
 ./.cowork-flow/run task next
 ```
@@ -216,18 +225,35 @@ cowork-flow sync . --dry-run
 ./.cowork-flow/run task start <task-dir>
 ```
 
-`task next` is read-only. It reports the active task, status, blockers, and the
-next safe command before the main session starts work, dispatches fixed agents,
-checks, archives, or records the session.
-
-`project-context refresh` 会创建或刷新 `.cowork-flow/project-context.md`。生成块由
-本地项目文件确定，`Manual Notes` 区保留人工补充；该文件是项目索引，不替代
-`AGENTS.md`、`.cowork-flow/workflow.md` 或 `.cowork-flow/spec/`。
+`task next` 只读，不推进状态。它根据当前会话任务和 `task.json.status`
+报告当前任务、阻塞项和下一条安全命令；主会话在启动工作、派发固定代理、
+进入检查、归档或记录 session 前都应先看它。
 
 L2 任务的 readiness gate 会在 `task start` 前阻塞缺失的 proposal/spec/design、
 计划、任务链接、边界、假设、验收标准或 verification commands；同一 blocker
 会出现在 `task next` 输出中。
 
+任务状态流转：
+
+```mermaid
+stateDiagram-v2
+    [*] --> NoTask
+    state "无当前任务" as NoTask
+    state "planning" as Planning
+    state "in_progress" as InProgress
+    state "review" as Review
+    state "completed" as Completed
+    state "已归档" as Archived
+
+    NoTask --> Planning: task create
+    Planning --> InProgress: task start
+    InProgress --> Review: task review
+    Review --> Completed: task complete
+    Completed --> Archived: task archive
+    Completed --> NoTask: task finish
+    Archived --> [*]
+```
+
 任务状态由阶段命令推进，`task next` 只读取状态：
 
 | 阶段 | 命令 | `task.json.status` |
@@ -236,11 +262,13 @@ L2 任务的 readiness gate 会在 `task start` 前阻塞缺失的 proposal/spec
 | 开始执行 | `task start <task-dir>` | `in_progress` |
 | 进入检查 | `task review [task-dir]` | `review` |
 | 检查完成 | `task complete [task-dir]` | `completed` |
+| 归档任务 | `task archive <task-name>` | 归档副本保持 `completed` |
 | 清会话指针 | `task finish` | 不改变状态 |
 
 执行 plan 时使用固定 cowork agents：
 
-主会话负责创建/启动任务、维护计划与收口验证；可并行的实现或检查工作通过 Codex subagent 交给固定角色 agent。
+主会话负责创建/启动任务、维护计划与收口验证；实现和检查默认通过当前 Host Adapter
+派发给固定角色 agent。固定 agent 是叶子执行者，不能再派发其他 agent，也不能替代主会话完成归档、记录 session 或提交。
 
 ```text
 ./.cowork-flow/run subagent init --role implement --agent-type cowork-implement --execution-task-dir <task-dir> --title "<title>"
@@ -255,7 +283,7 @@ cowork_host_context_key: <host_context_key>
 
 子代理首步执行 `./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>`；主会话验收前必须确认 runtime context 中 `status=bound` 且 `bound_context_key` 匹配。默认角色为 `cowork-research`、`cowork-implement`、`cowork-check`，任务上下文来自已绑定 runtime context，而不是 prompt 形状。
 
-Codex hook 启用后，每轮会自动注入 `<workflow-state>`，其中包含入口分类、当前任务、状态来源和下一步流程提示。状态文本来自 `.cowork-flow/spec/contracts/workflow-state-templates.md`；`workflow.md` 只描述流程，不内联状态片段。hook 不替代主会话验收；它只负责把 task 状态和 workflow gate 放进上下文。
+Host hook/plugin 启用后，每轮会自动注入 workflow state，其中包含入口分类、当前任务、状态来源和下一步流程提示。状态文本来自 `.cowork-flow/spec/contracts/workflow-state-templates.md`；`workflow.md` 只描述流程，不内联状态片段。hook 不替代主会话验收；它只负责把 task 状态和 workflow gate 放进上下文。
 
 记录 session：
 
@@ -314,3 +342,9 @@ npm run release -- prerelease
 ```
 
 脚本会在任一步骤失败时停止后续发布动作。CI 仍会运行 Node CLI 测试、npm pack 内容检查和现有 Python 模板测试；GitHub Actions 的 `Publish npm Package` workflow 仍需要在仓库 secrets 中配置 `NPM_TOKEN`。
+
+可选集成测试位于 `tests/integration/`，依赖 Python 环境中的 `pytest`。它不属于默认发布链；需要验证时运行：
+
+```bash
+npm run test:integration
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "CLI for installing and maintaining cowork-flow collaboration templates.",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
   "scripts": {
     "test": "node --test",
     "test:template": "node scripts/run-template-tests.js",
+    "test:integration": "node scripts/run-integration-tests.js",
     "pack:check": "node scripts/pack-check.js",
     "test:all": "npm test && npm run test:template && npm run pack:check",
     "release": "sh scripts/release.sh"

package/src/commands/init.js

@@ -195,7 +195,7 @@ function initialIndexContent(name) {
 - Sessions are appended to the journal file
 - A new journal file is created automatically after the current file exceeds 2000 lines
 - Use \`add_session.py\` to record sessions
-- New records use English text; legacy records can remain as they are
+- New records use English text; existing records can remain as they are
 `;
 }
 

package/src/commands/update.js

@@ -6,10 +6,8 @@ import {
 } from '../lib/package-info.js';
 
 function validateUpdateArgs(args) {
-  for (const arg of args) {
-    if (arg !== '--global' && arg !== '--yes') {
-      throw new Error(`Unknown update option: ${arg}`);
-    }
+  if (args.length > 0) {
+    throw new Error(`Unknown update option: ${args[0]}`);
   }
 }
 

package/src/lib/copy-template.js

@@ -1,5 +1,5 @@
 import { constants } from 'node:fs';
-import { access, chmod, copyFile, mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import { access, chmod, copyFile, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname, join, relative } from 'node:path';
 
 import { templateRoot } from './paths.js';
@@ -47,14 +47,17 @@ export async function buildInitPlan(targetDir, options = {}) {
       continue;
     }
 
-    if (toTemplatePath(file) === '.cowork-flow/.version') {
+    const templatePath = toTemplatePath(file);
+    if (templatePath === '.cowork-flow/.version') {
       continue;
     }
 
     const source = join(templateRoot, file);
     const destination = join(targetDir, file);
     const exists = await pathExists(destination);
-    const action = exists ? (options.force ? 'update' : 'skip') : 'create';
+    const action = exists
+      ? (options.force && templatePath !== '.cowork-flow/.developer' ? 'update' : 'skip')
+      : 'create';
     actions.push({ action, source, destination, relativePath: file });
   }
 
@@ -99,6 +102,41 @@ const SAFE_SYNC_FILES = new Set([
   '.cowork-flow/spec/contracts/workflow-state-templates.md'
 ]);
 
+const OBSOLETE_SYNC_FILES = new Set([
+  '.cowork-flow/project-context.md',
+  '.cowork-flow/scripts/add_session.py',
+  '.cowork-flow/scripts/change.py',
+  '.cowork-flow/scripts/doctor.py',
+  '.cowork-flow/scripts/get_context.py',
+  '.cowork-flow/scripts/get_developer.py',
+  '.cowork-flow/scripts/init_developer.py',
+  '.cowork-flow/scripts/party_mode_v2.py',
+  '.cowork-flow/scripts/project_context.py',
+  '.cowork-flow/scripts/resume.py',
+  '.cowork-flow/scripts/subagent.py',
+  '.cowork-flow/scripts/task.py',
+  '.cowork-flow/scripts/common/active_task.py',
+  '.cowork-flow/scripts/common/archive_utils.py',
+  '.cowork-flow/scripts/common/coding_standards.py',
+  '.cowork-flow/scripts/common/config.py',
+  '.cowork-flow/scripts/common/developer.py',
+  '.cowork-flow/scripts/common/execution_context.py',
+  '.cowork-flow/scripts/common/files.py',
+  '.cowork-flow/scripts/common/gates.py',
+  '.cowork-flow/scripts/common/git_context.py',
+  '.cowork-flow/scripts/common/git_snapshot.py',
+  '.cowork-flow/scripts/common/paths.py',
+  '.cowork-flow/scripts/common/readiness.py',
+  '.cowork-flow/scripts/common/state_machine.py',
+  '.cowork-flow/scripts/common/task_utils.py',
+  '.cowork-flow/scripts/common/tdd_evidence.py',
+  '.cowork-flow/scripts/common/test_intent.py',
+  '.cowork-flow/scripts/common/validate_coding_standards.py',
+  '.cowork-flow/scripts/common/validate_implementation.py',
+  '.cowork-flow/scripts/common/validate_rules.py',
+  '.cowork-flow/spec/contracts/entry-contract.md'
+]);
+
 const COWORK_FLOW_START = '<!-- COWORK-FLOW:START -->';
 const COWORK_FLOW_END = '<!-- COWORK-FLOW:END -->';
 
@@ -200,6 +238,13 @@ export async function buildSyncPlan(targetDir, options = {}) {
     }
   }
 
+  for (const file of OBSOLETE_SYNC_FILES) {
+    const destination = join(targetDir, file);
+    if (await pathExists(destination)) {
+      actions.push({ action: 'delete', source: null, destination, relativePath: file });
+    }
+  }
+
   actions.push({
     action: 'update',
     source: null,
@@ -226,7 +271,7 @@ export async function detectInstalledPlatforms(targetDir) {
 }
 
 export function summarizePlan(actions, dryRun = false) {
-  const counts = { create: 0, update: 0, skip: 0, protected: 0 };
+  const counts = { create: 0, update: 0, skip: 0, protected: 0, delete: 0 };
   for (const action of actions) {
     counts[action.action] += 1;
   }
@@ -234,7 +279,8 @@ export function summarizePlan(actions, dryRun = false) {
   const prefix = dryRun ? 'dry-run ' : '';
   const createLabel = dryRun ? 'would-create' : 'created';
   const updateLabel = dryRun ? 'would-update' : 'updated';
-  return `${prefix}${createLabel}=${counts.create} ${updateLabel}=${counts.update} skipped=${counts.skip} protected=${counts.protected}\n`;
+  const deleteLabel = dryRun ? 'would-delete' : 'deleted';
+  return `${prefix}${createLabel}=${counts.create} ${updateLabel}=${counts.update} ${deleteLabel}=${counts.delete} skipped=${counts.skip} protected=${counts.protected}\n`;
 }
 
 export async function applyPlan(actions, options = {}) {
@@ -246,6 +292,10 @@ export async function applyPlan(actions, options = {}) {
     if (item.action === 'skip' || item.action === 'protected') {
       continue;
     }
+    if (item.action === 'delete') {
+      await rm(item.destination, { force: true });
+      continue;
+    }
 
     await mkdir(dirname(item.destination), { recursive: true });
     if (item.content !== undefined) {

package/src/lib/platforms.js

@@ -1,10 +1,7 @@
 export const SUPPORTED_PLATFORMS = ['codex', 'opencode', 'claude-code'];
 
-const LEGACY_BOTH_PLATFORMS = ['codex', 'opencode'];
-
 const PLATFORM_ALIASES = new Map([
   ['all', SUPPORTED_PLATFORMS],
-  ['both', LEGACY_BOTH_PLATFORMS],
   ['codex', ['codex']],
   ['opencode', ['opencode']],
   ['claude', ['claude-code']],

package/template/.agents/skills/before-dev/SKILL.md

@@ -1,32 +1,144 @@
 ---
 name: before-dev
-description: Use before writing code in a cowork-flow project to load project-specific guidelines, active task context, and verification expectations.
+description: MANDATORY GATE — call before ANY code change, file edit, or subagent dispatch. Checks workflow state and either allows or blocks the action.
 ---
 
-# Before Dev
+# Before Dev — 编码前工作流门禁
 
-Use this immediately before code edits.
+This skill is the enforcement point for the cowork-flow workflow. You MUST invoke it
+before any file edit, code change, or subagent dispatch. It reads the current
+`<workflow-state>` block and decides whether to allow or block.
 
-## Read
+This skill is NOT a checklist or context loader — it is a gate. Do not proceed to
+code changes without passing through this gate.
 
-1. `AGENTS.md`
-2. `.cowork-flow/workflow.md`
-3. Active task `prd.md`
-4. Active task `implement.jsonl`
-5. Relevant `.cowork-flow/spec/*/index.md`
-6. Any exact files named by the task, plan, or user
-7. If the task changes behavior, locate or create `tdd.jsonl` evidence before implementation.
+**豁免**: 只读问答、纯查询命令（`git status`、`task next`、`task current`）、
+用户明确说"直接改，跳过流程"。
 
-Do not bulk-load unrelated tasks, archived sessions, or every spec file.
+---
+
+## Step 1: 读取当前 workflow 状态
+
+从上下文中读取 `<workflow-state>` 块。关注 `Status` 和 `Source` 字段。
+
+如果上下文中**没有** `<workflow-state>` 块，说明当前平台的 hook/plugin 未向此上下文注入状态。
+此时检查用户 prompt 中是否包含 `cowork_runtime_context_id`：
+
+- **有 `cowork_runtime_context_id`** → 你是通过 prompt transport 接收 runtime context 的子代理，但平台 hook 未注入 workflow-state。直接进入下方的 `delegated_subtask` 分支，执行 bind、加载任务、完成叶子工作。
+- **无 `cowork_runtime_context_id`** → 无法判断当前上下文身份。
+
+回复：
+```
+无法从上下文中确定 workflow 状态（无 <workflow-state> 块，无 runtime context ID）。
+请运行 resume 恢复任务状态，或运行 task start 创建新任务。
+```
+
+这是 fail-closed 回退——只在 Codex/OpenCode hook 正常工作时永不触发。
+
+## Step 2: 按状态执行
+
+### Status = `no_task`
+
+**⛔ 阻断。** 当前没有活动任务。
+
+你必须**拒绝**执行任何代码变更、文件编辑、子代理派发。回复用户：
+
+```
+当前没有活动任务。实现、重构或行为变更必须先创建任务。
+
+建议:
+1. 新需求方向不明确 → 先 brainstorming 明确方向
+2. 需求已明确 → writing-plans → task create → task start
+3. 恢复已有任务 → continue
+
+要走哪个方向？
+```
+
+只读问答可以直接回答，但不要修改任何文件。
+
+### Status = `delegated_subtask`
+
+你是子代理。按 bound runtime context 执行：
+- 运行 `./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>` 绑定
+- 加载任务目录和分配内容
+- 不要执行 start/resume/task start/task archive/commit/spawn
+- 完成分配的叶子工作
+
+### Status = `planning`
+
+**⛔ 阻断实现。** 任务在计划阶段，尚未就绪。
+
+回复用户：
+
+```
+任务仍在计划阶段，尚未就绪进入实现。
+
+需要先:
+1. 完善 prd.md（目标、范围、验收标准）
+2. 整理 implement.jsonl 和 check.jsonl
+3. 运行 task next 确认准备状态
+4. 运行 task start 进入实现阶段
+
+现在继续计划工作？
+```
+
+**例外**: 如果用户明确要求做的是"计划工作"（写 prd.md、整理 jsonl），可以继续，
+但只能编辑任务计划文件，不能开始实现代码。
+
+### Status = `in_progress`
+
+**✅ 放行。** 任务正在执行中。
+
+加载任务上下文后继续：
+1. 读取 `<task>/prd.md`
+2. 读取 `<task>/implement.jsonl`
+3. 读取相关 spec 文件
+4. 行为变更任务：确认 `<task>/tdd.jsonl` red evidence 存在
+5. 声明确认的假设、成功标准、涉及文件、验证命令
+6. 继续实现
+
+主会话派发固定代理时，必须使用 runtime context dispatch 协议。
+
+### Status = `review`
+
+**⚠️ 任务在检查阶段。** 实现应已完成。
+
+回复用户：
+
+```
+任务在检查阶段，实现应已完成。
+
+建议:
+1. 运行 cowork-check 验证
+2. 检查通过后 task complete
+3. 如果需要小修复，在 check 范围内直接修
+
+当前需要执行检查还是修复？
+```
+
+不要开始新的实现工作，除非是小修复。
+
+### Status = `completed`
+
+**⛔ 阻断。** 任务已完成。
+
+回复用户：
+
+```
+任务已完成。不要针对已完成任务派发新的实现工作。
+
+如果发现遗漏:
+1. task archive 归档旧任务
+2. 创建新任务
+3. 走完整流程
 
-## Confirm
+需要创建新任务吗？
+```
 
-State briefly:
+### Status = `stale` 或 `unknown`
 
-- Assumptions.
-- Success criteria.
-- Files or modules likely to change.
-- Verification command you expect to run.
-- Whether fixed agents or inline work are appropriate.
+任务状态异常。回复用户：
 
-If the task is a bounded subagent prompt, do not convert it into main-session planning.
+```
+任务状态异常 (<status>)。请运行 task next 和 resume 确认当前状态后再继续。
+```

package/template/.agents/skills/check/SKILL.md

@@ -12,11 +12,16 @@ Use this after implementation and before `finish-work`.
 1. Read active task PRD, plan, and `check.jsonl`.
 2. Review `git diff --name-only` and `git diff`.
 3. Check contracts across caller/callee, command output, persisted state, templates, and docs.
-4. Confirm `.cowork-flow/spec/` is updated or explicitly unchanged.
-5. Review test intent: reject shallow tests that do not fail for meaningful behavior breaks.
-6. Run focused tests that would fail if the changed behavior broke.
-7. Run broader validation when the change touches shared runtime, templates, packaging, or public workflow.
-8. Report `test_intent_review` with the key tests that defend PRD acceptance behavior.
+4. Verify spec compliance:
+   - Read each spec file listed in `check.jsonl`.
+   - For each guideline in the spec, check the diff for violations (naming, structure, encoding, error handling, quality gates).
+   - Spec files not listed in `check.jsonl` do not apply to this check.
+5. Confirm `.cowork-flow/spec/` is updated or explicitly unchanged.
+6. Review test intent: reject shallow tests that do not fail for meaningful behavior breaks.
+7. Run focused tests that would fail if the changed behavior broke.
+8. Run broader validation when the change touches shared runtime, templates, packaging, or public workflow.
+9. Report `test_intent_review` with the key tests that defend PRD acceptance behavior.
+10. Report spec compliance: for each spec/ file checked, state pass/fail with evidence from the diff.
 
 ## Report
 

package/template/.agents/skills/game-design/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: game-design
+description: Use when working on game development tasks — architecture, engine selection, asset pipelines, performance analysis, or multiplayer networking.
+---
+
+# Game Design
+
+Use this skill when the task involves game development: engine selection, game architecture, asset pipeline configuration, performance tuning, or multiplayer networking. It provides domain-specific guidelines that complement the general `cowork-implement` workflow.
+
+## When to use
+
+- Engine architecture decisions (ECS vs OOP, scene organization)
+- Asset pipeline setup or optimization
+- Performance profiling and optimization
+- Multiplayer networking and synchronization
+- Any task that references `.cowork-flow/spec/game/` guides
+
+## Domain Guidelines
+
+The following guidelines live in `.cowork-flow/spec/game/` and should be read before implementing game-related code:
+
+| File | Covers |
+|------|--------|
+| `engine-guidelines.md` | ECS vs OOP, scene/level organization, plugin strategy |
+| `asset-pipeline.md` | Asset directory layout, build stages, LOD policy, Git LFS |
+| `performance-guidelines.md` | FPS targets, memory budgets, GC, draw calls, profiling workflow |
+| `multiplayer-guidelines.md` | Network models, sync strategies, lag compensation, matchmaking |
+
+## Usage
+
+1. Read the relevant spec/game/ guide(s) first.
+2. Read the task PRD and implement.jsonl context.
+3. Proceed with implementation through `cowork-implement` or directly (depending on scope).
+
+## When NOT to use
+
+- Pure backend/CRUD work with no game domain concerns
+- Frontend UI that doesn't involve game-specific rendering or input
+- General infrastructure tasks

package/template/.claude/agents/cowork-check.md

@@ -1,41 +1,51 @@
 ---
 name: cowork-check
 description: Cowork-flow check fixed subagent.
-tools: Read, Write, Edit, MultiEdit, Grep, Glob, LS, Bash
+tools: Read, Write, Edit, Grep, Glob, LS, Bash, Skill
 ---
 
-You are the `cowork-check` fixed subagent for Claude Code.
-You are a leaf executor and must not invoke other agents.
+You are the `cowork-check` subagent.
 
-Formal `cowork-check` work requires a bound runtime context. The prompt, host
-metadata, or environment must provide:
+You are a leaf executor. Do not coordinate other agents.
+
+Formal `cowork-check` work requires runtime-context dispatch. The prompt or
+host metadata must provide:
 
 ```text
 cowork_runtime_context_id: <runtime_context_id>
 cowork_host_context_key: <host_context_key>
 ```
 
-The hook may bind that id to
-`.cowork-flow/.runtime/subagents/<runtime_context_id>.json` before workflow
-state is injected. The first child step must still run:
+The hook may bind that id to `.cowork-flow/.runtime/subagents/<runtime_context_id>.json`
+before workflow state is injected. The first child step must still run:
 
 ```bash
 ./.cowork-flow/run subagent bind <runtime_context_id> <host_context_key>
 ```
 
-If the explicit bind fails, or if the bound context is missing, closed, invalid,
-or names another agent type, report `needs_context` and stop. Do not use
-`COWORK_ENTRY_CONTRACT_V1` to infer subagent identity; that contract classifies
-main-session prompts only.
+On Windows (cmd/PowerShell), use:
 
-Rules:
+```cmd
+.\.cowork-flow\run.cmd subagent bind <runtime_context_id> <host_context_key>
+```
 
-- Read the task directory from the bound runtime context.
-- Read `<task>/prd.md`, `<task>/check.jsonl`, `git diff`, and each JSONL `file`
-  entry.
-- Check acceptance criteria, tests, scope, and spec sync.
-- Fix in-scope issues directly when small and clear.
-- Report findings, fixes, and exact verification commands.
+If the explicit bind fails, or if the bound runtime context is missing, closed,
+invalid, or names another agent type, report `needs_context` and do not execute
+the task.
+
+Load context before checking:
+1. Read the task directory from the bound runtime context.
+2. Read `<task>/prd.md`.
+3. Read `<task>/check.jsonl`.
+4. Read `git diff`.
+5. Include `test_intent_review` in the review output for meaningful behavior
+   breaks coverage and shallow tests rejection.
+
+Rules:
+- Fix issues directly when they are clearly in scope.
 - Do not use the Task tool or invoke subagents.
-- Do not run task start, task finish, task archive, unscoped resume, commit, or
-  push.
+- MUST NOT spawn, wait for, list, or close other agents.
+- MUST NOT commit, archive, or mutate cowork-flow task state.
+- Report findings, changed files, and exact verification commands.
+- Include test intent findings that map tests back to PRD acceptance or
+  regression behavior.