cowork-flow 0.0.42 → 0.0.44

package/README.md

@@ -39,10 +39,9 @@ template/
 ├── .codex/                    # Codex agents / hooks / config
 ├── .claude/                   # Claude Code settings / agents / hooks
 ├── .opencode/                 # OpenCode agents / commands / plugins
-├── .zcode/                    # ⭐ ZCode 插件（hooks + runtime + scaffold）
+├── .zcode/                    # ⭐ ZCode 插件（hooks + skills + scaffold instructions）
 └── .cowork-flow/
     ├── config.yaml            # 项目配置
-    ├── workflow.md            # 主流程定义
     ├── scripts/               # Python 运行时
     ├── spec/                  # 规范文档（contracts / schemas / guides）
     ├── changes/               # 行为变更管理
@@ -58,17 +57,19 @@ template/
 - **Host Asset Manifest**：`spec/runtime/host-assets.json` 是宿主资产、平台识别、同步策略和 obsolete 迁移清单的权威来源。新增平台或资产时更新 Manifest 与 schema，不在 CLI 中新增硬编码集合。
 - **事务式 init/sync**：CLI 先构建不可变 Asset Plan，在同文件系统 staging 中校验 hash/权限，再按备份清单提交；失败时逆序回滚，`.cowork-flow/.version` 最后更新。
 - **共享 Hook 核心**：Codex 与 Claude Code Hook 只做宿主输入适配，工作流状态解析由 `scripts/common/host/workflow_state_hook.py` 统一实现。
+- **流程内核**：公开任务入口只有 `task next`；阶段动作由内核动作表推荐对应 Skill，硬门禁由 runtime gate 执行，不再分发独立流程中枢文件或 Skill 注册控制面。
+- **Skill 自带脚本**：只服务单个 Skill 的控制器或辅助脚本放在 `template/skills/<skill-id>/scripts/`，由 `.cowork-flow/run` 薄分发；`scripts/` 内核只保留任务导航、生命周期、gate、host/runtime、存储和分发所需代码。
 
 ## Skills 分发机制
 
-Skills 维护在 `template/skills/` 唯一源码，`init` 时按平台分发到对应目录：
+Skills 维护在 `template/skills/` 唯一源码，`init` / `sync` 时按目录分发到对应平台；`SKILL.md`、可选的 command `manifest.json` 和 `scripts/` 一起归属该 Skill：
 
 | 平台 | 目标目录 |
 |---|---|
 | `codex` / `opencode` | `.agents/skills/` |
 | `claude-code` | `.claude/skills/` |
 
-分发动作：`batch-mode`、`brainstorming`、`break-loop`、`cowork-flow`、`doubt-review`、`game-design`、`party-mode`、`writing-plans`
+分发动作：`adversarial-review`、`agent-dispatch`、`batch-execution`、`brainstorming`、`cowork-flow`、`cowork-flow-maintenance`、`decision-audit`、`failure-analysis`、`game-design`、`party-mode`、`python-runtime-design`、`runtime-health`、`spec-sync`、`task-planning`、`task-review`、`test-first`
 
 ## CLI 命令
 
@@ -92,7 +93,7 @@ Skills 维护在 `template/skills/` 唯一源码，`init` 时按平台分发到
 
 - **自动识别**已安装 host 目录，只同步对应平台资产
 - **Skills** 从 `template/skills/` 按平台分发
-- **保护文件**：`config.yaml`、`workflow.md`、`spec/`（除 `workflow-state-templates.md`）、任务、计划、变更、workspace
+- **保护文件**：`config.yaml`、`spec/`（除 `workflow-state-templates.md`）、任务、计划、变更、workspace
 - **正式版旧资产清理**：旧脚本位置、旧 adapter 资产和已废弃文件按 Host Asset Manifest 的 `obsoleteFiles` 清理；用户保护文件保持不变
 - **事务恢复**：上次未完成事务会在新一轮 sync 前恢复；事务元数据缺失或损坏时 fail-closed，不在未知状态上继续写入
 - `--force` 整文件覆盖保护文件
@@ -106,6 +107,8 @@ cowork-flow install-zcode-plugin --force  # 覆盖已安装
 
 安装到 `~/.zcode/cli/plugins/cache/zcode-plugins-official/cowork-flow/<version>/`
 
+ZCode 插件只安装 hook、skills 和轻量说明文件；`.cowork-flow/` 流程文件仍由显式 `cowork-flow init` / `cowork-flow sync` 在项目根目录管理。插件不会通过 scaffold 创建 `.cowork-flow/`，因此不会在多模块项目的模块目录重复落盘流程文件。
+
 **Hook 注入内容：**
 - `workflow-state` — 当前任务状态
 - `contract-digest` — 合同摘要（SHA256 fingerprint）
@@ -117,19 +120,17 @@ cowork-flow install-zcode-plugin --force  # 覆盖已安装
 changes → brainstorming → read spec → plan → tasks → implement → check → complete
 ```
 
-| 阶段 | 命令 | status |
+`./.cowork-flow/run task next` 是唯一公开任务流程入口。它读取当前状态，输出下一步 action、激活 Skill、runtime gate、blocker，以及可执行时的 `task next --run` 命令。
+
+| action | 入口 | status 结果 |
 |---|---|---|
-| 创建/计划 | `task create` | `planning` |
-| 开始执行 | `task start <dir>` | `in_progress` |
-| 进入检查 | `task review [dir]` | `review` |
-| 检查完成 | `task complete [dir]` | `completed` |
-| 归档 | `task archive <name>` | `completed`（归档副本） |
-| 清会话指针 | `task finish` | 不变 |
-
-> Batch 使用任务图和持久化 Host action：运行
-> `task start <parent-task> --auto --approved` 获取 `next_action`，
-> Host 完成真实生命周期动作后用 `task batch-record-result <batch-id> --file <result.json>`
-> 回写结果；失败会暂停，可用 `task batch-resume <batch-id>` 生成新的重试动作。
+| `create_task` | `task next --run --title "<title>" --slug <name> --assignee <name>` | `planning` |
+| `start_task` | `task next <dir> --run` | `in_progress` |
+| `request_review` | `task next <dir> --run --intent review` | `review` |
+| `complete_task` | `task next <dir> --run --intent review` | `completed` |
+| `archive_task` | `task next <dir> --run --intent archive` | 归档副本保持 `completed` |
+
+Batch 使用任务图和持久化 Host action：运行 `task next <parent-task> --run --intent batch --auto --approved` 获取 `next_action`；Host 完成真实生命周期动作后继续通过 `task next` 导航，不暴露独立 batch 子命令。
 
 ## 常用命令
 
@@ -140,16 +141,20 @@ changes → brainstorming → read spec → plan → tasks → implement → che
 
 # 上下文
 ./.cowork-flow/run get-context
-./.cowork-flow/run task list
 ./.cowork-flow/run task next
+./.cowork-flow/run task next --json
+./.cowork-flow/run task next --list
+./.cowork-flow/run task next <dir> --validate
 
 # 变更
 ./.cowork-flow/run change create <slug>
 ./.cowork-flow/run change validate <slug>
 
 # 任务
-./.cowork-flow/run task create "<title>" --slug <name>
-./.cowork-flow/run task start <dir>
+./.cowork-flow/run task next --run --title "<title>" --slug <name> --assignee <name>
+./.cowork-flow/run task next <dir> --run
+./.cowork-flow/run task next <dir> --run --intent review
+./.cowork-flow/run task next <dir> --run --intent archive
 
 # 子代理
 ./.cowork-flow/run subagent init --role implement --agent-type cowork-implement --execution-task-dir <dir> --title "<title>"
@@ -170,14 +175,25 @@ runtime 发出的 host-neutral action、记录执行结果并纠偏漂移。
 
 ## 发布
 
+测试按反馈速度和覆盖范围分层：
+
+```bash
+npm run test:fast          # 快速 Node 测试，等价于 npm test
+npm run test:integration   # init/sync 关键集成路径
+npm run test:node:full     # 完整 Node 测试
+npm run test:template      # 核心模板集成测试
+npm run test:template:full # 完整模板 Python discovery
+npm run test:all           # 发布前全量测试与打包检查
+```
+
 ```bash
 npm run release          # patch
 npm run release -- minor # minor
 ```
 
 **发布流程：**
-1. `npm test`、`npm run test:template`、`npm run pack:check`、`git diff --check`
-2. 稳定性变更使用 `COWORK_TEMPLATE_TEST_REPEAT=3` 和固定 `COWORK_TEMPLATE_TEST_SEED` 重复运行模板测试
+1. `npm run test:all`、`git diff --check`
+2. 稳定性变更使用 `COWORK_TEMPLATE_TEST_REPEAT=3` 和固定 `COWORK_TEMPLATE_TEST_SEED` 重复运行 `npm run test:template:full`
 3. `npm version` 升级版本
 4. 同步版本到 `template/.cowork-flow/.version` 和 `template/.zcode/.zcode-plugin/plugin.json`
 5. `git commit` + `git tag`
@@ -191,5 +207,5 @@ Windows 上发布前使用 `run.cmd` 入口验证；POSIX shell 专属 release
 
 - 以目标项目事实为准，不把模板内容当成项目事实
 - 保留有价值的流程骨架，删除不存在的场景
-- 项目差异写入 `AGENTS.md`、`workflow.md`、`config.yaml`、`spec/`
+- 项目差异写入 `AGENTS.md`、`config.yaml`、`spec/` 或项目自有 Skill；不要恢复第二套流程中枢文档
 - 不为了替换项目命令而改写通用 skill

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "description": "CLI for installing and maintaining cowork-flow collaboration templates.",
   "type": "module",
   "bin": {
@@ -16,10 +16,14 @@
     "!template/**/*.pyc"
   ],
   "scripts": {
-    "test": "node --test",
-    "test:template": "node scripts/run-template-tests.js",
+    "test": "npm run test:fast",
+    "test:fast": "node --test test/asset-plan.test.js test/cli.test.js test/host-assets.test.js test/opencode-plugin.test.js test/template-runner.test.js test/update.test.js test/zcode-plugin.test.js",
+    "test:integration": "node --test --test-name-pattern=\"^(init copies the template into a new target directory|sync updates safe template files and preserves protected files)$\" test/init.test.js test/sync.test.js",
+    "test:node:full": "node --test",
+    "test:template": "node scripts/run-template-tests.js --suite core",
+    "test:template:full": "node scripts/run-template-tests.js --suite full",
     "pack:check": "node scripts/pack-check.js",
-    "test:all": "npm test && npm run test:template && npm run pack:check",
+    "test:all": "npm run test:node:full && npm run test:template:full && npm run pack:check",
     "release": "sh scripts/release.sh"
   },
   "engines": {

package/src/commands/install-zcode-plugin.js

@@ -72,7 +72,6 @@ export async function runInstallZCodePlugin(args = []) {
   const { dryRun, force } = parseArgs(args);
   const pluginSrc = join(templateRoot, ".zcode");
   const skillsSrc = join(templateRoot, "skills");
-  const specSrc = join(templateRoot, ".cowork-flow", "spec");
   const { version } = await readPackageInfo();
 
   if (!(await pathExists(pluginSrc))) {
@@ -81,9 +80,6 @@ export async function runInstallZCodePlugin(args = []) {
   if (!(await pathExists(skillsSrc))) {
     throw new Error(`Skills source missing at ${skillsSrc}. Reinstall cowork-flow.`);
   }
-  if (!(await pathExists(specSrc))) {
-    throw new Error(`Spec source missing at ${specSrc}. Reinstall cowork-flow.`);
-  }
 
   const cacheRoot = await getZCodeCacheDir();
   const destDir = join(cacheRoot, version);
@@ -98,7 +94,6 @@ export async function runInstallZCodePlugin(args = []) {
     console.log(`[dry-run] Would install ZCode plugin:`);
     console.log(`  Plugin: ${pluginSrc} -> ${destDir}`);
     console.log(`  Skills: ${skillsSrc} -> ${join(destDir, 'skills')}`);
-    console.log(`  Spec: ${specSrc} -> ${join(destDir, 'scaffold', '.cowork-flow', 'spec')}`);
     return;
   }
 
@@ -110,16 +105,9 @@ export async function runInstallZCodePlugin(args = []) {
   // Copy plugin runtime (.zcode-plugin/, hooks/, runtime/, scaffold/) from .zcode/
   await cp(pluginSrc, destDir, { recursive: true });
 
-  // Sync package.json version to scaffold/.version so the plugin-only launcher
-  // can resolve the correct versioned plugin cache path at runtime.
-  const scaffoldVersionPath = join(destDir, "scaffold", ".cowork-flow", ".version");
-  await writeFile(scaffoldVersionPath, `${version}\n`, "utf8");
-
-  // Materialize scaffold specs from the main template instead of maintaining
-  // a second static copy under template/.zcode/scaffold/.
-  const scaffoldSpecDest = join(destDir, "scaffold", ".cowork-flow", "spec");
-  await rm(scaffoldSpecDest, { recursive: true, force: true });
-  await cp(specSrc, scaffoldSpecDest, { recursive: true, force: true });
+  // ZCode may apply plugin scaffold files to each workspace folder. Keep
+  // workflow runtime files out of scaffold; explicit init/sync owns .cowork-flow.
+  await rm(join(destDir, "scaffold", ".cowork-flow"), { recursive: true, force: true });
 
   // Sync canonical scripts from main template (single source of truth).
   // The .zcode/hooks/runtime/scripts/ copy is stale; overwrite with the

package/src/lib/copy-template.js

@@ -1,5 +1,5 @@
 import { constants } from 'node:fs';
-import { access, readFile, readdir } from 'node:fs/promises';
+import { access, readFile, readdir, stat } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 
 import { createAssetPlan, planActions } from './asset-plan.js';
@@ -7,7 +7,6 @@ import { hostRegistry } from './host-assets.js';
 import { applyAssetPlan } from './plan-applier.js';
 import { templateRoot } from './paths.js';
 import { shouldIncludeForPlatforms, skillDestinationForPlatform } from './platforms.js';
-import { skillRegistry } from './skill-registry.js';
 
 async function pathExists(path) {
   try {
@@ -41,6 +40,83 @@ function toTemplatePath(relativePath) {
   return relativePath.replaceAll('\\', '/');
 }
 
+async function listSkillDirs() {
+  const skillsRoot = join(templateRoot, 'skills');
+  const entries = await readdir(skillsRoot, { withFileTypes: true });
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const skillRoot = join(skillsRoot, entry.name);
+    if (await pathExists(join(skillRoot, 'SKILL.md'))) {
+      skills.push({ id: entry.name, sourceRoot: skillRoot });
+    }
+  }
+  return skills.sort((left, right) => left.id.localeCompare(right.id));
+}
+
+async function listSkillFiles(skill) {
+  const sourceRoot = skill.sourceRoot;
+  return (await listFiles(sourceRoot)).map((file) => ({
+    source: join(sourceRoot, file),
+    skillRelativePath: file
+  }));
+}
+
+async function sourceMatchesDestination(source, destination) {
+  try {
+    const [sourceContent, targetContent, sourceStats, targetStats] = await Promise.all([
+      readFile(source),
+      readFile(destination),
+      stat(source),
+      stat(destination)
+    ]);
+    return sourceContent.equals(targetContent)
+      && (sourceStats.mode & 0o777) === (targetStats.mode & 0o777);
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function appendSkillFileActions(actions, {
+  targetDir,
+  platforms,
+  seen,
+  sync = false
+}) {
+  for (const skill of await listSkillDirs()) {
+    const skillFiles = await listSkillFiles(skill);
+    for (const platform of platforms) {
+      const destBase = skillDestinationForPlatform(platform);
+      if (!destBase) continue;
+      for (const skillFile of skillFiles) {
+        const destination = join(
+          targetDir,
+          destBase,
+          skill.id,
+          skillFile.skillRelativePath
+        );
+        if (seen.has(destination)) continue;
+        seen.add(destination);
+        const exists = await pathExists(destination);
+        const unchanged = sync && exists
+          ? await sourceMatchesDestination(skillFile.source, destination)
+          : false;
+        actions.push({
+          action: exists ? (sync ? (unchanged ? 'skip' : 'update') : 'skip') : 'create',
+          source: skillFile.source,
+          destination,
+          relativePath: join(destBase, skill.id, skillFile.skillRelativePath)
+        });
+      }
+    }
+  }
+}
+
 export async function buildInitPlan(targetDir, options = {}) {
   const files = await listFiles(templateRoot);
   const actions = [];
@@ -67,21 +143,7 @@ export async function buildInitPlan(targetDir, options = {}) {
     actions.push({ action, source, destination, relativePath: file });
   }
 
-  for (const entry of skillRegistry.publicEntries) {
-    for (const platform of platforms) {
-      const destBase = skillDestinationForPlatform(platform);
-      if (!destBase) continue;
-      const dest = join(targetDir, destBase, entry.id, 'SKILL.md');
-      if (seen.has(dest)) continue;
-      seen.add(dest);
-      actions.push({
-        action: (await pathExists(dest)) ? 'skip' : 'create',
-        source: join(templateRoot, entry.source),
-        destination: dest,
-        relativePath: join(destBase, entry.id, 'SKILL.md')
-      });
-    }
-  }
+  await appendSkillFileActions(actions, { targetDir, platforms, seen });
 
   const versionDestination = join(targetDir, '.cowork-flow', '.version');
   const versionExists = await pathExists(versionDestination);
@@ -144,6 +206,10 @@ function isSafeSyncFile(relativePath) {
     || templatePath.endsWith('/.gitkeep');
 }
 
+function isCoveredByDeletedParent(relativePath, deletedParents) {
+  return deletedParents.some((parent) => relativePath.startsWith(`${parent}/`));
+}
+
 function replaceManagedBlock(targetContent, templateContent) {
   const targetStart = targetContent.indexOf(COWORK_FLOW_START);
   const targetEnd = targetContent.indexOf(COWORK_FLOW_END, targetStart + COWORK_FLOW_START.length);
@@ -183,9 +249,22 @@ async function buildManagedBlockSyncAction({ source, destination, exists, option
     return { action: 'protected', source, destination, relativePath };
   }
 
+  if (content === targetContent) {
+    return { action: 'skip', source, destination, relativePath };
+  }
+
   return { action: 'update', source, destination, relativePath, content };
 }
 
+async function buildFileSyncAction({ source, destination, relativePath }) {
+  return {
+    action: await sourceMatchesDestination(source, destination) ? 'skip' : 'update',
+    source,
+    destination,
+    relativePath
+  };
+}
+
 export async function buildSyncPlan(targetDir, options = {}) {
   if (!await pathExists(join(targetDir, '.cowork-flow'))) {
     throw new Error(`Target is not initialized: ${targetDir}`);
@@ -221,7 +300,11 @@ export async function buildSyncPlan(targetDir, options = {}) {
     if (protectedFile) {
       actions.push({ action: 'protected', source, destination, relativePath: file });
     } else if (exists && (safeFile || options.force)) {
-      actions.push({ action: 'update', source, destination, relativePath: file });
+      actions.push(await buildFileSyncAction({
+        source,
+        destination,
+        relativePath: file
+      }));
     } else if (!exists) {
       actions.push({ action: 'create', source, destination, relativePath: file });
     } else {
@@ -229,66 +312,36 @@ export async function buildSyncPlan(targetDir, options = {}) {
     }
   }
 
-  for (const entry of skillRegistry.publicEntries) {
-    for (const platform of platforms) {
-      const destBase = skillDestinationForPlatform(platform);
-      if (!destBase) continue;
-      const dest = join(targetDir, destBase, entry.id, 'SKILL.md');
-      if (seen.has(dest)) continue;
-      seen.add(dest);
-      const destExists = await pathExists(dest);
-      const safe = hostRegistry.skillTargets.some(
-        (target) => dest.startsWith(join(targetDir, target))
-      );
-      if (destExists && (safe || options.force)) {
-        actions.push({
-          action: 'update',
-          source: join(templateRoot, entry.source),
-          destination: dest,
-          relativePath: join(destBase, entry.id, 'SKILL.md')
-        });
-      } else if (!destExists) {
-        actions.push({
-          action: 'create',
-          source: join(templateRoot, entry.source),
-          destination: dest,
-          relativePath: join(destBase, entry.id, 'SKILL.md')
-        });
-      }
-    }
-  }
+  await appendSkillFileActions(actions, { targetDir, platforms, seen, sync: true });
 
-  for (const entry of skillRegistry.entries) {
-    if (entry.status === 'active') {
-      continue;
+  const deletedObsoleteParents = [];
+  const obsoleteFiles = [...OBSOLETE_SYNC_FILES].sort((left, right) => {
+    if (left.length !== right.length) {
+      return left.length - right.length;
     }
-    for (const managedPath of entry.managedPaths) {
-      const relativePath = managedPath.slice(0, -1);
-      const destination = join(targetDir, relativePath);
-      if (await pathExists(destination)) {
-        actions.push({
-          action: 'delete',
-          source: null,
-          destination,
-          relativePath
-        });
-      }
+    return left.localeCompare(right);
+  });
+  for (const file of obsoleteFiles) {
+    if (isCoveredByDeletedParent(file, deletedObsoleteParents)) {
+      continue;
     }
-  }
-
-  for (const file of OBSOLETE_SYNC_FILES) {
     const destination = join(targetDir, file);
     if (await pathExists(destination)) {
+      deletedObsoleteParents.push(file);
       actions.push({ action: 'delete', source: null, destination, relativePath: file });
     }
   }
 
+  const versionDestination = join(targetDir, '.cowork-flow', '.version');
+  const versionContent = `${options.version}\n`;
+  const versionUnchanged = await pathExists(versionDestination)
+    && (await readFile(versionDestination, 'utf8')) === versionContent;
   actions.push({
-    action: 'update',
+    action: versionUnchanged ? 'skip' : 'update',
     source: null,
-    destination: join(targetDir, '.cowork-flow', '.version'),
+    destination: versionDestination,
     relativePath: '.cowork-flow/.version',
-    content: `${options.version}\n`
+    content: versionContent
   });
 
   return createAssetPlan({

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

@@ -6,67 +6,23 @@ tools: Read, Write, Edit, Grep, Glob, LS, Bash, Skill
 
 You are the `cowork-check` subagent.
 
-You are a leaf executor. Do not coordinate other agents.
+Read and apply these Skills before review work:
 
-Formal `cowork-check` work requires runtime-context dispatch. The prompt or
-host metadata must provide:
+- `.claude/skills/agent-dispatch/SKILL.md`
+- `.claude/skills/task-review/SKILL.md`
+- `.claude/skills/decision-audit/SKILL.md`
+- `.claude/skills/spec-sync/SKILL.md`
 
-```text
-cowork_runtime_context_id: <runtime_context_id>
-cowork_host_context_key: <host_context_key>
-```
+Execution:
 
-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>
-```
-
-On Windows (cmd/PowerShell), use:
-
-```cmd
-.\.cowork-flow\run.cmd subagent bind <runtime_context_id> <host_context_key>
-```
-
-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>/decision-anchor.md`.
-3. Read the plan file linked from this task (check `<task>/task.json` `relatedFiles` for a plan path, or search `.cowork-flow/plans/` for a plan file referencing this task directory). Use the plan's Verify commands and Expected results as the checklist for each step.
-4. Read `<task>/check.jsonl`.
-5. Read each JSONL `file` entry from `<task>/check.jsonl`.
-6. Read `<task>/quality-review.jsonl` if present and verify machine warning,
-   checklist, and Definition of Done evidence.
-7. Read `git diff`.
-8. Include `test_intent_review` in the review output for meaningful behavior
-   breaks coverage and shallow tests rejection.
-
-Authoritative internal protocols:
-- `.cowork-flow/spec/protocols/review.md`
-- `.cowork-flow/spec/protocols/decision-review.md`
-- `.cowork-flow/spec/protocols/spec-maintenance.md`
-
-Apply their output contracts exactly. Review output must preserve
-`acceptanceId`, `findings`, `test_intent_review`, `resolution`, and
-`specUpdates`.
+1. Follow `agent-dispatch` to bind runtime context. If binding fails, report `needs_context` and stop.
+2. Read the task directory, `decision-anchor.md`, linked plan, the `check.jsonl` context index, every referenced `file` entry, and current `git diff`; do not write review conclusions to JSONL.
+3. Apply `task-review` to verify scope, tests, specs, advisory facts, lifecycle facts, and Definition of Done coverage.
+4. Fix only clearly in-scope issues; otherwise report findings with acceptance IDs, resolutions, `test_intent_review` (test intent review), and verification commands.
 
 Rules:
-- Fix issues directly when they are clearly in scope.
+
 - Do not use the Task tool or invoke subagents.
-- 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 decision-anchor acceptance or
-  regression behavior.
-- Run the deterministic coding gate before accepting quality:
-  `./.cowork-flow/run python .cowork-flow/scripts/common/gates/validate_coding_standards.py --validate --repo-root .`.
-  This gate enforces machine-decidable UTF-8/IO checks; backend/frontend
-  natural-language markdown remains checklist context, not dynamic hard validators.
-- Treat machine warning output as review evidence: fix real issues or require
-  acknowledged warning records in `<task>/quality-review.jsonl`.
-- Verify `<task>/quality-review.jsonl` covers Definition of Done, checklist
-  sources, affected files, and exact verification commands before acceptance.
+- Do not run task start, finish, archive, unscoped resume, commit, or push.
+- Treat backend/frontend natural-language specs as checklist context, not dynamic hard validators.
+- Do not accept shallow tests that would still pass when target behavior breaks.

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

@@ -6,71 +6,24 @@ tools: Read, Write, Edit, Grep, Glob, LS, Bash, Skill
 
 You are the `cowork-implement` subagent.
 
-You are a leaf executor. Do not coordinate other agents.
+Read and apply these Skills before task work:
 
-Formal `cowork-implement` work requires runtime-context dispatch. The prompt or
-host metadata must provide:
+- `.claude/skills/agent-dispatch/SKILL.md`
+- `.claude/skills/decision-audit/SKILL.md`
+- `.claude/skills/spec-sync/SKILL.md`
+- `.claude/skills/test-first/SKILL.md` for behavior changes
 
-```text
-cowork_runtime_context_id: <runtime_context_id>
-cowork_host_context_key: <host_context_key>
-```
+Execution:
 
-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>
-```
-
-On Windows (cmd/PowerShell), use:
-
-```cmd
-.\.cowork-flow\run.cmd subagent bind <runtime_context_id> <host_context_key>
-```
-
-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 editing:
-1. Read the task directory from the bound runtime context.
-2. Read `<task>/decision-anchor.md`.
-3. Read `<task>/info.md` if present.
-4. Read `<task>/implement.jsonl`.
-5. Read each JSONL `file` entry.
-6. Read the plan file linked from this task (check `<task>/task.json` `relatedFiles` for a plan path, or search `.cowork-flow/plans/` for a plan file referencing this task directory). Follow the plan steps in order — each step has Files, Action, Verify, and Expected fields.
-7. Read quality source entries from context; backend/frontend natural-language
-   specs are review checklists, not dynamic hard validators.
-8. For behavior-change tasks, create or verify `<task>/tdd.jsonl` before
-   implementation or record a documented exemption.
-9. Before reporting completion, write `<task>/quality-review.jsonl` with
-   checklist, machine warning, and Definition of Done evidence.
-
-Authoritative internal protocols:
-- `.cowork-flow/spec/protocols/tdd.md`
-- `.cowork-flow/spec/protocols/decision-review.md`
-- `.cowork-flow/spec/protocols/spec-maintenance.md`
-
-Apply their output contracts exactly. Implementation reports and `tdd.jsonl`
-must preserve `acceptanceId`, `redCommand`, `redExitCode`, `greenCommand`,
-`greenExitCode`, and `specUpdates`.
+1. Follow `agent-dispatch` to bind runtime context. If binding fails, report `needs_context` and stop.
+2. Read the task directory, `decision-anchor.md`, optional `info.md`, `implement.jsonl`, every JSONL `file` entry, and the linked plan.
+3. Follow the plan in order, keeping edits inside assigned scope.
+4. Use project specs and quality sources as checklist context; runtime gates remain kernel-owned commands.
+5. Run planned verification and report changed files, acceptance IDs, verification commands, and spec updates or why none were needed.
 
 Rules:
+
 - Do not use the Task tool or invoke subagents.
-- MUST NOT spawn, wait for, list, or close other agents.
-- MUST NOT run task start, task finish, task archive, or unscoped resume.
-- MUST NOT commit or push.
-- Keep edits inside requested scope.
-- Do not treat shallow tests as TDD evidence; red-green-refactor proof must
-  include redCommand, redExitCode, greenCommand, greenExitCode, and
-  decision-anchor acceptance ID mapping.
-- Report changed files and exact verification commands.
-- Before editing source files, run the deterministic coding gate:
-  `./.cowork-flow/run python .cowork-flow/scripts/common/gates/validate_coding_standards.py --validate --repo-root .`.
-  This gate enforces machine-decidable UTF-8/IO checks; backend/frontend
-  natural-language markdown remains checklist context, not dynamic hard validators.
-- Fix machine warning findings or record acknowledged warning evidence in
-  `<task>/quality-review.jsonl`.
-- Record Definition of Done and quality checklist evidence in
-  `<task>/quality-review.jsonl`.
+- Do not run task start, finish, archive, unscoped resume, commit, or push.
+- Do not create task-local review artifacts, `tdd.jsonl`, or TDD evidence records in `check.jsonl`.
+- Do not claim completion without current verification.