cowork-flow 0.0.45 → 0.0.47

package/README.md

@@ -39,7 +39,7 @@ template/
 ├── .codex/                    # Codex agents / hooks / config
 ├── .claude/                   # Claude Code settings / agents / hooks
 ├── .opencode/                 # OpenCode agents / commands / plugins
-├── .zcode/                    # ⭐ ZCode 插件（hooks + skills + scaffold instructions）
+├── .zcode/                    # ⭐ ZCode 插件（hooks + skills + agents + scaffold instructions）
 └── .cowork-flow/
     ├── config.yaml            # 项目配置
     ├── scripts/               # Python 运行时
@@ -103,17 +103,25 @@ Skills 维护在 `template/skills/` 唯一源码，`init` / `sync` 时按目录
 ```bash
 cowork-flow install-zcode-plugin     # 安装
 cowork-flow install-zcode-plugin --force  # 覆盖已安装
+cowork-flow install-zcode-plugin --force --prune-old  # 覆盖并清理旧版本缓存
 ```
 
-安装到 `~/.zcode/cli/plugins/cache/zcode-plugins-official/cowork-flow/<version>/`
+安装到 `~/.zcode/cli/plugins/cache/cowork-flow-local/cowork-flow/<version>/`。安装器会同时写入稳定 marketplace source：`~/.zcode/cli/plugins/cache/marketplaces/cowork-flow-local/marketplace.json`，以及 ZCode 当前使用的活动副本：`~/.zcode/cli/plugins/marketplaces/cowork-flow-local/marketplace.json`。`known_marketplaces.json` 指向稳定 source 目录，避免 ZCode 刷新活动副本时删除自己的 source。
 
-ZCode 插件只安装 hook、skills 和轻量说明文件；`.cowork-flow/` 流程文件仍由显式 `cowork-flow init` / `cowork-flow sync` 在项目根目录管理。插件不会通过 scaffold 创建 `.cowork-flow/`，因此不会在多模块项目的模块目录重复落盘流程文件。
+安装新版本时，marketplace 中只保留一个 `cowork-flow` entry 并指向最新版本目录；旧版本缓存默认保留，避免正在运行的 ZCode session 仍引用旧插件根目录。需要清理旧版本时显式传 `--prune-old`。
+
+ZCode 插件只安装 hook、skills、agents 和轻量说明文件；`.cowork-flow/` 流程文件仍由显式 `cowork-flow init` / `cowork-flow sync` 在项目根目录管理。插件不会通过 scaffold 创建 `.cowork-flow/`，因此不会在多模块项目的模块目录重复落盘流程文件。
 
 **Hook 注入内容：**
 - `workflow-state` — 当前任务状态
 - `contract-digest` — 合同摘要（SHA256 fingerprint）
 - `delegated_subtask` — 子代理运行时上下文
 
+**插件子代理：**
+- `cowork-implement` — 绑定 runtime context 后执行计划内实现
+- `cowork-check` — 绑定 runtime context 后做独立检查
+- `cowork-research` — 绑定 runtime context 后做只读调研
+
 ## 任务流程
 
 ```

package/package.json

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

package/src/cli.js

@@ -12,7 +12,7 @@ const HELP = `cowork-flow
 
 Usage:
   cowork-flow init [target] --platform <codex|opencode|claude-code|all> [--developer <name>] [--dry-run] [--force]
-  cowork-flow install-zcode-plugin [--force]
+  cowork-flow install-zcode-plugin [--dry-run] [--force] [--prune-old]
   cowork-flow update
   cowork-flow sync [target] [--dry-run] [--force]
   cowork-flow --version

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

@@ -1,17 +1,20 @@
-import { cp, mkdir, readFile, writeFile, access, rm } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
+import { cp, mkdir, readFile, writeFile, access, rm, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
 import { homedir } from 'node:os';
 
 import { readPackageInfo } from '../lib/package-info.js';
 import { templateRoot } from '../lib/paths.js';
 
-const ZCODE_MARKETPLACE = 'zcode-plugins-official';
+const ZCODE_MARKETPLACE = 'cowork-flow-local';
+const LEGACY_ZCODE_MARKETPLACE = 'zcode-plugins-official';
 const PLUGIN_NAME = 'cowork-flow';
+const LOCAL_MARKETPLACE_DESCRIPTION = 'Local marketplace registration for cowork-flow during local development.';
 
 function parseArgs(args) {
   return {
     dryRun: args.includes('--dry-run'),
-    force: args.includes('--force')
+    force: args.includes('--force'),
+    pruneOld: args.includes('--prune-old')
   };
 }
 
@@ -24,9 +27,13 @@ async function pathExists(target) {
   }
 }
 
-async function getZCodeCacheDir() {
+function getZCodePluginsRoot() {
   const base = process.env.ZCODE_HOME || join(homedir(), '.zcode');
-  return join(base, 'cli', 'plugins', 'cache', ZCODE_MARKETPLACE, PLUGIN_NAME);
+  return join(base, 'cli', 'plugins');
+}
+
+async function getZCodeCacheDir() {
+  return join(getZCodePluginsRoot(), 'cache', ZCODE_MARKETPLACE, PLUGIN_NAME);
 }
 
 async function readJsonSafe(path) {
@@ -46,14 +53,46 @@ function dirname(path) {
   return idx >= 0 ? path.slice(0, idx) : path;
 }
 
-async function updateMarketplace(cacheRoot, version) {
-  const marketPath = resolve(cacheRoot, '..', '..', '..', 'marketplaces', ZCODE_MARKETPLACE, 'marketplace.json');
-  const market = (await readJsonSafe(marketPath)) || { name: ZCODE_MARKETPLACE, plugins: [], version: 1 };
+function normalizedPath(path) {
+  return path.split('\\').join('/');
+}
+
+function marketplacePaths(pluginsRoot) {
+  return {
+    activeMarketplacePath: join(pluginsRoot, 'marketplaces', ZCODE_MARKETPLACE, 'marketplace.json'),
+    sourceMarketplacePath: join(pluginsRoot, 'cache', 'marketplaces', ZCODE_MARKETPLACE, 'marketplace.json')
+  };
+}
+
+async function updateMarketplace(pluginsRoot, cacheRoot, version, manifest = {}) {
+  const { activeMarketplacePath, sourceMarketplacePath } = marketplacePaths(pluginsRoot);
+  const market = (await readJsonSafe(sourceMarketplacePath))
+    || (await readJsonSafe(activeMarketplacePath))
+    || {
+      name: ZCODE_MARKETPLACE,
+      description: LOCAL_MARKETPLACE_DESCRIPTION,
+      plugins: [],
+      version: 1
+    };
+  const pluginPath = normalizedPath(join(cacheRoot, version));
+
+  market.name = ZCODE_MARKETPLACE;
+  market.description = market.description || LOCAL_MARKETPLACE_DESCRIPTION;
+  market.version = 1;
+  if (!Array.isArray(market.plugins)) {
+    market.plugins = [];
+  }
 
   const entry = {
-    cachePath: join(cacheRoot, version).split('\\').join('/'),
+    author: manifest.author || { name: 'fisklikewater' },
+    category: 'developer-tools',
+    description: manifest.description || 'cowork-flow task lifecycle, hooks, skills, and fixed subagents for ZCode.',
+    license: manifest.license || 'MIT',
     name: PLUGIN_NAME,
-    source: 'filesystem',
+    source: {
+      source: 'directory',
+      path: pluginPath
+    },
     version
   };
 
@@ -64,15 +103,99 @@ async function updateMarketplace(cacheRoot, version) {
     market.plugins.push(entry);
   }
 
-  await mkdir(dirname(marketPath), { recursive: true });
-  await writeJsonAtomic(marketPath, market);
+  for (const targetPath of [sourceMarketplacePath, activeMarketplacePath]) {
+    await mkdir(dirname(targetPath), { recursive: true });
+    await writeJsonAtomic(targetPath, market);
+  }
+  return { activeMarketplacePath, sourceMarketplacePath };
+}
+
+async function updateKnownMarketplaces(pluginsRoot) {
+  const knownPath = join(pluginsRoot, 'known_marketplaces.json');
+  const known = (await readJsonSafe(knownPath)) || {
+    version: 1,
+    marketplaces: []
+  };
+  const now = new Date().toISOString();
+  const marketplaceDir = join(pluginsRoot, 'cache', 'marketplaces', ZCODE_MARKETPLACE);
+  const existingIdx = Array.isArray(known.marketplaces)
+    ? known.marketplaces.findIndex((marketplace) => marketplace.id === ZCODE_MARKETPLACE)
+    : -1;
+  const existing = existingIdx >= 0 ? known.marketplaces[existingIdx] : {};
+  const entry = {
+    id: ZCODE_MARKETPLACE,
+    source: {
+      source: 'directory',
+      path: normalizedPath(marketplaceDir)
+    },
+    name: ZCODE_MARKETPLACE,
+    description: LOCAL_MARKETPLACE_DESCRIPTION,
+    addedAt: existing.addedAt || now,
+    pluginCount: 1,
+    lastUpdated: now
+  };
+
+  known.version = 1;
+  if (!Array.isArray(known.marketplaces)) {
+    known.marketplaces = [];
+  }
+  if (existingIdx >= 0) {
+    known.marketplaces[existingIdx] = entry;
+  } else {
+    known.marketplaces.push(entry);
+  }
+
+  await mkdir(dirname(knownPath), { recursive: true });
+  await writeJsonAtomic(knownPath, known);
+  return knownPath;
+}
+
+async function removeLegacyMarketplaceEntry(pluginsRoot) {
+  const legacyPath = join(
+    pluginsRoot,
+    'marketplaces',
+    LEGACY_ZCODE_MARKETPLACE,
+    'marketplace.json'
+  );
+  const legacy = await readJsonSafe(legacyPath);
+  if (!legacy || !Array.isArray(legacy.plugins)) {
+    return false;
+  }
+
+  const filteredPlugins = legacy.plugins.filter((plugin) => plugin.name !== PLUGIN_NAME);
+  if (filteredPlugins.length === legacy.plugins.length) {
+    return false;
+  }
+
+  legacy.plugins = filteredPlugins;
+  await writeJsonAtomic(legacyPath, legacy);
+  return true;
+}
+
+async function pruneOldVersions(cacheRoot, currentVersion) {
+  if (!(await pathExists(cacheRoot))) {
+    return [];
+  }
+
+  const removed = [];
+  const entries = await readdir(cacheRoot, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === currentVersion) {
+      continue;
+    }
+    const target = join(cacheRoot, entry.name);
+    await rm(target, { recursive: true, force: true });
+    removed.push(entry.name);
+  }
+  return removed;
 }
 
 export async function runInstallZCodePlugin(args = []) {
-  const { dryRun, force } = parseArgs(args);
+  const { dryRun, force, pruneOld } = parseArgs(args);
   const pluginSrc = join(templateRoot, ".zcode");
   const skillsSrc = join(templateRoot, "skills");
   const { version } = await readPackageInfo();
+  const manifest = (await readJsonSafe(join(pluginSrc, '.zcode-plugin', 'plugin.json'))) || {};
 
   if (!(await pathExists(pluginSrc))) {
     throw new Error(`ZCode plugin source missing at ${pluginSrc}. Reinstall cowork-flow.`);
@@ -81,19 +204,32 @@ export async function runInstallZCodePlugin(args = []) {
     throw new Error(`Skills source missing at ${skillsSrc}. Reinstall cowork-flow.`);
   }
 
+  const pluginsRoot = getZCodePluginsRoot();
   const cacheRoot = await getZCodeCacheDir();
   const destDir = join(cacheRoot, version);
 
-  if (!force && (await pathExists(destDir))) {
-    console.log(`cowork-flow ZCode plugin already installed at ${destDir}`);
-    console.log('Use --force to overwrite.');
-    return;
-  }
-
   if (dryRun) {
     console.log(`[dry-run] Would install ZCode plugin:`);
     console.log(`  Plugin: ${pluginSrc} -> ${destDir}`);
     console.log(`  Skills: ${skillsSrc} -> ${join(destDir, 'skills')}`);
+    console.log(`  Marketplace source: ${join(pluginsRoot, 'cache', 'marketplaces', ZCODE_MARKETPLACE, 'marketplace.json')}`);
+    console.log(`  Active marketplace: ${join(pluginsRoot, 'marketplaces', ZCODE_MARKETPLACE, 'marketplace.json')}`);
+    console.log(`  Known marketplaces: ${join(pluginsRoot, 'known_marketplaces.json')}`);
+    return;
+  }
+
+  if (!force && (await pathExists(destDir))) {
+    await updateMarketplace(pluginsRoot, cacheRoot, version, manifest);
+    await updateKnownMarketplaces(pluginsRoot);
+    await removeLegacyMarketplaceEntry(pluginsRoot);
+    if (pruneOld) {
+      const removed = await pruneOldVersions(cacheRoot, version);
+      if (removed.length > 0) {
+        console.log(`Pruned old cowork-flow ZCode plugin versions: ${removed.join(', ')}`);
+      }
+    }
+    console.log(`cowork-flow ZCode plugin already installed at ${destDir}`);
+    console.log('Use --force to overwrite.');
     return;
   }
 
@@ -121,7 +257,15 @@ export async function runInstallZCodePlugin(args = []) {
   // Copy canonical skills into the plugin cache so plugin.json "skills" resolves.
   await cp(skillsSrc, join(destDir, "skills"), { recursive: true, force: true });
 
-  await updateMarketplace(cacheRoot, version);
+  await updateMarketplace(pluginsRoot, cacheRoot, version, manifest);
+  await updateKnownMarketplaces(pluginsRoot);
+  await removeLegacyMarketplaceEntry(pluginsRoot);
+  if (pruneOld) {
+    const removed = await pruneOldVersions(cacheRoot, version);
+    if (removed.length > 0) {
+      console.log(`Pruned old cowork-flow ZCode plugin versions: ${removed.join(', ')}`);
+    }
+  }
 
   // Write seed file for install tracking
   await writeJsonAtomic(join(destDir, ".zcode-plugin-seed.json"), {

package/template/.cowork-flow/.version

@@ -1 +1 @@
-0.0.45
+0.0.47

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

@@ -72,6 +72,8 @@ def _detect_host() -> str:
         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"
@@ -82,6 +84,7 @@ def _detect_adapter(host: str) -> str:
         "claude-code": "claude-code.hooks",
         "codex": "codex.spawn_agent",
         "opencode": "opencode.task",
+        "zcode": "zcode.plugin",
     }
     return adapters.get(host, "codex.spawn_agent")
 

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

@@ -5,7 +5,6 @@
 from __future__ import annotations
 
 import argparse
-import json
 import sys
 from datetime import datetime
 from pathlib import Path
@@ -48,6 +47,11 @@ from adapters.cli.task_context_commands import (
 from adapters.cli.task_create_command import cmd_create, ensure_tasks_dir
 from adapters.cli import task_navigation
 from adapters.cli.task_parser import build_parser, show_usage
+from adapters.cli.task_next_runner import (
+    NextActionHandlers,
+    namespace_with as _args_with,
+    run_next_action,
+)
 from adapters.cli.task_support import (
     Colors,
     colored,
@@ -57,6 +61,7 @@ from adapters.cli.task_support import (
 from adapters.cli.task_tree_commands import (
     cmd_add_subtask,
     cmd_list,
+    cmd_list_json,
     cmd_list_archive,
     cmd_remove_subtask,
 )
@@ -537,189 +542,6 @@ def cmd_current(args: argparse.Namespace) -> int:
     return 0
 
 
-def _next_target_for_run(args: argparse.Namespace, repo_root: Path):
-    target_input = getattr(args, "dir", None)
-    if target_input:
-        task_dir = _resolve_task_dir(target_input, repo_root)
-        return task_dir, _display_task_path(repo_root, task_dir), False
-
-    active = get_active_task(repo_root)
-    if active.task_path:
-        task_dir = repo_root / active.task_path
-        return task_dir, active.task_path, True
-    return None, None, False
-
-
-def _next_payload_for_run(args: argparse.Namespace, repo_root: Path) -> dict[str, object]:
-    task_dir, task_path, active_target = _next_target_for_run(args, repo_root)
-    if task_dir is None or task_path is None:
-        return task_navigation.build_navigation_payload(
-            args=args,
-            status="no_task",
-            blockers=[],
-            active_target=False,
-            task_path=None,
-        )
-    if not task_dir.is_dir():
-        return task_navigation.build_navigation_payload(
-            args=args,
-            status="stale",
-            blockers=[f"task directory not found: {task_path}"],
-            active_target=active_target,
-            task_path=task_path,
-        )
-    status = task_navigation._status(repo_root, task_dir)
-    blockers = task_navigation._blockers(repo_root, task_dir) if status == "planning" else []
-    return task_navigation.build_navigation_payload(
-        args=args,
-        status=status,
-        blockers=blockers,
-        active_target=active_target,
-        task_path=task_path,
-    )
-
-
-def _args_with(args: argparse.Namespace, **overrides) -> argparse.Namespace:
-    values = vars(args).copy()
-    values.update(overrides)
-    return argparse.Namespace(**values)
-
-
-def _run_create_action(args: argparse.Namespace, action: dict[str, object]) -> int:
-    if not getattr(args, "title", None):
-        print(
-            colored("Error: create_task requires --title", Colors.RED),
-            file=sys.stderr,
-        )
-        print(f"Command: {action.get('command')}", file=sys.stderr)
-        return 1
-    return cmd_create(
-        _args_with(
-            args,
-            title=args.title,
-            slug=getattr(args, "slug", None),
-            assignee=getattr(args, "assignee", None),
-            priority=getattr(args, "priority", "P2"),
-            description=getattr(args, "description", None),
-            parent=getattr(args, "parent", None),
-            from_plan=getattr(args, "from_plan", None),
-        )
-    )
-
-
-def _create_input_names(args: argparse.Namespace) -> list[str]:
-    names = (
-        "title",
-        "slug",
-        "assignee",
-        "description",
-        "parent",
-        "from_plan",
-    )
-    return [name for name in names if getattr(args, name, None)]
-
-
-def _validated_next_action(args: argparse.Namespace) -> tuple[dict[str, object] | None, int]:
-    payload = _next_payload_for_run(args, get_repo_root())
-    action = payload.get("action")
-    if not isinstance(action, dict):
-        print(
-            colored("Error: task next did not return an action", Colors.RED),
-            file=sys.stderr,
-        )
-        return None, 1
-    create_inputs = _create_input_names(args)
-    action_id = action.get("id")
-    if create_inputs and action_id != "create_task":
-        print(
-            colored(
-                f"Error: create_task inputs cannot run {action_id}",
-                Colors.RED,
-            ),
-            file=sys.stderr,
-        )
-        print(
-            "Hint: archive or finish the current task first, then rerun "
-            "`task next --run --title ... --slug ... --assignee <name>`.",
-            file=sys.stderr,
-        )
-        return None, 1
-    if payload.get("blockers") or action.get("blockers"):
-        print(colored("Error: next action is blocked", Colors.RED), file=sys.stderr)
-        for blocker in payload.get("blockers", []) or action.get("blockers", []):
-            print(f"  - {blocker}", file=sys.stderr)
-        return None, 1
-    if not action.get("runnable"):
-        action_id = action.get("id")
-        print(
-            colored(f"Error: next action is not executable: {action_id}", Colors.RED),
-            file=sys.stderr,
-        )
-        if action.get("command"):
-            print(f"Command: {action['command']}", file=sys.stderr)
-        return None, 1
-    return action, 0
-
-
-def _resolved_next_action_task(args: argparse.Namespace, action_id: object) -> str | None:
-    if action_id == "create_task":
-        return None
-    _, task_path_value, _ = _next_target_for_run(args, get_repo_root())
-    if task_path_value is None:
-        print(colored("Error: no task target for action", Colors.RED), file=sys.stderr)
-        return None
-    return task_path_value
-
-
-def _dispatch_next_lifecycle_action(
-    args: argparse.Namespace,
-    action_id: object,
-    task_path: str | None,
-    action: dict[str, object],
-) -> int:
-    if action_id == "create_task":
-        return _run_create_action(args, action)
-    if task_path is None:
-        return 1
-    if action_id == "start_task":
-        return cmd_start(_args_with(
-            args,
-            dir=task_path,
-            auto=bool(getattr(args, "auto", False)),
-            approved=bool(getattr(args, "approved", False)),
-        ))
-    if action_id == "request_review":
-        return cmd_review(_args_with(args, dir=task_path))
-    if action_id == "complete_task":
-        return cmd_complete(_args_with(args, dir=task_path))
-    if action_id == "archive_task":
-        return cmd_archive(_args_with(
-            args,
-            name=Path(str(task_path)).name,
-            commit=bool(getattr(args, "commit", False)),
-        ))
-    if action_id == "batch_execute":
-        return cmd_start(_args_with(
-            args,
-            dir=task_path,
-            auto=True,
-            approved=bool(getattr(args, "approved", False)),
-        ))
-    print(
-        colored(f"Error: unsupported next action: {action_id}", Colors.RED),
-        file=sys.stderr,
-    )
-    return 1
-
-
-def _run_next_action(args: argparse.Namespace) -> int:
-    action, error_code = _validated_next_action(args)
-    if action is None:
-        return error_code
-    action_id = action.get("id")
-    task_path = _resolved_next_action_task(args, action_id)
-    return _dispatch_next_lifecycle_action(args, action_id, task_path, action)
-
 def cmd_next(args: argparse.Namespace) -> int:
     """Show or run the next workflow action."""
     if getattr(args, "list_tasks", False):
@@ -729,6 +551,14 @@ def cmd_next(args: argparse.Namespace) -> int:
                 file=sys.stderr,
             )
             return 1
+        if getattr(args, "json", False):
+            return cmd_list_json(
+                _args_with(
+                    args,
+                    mine=bool(getattr(args, "mine", False)),
+                    status=getattr(args, "status", None),
+                )
+            )
         return cmd_list(
             _args_with(
                 args,
@@ -751,7 +581,16 @@ def cmd_next(args: argparse.Namespace) -> int:
             return 1
         return cmd_validate(_args_with(args, dir=args.dir))
     if getattr(args, "run", False):
-        return _run_next_action(args)
+        return run_next_action(
+            args,
+            NextActionHandlers(
+                create=cmd_create,
+                start=cmd_start,
+                review=cmd_review,
+                complete=cmd_complete,
+                archive=cmd_archive,
+            ),
+        )
     return task_navigation.cmd_next(args)
 
 

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

@@ -18,6 +18,13 @@ from services.task_repository import TaskRepository, TaskRepositoryError
 from services.task_routing import _default_intent, route_request
 
 
+RECOVERABLE_TASK_STATUSES = {
+    "in_progress": "active_unbound",
+    "review": "active_unbound",
+    "completed": "completed_unarchived",
+}
+
+
 
 def _display(repo_root: Path, task_dir: Path) -> str:
     try:
@@ -41,6 +48,61 @@ def _blockers(repo_root: Path, task_dir: Path) -> list[str]:
     return blockers
 
 
+def repository_recovery_signals(repo_root: Path) -> list[dict[str, str]]:
+    tasks_dir = repo_root / ".cowork-flow" / "tasks"
+    if not tasks_dir.is_dir():
+        return []
+    signals: list[dict[str, str]] = []
+    for task_dir in sorted(tasks_dir.iterdir()):
+        if not task_dir.is_dir() or task_dir.name == "archive":
+            continue
+        status = _status(repo_root, task_dir)
+        kind = RECOVERABLE_TASK_STATUSES.get(status)
+        if kind is None:
+            continue
+        task = _display(repo_root, task_dir)
+        hint = f"./.cowork-flow/run task next {task} --run"
+        if kind == "completed_unarchived":
+            hint = f"{hint} --intent archive"
+        signals.append(
+            {
+                "kind": kind,
+                "task": task,
+                "status": status,
+                "hint": hint,
+            }
+        )
+    return signals
+
+
+def _attach_recovery(payload: dict[str, object], repo_root: Path) -> dict[str, object]:
+    signals = repository_recovery_signals(repo_root)
+    if signals:
+        payload["recovery"] = {
+            "signals": signals,
+            "listCommand": "./.cowork-flow/run task next --list --json",
+        }
+    return payload
+
+
+def _print_recovery(payload: dict[str, object]) -> None:
+    recovery = payload.get("recovery")
+    if not isinstance(recovery, dict):
+        return
+    signals = recovery.get("signals")
+    if not isinstance(signals, list) or not signals:
+        return
+    print("Recovery:")
+    for signal in signals:
+        if isinstance(signal, dict):
+            print(
+                f"  - {signal.get('kind')}: {signal.get('task')} "
+                f"({signal.get('status')})"
+            )
+            print(f"    Hint: {signal.get('hint')}")
+    print(f"List: {recovery.get('listCommand')}")
+
+
 def _print_blockers(blockers: list[str]) -> None:
     if not blockers:
         print("Blockers: none")
@@ -105,6 +167,9 @@ def _print_text_payload(payload: dict[str, object]) -> None:
     print(f"Next action: {action['label']}")
     print(f"Skill: {action['activatedSkill'] or 'none'}")
     print(f"Command: {action['command'] or 'none'}")
+    diagnostics_command = action.get("diagnosticsCommand")
+    if diagnostics_command:
+        print(f"Diagnostics: {diagnostics_command}")
     blockers = payload["blockers"]
     if not isinstance(blockers, list):
         raise TypeError("navigation payload blockers must be a list")
@@ -123,13 +188,15 @@ def _navigation_target(args, repo_root: Path, structured: bool):
     if active.task_path:
         return repo_root / active.task_path, active.task_path, source, True
     if structured:
-        _print_json_route(
+        payload = build_navigation_payload(
             args=args,
             status="no_task",
             blockers=[],
             active_target=False,
             task_path=None,
         )
+        _attach_recovery(payload, repo_root)
+        print(json.dumps(payload, ensure_ascii=False, sort_keys=False))
     else:
         print("Status: no_task")
         print(f"Source: {source}")
@@ -140,7 +207,9 @@ def _navigation_target(args, repo_root: Path, structured: bool):
             blockers=[],
             active_target=False,
         )
+        _attach_recovery(payload, repo_root)
         _print_text_payload(payload)
+        _print_recovery(payload)
     return None