cowork-flow 1.4.0 → 1.6.0

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

@@ -1,10 +1,12 @@
-import { cp, mkdir, rm, access } from 'node:fs/promises';
+import { cp, mkdir, rm, access, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
 import { packageRoot, templateRoot } from '../lib/paths.js';
+import { readPackageInfo } from '../lib/package-info.js';
 
 const PRESET_ID = 'cowork-flow';
+const MARKER_FILE = '.cowork-flow-preset.json';
 const PRESET_SRC = join(packageRoot, 'presets', 'dsh');
 const SKILLS_SRC = join(templateRoot, 'skills');
 
@@ -33,6 +35,17 @@ function getDshPresetRoot() {
 }
 
 
+async function readInstalledVersion(destDir) {
+  try {
+    const raw = await readFile(join(destDir, MARKER_FILE), 'utf8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === 'string' ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+
+
 export async function runInstallDshPreset(args = []) {
   const { dryRun, force } = parseArgs(args);
 
@@ -53,9 +66,25 @@ export async function runInstallDshPreset(args = []) {
     return;
   }
 
+  const { version } = await readPackageInfo();
+
   if (!force && (await pathExists(destDir))) {
+    const installedVersion = await readInstalledVersion(destDir);
     console.log(`cowork-flow DSH preset already installed at ${destDir}`);
-    console.log('Use --force to overwrite.');
+    if (installedVersion === null) {
+      console.log(
+        `Installed version unknown (no ${MARKER_FILE}); current version is ${version}.`
+      );
+      console.log('Refresh it with: cowork-flow install-dsh-preset --force');
+    } else if (installedVersion !== version) {
+      console.log(
+        `Installed version ${installedVersion} differs from current version ${version}.`
+      );
+      console.log('The preset does not update with sync or npm; refresh it with:');
+      console.log('  cowork-flow install-dsh-preset --force');
+    } else {
+      console.log('Use --force to overwrite.');
+    }
     return;
   }
 
@@ -66,6 +95,11 @@ export async function runInstallDshPreset(args = []) {
 
   await cp(PRESET_SRC, destDir, { recursive: true });
   await cp(SKILLS_SRC, skillsDest, { recursive: true, force: true });
+  await writeFile(
+    join(destDir, MARKER_FILE),
+    `${JSON.stringify({ version, installedAt: new Date().toISOString() }, null, 2)}\n`,
+    'utf8'
+  );
 
   console.log(`✓ cowork-flow DSH preset installed to ${destDir}`);
   console.log('  Start a new DSH session and pick the "Cowork Flow" preset.');

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

@@ -0,0 +1,343 @@
+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';
+import { readPackageInfo } from '../lib/package-info.js';
+
+const SHIM_NAME = 'cowork-flow-inject.mjs';
+const SHIM_SRC = join(packageRoot, 'presets', 'kimi-code', 'hooks', SHIM_NAME);
+const MARKER_FILE = '.cowork-flow-kimi-hook.json';
+const HOOK_EVENT = 'UserPromptSubmit';
+// Kimi Code's own hook default; kept explicit so an edit is visible here.
+const HOOK_TIMEOUT = 30;
+const MANAGED_START = '# cowork-flow: kimi hook start. Managed by "cowork-flow install-kimi-hook"; edits inside this block are replaced.';
+const MANAGED_END = '# cowork-flow: kimi hook end.';
+
+
+function parseArgs(args) {
+  return {
+    dryRun: args.includes('--dry-run'),
+    force: args.includes('--force'),
+    uninstall: args.includes('--uninstall')
+  };
+}
+
+
+function getKimiHome() {
+  return process.env.KIMI_CODE_HOME || join(homedir(), '.kimi-code');
+}
+
+
+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;
+  }
+}
+
+
+/**
+ * Kimi Code's user-level config.toml, holding the `[[hooks]]` rows.
+ */
+function configFile(home) {
+  return join(home, 'config.toml');
+}
+
+
+/**
+ * Transport shim installed beside the config, spawned as
+ * `node <home>/hooks/cowork-flow-inject.mjs` from every session.
+ */
+function shimDest(home) {
+  return join(home, 'hooks', SHIM_NAME);
+}
+
+
+/**
+ * Version marker for the installed hook, written next to the shim. The
+ * installed files live outside any project, so nothing else records which
+ * release put them there — doctor reads this to tell an up-to-date install
+ * from one that predates the project runtime.
+ */
+function markerDest(home) {
+  return join(home, 'hooks', MARKER_FILE);
+}
+
+
+/**
+ * One `[[hooks]]` row that pipes every UserPromptSubmit payload into the
+ * shim. Kimi Code allows exactly four hook fields — event, matcher, command,
+ * timeout — and rejects the whole config when a row carries anything else,
+ * so the row is deliberately minimal. `matcher` is omitted on purpose:
+ * omitted means "match every prompt". Paths are quoted because a Kimi Code
+ * home may contain spaces (Windows user profiles).
+ */
+function hookBlock(home) {
+  const command = 'node "' + shimDest(home) + '"';
+  return [
+    MANAGED_START,
+    '[[hooks]]',
+    'event = ' + JSON.stringify(HOOK_EVENT),
+    'command = ' + JSON.stringify(command),
+    'timeout = ' + HOOK_TIMEOUT,
+    MANAGED_END
+  ].join('\n');
+}
+
+
+/**
+ * End of the `[[hooks]]` row starting at `start`: the next table header, the
+ * next row of the same array, or the end of file. Trailing blank lines stay
+ * outside the range so removal leaves them for the surrounding layout.
+ */
+function hookRowEnd(lines, start) {
+  let end = start + 1;
+  while (end < lines.length) {
+    const trimmed = lines[end].trim();
+    if (trimmed === '[[hooks]]' || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+      break;
+    }
+    end += 1;
+  }
+  while (end > start + 1 && lines[end - 1].trim() === '') {
+    end -= 1;
+  }
+  return end;
+}
+
+
+/**
+ * Locate the managed block inside the config text.
+ *
+ * The config is edited as text on purpose: a TOML round-trip would rewrite
+ * every pretty-printed entry of the user's own config (providers, models,
+ * permissions), and the file must stay byte-stable outside the block. The
+ * marker comments take precedence so the block is removed even when the row
+ * no longer resembles ours; without markers, the only ownership signal left
+ * is a `[[hooks]]` row whose command names this shim. Returns null when
+ * neither exists.
+ */
+function findManagedBlock(text, home) {
+  const lines = text.split('\n');
+  const marked = lines.findIndex((line) => line.trim() === MANAGED_START);
+  if (marked !== -1) {
+    let end = marked + 1;
+    while (end < lines.length && lines[end].trim() !== MANAGED_END) {
+      end += 1;
+    }
+    return { start: marked, end: Math.min(end + 1, lines.length) };
+  }
+  const owns = shimDest(home).replace(/\\/g, '/');
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index].trim() !== '[[hooks]]') {
+      continue;
+    }
+    const end = hookRowEnd(lines, index);
+    const row = lines.slice(index, end).join('\n');
+    if (row.includes(MANAGED_START) || row.replace(/\\/g, '/').includes(owns)) {
+      return { start: index, end };
+    }
+  }
+  return null;
+}
+
+
+function withBlock(text, home) {
+  const block = hookBlock(home).split('\n');
+  const range = findManagedBlock(text, home);
+  if (range !== null) {
+    const lines = text.split('\n');
+    if (lines.slice(range.start, range.end).join('\n') === block.join('\n')) {
+      return { text, changed: false, existed: true };
+    }
+    return {
+      text: lines.slice(0, range.start).concat(block).concat(lines.slice(range.end)).join('\n'),
+      changed: true,
+      existed: true
+    };
+  }
+  const base = text.replace(/\s+$/, '');
+  const appended = base === '' ? block.join('\n') : base + '\n\n' + block.join('\n');
+  return { text: appended + '\n', changed: true, existed: false };
+}
+
+
+function withoutBlock(text, home) {
+  const range = findManagedBlock(text, home);
+  if (range === null) {
+    return { text, changed: false };
+  }
+  const lines = text.split('\n');
+  const kept = lines.slice(0, range.start).concat(lines.slice(range.end));
+  const body = kept.join('\n').replace(/^\n+/, '').replace(/\s+$/, '');
+  if (body === '') {
+    // Nothing of the user's own config remains: an empty file left behind
+    // would be a config that only ever held this hook.
+    return { text: '', changed: true };
+  }
+  return { text: body + '\n', changed: true };
+}
+
+
+/**
+ * Compact line preview for --dry-run: every line that differs plus its
+ * neighbours, so the operator sees where the block lands without a full-file
+ * dump.
+ */
+function previewDiff(before, after) {
+  // A trailing newline is a line terminator, not an extra empty line; without
+  // this the preview would always report a phantom last-line change.
+  const toLines = (text) => {
+    if (text === '') {
+      return [];
+    }
+    return (text.endsWith('\n') ? text.slice(0, -1) : text).split('\n');
+  };
+  const left = toLines(before);
+  const right = toLines(after);
+  const total = Math.max(left.length, right.length);
+  const shown = new Set();
+  for (let index = 0; index < total; index += 1) {
+    if (left[index] !== right[index]) {
+      for (let offset = -2; offset <= 2; offset += 1) {
+        if (index + offset >= 0 && index + offset < total) {
+          shown.add(index + offset);
+        }
+      }
+    }
+  }
+  const lines = [];
+  let previous = -1;
+  for (const index of [...shown].sort((a, b) => a - b)) {
+    if (previous !== -1 && index > previous + 1) {
+      lines.push('  ...');
+    }
+    const marker = left[index] === right[index] ? '  ' : '+ ';
+    lines.push('  ' + (index + 1) + ' ' + marker + (right[index] ?? ''));
+    previous = index;
+  }
+  return lines;
+}
+
+
+/**
+ * Install (or uninstall) the user-level Kimi Code context-injection hook.
+ *
+ * Kimi Code reads hooks only from $KIMI_CODE_HOME/config.toml, so the shim is
+ * installed under the same home and every session — in every project —
+ * invokes it; the shim itself exits silently outside cowork-flow projects.
+ * Only the Kimi Code home is written: no project file is touched.
+ */
+export async function runInstallKimiHook(args = []) {
+  const { dryRun, uninstall } = parseArgs(args);
+
+  if (!(await pathExists(SHIM_SRC))) {
+    throw new Error('Kimi Code hook shim missing at ' + SHIM_SRC + '. Reinstall cowork-flow.');
+  }
+
+  const home = getKimiHome();
+  const config = configFile(home);
+  const shim = shimDest(home);
+  const marker = markerDest(home);
+
+  if (dryRun) {
+    const before = await readIfExists(config);
+    if (uninstall) {
+      const result = before === null ? { changed: false } : withoutBlock(before, home);
+      console.log('[dry-run] Would uninstall Kimi Code context hook:');
+      console.log(
+        '  Config: ' + config
+          + (before === null
+            ? ' (absent; nothing to remove)'
+            : (result.changed ? ' (managed block found)' : ' (no managed block)'))
+      );
+      console.log('  Remove shim: ' + shim);
+      console.log('  Remove marker: ' + marker);
+      return;
+    }
+    console.log('[dry-run] Would install Kimi Code context hook:');
+    console.log('  Shim: ' + SHIM_SRC + ' -> ' + shim);
+    console.log('  Marker: ' + marker);
+    if (before === null) {
+      console.log('  Create config: ' + config);
+      for (const line of previewDiff('', hookBlock(home))) {
+        console.log(line);
+      }
+      return;
+    }
+    const result = withBlock(before, home);
+    if (!result.changed) {
+      console.log('  Config: ' + config + ' (managed block already up to date)');
+      return;
+    }
+    console.log('  Config: ' + config + (result.existed ? ' (update managed block)' : ' (append managed block)'));
+    for (const line of previewDiff(before, result.text)) {
+      console.log(line);
+    }
+    return;
+  }
+
+  if (uninstall) {
+    const before = await readIfExists(config);
+    if (before === null) {
+      console.log('No Kimi Code config at ' + config + '; nothing to uninstall.');
+    } else {
+      const result = withoutBlock(before, home);
+      if (!result.changed) {
+        console.log('No managed hook block found in ' + config + '.');
+      } else if (result.text === '') {
+        await rm(config, { force: true });
+        console.log('✓ Kimi Code context hook removed; ' + config + ' held nothing else and was deleted.');
+      } else {
+        await writeFile(config, result.text, 'utf8');
+        console.log('✓ Kimi Code context hook removed from ' + config);
+      }
+    }
+    const hadShim = await pathExists(shim);
+    await rm(shim, { force: true });
+    if (hadShim) {
+      console.log('✓ Removed hook shim ' + shim);
+    }
+    const hadMarker = await pathExists(marker);
+    await rm(marker, { force: true });
+    if (hadMarker) {
+      console.log('✓ Removed version marker ' + marker);
+    }
+    return;
+  }
+
+  const { version } = await readPackageInfo();
+  await mkdir(dirname(shim), { recursive: true });
+  await copyFile(SHIM_SRC, shim);
+  await writeFile(
+    marker,
+    `${JSON.stringify({ version, installedAt: new Date().toISOString() }, null, 2)}\n`,
+    'utf8'
+  );
+  const before = (await readIfExists(config)) ?? '';
+  const result = withBlock(before, home);
+  if (result.changed) {
+    await writeFile(config, result.text, 'utf8');
+  }
+
+  console.log('✓ cowork-flow Kimi Code hook shim installed to ' + shim);
+  console.log('  Recorded version ' + version + ' in ' + marker);
+  console.log(
+    '  Registered UserPromptSubmit hook in ' + config
+      + (result.changed ? (result.existed ? ' (block updated)' : ' (block appended)') : ' (already up to date)')
+  );
+  console.log('  Start a new Kimi Code session (or reload the config) for the hook to load.');
+  console.log('  Note: injection happens once per submitted prompt; other Kimi Code events cannot inject.');
+}

package/src/lib/host-assets.js

@@ -19,12 +19,6 @@ const REQUIRED_HOST_NEUTRAL_CAPABILITIES = [
   'file_write',
   'party_board_action'
 ];
-const REQUIRED_CAPABILITY_MATRIX_HOSTS = [
-  'codex',
-  'claude-code',
-  'opencode',
-  'zcode'
-];
 const CAPABILITY_STATUS_VALUES = [
   'native',
   'shim',
@@ -406,10 +400,7 @@ function validateCapabilityMatrix(matrix, allowed, platformIds) {
   if (!matrix.hosts || typeof matrix.hosts !== 'object' || Array.isArray(matrix.hosts)) {
     throw new Error('Host Asset Manifest capabilityMatrix.hosts must be an object');
   }
-  const requiredHosts = new Set([
-    ...REQUIRED_CAPABILITY_MATRIX_HOSTS,
-    ...platformIds
-  ]);
+  const requiredHosts = new Set([...platformIds]);
   for (const hostId of [...requiredHosts].sort()) {
     if (!matrix.hosts[hostId]) {
       throw new Error(`Host Asset Manifest capability matrix missing host: ${hostId}`);

package/template/.codex/hooks.json

@@ -10,6 +10,18 @@
           }
         ]
       }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "apply_patch|Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": ".cowork-flow/run python .codex/hooks/inject-workflow-state.py",
+            "timeout": 5
+          }
+        ]
+      }
     ]
   }
 }

package/template/.cowork-flow/.version

@@ -1 +1 @@
-1.4.0
+1.6.0

package/template/.cowork-flow/adapters/kimi-code/adapter.yaml

@@ -0,0 +1,31 @@
+schemaVersion: 1
+host: kimi-code
+displayName: Kimi Code
+capabilities:
+  dispatchSubagent: native
+  freshChildContext: native
+  sendFollowup: native
+  waitChild: native
+  listChildren: native
+  cancelChild: native
+  stateInjection: shim
+  backgroundChild: native
+  runtimeContextDispatch: native
+  runtimeContextBinding: shim
+  runtimeContextCleanup: native
+  editScopeWarning: unsupported
+dispatch:
+  primitive: subagent
+  agentsPath: .kimi-code/agents
+  skillsPath: .agents/skills
+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/spec_check.py

@@ -33,7 +33,7 @@ def main() -> int:
         "--phase",
         choices=("edit", "lifecycle"),
         default="lifecycle",
-        help="edit: only declarations matching the given files (3s clamp); "
+        help="edit: only declarations matching the given files (2.5s clamp); "
         "lifecycle: every declaration honoring its files scope.",
     )
     parser.add_argument(

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

@@ -4,7 +4,7 @@
 
 Assembles one machine-readable fact view per task (task.json, decision-anchor
 essentials, plan binding, bound sessions, trusted snapshot). See
-services/fact_view.py and docs/direction.md stage 1.
+services/fact_view.py and the fact-layer stage 1 design.
 """
 
 from __future__ import annotations

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

@@ -16,6 +16,13 @@ if __package__:
     from . import _bootstrap as _bootstrap  # noqa: F401
 else:
     import _bootstrap  # noqa: F401
+from runtime.host_identity import (
+    HostIdentity,
+    declared_host,
+    detect_host,
+    host_ids,
+    identity_for,
+)
 from runtime.session_state import (
     resolve_context_key,
     runtime_context_path,
@@ -66,27 +73,34 @@ def _next_id(base_dir: Path, title: str) -> str:
     return candidate
 
 
-def _detect_host() -> str:
-    env = os.environ
-    if env.get("CLAUDE_CODE_SESSION_ID") or env.get("CLAUDE_SESSION_ID"):
-        return "claude-code"
-    if env.get("CODEX_SESSION_ID") or env.get("CODEX_THREAD_ID"):
-        return "codex"
-    if env.get("ZCODE_SESSION_ID"):
-        return "zcode"
-    if env.get("OPENCODE_SESSION_ID"):
-        return "opencode"
-    return "codex"
-
-
-def _detect_adapter(host: str) -> str:
-    adapters = {
-        "claude-code": "claude-code.hooks",
-        "codex": "codex.spawn_agent",
-        "opencode": "opencode.task",
-        "zcode": "zcode.plugin",
-    }
-    return adapters.get(host, "codex.spawn_agent")
+def _detect_host() -> str | None:
+    """The host whose per-session env var is present, or None.
+
+    None is the honest answer when this process carries no host evidence:
+    defaulting to another host would file this session's runtime context
+    under that host's identity.
+    """
+    return detect_host(os.environ)
+
+
+def _resolve_host(host_id: str | None) -> HostIdentity:
+    """The host for this dispatch, or ValueError when it cannot be established.
+
+    Guessing another host would file this session's runtime context under that
+    host's identity, so a missing or unregistered host is refused instead.
+    """
+    resolved = host_id or declared_host(os.environ) or _detect_host()
+    if resolved is None:
+        raise ValueError(
+            "host is required when no session host is detectable; "
+            f"pass --host with one of: {', '.join(host_ids())}"
+        )
+    identity = identity_for(resolved)
+    if identity is None:
+        raise ValueError(
+            f"unknown host: {resolved}; known hosts: {', '.join(host_ids())}"
+        )
+    return identity
 
 
 def _host_context_prefix(host: str) -> str:
@@ -128,13 +142,14 @@ def cmd_init(args: argparse.Namespace) -> int:
     base_dir = subagent_contexts_dir(repo_root)
     runtime_context_id = _next_id(base_dir, args.title)
     task_dir = getattr(args, "execution_task_dir", None)
-    host = args.host or _detect_host()
-    adapter = args.adapter or _detect_adapter(host)
     try:
+        identity = _resolve_host(args.host)
+        adapter = args.adapter or identity.adapter
         agent_type, dispatch_kind = _resolve_agent_type(args.role, getattr(args, "agent_type", None))
     except ValueError as error:
         print(f"Error: {error}", file=sys.stderr)
         return 1
+    host = identity.id
     if dispatch_kind == "formal" and not task_dir:
         print("Error: fixed agent dispatch requires --execution-task-dir", file=sys.stderr)
         return 1

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

@@ -19,13 +19,10 @@ from services.context_discovery import (
     get_implement_spec,
 )
 from services.task_context import (
-    detect_installed_platforms as _detect_installed_platforms,
     discover_spec_files as _discover_spec_files,
     get_check_context,
     get_debug_context,
-    is_skill_path as _is_skill_path,
     iter_jsonl_lines as _iter_jsonl_lines,
-    skill_path as _skill_path,
     write_jsonl as _write_jsonl,
 )
 from adapters.cli.task_archive_commands import cmd_archive

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

@@ -82,7 +82,9 @@ def _resolve_status_task_dir(
             print(
                 colored(
                     "Error: Session binding is process-fallback (shared); "
-                    "pass a task dir explicitly.",
+                    "set COWORK_FLOW_CONTEXT_ID to the session value shown "
+                    "in the workflow-state header, or pass a task dir "
+                    "explicitly.",
                     Colors.RED,
                 ),
                 file=sys.stderr,
@@ -368,7 +370,8 @@ def cmd_finish(args: argparse.Namespace) -> int:
         print(
             colored(
                 "Error: Refusing to clear a session binding resolved from "
-                "process-fallback identity; archive the task to clear it.",
+                "process-fallback identity; archive the task to clear it, or "
+                "set COWORK_FLOW_CONTEXT_ID to your own session identity.",
                 Colors.RED,
             ),
             file=sys.stderr,

package/template/.cowork-flow/scripts/adapters/host/claude_code_policy.py

@@ -3,9 +3,9 @@
 workflow hook.
 
 Rendering stays in workflow_state_hook.py; this module owns only the
-claude-code transport specifics — the session alias ported from the claude
-wrapper, the runtime preamble block, and the PostToolUse spec-advisory path
-(stderr + exit 2, shared with codex via the neutral helper).
+claude-code transport specifics — the runtime preamble block and the
+PostToolUse spec-advisory path (stderr + exit 2, shared with codex via the
+neutral helper).
 """
 
 from __future__ import annotations
@@ -24,16 +24,6 @@ CLAUDE_PREAMBLE = (
 )
 
 
-def claude_session_alias(data: dict[str, Any]) -> dict[str, Any]:
-    # Ported from the claude-code wrapper: bare session_id must resolve as a
-    # claude session, not fall through to the codex session_id rule.
-    if "claude_session_id" not in data:
-        session_id = data.get("session_id")
-        if isinstance(session_id, str) and session_id.strip():
-            data["claude_session_id"] = session_id
-    return data
-
-
 def preamble(root: Path) -> tuple[str, ...]:
     return CLAUDE_PREAMBLE
 
@@ -46,7 +36,6 @@ def post_tool_use(root: Path, hook_input: dict[str, Any]) -> tuple[str, int]:
 
 POLICY = HostPolicy(
     host="claude-code",
-    session_alias=claude_session_alias,
     preamble=preamble,
     post_tool_use=post_tool_use,
 )