cc-devflow 4.1.6 → 4.2.0

package/.claude/commands/core/architecture.md

@@ -29,6 +29,36 @@ architecture-designer (research, no dialogue)
 ARCHITECTURE.md (4 diagrams)
 ```
 
+## Harness Engineering 增强（Long-running Session Protocol）
+
+为防止跨上下文窗口后出现“图表半生成、ADR 丢失、误判已完成”，执行分为 Initializer 与 Worker 两类会话。
+
+### Phase 0: Initializer Session（首次或 --force）
+
+先建立/刷新架构任务工件（不要一次性生成整份文档）：
+- `devflow/.core-harness/architecture/checklist.json`
+  - 列出 4 张图、ADR、NFR、演进路径等验收项，默认 `passes=false`
+- `devflow/.core-harness/architecture/progress.md`
+  - 记录本次修改、风险、下一步
+- `devflow/.core-harness/architecture/init.md`
+  - 固定启动流程（读取 ROADMAP、读取最近进展、执行 Mermaid 冒烟验证）
+
+### Worker Session（增量交付）
+
+每个窗口只处理一个子目标，例如：
+- 只完成一张 Mermaid 图并自检语法
+- 只补齐 ADR 与对应图表映射
+- 只修复依赖图节点/边一致性问题
+
+会话收尾要求：
+1. 运行当前文档校验（占位符、图表数量、语法）
+2. 更新 checklist 的 `passes` 字段
+3. 写入 progress/handoff，明确下一窗口优先任务
+
+### Done Gate
+
+`checklist.json` 全绿 + Phase 4 校验通过，才可输出成功报告。
+
 ## 执行流程
 
 ### Phase 1: Prerequisites Check

package/.claude/commands/core/guidelines.md

@@ -35,6 +35,31 @@ description: 'Generate project-specific development guidelines skills (frontend/
 /core-guidelines --dry-run
 ```
 
+## Harness Engineering 增强（Eval-Driven + Incremental）
+
+`/core-guidelines` 容易出现两类失败：一次生成过大导致中断、未验证触发规则就标记完成。为此引入双阶段协议。
+
+### Step 0: Initializer Session
+
+创建会话工件：
+- `devflow/.core-harness/guidelines/skill-checklist.json`
+  - Frontend/Backend 分别列出验收项：触发规则、关键资源文件、示例质量、约束合规，默认 `passes=false`
+- `devflow/.core-harness/guidelines/progress.md`
+- `devflow/.core-harness/guidelines/session-handoff.md`
+
+### Worker Session
+
+- 一次只处理一个 skill（frontend 或 backend），禁止同窗口双线并发重写
+- 每次只完成一个最小闭环：`生成/更新 → 触发验证 → 示例验证 → 勾选 passes`
+- 结束前必须写 handoff，明确下一窗口要做的单一目标
+
+### Eval Gate（禁止“看起来差不多”）
+
+只有当以下检查全部通过才标记对应 skill 完成：
+1. `skill-rules.json` 触发范围正确，且前后端互不污染
+2. SKILL + resources 无占位符/虚构路径
+3. 至少 1 个真实文件路径触发测试通过（frontend 与 backend 各自独立）
+
 ---
 
 ## Process

package/.claude/commands/core/roadmap.md

@@ -102,6 +102,35 @@ guides:
 - **roadmap-planner (Agent)**: 根据上下文生成文档，无对话
 - **architecture-designer (Agent)**: 生成架构图，无对话
 
+## Harness Engineering 增强（OpenAI + Anthropic 实践融合）
+
+为避免长会话中的“半成品漂移 / 提前宣布完成 / 上下文断片”，`/core-roadmap` 强制采用双阶段执行。
+
+### Stage -1: Initializer Session（只做地基，不做全量生成）
+
+在首次运行或 `--regenerate` 时先建立可恢复工件：
+- `devflow/.core-harness/roadmap/feature-checklist.json`
+  - 结构化列出路线图必须产物（愿景、里程碑、依赖图、容量评估、季度分配等），默认 `passes=false`
+- `devflow/.core-harness/roadmap/progress.md`
+  - 记录每次会话完成内容、未决问题、下一步
+- `devflow/.core-harness/roadmap/session-handoff.md`
+  - 给下一窗口的启动指令（从哪个 Stage 继续、先做什么验证）
+
+### Worker Session（增量推进，每次只完成一个最小目标）
+
+每个窗口必须遵守：
+1. 启动先读状态：`pwd` → `progress.md` → `feature-checklist.json` → 最近 git log（若仓库可用）
+2. 先做冒烟检查：确认现有 `ROADMAP.md/BACKLOG.md/ARCHITECTURE.md` 不是损坏状态
+3. 只推进一个最小单元：
+   - 一个 Stage 的信息收集，或
+   - 一个 RM 依赖簇的整理，或
+   - 一次时间线冲突修复
+4. 结束前必须更新工件：勾选 `passes`、写入 progress/handoff、明确下一步
+
+### 完成判定（禁止“口头完成”）
+
+只有 `feature-checklist.json` 全部 `passes=true`，且 Stage 8 输出文件全部存在并通过校验，才允许宣告完成。
+
 ---
 
 ## 执行流程骨架

package/.claude/commands/core/style.md

@@ -21,6 +21,24 @@ $ARGUMENTS = "[--update]"
 /core-style --update   # 更新已有风格指南
 ```
 
+## Harness Engineering 增强（多窗口稳定执行）
+
+为避免风格文档在多轮会话中变成“补丁堆”，执行采用 initializer + incremental worker。
+
+### 0. Initializer Session
+- 建立 `devflow/.core-harness/style/` 工件：
+  - `checklist.json`: token 体系、组件约束、可访问性、响应式、动效、禁用项等验收项（默认 `passes=false`）
+  - `progress.md`: 本轮修改与未决项
+  - `session-handoff.md`: 下一轮优先任务与验证命令
+
+### 1. Worker Session
+- 每轮只处理一个最小块（例如颜色 token、排版 token、某一类组件约束）
+- 修改后立即做局部验证，不通过则回滚该块后重试
+- 收尾必须同步 checklist/progress/handoff，保持可恢复
+
+### 2. Done Gate
+- 只有 checklist 全部 `passes=true` 且第 4 步校验通过，才允许输出“STYLE 生成完成”
+
 ## 执行步骤
 
 ### 1. 入口检查

package/.claude/skills/cc-devflow-orchestrator/SKILL.md

@@ -19,6 +19,29 @@ Guide users to the correct command/skill without duplicating detailed implementa
 /core:style        → STYLE.md
 ```
 
+## Project-Level Harness Protocol (Long-running)
+
+For `/core:*` commands, enforce a two-session model before declaring completion:
+
+1. Initializer session
+   - establish/update `devflow/.core-harness/<command>/checklist.json`, `progress.md`, `session-handoff.md`
+   - convert high-level goal into structured acceptance checks (default all failing)
+2. Worker session(s)
+   - resume from `session-handoff.md` + `progress.md`
+   - execute one smallest deliverable per session
+   - update checklist status only after command-specific validation
+3. Completion gate
+   - completion is allowed only when checklist is fully passing and command validation gates pass
+   - never declare success from “looks complete”; require artifact evidence
+
+### Core Route Defaults
+
+- no `devflow/ROADMAP.md` → route to `/core:roadmap` (initializer first)
+- roadmap exists but architecture missing/stale → route to `/core:architecture`
+- architecture exists but guidelines missing/stale → route to `/core:guidelines`
+- style missing/stale → route to `/core:style`
+- interrupted core command → rerun same command from handoff (`/core:roadmap --resume` if supported; otherwise run command again and continue from `session-handoff.md`)
+
 ### Requirement-Level Canonical Mainline (v6)
 
 ```text
@@ -140,5 +163,7 @@ This skill only does routing:
 - Which command to run next
 - Which gate blocks progress
 - Which migration path applies for deprecated commands
+- Prefer incremental convergence over one-shot generation
+- Require artifact-backed completion for long-running sessions
 
 Detailed quality standards stay in command files and workflow skills.

package/.claude/skills/workflow/flow-dev/SKILL.md

@@ -11,6 +11,42 @@ description: 'Execute task-manifest with dependency-aware parallel dispatch and
 
 执行 `task-manifest.json` 中的任务，默认并行调度并写入 checkpoint/events 供恢复。
 
+## Long-Running Harness Protocol（Initializer/Worker/Done Gate）
+
+`/flow:dev` 是最长链路阶段，必须严格执行“先读状态、再增量、后留证据”。
+
+### Session Start（禁止盲跑）
+
+每个窗口开始时先同步以下信息：
+- `devflow/requirements/${REQ_ID}/session-checklist.json`（若存在）
+- `devflow/requirements/${REQ_ID}/session-progress.md`（若存在）
+- `devflow/requirements/${REQ_ID}/session-handoff.md`（若存在）
+- `devflow/requirements/${REQ_ID}/task-manifest.json`
+- `.harness/runtime/${REQ_ID}/**/checkpoint.json` 与 `events.jsonl`（若存在）
+
+然后执行一次基础健康检查：
+1. 不存在损坏的 `running` 残留状态
+2. 上轮失败任务与失败原因可定位
+
+### Worker Session（最小可执行前沿）
+
+单窗口仅推进一个最小前沿：
+- 仅处理当前 `dependsOn` 已满足的一组任务
+- 每完成一组任务即写入 checkpoint/events
+- 遇到失败立即收敛原因并记录，不并行扩散新的失败面
+
+会话收尾必须：
+1. 更新 `task-manifest.json` 状态
+2. 更新 `session-progress.md` 与 `session-handoff.md`
+3. 推荐提交一个可回滚的最小 git commit（若仓库策略允许）
+
+### Done Gate
+
+仅当以下条件满足才标记 `flow:dev` 完成：
+- 全部任务为 `passed` 或 `skipped`
+- 无 `running`/`failed` 残留
+- `session-checklist.json` 中 `flow:dev.passes == true`
+
 ## Input Format
 
 ```bash

package/.claude/skills/workflow/flow-init/SKILL.md

@@ -11,6 +11,35 @@ description: 'Initialize a requirement with harness state and context package. U
 
 初始化需求目录的 harness 运行状态，并生成可执行上下文包。
 
+## Long-Running Harness Protocol（Initializer/Worker/Done Gate）
+
+为与 `/core:*` 保持一致，`/flow:init` 也采用会话分层协议。
+
+### Initializer Session（为后续窗口建立可恢复上下文）
+
+在执行 `harness:init + harness:pack` 后，确保以下工件存在：
+- `devflow/requirements/${REQ_ID}/session-checklist.json`
+  - 至少包含 `flow:init/flow:spec/flow:dev/flow:verify/flow:release` 五个阶段，默认 `passes=false`
+- `devflow/requirements/${REQ_ID}/session-progress.md`
+  - 记录本窗口完成内容、风险和阻塞
+- `devflow/requirements/${REQ_ID}/session-handoff.md`
+  - 明确下一窗口唯一优先动作（通常是 `/flow:spec "${REQ_ID}"`）
+
+### Worker Session（只做 init 的原子闭环）
+
+每次仅执行一个最小闭环：
+1. 读取 `session-progress.md` 与 `session-handoff.md`
+2. 运行 `harness:init`
+3. 运行 `harness:pack`
+4. 验证产物并更新 session 工件
+
+### Done Gate（禁止口头完成）
+
+仅当以下条件同时满足才允许标记 `flow:init` 为完成：
+- `harness-state.json.status == "initialized"`
+- `context-package.md` 存在且包含 Next Commands
+- `session-checklist.json` 中 `flow:init.passes == true`
+
 ## Input Format
 
 ```bash

package/.claude/skills/workflow/flow-spec/SKILL.md

@@ -11,6 +11,38 @@ description: 'Generate and refresh task-manifest for a requirement. Use when con
 
 将需求上下文转换为 `task-manifest.json`，作为后续执行唯一任务源。
 
+## Long-Running Harness Protocol（Initializer/Worker/Done Gate）
+
+`/flow:spec` 必须以“可恢复、可验证”的增量方式生成计划，而不是一次性黑箱产出。
+
+### Session Start（先同步上下文，再规划）
+
+每个窗口启动先读取：
+- `devflow/requirements/${REQ_ID}/session-checklist.json`（若存在）
+- `devflow/requirements/${REQ_ID}/session-progress.md`（若存在）
+- `devflow/requirements/${REQ_ID}/session-handoff.md`（若存在）
+- `devflow/requirements/${REQ_ID}/context-package.md`
+- 旧版 `task-manifest.json`（若存在）
+
+### Worker Session（一次只收敛一个规划目标）
+
+每轮只完成一个最小目标，例如：
+- 修正一个依赖子图
+- 补齐一组缺失的 `run` 指令
+- 处理一次 `--overwrite` 下的清理重建
+
+完成后必须：
+1. 运行 `harness:plan` 生成/刷新 manifest
+2. 校验 schema 与依赖无环
+3. 更新 progress/handoff，写明下一轮唯一目标
+
+### Done Gate
+
+仅当以下条件满足才标记 `flow:spec` 完成：
+- `task-manifest.json` 存在且 `tasks` 非空
+- `id/dependsOn/run` 字段完整且无自循环
+- `session-checklist.json` 中 `flow:spec.passes == true`
+
 ## Input Format
 
 ```bash

package/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [4.2.0] - 2026-02-19
+
+### 🧠 Long-Running Harness Protocol Alignment
+
+v4.2.0 unifies long-running execution protocol across project-level `/core:*` commands and requirement-level `/flow:*` skills, reducing context-loss regressions and premature completion.
+
+#### Added
+
+- **Project-level harness protocol**
+  - Added `Initializer / Worker / Done Gate` guidance to:
+    - `.claude/commands/core/roadmap.md`
+    - `.claude/commands/core/architecture.md`
+    - `.claude/commands/core/guidelines.md`
+    - `.claude/commands/core/style.md`
+  - Standardized resumable artifacts under `devflow/.core-harness/*` (`checklist`, `progress`, `handoff`)
+
+- **Requirement-level protocol parity**
+  - Added the same long-running protocol to:
+    - `.claude/skills/workflow/flow-init/SKILL.md`
+    - `.claude/skills/workflow/flow-spec/SKILL.md`
+    - `.claude/skills/workflow/flow-dev/SKILL.md`
+  - Standardized requirement session artifacts:
+    - `session-checklist.json`
+    - `session-progress.md`
+    - `session-handoff.md`
+
+- **Routing-level enforcement**
+  - Extended `.claude/skills/cc-devflow-orchestrator/SKILL.md` with project-level harness routing defaults and artifact-backed completion rules
+
+#### Benefits
+
+- ✅ Consistent long-running behavior between `/core:*` and `/flow:*`
+- ✅ Clear resumability across context windows
+- ✅ Stronger done criteria via artifact-backed gates (instead of subjective completion)
+
 ## [4.1.6] - 2026-02-18
 
 ### 🔧 Multi-Platform Adapt Pipeline Stabilization
@@ -19,6 +54,12 @@ v4.1.6 fixes multi-platform `adapt` compilation drift and parsing failures, with
   - `.claude/commands/**/CLAUDE.md` is now excluded from command parsing
   - Prevents false `Missing YAML frontmatter` failures during `npm run adapt`
 
+- **Harness runtime chain bootstrap**
+  - `cc-devflow init` and `cc-devflow adapt` now auto-add missing `harness:*` npm scripts into target `package.json`
+  - Added `cc-devflow harness <subcommand>` passthrough so injected scripts have a stable runtime entry
+  - Injected scripts are now machine-portable (`cc-devflow harness ...`) with no absolute-path coupling
+  - Auto-repairs legacy `node bin/harness.js <cmd>`, old `npx` wrappers, and prior absolute-path script values
+
 - **Manifest consistency across platforms**
   - Separated source hash (`sourceHash`) and emitted target hash (`hash`)
   - Drift detection now compares emitted artifact hashes correctly

package/README.md

@@ -184,8 +184,13 @@ cc-devflow init --dir /path/to/project
 # Compile for specific platform
 cc-devflow adapt --platform codex
 cc-devflow adapt --cwd /path/to/project --platform cursor
+
+# Run harness runtime directly (for npm script delegation)
+cc-devflow harness release --change-id REQ-123
 ```
 
+`cc-devflow init` and `cc-devflow adapt` now auto-bootstrap missing `harness:*` npm scripts in `package.json` using portable `cc-devflow harness <subcommand>` entries (no machine-specific absolute paths), so `/flow:*` can execute the runtime chain without manual script patching.
+
 ### Optional Dependencies
 
 ```bash

package/README.zh-CN.md

@@ -184,8 +184,13 @@ cc-devflow init --dir /path/to/project
 # 编译到特定平台
 cc-devflow adapt --platform codex
 cc-devflow adapt --cwd /path/to/project --platform cursor
+
+# 直接运行 harness runtime（供 npm scripts 委派）
+cc-devflow harness release --change-id REQ-123
 ```
 
+`cc-devflow init` 与 `cc-devflow adapt` 现在会自动补齐 `package.json` 中缺失的 `harness:*` scripts，且统一写入可移植的 `cc-devflow harness <subcommand>`（不使用机器绝对路径），避免 `/flow:*` 因脚本缺失退化到手工 fallback。
+
 ### 验证安装
 
 ```bash

package/bin/cc-devflow-cli.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+/**
+ * [INPUT]: 依赖 .claude 模板、adapt 编译入口与 harness 运行时入口。
+ * [OUTPUT]: 提供 init/adapt/harness 命令，并在目标仓库自动补齐 harness npm scripts。
+ * [POS]: cc-devflow 的统一 CLI 门面，串联安装、编译与运行时发布链路。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
@@ -7,6 +13,17 @@ const PACKAGE_ROOT = path.resolve(__dirname, '..');
 const TEMPLATE_DIR = path.join(PACKAGE_ROOT, '.claude');
 const ADAPT_BIN = path.join(PACKAGE_ROOT, 'bin', 'adapt.js');
 const ADAPTER_BIN = path.join(PACKAGE_ROOT, 'bin', 'cc-devflow.js');
+const HARNESS_BIN = path.join(PACKAGE_ROOT, 'bin', 'harness.js');
+const HARNESS_SCRIPT_COMMANDS = {
+  'harness:init': 'init',
+  'harness:pack': 'pack',
+  'harness:plan': 'plan',
+  'harness:dispatch': 'dispatch',
+  'harness:verify': 'verify',
+  'harness:release': 'release',
+  'harness:resume': 'resume',
+  'harness:janitor': 'janitor'
+};
 
 function showHelp() {
   console.log(`
@@ -15,6 +32,7 @@ Usage: cc-devflow <command> [options]
 Commands:
   init                Install .claude template into a project
   adapt               Compile .claude into multi-platform outputs
+  harness             Run harness runtime commands (init/verify/release/janitor...)
 
 Init options:
   --dir <path>         Target project path (default: cwd)
@@ -34,6 +52,7 @@ Examples:
   cc-devflow init --dir /path/to/project
   cc-devflow adapt --platform cursor
   cc-devflow adapt --cwd /path/to/project --platform codex
+  cc-devflow harness release --change-id REQ-123
 `);
 }
 
@@ -122,6 +141,114 @@ function copyIncremental(src, dest) {
   }
 }
 
+function detectJsonIndent(content) {
+  const match = content.match(/\n([ \t]+)"[^"\n]+":/);
+  if (!match) {
+    return 2;
+  }
+
+  const indent = match[1];
+  return indent.includes('\t') ? '\t' : indent.length;
+}
+
+function hasLocalHarnessBinary(targetRoot) {
+  return fs.existsSync(path.join(targetRoot, 'bin', 'harness.js'));
+}
+
+function getHarnessScriptCommand(targetRoot, subcommand) {
+  if (hasLocalHarnessBinary(targetRoot)) {
+    return `node bin/harness.js ${subcommand}`;
+  }
+  return `cc-devflow harness ${subcommand}`;
+}
+
+function ensureHarnessScripts(targetRoot) {
+  const pkgPath = path.join(targetRoot, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    console.warn(`[WARN] Missing package.json in ${targetRoot}; skipping harness script bootstrap.`);
+    return;
+  }
+
+  let raw;
+  let packageJson;
+  try {
+    raw = fs.readFileSync(pkgPath, 'utf8');
+    packageJson = JSON.parse(raw);
+  } catch (error) {
+    console.warn(`[WARN] Skipping harness script bootstrap: cannot parse package.json (${error.message})`);
+    return;
+  }
+
+  if (!packageJson || typeof packageJson !== 'object' || Array.isArray(packageJson)) {
+    console.warn('[WARN] Skipping harness script bootstrap: package.json root must be an object.');
+    return;
+  }
+
+  if (!packageJson.scripts || typeof packageJson.scripts !== 'object' || Array.isArray(packageJson.scripts)) {
+    packageJson.scripts = {};
+  }
+
+  const hasLocalBinary = hasLocalHarnessBinary(targetRoot);
+  const added = [];
+  const repaired = [];
+  let changed = false;
+
+  for (const [scriptName, subcommand] of Object.entries(HARNESS_SCRIPT_COMMANDS)) {
+    const desired = getHarnessScriptCommand(targetRoot, subcommand);
+    const existing = packageJson.scripts[scriptName];
+
+    if (typeof existing === 'undefined') {
+      packageJson.scripts[scriptName] = desired;
+      added.push(scriptName);
+      changed = true;
+      continue;
+    }
+
+    if (typeof existing !== 'string') {
+      continue;
+    }
+
+    // Auto-repair legacy value when local harness binary does not exist.
+    if (!hasLocalBinary && existing.trim() === `node bin/harness.js ${subcommand}`) {
+      packageJson.scripts[scriptName] = desired;
+      repaired.push(scriptName);
+      changed = true;
+      continue;
+    }
+
+    // Auto-repair previous injected npx-based value to deterministic runtime path.
+    if (!hasLocalBinary && existing.trim() === `npx --yes cc-devflow harness ${subcommand}`) {
+      packageJson.scripts[scriptName] = desired;
+      repaired.push(scriptName);
+      changed = true;
+      continue;
+    }
+
+    // Auto-repair previous absolute-path fallback value (not portable across machines).
+    const escapedHarnessBin = HARNESS_BIN.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const absoluteLegacy = new RegExp(`^node\\s+["']?${escapedHarnessBin}["']?\\s+${subcommand}(\\s*\\|\\|\\s*cc-devflow\\s+harness\\s+${subcommand})?$`);
+    if (!hasLocalBinary && absoluteLegacy.test(existing.trim())) {
+      packageJson.scripts[scriptName] = desired;
+      repaired.push(scriptName);
+      changed = true;
+    }
+  }
+
+  if (!changed) {
+    return;
+  }
+
+  const indent = detectJsonIndent(raw);
+  fs.writeFileSync(pkgPath, `${JSON.stringify(packageJson, null, indent)}\n`);
+
+  if (added.length > 0) {
+    console.log(`[UPDATE] package.json (added ${added.join(', ')})`);
+  }
+  if (repaired.length > 0) {
+    console.log(`[UPDATE] package.json (repaired ${repaired.join(', ')})`);
+  }
+}
+
 function runInit(args) {
   const { options } = parseCliArgs(args);
 
@@ -141,6 +268,7 @@ function runInit(args) {
   // Case 1: Directory does not exist - Clean Install
   if (!fs.existsSync(targetDir)) {
     fs.cpSync(TEMPLATE_DIR, targetDir, { recursive: true });
+    ensureHarnessScripts(targetRoot);
     console.log(`Initialized .claude in ${targetRoot}`);
     return 0;
   }
@@ -150,6 +278,7 @@ function runInit(args) {
     console.log('Force flag detected. Resetting .claude directory...');
     fs.rmSync(targetDir, { recursive: true, force: true });
     fs.cpSync(TEMPLATE_DIR, targetDir, { recursive: true });
+    ensureHarnessScripts(targetRoot);
     console.log(`Re-initialized .claude in ${targetRoot}`);
     return 0;
   }
@@ -157,6 +286,7 @@ function runInit(args) {
   // Case 3: Directory exists - Incremental Update
   console.log(`Target ${targetDir} already exists. Performing incremental update...`);
   copyIncremental(TEMPLATE_DIR, targetDir);
+  ensureHarnessScripts(targetRoot);
   console.log('Incremental update complete. Existing files were preserved.');
   return 0;
 }
@@ -178,6 +308,8 @@ function runAdapt(args) {
     return 1;
   }
 
+  ensureHarnessScripts(targetRoot);
+
   const result = spawnSync(process.execPath, [ADAPT_BIN, ...rest], {
     stdio: 'inherit',
     cwd: targetRoot
@@ -191,6 +323,24 @@ function runAdapt(args) {
   return typeof result.status === 'number' ? result.status : 1;
 }
 
+function runHarness(args) {
+  const { options, rest } = parseCliArgs(args);
+
+  const targetRoot = path.resolve(options.cwd || process.cwd());
+  const cliArgs = options.help || rest.length === 0 ? ['--help'] : rest;
+  const result = spawnSync(process.execPath, [HARNESS_BIN, ...cliArgs], {
+    stdio: 'inherit',
+    cwd: targetRoot
+  });
+
+  if (result.error) {
+    console.error(`Failed to run harness: ${result.error.message}`);
+    return 1;
+  }
+
+  return typeof result.status === 'number' ? result.status : 1;
+}
+
 function runAdapter(command, args) {
   const result = spawnSync(process.execPath, [ADAPTER_BIN, command, ...args], {
     stdio: 'inherit'
@@ -221,6 +371,10 @@ function main() {
     return runAdapt(rest);
   }
 
+  if (command === 'harness') {
+    return runHarness(rest);
+  }
+
   return runAdapter(command, rest);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cc-devflow",
-    "version": "4.1.6",
+    "version": "4.2.0",
     "description": "DevFlow CLI tool",
     "main": "bin/cc-devflow.js",
     "bin": {