cowork-flow 0.0.51 → 1.0.0

package/CHANGELOG.md

@@ -1,41 +1,103 @@
 # Changelog
 
-## 0.0.47 - 2026-08-05
+## 1.0.0 - 2026-08-26
 
-### Release readiness
+首个稳定主线发布：核心流程契约、会话模型与宿主矩阵在此版本冻结，后续改动进入语义化版本约束。
 
-- Added `npm run release:check` as the documented local release confidence gate. It currently delegates to `npm run test:all`, which runs Node full tests, template full tests, and `pack:check`.
-- Added this changelog to summarize release highlights and publish-time verification notes.
+### 稳定性声明
 
-### Runtime and workflow hardening
+- **宿主矩阵冻结**：`codex` / `opencode` / `claude-code` / `dsh` / `zcode` 五宿主经 host-assets 注册、adapter 一致性校验与 doctor 全链路覆盖；zcode 插件资产与工作区流程资产均为单源分发（`.zcode/` 走插件市场，技能落盘 `.cowork-flow/skills/` 供内核解析且不进入提示层）。
+- **状态注入协议冻结**：`<workflow-state>` 块 + contract-digest（SessionStart 全量 / 逐消息指纹行）+ 生命周期快照（`.runtime/state-snapshot.json`，与状态转换同单元原子提交）构成宿主 hook 的标准输入；`build_hook_context` 共享协议具备直接单测覆盖。
+- **会话模型冻结**：按会话身份（host session id / 显式 context id / hook sessionId）绑定；显式身份无绑定时判 `no_task` 并列可改绑任务，无身份请求才走全局最新有效兜底；进程级 fallback 绑定不再自动跟随。
 
-- Hardened runtime context lifecycle, recovery observability, and fixed-subagent binding diagnostics.
-- Added Batch execution inspect facts, stronger Host action result validation, and documented Batch recovery behavior.
-- Normalized runtime-health and task-review issue facts so review output is easier to consume.
+### 自 0.0.52 以来的变更
 
-### Host assets and integrations
+- 会话绑定安全加固：进程 fallback 会话键（`ZCODE_PROCESS_LABEL`）带 provenance 标记，导航、`--run` 派发、review/complete 目标解析与命令行收尾拒绝自动跟随 fallback 绑定，要求显式任务目录；trusted 身份（显式 env、宿主 session env、hook sessionId）保持完整绑定语义。
+- 对抗性审查修正批次：显式 `COWORK_FLOW_CONTEXT_ID` 按裸键解析与 CLI 对齐；PostToolUse 刷新过滤支持 `cd` + 裸 `run` 与 Windows `run.cmd` 命令形态；legacy cursor 宿主保留完整 contract-digest；改绑提示排除已完成的终态任务；doctor 会话卫生检查对无时区时间戳降级为告警而非崩溃。
+- 交互式平台选择器与平台检测断言随五宿主矩阵更新。
+- release.sh 容错：`--version` 精确模式在版本文件已全部就位（干净工作树）时，`git commit` 的 no-op 空提交不再中止脚本，继续 tag 与 publish；其余 commit 失败仍立即中止。新增回归测试覆盖两条路径。
+- release.sh 容错：目标发布 tag 已存在且指向当前 HEAD 时跳过创建并继续 publish（上次运行 tag 后 publish 未完成的重跑场景）；指向其它提交则中止报错。新增回归测试覆盖两条路径。
 
-- Centralized Host Asset Manifest sync policy helpers and added a Host capability matrix contract.
-- Protected the ZCode multi-module scaffold boundary so plugin scaffolding does not vendor `.cowork-flow/` runtime files into module directories.
+## 0.0.52 - 2026-08-26
 
-### Party Mode
+### ZCode 宿主与 hook 体验
 
-- Extracted Party Mode board storage, enriched final report facts, and aligned Host action fallbacks with the capability matrix boundary.
-- Preserved the advisory-only contract: Party Mode does not advance task lifecycle state and does not replace implement/check review.
+- 修复 hook 过期会话污染：按会话身份选取活动任务，全局兜底跳过失效绑定与 subagent 会话；显式身份无绑定时对齐 CLI 判 `no_task` 并列出可改绑活动任务。
+- 注册 zcode 为一等宿主平台：`host-assets.json` platforms 条目 + `adapters/zcode/adapter.yaml`，alias 解析、平台检测、adapter 一致性校验与 doctor 全链路覆盖；`.zcode/` 维持插件分发不落工程。
+- 纯 zcode 工程生命周期可用：技能落盘 `.cowork-flow/skills/`（宿主提示层仍由插件单源提供），内核 `skill_roots()` 解析 action owner；`detectAny` 增加 adapter 标记修复 sync 静默失养。
+- contract digest 注入瘦身：SessionStart（含 compact/clear）注入完整块，UserPromptSubmit 仅重复指纹行。
+- 新增 PostToolUse(Bash) 轮内刷新：生命周期命令落定后立即注入最新 workflow-state 与指纹行，无关命令零输出。
 
-### Sync, update, and support UX
+### 运行时与诊断
 
-- Added `sync --dry-run` readiness reports covering would-copy, protected skips, obsolete removals, Host asset refresh, pending recovery, and warnings.
-- Added `update --dry-run` readiness output so CLI updates can be previewed without installing.
-- Added the product support and troubleshooting playbook for task routing, runtime binding, Batch, Host asset drift, Party Mode, and release checks.
+- 生命周期转换在提交单元内原子写 `.runtime/state-snapshot.json`；hook 在快照与所选任务一致时采用快照面包屑键，缺失或不一致回退 status 推导。Python 共享 hook 协议（build_hook_context）补直接单测。
+- doctor 新增会话卫生检查：报告失效任务绑定、超龄未活跃、不可读的运行时会话文件。
 
-### Verification
+### 文档
 
-- Release gate: `npm run release:check`
-- Formatting gate: `git diff --check`
-- Windows note: POSIX-shell-only release tests may be reported as skipped when POSIX shell is unavailable; skips must remain visible and must not be reported as passes.
+- AGENTS.md 0.1 明确注入块优先、勿重复运行导航器；README 平台清单与技能分发表同步 zcode。
 
-### Publish notes
+## 0.0.51 - 2026-08-15
 
-- This entry documents the current `0.0.47` release candidate. It does not tag, publish, or bump the package version by itself.
-- Before publishing, confirm the version in `package.json`, `package-lock.json`, `template/.cowork-flow/.version`, and `template/.zcode/.zcode-plugin/plugin.json` matches the intended release.
+### DSH host 接入
+
+- 注册 DeepSeek Harness（dsh）host adapter 与平台标签映射（dsh_ context keys）。
+- 新增 `install-dsh-preset` 分发 DSH agent 预设；预设内置 workflow-state hook 插件，向系统提示注入与其它宿主同构的 `<workflow-state>` 块，每条用户消息刷新，生命周期命令落定后轮内刷新。
+- 补齐协议失败静默降级边界测试；记录 DSH 子代理绑定 field-test 路径（subagent init/bind/close）。
+
+### 计划绑定
+
+- `--from-plan` 支持绑定计划到 planning 任务（plan binding lite 收口），补 --from-plan help 与实际行为一致。
+- 归档任务快照绑定计划（snapshot bound plan into archived task）。
+
+### 运行时与发布
+
+- `platform_from_context_key` 单源化并修复 zcode 平台漂移；zcode 会话上下文确定性解析；slug 前缀与任务 id/name 归一。
+- 共享 PYTHONPATH bootstrap；批量动作与 codex hook 在 Windows 通过 cmd wrapper 运行。
+- CI 在 Ubuntu/Windows 双平台跑全量 pytest；发布流程先同步 Skill replicas 再过全量门禁。
+
+## 0.0.50 - 2026-08-10
+
+### 文档
+
+- task-review 技能把用户自定义 spec 明确为绑定义务（binding obligations）。
+
+## 0.0.49 - 2026-08-08
+
+### 计划与任务
+
+- 引入 plan binding lite：任务元数据绑定计划文件，Normal/High-risk 任务启动前校验计划与 decision anchor 就绪。
+- `task next` 暴露实现优先读上下文（implement read-first）；test-first 技能强化 red-green 指引。
+
+### 运行时与架构
+
+- 新增源码检出 source-refresh 命令；任务上下文服务模块化，lifecycle CLI adapter 瘦身；架构护栏测试固化边界。
+- 状态恢复诊断增强；host manifest 契约对齐；批量与 party 编排器模块化。
+- 保持 python 3.9 runner 兼容。
+
+### CI / 发布
+
+- 增加 Windows 发布信心门禁；发布验证测试稳定化。
+
+## 0.0.48 - 2026-08-05
+
+### 运行时与流程
+
+- 拆分 lifecycle 命令；route 契约收紧；runtime context 生命周期硬化，恢复元数据错误 fail-closed；subagent 运行错误码透出。
+- 移除 legacy changes control plane 与 add-session journal 工作流；guides 指引归入规划阶段。
+
+### Party Mode 与 Batch
+
+- 抽取 Party board 存储层；final report facts 丰富；host action fallback 对齐 capability matrix。
+- Batch 增加 inspect facts 与 host action 结果校验；恢复契约文档化。
+
+### Host 资产与健康
+
+- 新增 host capability matrix 契约；host-assets sync 策略集中；防止 ZCode scaffold 向模块目录泄漏流程文件。
+- task-review issue 与 runtime-health envelope 归一，review/health 输出更易消费。
+
+### 文档
+
+- README 项目概览刷新、任务流程图；产品故障排查 playbook；changelog 发布就绪说明。
+
+## 0.0.47 - 2026-08-05

package/README.md

@@ -58,14 +58,17 @@ cowork-flow update --dry-run
 # 安装 ZCode 插件（可选）
 cowork-flow install-zcode-plugin
 
-# 安装 DSH 预设（可选）
+# 安装 DSH 预设（可选，整套 agent）
 cowork-flow install-dsh-preset
 
+# 机器级安装实时 workflow-state 注入（推荐：不换预设，任意 DSH 会话生效）
+cowork-flow install-dsh-hook
+
 # 维护者发布前检查
 npm run release:check
 ```
 
-平台选项：`codex` / `opencode` / `claude-code` / `dsh` / `all`（逗号分隔）
+平台选项：`codex` / `opencode` / `claude-code` / `dsh` / `zcode` / `all`（逗号分隔）
 
 ## 仓库结构
 
@@ -106,6 +109,7 @@ Skills 维护在 `template/skills/` 唯一源码，`init` / `sync` 时按目录
 | `codex` / `opencode` | `.agents/skills/` |
 | `dsh` | `.agents/skills/` |
 | `claude-code` | `.claude/skills/` |
+| `zcode` | `.cowork-flow/skills/`（内核 owner 解析用；系统提示层仍由 ZCode 插件单源提供，不重复加载） |
 
 分发动作：`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`
 
@@ -117,14 +121,15 @@ Skills 维护在 `template/skills/` 唯一源码，`init` / `sync` 时按目录
 | `sync <path> [--dry-run]` | 同步已初始化项目的模板和技能 |
 | `source-refresh [path] [--dry-run]` | 维护者刷新 source checkout 的 ignored live runtime 与 Host Skill replica |
 | `install-zcode-plugin` | 安装 ZCode 插件到全局缓存 |
-| `install-dsh-preset` | 安装 DSH agent 预设到 `~/.dsh/.agent-presets/cowork-flow/` |
+| `install-dsh-preset` | 安装 DSH agent 预设到 `~/.dsh/.agent-presets/cowork-flow/`（整套 agent，可选） |
+| `install-dsh-hook` | 机器级注册 workflow-state hook 组合行到 `$DSH_HOME/cordis.patch.yml`（当前 DSH 的 agent 提示不收集 host 层 section，实时注入请用预设方式） |
 | `update [--dry-run]` | 升级 CLI 本身 |
 
 ### init 选项
 
 | 选项 | 说明 |
 |---|---|
-| `--platform <p>` | 平台：`codex` / `opencode` / `claude-code` / `dsh` / `all` |
+| `--platform <p>` | 平台：`codex` / `opencode` / `claude-code` / `dsh` / `zcode` / `all` |
 | `--developer <n>` | 开发者名称 |
 | `--force` | 覆盖已有文件 |
 | `--dry-run` | 预览不写入 |
@@ -167,7 +172,7 @@ ZCode 插件只安装 hook、skills、agents 和轻量说明文件；`.cowork-fl
 
 **Hook 注入内容：**
 - `workflow-state` — 当前任务状态
-- `contract-digest` — 合同摘要（SHA256 fingerprint）
+- `contract-digest` — 合同摘要：SessionStart 注入完整块，后续消息仅重复 SHA256 fingerprint
 - `delegated_subtask` — 子代理运行时上下文
 
 **插件子代理：**
@@ -175,6 +180,21 @@ ZCode 插件只安装 hook、skills、agents 和轻量说明文件；`.cowork-fl
 - `cowork-check` — 绑定 runtime context 后做独立检查
 - `cowork-research` — 绑定 runtime context 后做只读调研
 
+## DSH 接入
+
+```bash
+cowork-flow init ./my-project --platform dsh   # 项目资产：AGENTS.md + .agents/skills/ + .dsh 标记
+cowork-flow install-dsh-hook                   # 机器级：注册 hook 组合行（实时注入见下方说明）
+```
+
+`install-dsh-hook` 把 `workflow-state.js` 插件作为 `insert:` patch 注册到 `$DSH_HOME/cordis.patch.yml`（未设置 `DSH_HOME` 时默认 `~/.dsh`），组合层面可被 `dsh --dump-config` 验证。经实测（DSH 0.1.1-rc.1），**agent 提示组装不收集 host 层 section**：该组合行不会在会话系统提示中产生 `<workflow-state>` 块。当前 DSH 版本下实时注入仍需预设方式（`install-dsh-preset`）；本命令保留为组合层面的幂等注册能力（卸载见下），待 DSH 支持 agent-scope patch / workspace 级组合后可直接生效（见 `docs/dsh-upstream-proposal.md`）。
+
+在未安装 cowork-flow 的项目里 hook 完全无感：JS 侧根目录预检直接短路——不注入内容、不启动 Python 进程。全局开关（环境变量）：`COWORK_FLOW_HOOKS=0` / `COWORK_FLOW_DISABLE_HOOKS=1`。卸载：`cowork-flow install-dsh-hook --uninstall`（`--force` 同时删除插件文件）。
+
+> 安装或更新后需要**重启 DSH**（`cordis.patch.yml` 在启动时组合，新增/变更不会被热加载）。
+
+> 使用预设（`install-dsh-preset`）时无需再运行 `install-dsh-hook`——预设已内置同一 hook。
+
 ## DSH 预设
 
 ```bash
@@ -294,6 +314,7 @@ npm run release:check     # 发布信心门禁；当前等价于 test:all
 ```bash
 npm run release          # patch
 npm run release -- minor # minor
+npm run release -- --version 0.1.0  # 精确发布指定版本（跳过自动 bump）
 ```
 
 **发布流程：**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "0.0.51",
+  "version": "1.0.0",
   "description": "CLI for installing and maintaining cowork-flow collaboration templates.",
   "type": "module",
   "bin": {

package/presets/dsh/plugins/workflow-state.js

@@ -22,6 +22,8 @@
 // falls back to running the navigator manually.
 
 import { execFile } from 'node:child_process';
+import { stat } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
 
 export const name = 'workflow-state-hook';
 export const inject = ['systemPrompt'];
@@ -35,6 +37,11 @@ const EXEC_OPTIONS = {
   maxBuffer: 1024 * 1024,
 };
 const NO_ROOT_MARKER = '__COWORK_FLOW_NO_ROOT__';
+// How long a "no .cowork-flow root" verdict is trusted for one cwd. Bounded
+// on purpose: a project that installs cowork-flow mid-session becomes visible
+// after at most one TTL, at the cost of at most one interpreter probe.
+const NO_ROOT_TTL_MS = 30_000;
+const noRootCache = new Map();
 
 // Python 3.9+ protocol reused from the host hook adapters. It resolves the
 // `.cowork-flow` root from the given cwd, loads the shared
@@ -157,13 +164,51 @@ export function resetWorkingPython() {
 }
 
 
+/**
+ * Nearest ancestor of `cwd` whose `.cowork-flow` entry is a directory, or
+ * `null` when no such ancestor exists. Mirrors the root resolution inside
+ * the Python protocol so a project without cowork-flow never pays for an
+ * interpreter spawn at all.
+ */
+export async function findCoworkRoot(cwd) {
+  let current = resolve(cwd);
+  for (;;) {
+    try {
+      const entry = await stat(join(current, '.cowork-flow'));
+      if (entry.isDirectory()) {
+        return current;
+      }
+    } catch {
+      // Missing or inaccessible — keep walking up.
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+
 /**
  * Produce the `<workflow-state>` hook context block for a workspace cwd.
  * Empty string means "contribute nothing" (no root, hooks disabled, no
  * usable interpreter, or a broken runtime).
  */
 export async function runWorkflowState(cwd) {
-  if (hooksDisabled()) {
+  if (hooksDisabled() || !cwd) {
+    return '';
+  }
+  const resolved = resolve(cwd);
+  const cached = noRootCache.get(resolved);
+  if (cached !== undefined && cached > Date.now()) {
+    return '';
+  }
+  if ((await findCoworkRoot(resolved)) === null) {
+    if (noRootCache.size > 1000) {
+      noRootCache.clear();
+    }
+    noRootCache.set(resolved, Date.now() + NO_ROOT_TTL_MS);
     return '';
   }
   if (workingPython !== null) {

package/src/cli.js

@@ -3,6 +3,7 @@ import { emitKeypressEvents } from 'node:readline';
 import { createInterface } from 'node:readline/promises';
 
 import { runInit } from './commands/init.js';
+import { runInstallDshHook } from './commands/install-dsh-hook.js';
 import { runInstallDshPreset } from './commands/install-dsh-preset.js';
 import { runInstallZCodePlugin } from './commands/install-zcode-plugin.js';
 import { runSourceRefresh } from './commands/source-refresh.js';
@@ -16,6 +17,7 @@ Usage:
   cowork-flow init [target] --platform <codex|opencode|claude-code|all> [--developer <name>] [--dry-run] [--force]
   cowork-flow install-zcode-plugin [--dry-run] [--force] [--prune-old]
   cowork-flow install-dsh-preset [--dry-run] [--force]
+  cowork-flow install-dsh-hook [--dry-run] [--force] [--uninstall]
   cowork-flow update
   cowork-flow sync [target] [--dry-run] [--force]
   cowork-flow source-refresh [target] [--dry-run]
@@ -193,6 +195,10 @@ export async function main(argv = process.argv.slice(2), options = {}) {
       return await runInstallDshPreset(args);
     }
 
+    if (command === 'install-dsh-hook') {
+      return await runInstallDshHook(args);
+    }
+
     io.writeErr(`Unknown command: ${command}\n`);
     return 1;
   } catch (error) {

package/src/commands/install-dsh-hook.js

@@ -0,0 +1,225 @@
+import { access, copyFile, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+import { packageRoot } from '../lib/paths.js';
+
+const PLUGIN_SRC = join(packageRoot, 'presets', 'dsh', 'plugins', 'workflow-state.js');
+const ROW_ID = 'workflow-state-hook';
+const MANAGED_MARK = '# cowork-flow: managed workflow-state-hook row. Run "cowork-flow install-dsh-hook" to change it.';
+
+
+function parseArgs(args) {
+  return {
+    dryRun: args.includes('--dry-run'),
+    force: args.includes('--force'),
+    uninstall: args.includes('--uninstall')
+  };
+}
+
+
+function getDshHome() {
+  return process.env.DSH_HOME || join(homedir(), '.dsh');
+}
+
+
+async function pathExists(target) {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+
+async function readIfExists(file) {
+  try {
+    return await readFile(file, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+
+function hookRowBlock(pluginPath) {
+  // cordis.patch.yml is a TOP-LEVEL YAML ARRAY of patch objects. A bare row
+  // would be read as a "modify existing entry" patch and skipped with
+  // "entry not found"; a new row therefore needs one id-less patch whose
+  // insert list appends rows at the top level of the composed entry list.
+  return [
+    MANAGED_MARK,
+    '- insert:',
+    '    - id: ' + ROW_ID,
+    '      name: ' + JSON.stringify(pluginPath),
+  ].join('\n');
+}
+
+
+/**
+ * Locate the managed hook block inside a patch file's text.
+ *
+ * The block is the marker comment (when present), the id-less insert patch
+ * line, and the hook row with its indented continuation lines. Returns null
+ * when no such row exists. The patch is edited as text on purpose: a YAML
+ * round-trip would destroy !!js expressions used by DSH compositions.
+ */
+function findManagedBlock(text) {
+  const lines = text.split('\n');
+  const start = lines.findIndex((line) => line.trim() === '- id: ' + ROW_ID);
+  if (start === -1) {
+    return null;
+  }
+  let markStart = start;
+  while (markStart > 0) {
+    const previous = lines[markStart - 1].trim();
+    if (
+      previous === MANAGED_MARK.trim()
+      || previous.startsWith('# cowork-flow: managed workflow-state-hook')
+      || previous === '- insert:'
+      || previous === 'insert:'
+    ) {
+      markStart -= 1;
+    } else {
+      break;
+    }
+  }
+  let end = start + 1;
+  while (end < lines.length && (lines[end].startsWith(' ') || lines[end].startsWith('\t'))) {
+    end += 1;
+  }
+  // The block excludes any following blank separator: replacement keeps the
+  // file's own line endings byte-stable, removal folds the leftover blank.
+  return { start: markStart, end };
+}
+
+
+function patchWithRow(text, pluginPath) {
+  const block = hookRowBlock(pluginPath);
+  const range = findManagedBlock(text);
+  if (range !== null) {
+    const lines = text.split('\n');
+    return lines.slice(0, range.start)
+      .concat(block.split('\n'))
+      .concat(lines.slice(range.end))
+      .join('\n');
+  }
+  const base = text.replace(/\s+$/, '');
+  return (base + '\n' + block + '\n').replace(/^\n+/, '');
+}
+
+
+function patchWithoutRow(text) {
+  const range = findManagedBlock(text);
+  if (range === null) {
+    return text;
+  }
+  const lines = text.split('\n');
+  const kept = lines.slice(0, range.start).concat(lines.slice(range.end));
+  const merged = kept.join('\n').replace(/\n{3,}/g, '\n\n');
+  if (merged.trim() === '') {
+    return '';
+  }
+  return merged.replace(/\s+$/, '') + '\n';
+}
+
+
+async function upsertRow(patchFile, pluginPath) {
+  const before = (await readIfExists(patchFile)) ?? '';
+  const after = patchWithRow(before, pluginPath);
+  if (after === before) {
+    return false;
+  }
+  await writeFile(patchFile, after, 'utf8');
+  return true;
+}
+
+
+async function removeRow(patchFile) {
+  const before = await readIfExists(patchFile);
+  if (before === null) {
+    return null;
+  }
+  const after = patchWithoutRow(before);
+  if (after === before) {
+    return false;
+  }
+  if (after === '') {
+    // Nothing of the user's own patch remains: drop the file instead of
+    // leaving an empty patch that shadows nothing.
+    await rm(patchFile, { force: true });
+  } else {
+    await writeFile(patchFile, after, 'utf8');
+  }
+  return true;
+}
+
+
+/**
+ * Install (or uninstall) the machine-level DSH workflow-state hook.
+ *
+ * Registers the shared workflow-state.js plugin as an id-less insert patch
+ * in $DSH_HOME/cordis.patch.yml, which DSH applies to every profile and
+ * agent session at boot. Any preset keeps working unchanged; the hook
+ * contributes nothing (and, since the plugin pre-checks for a .cowork-flow
+ * root, does not even spawn an interpreter) in projects that do not run
+ * cowork-flow.
+ */
+export async function runInstallDshHook(args = []) {
+  const { dryRun, force, uninstall } = parseArgs(args);
+
+  if (!(await pathExists(PLUGIN_SRC))) {
+    throw new Error('workflow-state hook source missing at ' + PLUGIN_SRC + '. Reinstall cowork-flow.');
+  }
+
+  const home = getDshHome();
+  const pluginDest = join(home, 'plugins', 'cowork-flow', 'workflow-state.js');
+  const patchFile = join(home, 'cordis.patch.yml');
+
+  if (dryRun) {
+    if (uninstall) {
+      console.log('[dry-run] Would uninstall workflow-state hook:');
+      console.log('  Remove managed row from: ' + patchFile);
+      if (force) {
+        console.log('  Remove plugin file: ' + pluginDest);
+      }
+    } else {
+      console.log('[dry-run] Would install workflow-state hook:');
+      console.log('  Plugin: ' + PLUGIN_SRC + ' -> ' + pluginDest);
+      console.log('  Patch insert: ' + patchFile + ' (id: ' + ROW_ID + ')');
+    }
+    return;
+  }
+
+  if (uninstall) {
+    const removed = await removeRow(patchFile);
+    if (removed === null) {
+      console.log('No patch file at ' + patchFile + '; nothing to uninstall.');
+    } else if (removed === false) {
+      console.log('No managed hook row found in ' + patchFile + '.');
+    } else {
+      console.log('✓ Workflow-state hook row removed from ' + patchFile);
+    }
+    if (force) {
+      await rm(pluginDest, { force: true });
+      console.log('✓ Removed plugin file ' + pluginDest);
+    }
+    return;
+  }
+
+  await mkdir(dirname(pluginDest), { recursive: true });
+  await copyFile(PLUGIN_SRC, pluginDest);
+  const changed = await upsertRow(patchFile, pluginDest);
+
+  console.log('✓ cowork-flow workflow-state hook installed to ' + pluginDest);
+  console.log('  Registered insert row "' + ROW_ID + '" in ' + patchFile + (changed === false ? ' (already up to date)' : ''));
+  console.log('  Restart DSH for the composition to load (installed at boot-time).');
+  console.log('  Note: current DSH builds compose this row but do not surface host-level sections');
+  console.log('  in agent prompts; use "cowork-flow install-dsh-preset" for real-time injection.');
+
+  const presetComposition = join(home, '.agent-presets', 'cowork-flow', 'agent.cordis.yml');
+  if (await pathExists(presetComposition)) {
+    console.log('  Note: the cowork-flow agent preset is also installed and already bundles this hook.');
+    console.log('  Keep only one to avoid duplicate injection: remove the preset, or run "cowork-flow install-dsh-hook --uninstall".');
+  }
+}

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.51
+1.0.0

package/template/.cowork-flow/adapters/zcode/adapter.yaml

@@ -0,0 +1,30 @@
+schemaVersion: 1
+host: zcode
+displayName: ZCode
+capabilities:
+  dispatchSubagent: native
+  freshChildContext: native
+  sendFollowup: native
+  waitChild: native
+  listChildren: shim
+  cancelChild: native
+  stateInjection: external
+  backgroundChild: native
+  runtimeContextDispatch: native
+  runtimeContextBinding: shim
+  runtimeContextCleanup: native
+dispatch:
+  primitive: subagent
+  agentsPath: .zcode/agents
+  pluginManifest: .zcode/.zcode-plugin/plugin.json
+runtimeContext:
+  transport: prompt
+  promptKey: cowork_runtime_context_id
+  envKey: COWORK_FLOW_RUNTIME_CONTEXT_ID
+  metadataKey: cowork_runtime_context_id
+contracts:
+  dispatch: RUNTIME_CONTEXT_DISPATCH_V2
+  leafExecutor: true
+fallback:
+  whenRequiredCapabilityMissing: inline_or_manual
+  whenRuntimeContextMissing: fail_closed

package/template/.cowork-flow/scripts/adapters/cli/task_lifecycle_commands.py

@@ -26,7 +26,11 @@ from infra.paths import (
     FILE_TASK_JSON,
     get_repo_root,
 )
-from runtime.session_state import clear_active_task, get_active_task
+from runtime.session_state import (
+    PROVENANCE_PROCESS_FALLBACK,
+    clear_active_task,
+    get_active_task,
+)
 
 
 def _report_check_block(title: str, blockers: tuple[str, ...]) -> int:
@@ -71,6 +75,19 @@ def _resolve_status_task_dir(
                 file=sys.stderr,
             )
             return None
+        if (
+            active.task_path
+            and active.provenance == PROVENANCE_PROCESS_FALLBACK
+        ):
+            print(
+                colored(
+                    "Error: Session binding is process-fallback (shared); "
+                    "pass a task dir explicitly.",
+                    Colors.RED,
+                ),
+                file=sys.stderr,
+            )
+            return None
         if not active.task_path:
             print(
                 colored(
@@ -342,6 +359,16 @@ def cmd_finish(args: argparse.Namespace) -> int:
     """Clear the active task for this session."""
     repo_root = get_repo_root()
     active = get_active_task(repo_root)
+    if active.task_path and active.provenance == PROVENANCE_PROCESS_FALLBACK:
+        print(
+            colored(
+                "Error: Refusing to clear a session binding resolved from "
+                "process-fallback identity; archive the task to clear it.",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return 1
     if not active.task_path:
         print(
             colored(