mancode 0.3.7 → 0.3.9

package/dist/cli.js

@@ -108,7 +108,7 @@ var PLAN_COACH_AGENT = {
   tools: ["Read", "Grep", "Glob"],
   body: `\u4F60\u662F mancode \u6559\u7EC3\u7EC4\u7684 Plan Coach\uFF08\u8BA1\u5212\u6559\u7EC3\uFF09\u3002
 
-\u4F60\u7684\u804C\u8D23\uFF1A\u5728\u7528\u6237\u786E\u8BA4\u524D\uFF0C\u628A Scout Report \u548C\u56E2\u961F\u4E0A\u4E0B\u6587\u6574\u7406\u6210\u53EF\u6267\u884C plan\u3002
+\u4F60\u7684\u804C\u8D23\uFF1A\u5148\u68C0\u67E5\u9700\u6C42\u662F\u5426\u8DB3\u591F\u652F\u6491\u8BA1\u5212\uFF0C\u518D\u5728\u7528\u6237\u786E\u8BA4\u524D\u628A Scout Report\u3001\u7ED3\u6784\u5316 requirements \u548C\u56E2\u961F\u4E0A\u4E0B\u6587\u6574\u7406\u6210\u53EF\u6267\u884C plan\u3002
 
 ## \u786C\u7EA6\u675F
 
@@ -116,6 +116,16 @@ var PLAN_COACH_AGENT = {
 - \u4E0D\u521B\u5EFA README\u3001\u6E90\u7801\u3001\u914D\u7F6E\u3001\u6D4B\u8BD5\u6216\u56E2\u961F memory\u3002
 - \u4E0D\u628A proposal \u5199\u6210 decision\u3002\u56E2\u961F\u51B3\u7B56\u53EA\u80FD\u5728\u7528\u6237\u786E\u8BA4\u5E76\u5B8C\u6210\u5B9E\u73B0\u540E\u8FDB\u5165 \`.mancode/memory/decisions.md\`\u3002
 - \u53EA\u5728\u6700\u7EC8\u54CD\u5E94\u91CC\u8FD4\u56DE\u8BA1\u5212\u6587\u672C\uFF1B\u8C03\u7528\u65B9\u4F1A\u8D1F\u8D23\u5199\u5165 \`.mancode/workflows/<taskId>/plan.md\`\u3002
+- \u4E0D\u7528\u81EA\u5DF1\u7684\u5047\u8BBE\u586B\u8865\u4F1A\u6539\u53D8\u8303\u56F4\u3001\u67B6\u6784\u3001\u6210\u672C\u6216\u9A8C\u6536\u7684 blocking \u51B3\u7B56\u3002
+
+## \u8F93\u5165\u5C31\u7EEA\u68C0\u67E5
+
+\u5148\u8BFB\u53D6 \`requirements.json\`\uFF0C\u4EE5\u5176\u4E2D\u7684 confirmedScope\u3001excludedScope\u3001technicalDecisions\u3001defaults\u3001blockingUnknowns\u3001coverage \u548C acceptanceCriteria \u4E3A\u6743\u5A01\u8F93\u5165\uFF1B\`requirements.md\` \u53EA\u7528\u4E8E\u9605\u8BFB\u3002\u9010\u9879\u68C0\u67E5 platform\u3001core_scope\u3001technical_stack\u3001data_and_persistence\u3001performance\u3001compatibility\u3001security \u7684\u72B6\u6001\u548C\u7406\u7531\u662F\u5426\u4E0E\u4E8B\u5B9E\u4E00\u81F4\u3002\u68C0\u67E5\u9700\u6C42\u662F\u5426\u8986\u76D6\u4EFB\u52A1\u5B9E\u9645\u9002\u7528\u7684\u7528\u6237\u76EE\u6807\u3001\u6838\u5FC3\u6D41\u7A0B\u3001\u9996\u671F\u8303\u56F4\u3001\u6392\u9664\u9879\u3001\u6280\u672F\u4E0E\u8FD0\u884C\u7EA6\u675F\u3001\u6570\u636E/\u72B6\u6001/\u96C6\u6210\u3001\u5173\u952E\u6027\u80FD/\u517C\u5BB9\u6027/\u5B89\u5168\u8981\u6C42\u548C\u9A8C\u6536\u6807\u51C6\u3002blockingUnknowns \u975E\u7A7A\u3001coverage \u7528\u65E0\u6839\u636E\u7684 not_applicable \u63A9\u76D6\u51B3\u7B56\u3001\u6838\u5FC3\u884C\u4E3A\u7F3A\u5C11\u9A8C\u6536 ID\uFF0C\u6216\u6587\u6863\u4E0E\u7ED3\u6784\u5316\u8F93\u5165\u77DB\u76FE\u65F6\u5FC5\u987B\u8FD4\u56DE NEEDS_CLARIFICATION\u3002
+
+\u53EA\u80FD\u8FD4\u56DE\u4E24\u79CD\u7ED3\u679C\uFF1A
+
+1. \`NEEDS_CLARIFICATION\`\uFF1A\u5B58\u5728 blocking \u7F3A\u53E3\u65F6\uFF0C\u4E0D\u751F\u6210\u8BA1\u5212\u3002\u5217\u51FA\u7F3A\u5931\u51B3\u7B56\u3001\u5BF9\u8BA1\u5212\u7684\u5F71\u54CD\u30012\u20133 \u4E2A\u53EF\u884C\u9009\u9879\u3001\u660E\u786E\u63A8\u8350\u548C\u5EFA\u8BAE\u95EE\u9898\u3002
+2. \`READY_FOR_PLAN\`\uFF1A\u6CA1\u6709 blocking \u7F3A\u53E3\u65F6\uFF0C\u8F93\u51FA\u6807\u8BB0\u540E\u518D\u751F\u6210\u5B8C\u6574\u8BA1\u5212\u3002defaultable \u7EC6\u8282\u5FC5\u987B\u4F5C\u4E3A\u663E\u5F0F\u9ED8\u8BA4\u503C\u5199\u5165\u8BA1\u5212\u3002
 
 ## \u8F93\u51FA\u683C\u5F0F
 
@@ -127,7 +137,7 @@ var PLAN_COACH_AGENT = {
 - \u7B80\u5355 / \u4E2D\u7B49 / \u590D\u6742\uFF1B\u8BF4\u660E\u7406\u7531
 ## \u6A21\u5757\u7D22\u5F15
 ## \u6280\u672F\u4E0E\u4EA4\u4ED8\u7EA6\u675F\uFF08\u4EC5\u65B0\u9879\u76EE\u6216\u6280\u672F\u9009\u62E9\u672A\u5B9A\u65F6\uFF09
-- \u5019\u9009\u65B9\u6848\uFF082\u20133 \u4E2A\uFF09\u3001\u4F18\u7F3A\u70B9\u3001\u63A8\u8350\u4E0E\u786E\u8BA4\u70B9\uFF1B\u5DF2\u6709\u9879\u76EE\u5199\u201C\u6CBF\u7528\u68C0\u6D4B\u5230\u7684\u9879\u76EE\u7EA6\u5B9A\u201D
+- \u5DF2\u786E\u8BA4\u65B9\u6848\u3001\u9009\u62E9\u7406\u7531\u548C\u53D6\u820D\uFF1B\u5C1A\u672A\u786E\u8BA4\u4F1A\u6539\u53D8\u67B6\u6784\u7684\u6280\u672F\u9009\u62E9\u65F6\u8FD4\u56DE NEEDS_CLARIFICATION\uFF1B\u5DF2\u6709\u9879\u76EE\u5199\u201C\u6CBF\u7528\u68C0\u6D4B\u5230\u7684\u9879\u76EE\u7EA6\u5B9A\u201D
 ## \u6A21\u5757\uFF1A<\u540D\u79F0>
 ### \u6539\u52A8\u6587\u4EF6 / \u65B0\u5EFA\u6587\u4EF6
 ### \u590D\u7528\u8D44\u6E90\uFF08\u5F15\u7528 scout-report.md \u884C\u53F7\uFF09
@@ -135,13 +145,16 @@ var PLAN_COACH_AGENT = {
 ### \u4E0D\u505A\u4EC0\u4E48
 ### \u5B9E\u65BD\u6B65\u9AA4
 ### \u98CE\u9669\u70B9
+### \u56DE\u9000\u65B9\u5F0F
 ### \u5B8C\u6210\u5B9A\u4E49
+## \u975E\u963B\u585E\u9ED8\u8BA4\u503C
 ## \u9A8C\u8BC1\u8BA1\u5212
+- \u628A\u6BCF\u4E2A required \u9A8C\u6536 ID \u6620\u5C04\u5230 automated / manual / hybrid \u9A8C\u8BC1\uFF0C\u4E0D\u5F97\u7528\u9875\u9762\u52A0\u8F7D\u6216\u4EE3\u7801\u9605\u8BFB\u4EE3\u66FF\u6838\u5FC3\u4EA4\u4E92
 - build / lint / typecheck / test / smoke test
 ## \u9884\u4F30
 \`\`\`
 
-\u5982\u679C\u4EFB\u52A1\u4E0D\u5E94\u7EE7\u7EED\u5B9E\u65BD\uFF0C\u660E\u786E\u5199\u5728 Risks \u6216 Questions \u4E2D\u3002`
+\u5982\u679C\u4EFB\u52A1\u4E0D\u5E94\u7EE7\u7EED\u5B9E\u65BD\uFF0C\u8FD4\u56DE NEEDS_CLARIFICATION\uFF0C\u4E0D\u8981\u7528\u4E00\u4EFD\u770B\u4F3C\u5B8C\u6574\u7684\u8BA1\u5212\u63A9\u76D6\u7F3A\u5931\u9700\u6C42\u3002`
 };
 
 // src/templates/agents/head-coach.ts
@@ -584,6 +597,21 @@ if (state.teamModeAutoDetected === true && mode === 'solo') {
   );
 }
 
+if (
+  mode === 'solo' &&
+  state.activeSoloPlan &&
+  typeof state.activeSoloPlan.taskId === 'string'
+) {
+  output.push(
+    '',
+    '### 已确认的 solo 实施计划',
+    'Task: ' + sanitize(state.activeSoloPlan.taskId),
+    'Plan version: ' + sanitize(state.activeSoloPlan.planVersion || 1),
+    '- 收到继续实施指令时，先读对应 workflow 的 requirements.md 和 plan.md。',
+    '- 按已确认范围轻量开发，不重新进入 /man，不运行独立 reviewer。',
+  );
+}
+
 console.log(output.join('\n'));
 
 function readJson(filePath) {
@@ -646,8 +674,31 @@ if (mode === 'solo') {
 const rawInput = readFileSync(0, 'utf8');
 const userPrompt = readPrompt(rawInput);
 const planningPattern = /先(?:别|不要|看|看看|调研|分析|评估)|给.*方案|给.*计划|怎么.*做|如何.*做|怎么.*实现|如何.*实现|应该怎么|怎么.*拆|拆分|只给.*计划|不要.*改代码|别.*改代码|不要.*动代码|别.*动代码|评估.*风险|风险.*评估|设计.*方案|架构|迁移|集成|\b(?:plan|planning|research|investigate|approach|proposal|architecture|risk|migration|integration)\b|how (?:should|would|to)|do not (?:edit|modify|change)|don.t (?:edit|modify|change)|no code changes|without changing code/iu;
+const approvedPlanExecutionPattern = /按.*计划|继续.*计划|执行.*计划|实现.*计划|(?:implement|execute|continue|resume).*(?:approved )?plan/iu;
+const hasActiveSoloPlan =
+  mode === 'solo' &&
+  state.activeSoloPlan &&
+  typeof state.activeSoloPlan.taskId === 'string';
+
+if (hasActiveSoloPlan) {
+  output.push(
+    '## mancode 已确认计划',
+    '',
+    '当前 solo 计划：.mancode/workflows/' +
+      sanitize(state.activeSoloPlan.taskId) +
+      '/plan.md（v' +
+      sanitize(state.activeSoloPlan.planVersion || 1) +
+      '）。',
+    '实施前同时读取 requirements.md；只执行确认范围，完成后运行 workflow handoff <taskId> --complete。',
+    '',
+  );
+}
 
-if (mode === 'solo' && planningPattern.test(userPrompt)) {
+if (
+  mode === 'solo' &&
+  planningPattern.test(userPrompt) &&
+  !(hasActiveSoloPlan && approvedPlanExecutionPattern.test(userPrompt))
+) {
   output.push(
     '## mancode 自动路由',
     '',
@@ -771,6 +822,14 @@ var SOLO_SKILL = `# mancode \xB7 solo mode
 3. \u641C\u7D22\u76F8\u4F3C\u5B9E\u73B0\uFF08"\u8FD9\u4E2A\u9879\u76EE\u91CC\u6709\u6CA1\u6709\uFF1F"\uFF09
 4. \u68C0\u67E5\u53EF\u590D\u7528\u8D44\u6E90
 
+### \u6267\u884C\u5DF2\u786E\u8BA4\u7684 /man \u8BA1\u5212
+\u5F53 \`.mancode/state.json\` \u7684 \`activeSoloPlan\` \u975E\u7A7A\u4E14\u7528\u6237\u8981\u6C42\u7EE7\u7EED\u8BE5\u8BA1\u5212\u65F6\uFF1A
+1. \u8BFB\u53D6\u5BF9\u5E94 workflow \u7684 \`requirements.md\` \u548C \`plan.md\`\uFF0C\u786E\u8BA4 taskId \u4E0E planVersion\u3002
+2. \u5F00\u5DE5\u524D\u56DE\u6267\u76EE\u6807\u3001\u6280\u672F\u65B9\u6848\u3001\u5305\u542B\u8303\u56F4\u3001\u6392\u9664\u8303\u56F4\u3001\u9A8C\u8BC1\u65B9\u5F0F\u548C\u6B8B\u4F59\u5047\u8BBE\u3002
+3. \u53EA\u6309\u8BA1\u5212\u8F7B\u91CF\u5B9E\u65BD\uFF1B\u4E0D\u91CD\u65B0\u89C4\u5212\u3001\u4E0D\u8C03\u7528 Film Reviewer\u3001\u4E0D\u521B\u5EFA\u65B0\u7684 /man workflow\u3002
+4. \u53D1\u73B0\u4F1A\u6539\u53D8\u67B6\u6784\u3001\u8303\u56F4\u6216\u9A8C\u6536\u7684\u7F3A\u53E3\u65F6\u6682\u505C\u5E76\u8BE2\u95EE\uFF0C\u4E0D\u81EA\u884C\u6269\u5927\u8BA1\u5212\u3002
+5. \u5B8C\u6210\u6700\u7A84\u6709\u6548\u9A8C\u8BC1\u548C\u4E00\u6B21\u53D7\u9650 diff \u81EA\u68C0\u540E\uFF0C\u8FD0\u884C \`mancode workflow handoff <taskId> --complete\`\uFF1B\u7531 CLI \u539F\u5B50\u6E05\u7406 \`activeSoloPlan\`\u3001\u628A workflow \u6807\u8BB0 completed \u5E76\u79FB\u51FA Active Plans\uFF0C\u4FDD\u7559\u8BA1\u5212\u6587\u4EF6\u3002
+
 ### UI \u4EFB\u52A1\uFF08\u6761\u4EF6\u6267\u884C\uFF09
 \u4EC5\u5F53 project-profile \u786E\u8BA4\u6709 UI \u8D44\u4EA7\u4E14\u4EFB\u52A1\u786E\u5B9E\u6D89\u53CA\u754C\u9762\u65F6\uFF1A
 1. UserPromptSubmit hook \u4F1A\u6CE8\u5165\u9879\u76EE\u5BA1\u7F8E token\uFF08\u5982\u6709\uFF09
@@ -813,16 +872,18 @@ var CORE_CODING_PRINCIPLES = `## \u94C1\u5F8B\uFF08\u6C38\u4E0D\u8FDD\u53CD\uFF0
 // src/templates/skills/man.ts
 var MAN_SKILL = {
   name: "man",
-  description: "Progressive 9-step engineering workflow: research, clarify, plan, choose plan-only or execution, implement, validate, review, and wrap up. Use for complex or high-risk changes.",
+  description: "Planning and progressive engineering workflow: research, align requirements, recommend options, produce a confirmed plan, then choose plan-only, lightweight solo implementation, or the full governed workflow. Use for planning requests and complex or high-risk changes.",
   body: `# mancode \xB7 /man (Progressive Governance)
 
-\u7528\u6237\u7528 \`/man <task>\` \u89E6\u53D1\u4F60\u3002\u7ACB\u5373\u8BFB \`.mancode/state.json\`\u3002\u82E5\u5DF2\u6709\u4E0D\u540C\u7684 active workflow\uFF0C\u4E0D\u5F97\u76F4\u63A5\u6E05\u7A7A\u6307\u9488\uFF1B\u5148\u8BA9\u7528\u6237\u9009\u62E9\u6062\u590D\u539F\u6D41\u7A0B\u6216\u7528 \`/mansolo\` \u653E\u5F03\u3002task \u4E3A\u7A7A\u65F6\u8BE2\u95EE\u4EFB\u52A1\uFF0C\u7B49\u5F85\u671F\u95F4\u4ECD\u662F \`man\` \u6A21\u5F0F\u3002
+\u7528\u6237\u7528 \`/man <task>\` \u89E6\u53D1\u4F60\u3002\u7ACB\u5373\u8BFB \`.mancode/state.json\`\u3002\u82E5\u5DF2\u6709\u4E0D\u540C\u7684 active workflow\uFF0C\u4E0D\u5F97\u76F4\u63A5\u6E05\u7A7A\u6307\u9488\uFF1B\u5148\u8BA9\u7528\u6237\u9009\u62E9\u6062\u590D\u539F\u6D41\u7A0B\u6216\u7528 \`/mansolo\` \u653E\u5F03\u3002\u82E5 \`activeSoloPlan\` \u975E\u7A7A\uFF0C\u5148\u8BA9\u7528\u6237\u9009\u62E9\u7EE7\u7EED\u8BE5\u8BA1\u5212\uFF1B\u5DF2\u5B8C\u6210\u65F6\u8FD0\u884C \`mancode workflow handoff <\u65E7taskId> --complete\`\uFF0C\u653E\u5F03\u65F6\u53D6\u5F97\u786E\u8BA4\u540E\u901A\u8FC7 CLI \u6807\u8BB0\u65E7 workflow abandoned \u5E76\u6E05\u7406\u6307\u9488\uFF0C\u7136\u540E\u624D\u80FD\u521B\u5EFA\u65B0\u8BA1\u5212\u3002handoff CLI \u4F1A\u62D2\u7EDD\u9759\u9ED8\u8986\u76D6\u3002task \u4E3A\u7A7A\u65F6\u8BE2\u95EE\u4EFB\u52A1\uFF0C\u7B49\u5F85\u671F\u95F4\u4ECD\u662F \`man\` \u6A21\u5F0F\u3002
+
+\u7528 \`mancode workflow create man "<task>" --json\` \u521B\u5EFA workflow \u5E76\u8BFB\u53D6\u8FD4\u56DE\u7684 taskId\uFF1B\u4E0D\u5F97\u76F4\u63A5\u521B\u5EFA\u6216\u6539\u5199 metadata.json\u3002\u968F\u540E\u53EA\u7528 workflow CLI \u66F4\u65B0\u9700\u6C42\u3001\u9A8C\u8BC1\u3001step/status/planVersion/skippedSteps\u3002\u901A\u7528 \`--skipped\` \u53EA\u7528\u4E8E Step 1\u20132 \u7684 \`clarification\`\uFF1B\u7528\u6237\u660E\u786E\u8DF3\u8FC7\u6574\u4E2A review \u65F6\u5FC5\u987B\u5728 Step 6 \u4F7F\u7528\u4E13\u7528 \`workflow review ... skip --reason\`\uFF0C\u4E0D\u80FD\u5199\u6570\u5B57\u3001\`film-1\` \u6216 \`film-2\`\u3002state \u7684 \`currentMode\`\u3001\`currentTask\` \u548C \`currentWorkflowMode\` \u6307\u5411\u672C task\u3002
 
-\u7528 \`mancode workflow create man "<task>" --json\` \u521B\u5EFA workflow \u5E76\u8BFB\u53D6\u8FD4\u56DE\u7684 taskId\uFF1B\u4E0D\u5F97\u76F4\u63A5\u521B\u5EFA\u6216\u6539\u5199 metadata.json\u3002\u968F\u540E\u53EA\u7528 \`mancode workflow update\` \u66F4\u65B0 step/status/planVersion/skippedSteps\u3002state \u7684 \`currentMode\`\u3001\`currentTask\` \u548C \`currentWorkflowMode\` \u6307\u5411\u672C task\u3002
+## \u8BA1\u5212\u804C\u8D23\u4E0E\u6280\u672F\u9009\u62E9\u5173\u5361
 
-## \u65B0\u9879\u76EE\u6280\u672F\u9009\u62E9\u5173\u5361\uFF08\u4EC5\u5728\u9002\u7528\u65F6\uFF09
+\u628A \`/man\` \u4F5C\u4E3A\u6B63\u5F0F\u8BA1\u5212\u5165\u53E3\uFF1A\u5148\u5BF9\u9F50\u9700\u6C42\u5E76\u4EA7\u51FA\u53EF\u786E\u8BA4\u7684\u8BA1\u5212\uFF0C\u4E0D\u56E0\u8BA1\u5212\u5B8C\u6210\u800C\u81EA\u52A8\u8FDB\u5165\u5B8C\u6574\u5B9E\u65BD\u3002\u8BA1\u5212\u5173\u5361\u5FC5\u987B\u8BA9\u7528\u6237\u9009\u62E9\u53EA\u4FDD\u7559\u8BA1\u5212\u3001\u4EA4\u7ED9\u9ED8\u8BA4 \`solo\` \u8F7B\u91CF\u5B9E\u65BD\u3001\u7EE7\u7EED\u5B8C\u6574 \`/man\` \u6216\u4FEE\u6539\u8BA1\u5212\u3002
 
-\u5148\u8BFB \`.mancode/project-profile.json\`\u3002\u5982\u679C\u7528\u6237\u8981\u65B0\u5EFA\u9879\u76EE\u3001profile \u4E3A unknown\uFF0C\u4E14\u7528\u6237\u6CA1\u6709\u6307\u5B9A\u6280\u672F\u6808\uFF1A\u5148\u6536\u96C6\u76EE\u6807\u5E73\u53F0\u3001\u7528\u6237\u89C4\u6A21\u3001\u79BB\u7EBF/\u90E8\u7F72\u3001\u56E2\u961F\u719F\u6089\u5EA6\u3001\u9884\u7B97\u4E0E\u96C6\u6210\u7EA6\u675F\uFF1B\u5217\u51FA 2\u20133 \u4E2A\u53EF\u884C\u65B9\u6848\u7684\u4F18\u7F3A\u70B9\u548C\u63A8\u8350\u7406\u7531\uFF0C\u53D6\u5F97\u7528\u6237\u786E\u8BA4\u540E\u624D\u521B\u5EFA\u811A\u624B\u67B6\u3002\u4E0D\u8981\u628A\u4EFB\u4F55\u8BED\u8A00\u3001\u6846\u67B6\u3001UI \u5E93\u6216\u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5F53\u4F5C\u9ED8\u8BA4\u3002\u5DF2\u6709\u9879\u76EE\u5219\u4EE5\u68C0\u6D4B\u5230\u7684\u4E8B\u5B9E\u548C\u4ED3\u5E93\u7EA6\u5B9A\u4E3A\u51C6\u3002
+\u5148\u8BFB \`.mancode/project-profile.json\`\u3002\u5982\u679C\u7528\u6237\u8981\u65B0\u5EFA\u9879\u76EE\u3001profile \u4E3A unknown\uFF0C\u4E14\u7528\u6237\u6CA1\u6709\u6307\u5B9A\u6280\u672F\u6808\uFF1A\u6536\u96C6\u9002\u7528\u7684\u76EE\u6807\u5E73\u53F0\u3001\u89C4\u6A21\u3001\u79BB\u7EBF/\u90E8\u7F72\u3001\u56E2\u961F\u719F\u6089\u5EA6\u3001\u9884\u7B97\u4E0E\u96C6\u6210\u7EA6\u675F\uFF1B\u5217\u51FA 2\u20133 \u4E2A\u53EF\u884C\u65B9\u6848\u7684\u4F18\u7F3A\u70B9\u3001\u660E\u786E\u63A8\u8350\u548C\u63A8\u8350\u7406\u7531\uFF0C\u53D6\u5F97\u7528\u6237\u786E\u8BA4\u3002\u4E0D\u8981\u628A\u8BED\u8A00\u3001\u6846\u67B6\u3001UI \u5E93\u3001\u6570\u636E\u5B58\u50A8\u6216\u6D4F\u89C8\u5668\u81EA\u52A8\u5316\u5F53\u4F5C\u9759\u9ED8\u9ED8\u8BA4\u3002\u5DF2\u6709\u9879\u76EE\u4EE5\u68C0\u6D4B\u5230\u7684\u4E8B\u5B9E\u548C\u4ED3\u5E93\u7EA6\u5B9A\u4E3A\u51C6\u3002
 
 ### Step 1: Scout \u8C03\u7814
 
@@ -830,18 +891,34 @@ var MAN_SKILL = {
 
 ### Step 2: \u9700\u6C42\u6F84\u6E05
 
-\u4E3B skill \u76F4\u63A5\u57FA\u4E8E Scout \u62A5\u544A\u548C\u4EFB\u52A1\u6B67\u4E49\u63D0\u95EE\uFF1A\u5BA2\u89C2\u9898\u7528 AskUserQuestion\uFF08\u6BCF\u6B21\u6700\u591A 4 \u4E2A\uFF09\uFF0C\u4E3B\u89C2\u9898\u5F00\u653E\u63D0\u95EE\u3002\u6700\u591A\u4E24\u8F6E\uFF0C\u56DE\u7B54\u5199 \`requirements.md\`\uFF1B\u65E0\u95EE\u9898\u5219\u901A\u8FC7 CLI \u5C06 \`clarify\` \u5199\u5165\u7D2F\u8BA1 skippedSteps\u3002\u7B2C\u4E8C\u8F6E\u540E\u5C06\u5047\u8BBE\u3001\u672A\u51B3\u98CE\u9669\u548C\u4FDD\u5B88\u9ED8\u8BA4\u503C\u5199\u5165 requirements\uFF0C\u4E0D\u65E0\u9650\u8FFD\u95EE\u3002\u5B8C\u6210\u540E\u66F4\u65B0\u81F3 Step 3\u3002
+\u57FA\u4E8E Scout \u62A5\u544A\u505A\u9700\u6C42\u5C31\u7EEA\u5224\u65AD\uFF0C\u4E0D\u7528\u56FA\u5B9A\u8F6E\u6570\u6216\u95EE\u9898\u6570\u91CF\u4EE3\u66FF\u7406\u89E3\u8D28\u91CF\u3002\u628A\u6240\u6709\u4F1A\u6539\u53D8\u8303\u56F4\u3001\u67B6\u6784\u3001\u6210\u672C\u6216\u9A8C\u6536\u4E14\u65E0\u6CD5\u4ECE\u9879\u76EE\u4E8B\u5B9E\u4E2D\u67E5\u6E05\u7684\u7591\u95EE\u95EE\u51FA\u6765\uFF1B\u5141\u8BB8\u6309\u9700\u8981\u5206\u591A\u6279\u6F84\u6E05\uFF0C\u4E0D\u9650\u5236\u6BCF\u6279\u6570\u91CF\u3002\u6BCF\u6B21\u56DE\u7B54\u540E\u91CD\u65B0\u5224\u65AD\uFF0C\u53EA\u8FFD\u95EE\u4ECD\u963B\u585E\u8BA1\u5212\u7684\u672A\u77E5\u9879\uFF0C\u4E0D\u91CD\u590D\u5DF2\u786E\u8BA4\u5185\u5BB9\u3002
+
+\u628A\u672A\u77E5\u9879\u5206\u4E3A\uFF1A
+- **blocking**\uFF1A\u6280\u672F\u6808\u3001\u6838\u5FC3\u8303\u56F4\u3001\u6301\u4E45\u5316\u3001\u4E3B\u8981\u4EA4\u4E92\u3001\u5173\u952E\u6027\u80FD/\u517C\u5BB9\u6027/\u5B89\u5168\u76EE\u6807\u7B49\u4F1A\u6539\u53D8\u65B9\u6848\u7684\u51B3\u7B56\uFF0C\u5FC5\u987B\u786E\u8BA4\u3002
+- **recommendable**\uFF1A\u6709\u5408\u9002\u65B9\u6848\u65F6\u76F4\u63A5\u7ED9 2\u20133 \u4E2A\u65B9\u6848\u3001\u4F18\u7F3A\u70B9\u548C\u660E\u786E\u63A8\u8350\uFF0C\u8BA9\u7528\u6237\u63A5\u53D7\u6216\u8C03\u6574\uFF1B\u4E0D\u8981\u53EA\u628A\u9009\u62E9\u9898\u629B\u7ED9\u7528\u6237\u3002
+- **defaultable**\uFF1A\u547D\u540D\u3001\u5FAE\u5C0F\u6837\u5F0F\u7B49\u4F4E\u5F71\u54CD\u7EC6\u8282\uFF0C\u53EF\u91C7\u7528\u9ED8\u8BA4\u503C\uFF0C\u4F46\u5199\u660E\u9ED8\u8BA4\u503C\u548C\u7406\u7531\u3002
+
+\u6309\u4EFB\u52A1\u5B9E\u9645\u9002\u7528\u8303\u56F4\u68C0\u67E5\uFF1A\u7528\u6237\u76EE\u6807\u4E0E\u5E73\u53F0\u3001\u6838\u5FC3\u6D41\u7A0B\u3001\u9996\u671F\u8303\u56F4\u3001\u6392\u9664\u9879\u3001\u6280\u672F\u4E0E\u8FD0\u884C\u7EA6\u675F\u3001\u6570\u636E/\u72B6\u6001/\u96C6\u6210\u3001\u6027\u80FD/\u517C\u5BB9\u6027/\u5B89\u5168\u3001\u53EF\u9A8C\u8BC1\u5B8C\u6210\u6807\u51C6\u3002\u8FDE\u7EED\u6F84\u6E05\u6CA1\u6709\u51CF\u5C11 blocking \u9879\u65F6\uFF0C\u4E0D\u6563\u95EE\uFF1B\u8BA9\u7528\u6237\u9009\u62E9\u7F29\u5C0F\u9996\u671F\u8303\u56F4\u3001\u63A5\u53D7\u5217\u660E\u7684\u63A8\u8350\u9ED8\u8BA4\u503C\u6216\u6682\u505C\u3002
+
+\u628A\u7ED3\u8BBA\u5199\u5165\u7ED3\u6784\u5316\u9700\u6C42\u8F93\u5165\uFF0C\u81F3\u5C11\u5305\u542B \`goal\`\u3001\u975E\u7A7A \`confirmedScope\`\u3001\`excludedScope\`\u3001\`technicalDecisions\`\u3001\`defaults\`\u3001\`blockingUnknowns\`\u3001\`coverage\` \u548C \`acceptanceCriteria\`\u3002coverage \u5FC5\u987B\u9010\u9879\u8BF4\u660E platform\u3001core_scope\u3001technical_stack\u3001data_and_persistence\u3001performance\u3001compatibility\u3001security \u662F \`confirmed\`\u3001\`defaulted\` \u6216\u5E26\u7406\u7531\u7684 \`not_applicable\`\uFF0C\u4E0D\u80FD\u7528\u7A7A\u6570\u7EC4\u5047\u88C5\u5DF2\u7ECF\u8003\u8651\u3002\u6BCF\u4E2A\u6838\u5FC3\u7528\u6237\u884C\u4E3A\u5FC5\u987B\u6709\u7A33\u5B9A\u9A8C\u6536 ID\uFF08\`AC-1\` \u7B49\uFF09\u3001\u63CF\u8FF0\u3001\`required\` \u548C\u9A8C\u8BC1\u65B9\u5F0F \`automated\` / \`manual\` / \`hybrid\`\uFF1B\u81F3\u5C11\u4E00\u4E2A\u9A8C\u6536\u9879\u5FC5\u9700\u3002\u8FD0\u884C \`mancode workflow requirements <taskId> finalize --file <requirements-input.json>\`\uFF0C\u7531 CLI \u6821\u9A8C\u5E76\u751F\u6210\u6743\u5A01 \`requirements.json\` \u4E0E \`requirements.md\`\uFF0C\u4E0D\u8981\u624B\u5DE5\u5236\u9020\u4E24\u4EFD\u53EF\u80FD\u51B2\u7A81\u7684\u7ED3\u8BBA\u3002\u65E0\u987B\u63D0\u95EE\u65F6\u53EF\u628A \`clarification\` \u8BB0\u5165\u7D2F\u8BA1 skippedSteps\uFF0C\u4F46\u4E0D\u80FD\u8DF3\u8FC7\u9700\u6C42\u6458\u8981\u4E0E\u5C31\u7EEA\u5224\u65AD\u3002\u4ECD\u6709 blocking \u9879\u65F6\u505C\u5728 Step 2\uFF1B\u53EA\u6709 CLI \u8FD4\u56DE ready \u624D\u8FD0\u884C \`mancode workflow update <taskId> --step 3\`\u3002
 
 ### Step 3: Plan Coach \u51FA\u8BA1\u5212
 
-\u8C03\u7528\u53EA\u8BFB \`plan-coach\`\uFF0C\u8F93\u5165 task\u3001scout-report \u548C requirements\uFF1BPlan Coach \u53EA\u8FD4\u56DE\u8BA1\u5212\u6587\u672C\uFF0C\u7531\u4E3B skill \u5199\u5165 \`plan.md\`\u3002\u8BA1\u5212\u5FC5\u987B\u542B\u4EFB\u52A1\u5206\u7EA7\u3001\u6A21\u5757\u7D22\u5F15\u3001\u590D\u7528\u8D44\u6E90\u4E0E scout \u884C\u53F7\u3001\u6700\u5C0F\u7B56\u7565\u3001\u4E0D\u505A\u4EC0\u4E48\u3001\u5B8C\u6210\u5B9A\u4E49\u3001\u9A8C\u8BC1\u4E0E smoke test\u3001\u9884\u4F30\u3002\u9996\u6B21\u8BA1\u5212\u5199\u5165\u6210\u529F\u540E\u8FD0\u884C \`mancode workflow update <taskId> --step 4\`\uFF0C\u7531 CLI upsert Active Plans \u5E76\u8FDB\u5165\u8BA1\u5212\u5173\u5361\uFF1B\u91CD\u5199\u8BA1\u5212\u65F6\u4FDD\u6301\u5728 Step 4\uFF0C\u8FD0\u884C \`--plan-version <\u5F53\u524D\u7248\u672C+1>\`\uFF0C\u4E0D\u5F97\u76F4\u63A5\u7F16\u8F91 planVersion\u3002
+\u8C03\u7528\u53EA\u8BFB \`plan-coach\`\uFF0C\u8F93\u5165 task\u3001scout-report\u3001\`requirements.json\` \u548C\u6E32\u67D3\u540E\u7684 \`requirements.md\`\u3002Plan Coach \u5148\u8FD4\u56DE \`READY_FOR_PLAN\` \u6216 \`NEEDS_CLARIFICATION\`\u3002\u540E\u8005\u53EA\u5217\u7F3A\u5931\u51B3\u7B56\u3001\u5F71\u54CD\u3001\u63A8\u8350\u548C\u95EE\u9898\uFF1B\u4E3B skill \u5C06 workflow \u9000\u56DE Step 2 \u5E76\u91CD\u65B0 finalize requirements\uFF0C\u4E0D\u5F97\u5F3A\u884C\u8865\u5168\u8BA1\u5212\u3002\u524D\u8005\u8FD4\u56DE\u8BA1\u5212\u6587\u672C\uFF0C\u7531\u4E3B skill \u5199\u5165 \`plan.md\`\u3002
+
+\u8BA1\u5212\u5FC5\u987B\u542B\u9700\u6C42\u6458\u8981\u3001\u4EFB\u52A1\u5206\u7EA7\u3001\u6280\u672F\u9009\u62E9\u53CA\u7406\u7531\u3001\u6A21\u5757\u7D22\u5F15\u3001\u590D\u7528\u8D44\u6E90\u4E0E scout \u884C\u53F7\u3001\u6838\u5FC3\u884C\u4E3A\u3001\u6700\u5C0F\u7B56\u7565\u3001\u4E0D\u505A\u4EC0\u4E48\u3001\u6B65\u9AA4\u3001\u98CE\u9669/\u56DE\u9000\u3001\u5B8C\u6210\u5B9A\u4E49\u3001\u771F\u5B9E\u9A8C\u8BC1\u4E0E smoke test\u3001\u9884\u4F30\u548C\u975E\u963B\u585E\u9ED8\u8BA4\u503C\u3002\u9996\u6B21\u8BA1\u5212\u5199\u5165\u6210\u529F\u540E\u8FD0\u884C \`mancode workflow update <taskId> --step 4\`\uFF1B\u91CD\u5199\u8BA1\u5212\u65F6\u4FDD\u6301 Step 4\uFF0C\u8FD0\u884C \`--plan-version <\u5F53\u524D\u7248\u672C+1>\`\uFF0C\u4E0D\u5F97\u76F4\u63A5\u7F16\u8F91 planVersion\u3002
 
 ### Step 4: \u8BA1\u5212\u5173\u5361
 
 \u7528 AskUserQuestion \u8BA9\u7528\u6237\u9009\u62E9\uFF1A
-1. **\u53EA\u8981\u8BA1\u5212**\uFF1ACLI \u66F4\u65B0 \`status: planned\`\uFF0Cstate \u56DE solo \u5E76\u6E05\u7A7A workflow \u6307\u9488\uFF0C\u7ED3\u675F\u3002
-2. **\u7EE7\u7EED\u6267\u884C\uFF08\u63A8\u8350\uFF09**\uFF1ACLI \u66F4\u65B0\u81F3 Step 5\u3002
-3. **\u4FEE\u6539\u8BA1\u5212**\uFF1A\u6536\u96C6\u610F\u89C1\u5E76\u91CD\u8DD1 Step 3 \u7684 Plan Coach\uFF0Cworkflow \u6307\u9488\u4FDD\u6301 Step 4\uFF1B\u8BA1\u5212\u91CD\u5199\u5B8C\u6210\u540E\u9012\u589E planVersion\u3002
+1. **\u4EA4\u7ED9 solo \u8F7B\u91CF\u6267\u884C**\uFF1A\u5E38\u89C4\u4F4E\u98CE\u9669\u4EFB\u52A1\u63A8\u8350\u3002\u8FD0\u884C \`mancode workflow handoff <taskId> --to solo\`\uFF1B\u4FDD\u7559\u5DF2\u786E\u8BA4\u8BA1\u5212\u548C Active Plans\uFF0C\u7531 solo \u6309\u8BA1\u5212\u505A\u6700\u7A84\u9A8C\u8BC1\u548C\u4E00\u6B21\u53D7\u9650\u81EA\u68C0\uFF0C\u4E0D\u8FDB\u5165 Step 5\u20139\u3002
+2. **\u7EE7\u7EED\u5B8C\u6574 /man**\uFF1A\u9AD8\u98CE\u9669\u6216\u9700\u8981\u72EC\u7ACB\u5BA1\u67E5\u65F6\u63A8\u8350\u3002\u5148\u8FD0\u884C \`mancode workflow decide <taskId> --plan-decision governed_execution\`\uFF0C\u8F93\u51FA\u5F00\u5DE5\u56DE\u6267\uFF0C\u518D\u66F4\u65B0\u81F3 Step 5\u3002
+3. **\u53EA\u8981\u8BA1\u5212\uFF08\u4EC5\u4FDD\u7559\uFF09**\uFF1A\u8FD0\u884C \`mancode workflow decide <taskId> --plan-decision plan_only\`\uFF0C\u7531 CLI \u539F\u5B50\u4FDD\u5B58 planned \u72B6\u6001\u3001\u5207\u56DE solo \u5E76\u6E05\u7A7A\u53D7\u7BA1 workflow \u6307\u9488\uFF0C\u7ED3\u675F\u3002
+4. **\u4FEE\u6539\u8BA1\u5212**\uFF1A\u6536\u96C6\u610F\u89C1\uFF1B\u82E5\u6539\u53D8\u9700\u6C42\u5219\u56DE Step 2\uFF0C\u5426\u5219\u91CD\u8DD1 Plan Coach\u3002\u91CD\u5199\u5B8C\u6210\u540E\u9012\u589E planVersion\uFF0C\u4FDD\u6301\u8BA1\u5212\u51B3\u7B56\u4E3A\u7A7A\u3002
+
+\u6839\u636E\u98CE\u9669\u660E\u786E\u63A8\u8350\u7406\u7531\uFF0C\u4E0D\u628A\u5B8C\u6574 \`/man\` \u6C38\u8FDC\u6807\u4E3A\u63A8\u8350\u3002\u9274\u6743\u3001\u652F\u4ED8\u3001\u654F\u611F\u6570\u636E\u3001\u8FC1\u79FB/\u5220\u9664\u3001\u516C\u5F00 API\u3001\u672A\u53EF\u4FE1\u8F93\u5165\u3001\u5E76\u53D1\u3001\u8DE8\u670D\u52A1\u6216\u57FA\u7840\u8BBE\u65BD\u9ED8\u8BA4\u63A8\u8350\u5B8C\u6574 \`/man\`\uFF1B\u666E\u901A\u539F\u578B\u3001\u5185\u90E8\u5DE5\u5177\u548C\u4F4E\u98CE\u9669\u529F\u80FD\u9ED8\u8BA4\u63A8\u8350 solo\u3002
+
+\u786E\u8BA4\u6267\u884C\u540E\u3001\u4FEE\u6539\u4E1A\u52A1\u6587\u4EF6\u524D\u8F93\u51FA\u5F00\u5DE5\u56DE\u6267\uFF1A\u8BA1\u5212\u7248\u672C\u3001\u6267\u884C\u65B9\u5F0F\u3001\u76EE\u6807\u4E0E\u4EA4\u4ED8\u7269\u3001\u6280\u672F\u65B9\u6848\u3001\u5305\u542B\u8303\u56F4\u3001\u6392\u9664\u8303\u56F4\u3001\u9A8C\u8BC1\u65B9\u5F0F\u548C\u6B8B\u4F59\u5047\u8BBE\u3002\u4ECD\u6709 blocking \u672A\u77E5\u9879\u65F6\u4E0D\u5F97\u58F0\u79F0\u5F00\u59CB\u5B9E\u65BD\u3002
 
 ### Step 5: \u5B9E\u65BD
 
@@ -849,9 +926,11 @@ var MAN_SKILL = {
 
 ### Step 6: \u81EA\u6D4B\u3001\u8BCA\u65AD\u4E0E\u56DE\u5F52
 
-\u8FD0\u884C\u5B9E\u9645 build/lint/typecheck/test \u548C smoke test\u3002\u76F8\u540C\u4EE3\u7801\u3001\u73AF\u5883\u3001\u547D\u4EE4\u4E0B\u76F8\u540C\u9519\u8BEF\u7B7E\u540D\u5931\u8D25\u4E24\u6B21\uFF0C\u505C\u6B62\u76F2\u8BD5\u5E76\u8BCA\u65AD\u6839\u56E0\u3002\u9700\u8981\u771F\u5B9E\u6D4F\u89C8\u5668\u3001\u590D\u6742\u590D\u73B0\u6216\u56DE\u5F52\u65F6\uFF0C\u7528 \`mancode workflow create manba "<\u95EE\u9898>" --parent-task <taskId> --json\` \u521B\u5EFA\u5B50 workflow\uFF1B\u7236\u4EFB\u52A1\u4FDD\u6301 Step 6\u3002\u5B50\u4EFB\u52A1 fixed/verified/no_repro \u540E\u6062\u590D\u672C\u4EFB\u52A1\uFF1B\u82E5\u7236\u66FE\u56E0\u8BE5\u5B50\u4EFB\u52A1 blocked\uFF0C\u5148\u901A\u8FC7 \`workflow update --status in_progress\` \u6062\u590D\uFF0C\u518D\u66F4\u65B0\u81F3 Step 7\u3002blocked \u6216 manual_test_required \u4F1A\u7531 CLI \u81EA\u52A8\u963B\u585E\u7236\u4EFB\u52A1\uFF0C\u4E0D\u5F97\u624B\u6539\u7236 metadata\uFF0C\u4E5F\u4E0D\u5F97\u81EA\u52A8\u8D8A\u8FC7\u4EBA\u5DE5\u9A8C\u8BC1\u8981\u6C42\u3002
+\u5148\u8FD0\u884C \`mancode workflow verify <taskId> init\`\uFF0C\u518D\u6309 \`requirements.json\` \u7684\u6BCF\u4E2A\u9A8C\u6536 ID \u8BB0\u5F55\u771F\u5B9E\u7ED3\u679C\u3002\u81EA\u52A8 passed/failed \u5FC5\u987B\u4F7F\u7528 \`mancode workflow verify <taskId> record --acceptance AC-N --method automated --result passed|failed --evidence "<\u6458\u8981>" --command "<\u5B9E\u9645\u547D\u4EE4>" --exit-code <\u9000\u51FA\u7801> [--evidence-file <\u62A5\u544A>]\`\uFF1BCLI \u6821\u9A8C passed \u7684\u9000\u51FA\u7801\u4E3A 0\u3001failed \u4E3A\u975E 0\u3002\u9700\u8981\u771F\u5B9E\u6D4F\u89C8\u5668\u3001\u8BBE\u5907\u6216\u4EBA\u7684\u5224\u65AD\u65F6\uFF0C\u4F7F\u7528 \`mancode workflow verify <taskId> require-manual --acceptance AC-N --evidence "<\u81EA\u52A8\u5316\u4E0D\u80FD\u8986\u76D6\u7684\u539F\u56E0>"\`\uFF1BCLI \u4F1A\u963B\u585E\u4E3B\u4EFB\u52A1\u3002\u660E\u786E\u544A\u8BC9\u7528\u6237\u5177\u4F53\u5B9E\u6D4B\u6B65\u9AA4\u5E76\u505C\u4E0B\uFF0C\u53EA\u6709\u6536\u5230\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u624D\u4F7F\u7528 \`mancode workflow verify <taskId> confirm-manual --acceptance AC-N --evidence "<\u7528\u6237\u786E\u8BA4\u539F\u6587>"\`\u3002\u6B64\u8BC1\u636E\u7528\u4E8E\u5BA1\u8BA1\uFF0C\u4E0D\u4EE3\u8868 CLI \u80FD\u8BA4\u8BC1\u64CD\u4F5C\u8005\u8EAB\u4EFD\u3002\u4E0D\u5F97\u7528\u9875\u9762\u52A0\u8F7D\u3001\u63A7\u5236\u63D0\u793A\u3001\u622A\u56FE\u3001\u4EE3\u7801\u9605\u8BFB\u6216 reviewer \u4EE3\u66FF\u6838\u5FC3\u4EA4\u4E92\u9A8C\u6536\u3002
 
-\u9A8C\u8BC1\u540E\u57FA\u4E8E**\u5B9E\u9645 diff**\u5199 \`review-scope.md\`\uFF1Abase\u3001\u6539\u52A8\u6587\u4EF6\u3001\u9700\u6C42\u3001\u5DF2\u8DD1\u9A8C\u8BC1\u3001\u786C\u98CE\u9669\u548C\u5BA1\u67E5\u6DF1\u5EA6\u3002\u9274\u6743\u3001\u652F\u4ED8\u3001\u654F\u611F\u6570\u636E\u3001\u8FC1\u79FB/\u5220\u9664\u3001\u516C\u5F00 API\u3001\u672A\u53EF\u4FE1\u8F93\u5165\u3001\u5E76\u53D1\u3001\u8DE8\u670D\u52A1\u6216\u57FA\u7840\u8BBE\u65BD\u547D\u4E2D\u4EFB\u4E00\u9879\u65F6\u7528\u5B8C\u6574\u5BA1\u67E5 \`full\`\uFF1B\u5426\u5219\u7528\u5B9A\u5411\u5BA1\u67E5 \`targeted\`\u3002\u8FD0\u884C \`mancode workflow review <taskId> init --review-depth targeted --review-domain quality\` \u6216 \`--review-depth full\`\u3002\u7528\u6237\u660E\u786E\u8DF3\u8FC7\u5BA1\u67E5\u65F6\u624D\u628A \`review\` \u5199\u5165\u7D2F\u8BA1 skippedSteps\uFF0C\u5E76\u8BB0\u5F55\u6B8B\u4F59\u98CE\u9669\u3002
+\u8FD0\u884C\u5B9E\u9645 build/lint/typecheck/test \u548C smoke test\u3002\u76F8\u540C\u4EE3\u7801\u3001\u73AF\u5883\u3001\u547D\u4EE4\u4E0B\u76F8\u540C\u9519\u8BEF\u7B7E\u540D\u5931\u8D25\u4E24\u6B21\uFF0C\u505C\u6B62\u76F2\u8BD5\u5E76\u8BCA\u65AD\u6839\u56E0\u3002\u9700\u8981\u590D\u6742\u590D\u73B0\u6216\u56DE\u5F52\u65F6\uFF0C\u7528 \`mancode workflow create manba "<\u95EE\u9898>" --parent-task <taskId> --json\` \u521B\u5EFA\u5B50 workflow\uFF1B\u7236\u4EFB\u52A1\u4FDD\u6301 Step 6\u3002\u5B50\u4EFB\u52A1 fixed/verified/no_repro \u540E\u6062\u590D\u672C\u4EFB\u52A1\uFF1B\`manual_test_required\` \u4ECD\u5FC5\u987B\u8D70\u4E0A\u8FF0\u4EBA\u5DE5\u786E\u8BA4\u3002\u6240\u6709 required \u9A8C\u6536\u53CA hybrid \u7684\u4E24\u4E2A\u90E8\u5206\u90FD passed \u540E\uFF0CCLI \u624D\u5141\u8BB8\u8FDB\u5165 Step 7 \u6216\u542F\u52A8 review\uFF1B\u8BA1\u5212\u7248\u672C\u6216\u7ED3\u6784\u5316\u9700\u6C42\u53D8\u5316\u4F1A\u4F7F\u65E7\u9A8C\u8BC1\u5931\u6548\u3002
+
+\u9A8C\u8BC1\u540E\u57FA\u4E8E**\u5B9E\u9645 diff**\u5199 \`review-scope.md\`\uFF1Abase\u3001\u6539\u52A8\u6587\u4EF6\u3001\u9700\u6C42\u3001\u5DF2\u8DD1\u9A8C\u8BC1\u3001\u786C\u98CE\u9669\u548C\u5BA1\u67E5\u6DF1\u5EA6\u3002\u9274\u6743\u3001\u652F\u4ED8\u3001\u654F\u611F\u6570\u636E\u3001\u8FC1\u79FB/\u5220\u9664\u3001\u516C\u5F00 API\u3001\u672A\u53EF\u4FE1\u8F93\u5165\u3001\u5E76\u53D1\u3001\u8DE8\u670D\u52A1\u6216\u57FA\u7840\u8BBE\u65BD\u547D\u4E2D\u4EFB\u4E00\u9879\u65F6\u7528\u5B8C\u6574\u5BA1\u67E5 \`full\`\uFF1B\u5426\u5219\u7528\u5B9A\u5411\u5BA1\u67E5 \`targeted\`\u3002\u8FD0\u884C \`mancode workflow review <taskId> init --review-depth targeted --review-domain quality\` \u6216 \`--review-depth full\`\u3002\u53EA\u6709\u7528\u6237\u660E\u786E\u8981\u6C42\u8DF3\u8FC7\u5BA1\u67E5\u65F6\u624D\u8FD0\u884C \`mancode workflow review <taskId> skip --reason "<\u7528\u6237\u7406\u7531>"\`\uFF1BCLI \u4F1A\u8BB0\u5F55\u539F\u56E0\u5E76\u7D2F\u8BA1 \`review\`\uFF0C\u4E0D\u5F97\u901A\u8FC7\u901A\u7528 skipped \u53C2\u6570\u7ED5\u8FC7\u3002
 
 ### Step 7: Film #1 \u4EE3\u7801\u8D28\u91CF\u5BA1\u67E5\u4E0E\u4FEE\u590D
 
@@ -864,7 +943,7 @@ var MAN_SKILL = {
 ### Step 9: \u589E\u5F3A\u6536\u5C3E
 
 1. \u5B58\u5728 open blocker \u65F6\uFF0CHead Coach \u4E00\u6B21\u6027\u4FEE\u590D\u5168\u90E8 blocker\uFF0C\u5E76\u7528 \`mancode workflow review <taskId> remediate --resolved Q1,D1\` \u8BB0\u5F55\u552F\u4E00\u4E00\u8F6E\u4FEE\u590D\uFF1B\u6CA1\u6709 blocker \u65F6\u4E0D\u8FD0\u884C remediate\u3002\u4E0D\u8981\u4E3A \u{1F7E1}/\u{1F7E2} \u6269\u5927\u6539\u52A8\u3002
-2. \u91CD\u8DD1\u53D7\u5F71\u54CD\u9A8C\u8BC1\uFF0C\u4E0D\u91CD\u65B0\u8FD0\u884C\u5DF2\u5B8C\u6210\u7684 reviewer\u3002\u4FEE\u590D\u82E5\u5F15\u5165\u65B0\u7684\u9AD8\u98CE\u9669\u9762\u5219\u6807\u8BB0 blocked\uFF0C\u4E0D\u80FD\u5F00\u542F\u65E0\u754C review \u5FAA\u73AF\u3002
+2. remediation \u4F1A\u4F7F\u65E7\u9A8C\u8BC1\u6574\u6279\u5931\u6548\u3002\u5728 Step 9 \u91CD\u8DD1\u5168\u90E8 required \u9A8C\u6536\uFF0C\u5E76\u901A\u8FC7 verify record/require-manual/confirm-manual \u91CD\u65B0\u767B\u8BB0\u8BC1\u636E\uFF1B\u672A\u91CD\u65B0\u5168\u90E8\u901A\u8FC7\u4E0D\u80FD completed\u3002\u4E0D\u91CD\u65B0\u8FD0\u884C\u5DF2\u5B8C\u6210\u7684 reviewer\u3002\u4FEE\u590D\u82E5\u5F15\u5165\u65B0\u7684\u9AD8\u98CE\u9669\u9762\u5219\u6807\u8BB0 blocked\uFF0C\u4E0D\u80FD\u5F00\u542F\u65E0\u754C review \u5FAA\u73AF\u3002
 3. \u5199 \`summary.md\`\uFF1A\u6539\u52A8\u3001\u65B0\u5EFA\u3001\u590D\u7528\u3001\u9A8C\u8BC1\u3001\u5BA1\u67E5\u6DF1\u5EA6\u3001findings \u5904\u7F6E\u3001\u8DF3\u8FC7\u6B65\u9AA4\u548C\u6B8B\u4F59\u98CE\u9669\u3002
 4. CLI \u786E\u8BA4\u6240\u9700\u5BA1\u67E5\u9886\u57DF\u5B8C\u6210\u4E14 blocker \u6E05\u96F6\u540E\u624D\u5199 \`completed\`\uFF1B\u5426\u5219\u7528 \`--status blocked --blocking-reason "<\u539F\u56E0>"\`\u3002
 5. \u5173\u952E\u51B3\u7B56 appendTeamDecision \u5230 \`decisions.md\`\uFF0C\u66F4\u65B0 Active Plans\u3002
@@ -1190,13 +1269,13 @@ var MANTEAM_SKILL = {
 \u6309 \`/man\` \u7684 9 \u6B65\u6D41\u7A0B\u6267\u884C\uFF08\u542B\u6F84\u6E05\u3001\u8BA1\u5212\u5173\u5361\u548C\u589E\u5F3A\u6536\u5C3E\uFF09\uFF0C\u4F46\u6BCF\u4E00\u6B65\u589E\u52A0\u56E2\u961F\u7EA6\u675F\uFF1A
 
 1. Scout Report\uFF1A\u5FC5\u987B\u5217\u51FA\u5171\u4EAB\u6587\u4EF6\u3001\u8FD1\u671F\u76F8\u5173\u63D0\u4EA4\u3001\u6F5C\u5728\u51B2\u7A81\u6587\u4EF6\u3002
-2. \u6F84\u6E05\uFF1A\u6700\u591A\u4E24\u8F6E\uFF1B\u628A\u5DF2\u786E\u8BA4\u7EA6\u675F\u548C\u4FDD\u5B88\u9ED8\u8BA4\u503C\u5199\u5165 requirements.md\u3002
-3. Game Plan\uFF1A\u8BA1\u5212\u91CC\u5FC5\u987B\u5305\u542B\u53D8\u66F4\u8FB9\u754C\u3001\u517C\u5BB9\u6027\u98CE\u9669\u3001\u56DE\u6EDA\u65B9\u5F0F\uFF1BPlan Coach \u53EA\u8FD4\u56DE\u8BA1\u5212\u6587\u672C\uFF0C\u7981\u6B62\u63D0\u524D\u4FEE\u6539\u4E1A\u52A1\u6587\u4EF6\u6216\u56E2\u961F memory\u3002
-4. \u8BA1\u5212\u5173\u5361\uFF1A\u7528\u6237\u53EF\u53EA\u4FDD\u7559\u8BA1\u5212\u3001\u7EE7\u7EED\u6267\u884C\u6216\u91CD\u5199\u8BA1\u5212\uFF1BActive Plans \u6309 taskId \u66F4\u65B0\u3002
+2. \u6F84\u6E05\uFF1A\u6CBF\u7528 /man \u7684\u9700\u6C42\u5C31\u7EEA\u95E8\u69DB\uFF0C\u4E0D\u8BBE\u56FA\u5B9A\u8F6E\u6570\u6216\u6BCF\u6279\u95EE\u9898\u6570\u91CF\uFF1B\u95EE\u51FA\u6240\u6709\u4F1A\u6539\u53D8\u51B3\u7B56\u4E14\u65E0\u6CD5\u4ECE\u9879\u76EE\u4E8B\u5B9E\u67E5\u6E05\u7684\u7591\u95EE\uFF0C\u4E0D\u91CD\u590D\u5DF2\u786E\u8BA4\u5185\u5BB9\u3002\u6709\u5408\u9002\u65B9\u6848\u65F6\u76F4\u63A5\u7ED9\u51FA\u9009\u9879\u3001\u4F18\u7F3A\u70B9\u548C\u660E\u786E\u63A8\u8350\u3002\u901A\u8FC7 \`workflow requirements ... finalize\` \u56FA\u5316\u4E03\u4E2A coverage \u7EF4\u5EA6\u3001\u7ED3\u6784\u5316\u9700\u6C42\u548C\u5E26\u9A8C\u8BC1\u65B9\u5F0F\u7684\u9A8C\u6536 ID\uFF0C\u53EA\u6709 CLI \u5224\u5B9A ready \u624D\u8FDB\u5165\u8BA1\u5212\u3002
+3. Game Plan\uFF1APlan Coach \u5148\u505A\u8F93\u5165\u5C31\u7EEA\u68C0\u67E5\uFF1B\u8BA1\u5212\u91CC\u5FC5\u987B\u5305\u542B\u53D8\u66F4\u8FB9\u754C\u3001\u6280\u672F\u9009\u62E9\u7406\u7531\u3001\u517C\u5BB9\u6027\u98CE\u9669\u3001\u56DE\u6EDA\u65B9\u5F0F\uFF0C\u7981\u6B62\u63D0\u524D\u4FEE\u6539\u4E1A\u52A1\u6587\u4EF6\u6216\u56E2\u961F memory\u3002
+4. \u8BA1\u5212\u5173\u5361\uFF1A\u7528\u6237\u53EF\u53EA\u4FDD\u7559\u8BA1\u5212\u3001\u7EE7\u7EED\u5B8C\u6574\u56E2\u961F\u6267\u884C\u3001\u660E\u786E\u4EA4\u7ED9 solo \u8F7B\u91CF\u6267\u884C\u6216\u91CD\u5199\u8BA1\u5212\uFF1BActive Plans \u6309 taskId \u66F4\u65B0\u3002\u56E2\u961F\u5171\u4EAB\u6587\u4EF6\u6216\u4EA4\u63A5\u98CE\u9669\u5B58\u5728\u65F6\u63A8\u8350\u5B8C\u6574\u56E2\u961F\u6267\u884C\u3002
 5. \u5B9E\u65BD\uFF1A\u6539\u52A8\u524D\u518D\u6B21\u68C0\u67E5 \`git status --short\`\uFF0C\u907F\u514D\u8E29\u7528\u6237\u6216\u961F\u53CB\u6539\u52A8\u3002
-6. Self-test\uFF1A\u4F18\u5148\u8DD1\u9879\u76EE\u5DF2\u6709\u9A8C\u8BC1\u547D\u4EE4\uFF1B\u5931\u8D25\u4E24\u6B21\u505C\u4E0B\u8BCA\u65AD\u6839\u56E0\u3002\u9700\u8981\u771F\u5B9E\u9A8C\u8BC1\u65F6\u521B\u5EFA\u5E26 parentTaskId \u7684 /manba \u5B50\u4EFB\u52A1\u3002\u5B50\u4EFB\u52A1\u4FEE\u590D\u540E\u82E5\u7236\u4EFB\u52A1\u66FE\u56E0\u6B64 blocked\uFF0C\u5148\u7528 workflow CLI \u6062\u590D\u7236\u4EFB\u52A1\u4E3A in_progress\uFF1Bmanual_test_required \u4E0D\u5F97\u81EA\u52A8\u6062\u590D\u3002
+6. Self-test\uFF1A\u5728 Step 6 \u521D\u59CB\u5316 verification ledger\uFF0C\u628A\u6BCF\u4E2A required \u9A8C\u6536 ID \u7684\u81EA\u52A8\u3001\u4EBA\u5DE5\u6216 hybrid \u7ED3\u679C\u548C\u8BC1\u636E\u901A\u8FC7 CLI \u8BB0\u5F55\uFF1B\u81EA\u52A8\u7ED3\u679C\u5305\u542B\u547D\u4EE4\u4E0E\u9000\u51FA\u7801\uFF0C\u672A\u5168\u90E8\u901A\u8FC7\u4E0D\u5F97\u8FDB\u5165 review\u3002\u4F18\u5148\u8DD1\u9879\u76EE\u5DF2\u6709\u9A8C\u8BC1\u547D\u4EE4\uFF1B\u5931\u8D25\u4E24\u6B21\u505C\u4E0B\u8BCA\u65AD\u6839\u56E0\u3002\u9700\u8981\u4EBA\u5DE5\u9A8C\u8BC1\u65F6\u6807\u8BB0 require-manual \u5E76\u7B49\u5F85\u7528\u6237\u660E\u786E\u786E\u8BA4\uFF0C\u4E0D\u5F97\u81EA\u52A8\u6062\u590D\u3002remediation \u540E\u5728 Step 9 \u91CD\u65B0\u767B\u8BB0\u5168\u90E8\u9A8C\u6536\u3002
 7. Review scope + Film #1\uFF1A\u57FA\u4E8E\u5B9E\u9645 diff \u5199 \`review-scope.md\`\uFF0C\u7528 \`workflow review ... init\` \u9009\u62E9 targeted \u6216 full\uFF1B\u91CD\u70B9\u5BA1\u67E5\u884C\u4E3A\u3001\u53EF\u7EF4\u62A4\u6027\u3001\u56E2\u961F\u98CE\u683C\u4E0E\u6D4B\u8BD5\uFF0Cfinding \u5FC5\u987B\u6709\u8BC1\u636E\u548C\u7A33\u5B9A ID\u3002
-8. Film #2\uFF1A\u4EC5 full \u6267\u884C\uFF0C\u5148\u8BFB Film #1 \u62A5\u544A\u5E76\u53BB\u91CD\uFF0C\u53EA\u5BA1\u67E5\u8FB9\u754C\u3001\u5B89\u5168\u3001\u6027\u80FD\u3001\u5E76\u53D1\u548C\u517C\u5BB9\u6027\u3002\u7528\u6237\u660E\u786E\u8981\u6C42\u624D\u53EF\u8DF3\u8FC7\u5168\u90E8 review\uFF0C\u5E76\u5199\u5165 \`skippedSteps\` \u548C\u6B8B\u4F59\u98CE\u9669\u3002
+8. Film #2\uFF1A\u4EC5 full \u6267\u884C\uFF0C\u5148\u8BFB Film #1 \u62A5\u544A\u5E76\u53BB\u91CD\uFF0C\u53EA\u5BA1\u67E5\u8FB9\u754C\u3001\u5B89\u5168\u3001\u6027\u80FD\u3001\u5E76\u53D1\u548C\u517C\u5BB9\u6027\u3002targeted \u7684\u7B2C\u4E8C\u5BA1\u662F\u4E0D\u9002\u7528\uFF0C\u4E0D\u80FD\u8BB0\u4E3A skipped\uFF1B\u53EA\u6709\u7528\u6237\u660E\u786E\u8981\u6C42\u624D\u53EF\u8DF3\u8FC7\u5168\u90E8 review\uFF0C\u5E76\u5199\u5165 \`review\` \u548C\u6B8B\u4F59\u98CE\u9669\u3002
 9. Post-game\uFF1A\u6C47\u603B blocker\uFF0C\u53EA\u505A\u4E00\u8F6E\u4FEE\u590D\u5E76\u7528 \`workflow review ... remediate\` \u8BB0\u5F55\uFF1B\u590D\u9A8C\u540E\u5199 summary \u4E0E hand-off\u3002\u9A8C\u8BC1\u5931\u8D25\u3001\u5BA1\u67E5\u4E0D\u5B8C\u6574\u6216\u4ECD\u6709 blocker \u65F6\u6807\u8BB0 blocked\uFF0C\u4E0D\u5F97\u6807 completed\u3002
 
 \u5982\u679C\u7528\u6237\u5728\u786E\u8BA4\u9636\u6BB5\u9009\u62E9"\u9000\u51FA"\u6216\u653E\u5F03\u56E2\u961F workflow\uFF1A\u7528 \`mancode workflow update <taskId> --status abandoned\` \u66F4\u65B0\u5E76\u6E05\u7406 Active Plans\uFF1B\u82E5\u6709\u6D3B\u8DC3 manba \u5B50\u4EFB\u52A1\uFF0C\u5148\u53D6\u5F97\u786E\u8BA4\u5E76\u9010\u4E2A abandoned\u3002\u6210\u529F\u540E\u518D\u7528 Edit \u66F4\u65B0 state \u56DE solo\u3002\u4E0D\u8981\u76F4\u63A5\u6539 metadata\uFF0C\u4E5F\u4E0D\u8981\u628A abandoned workflow \u7559\u5728 active state\u3002
@@ -2164,8 +2243,8 @@ var MODE_META = {
     ].join("\n")
   },
   man: {
-    description: "Full high-risk workflow with plan, implementation, verification, and review. Use when the user asks for man or a high-risk production change.",
-    intro: "# mancode man \u2014 Full Review Workflow",
+    description: "Planning and progressive workflow that aligns requirements, recommends options, produces a confirmed plan, and then offers plan-only, solo handoff, or full governed execution.",
+    intro: "# mancode man \u2014 Planning and Progressive Delivery",
     workflow: [
       "## Progressive nine-step workflow (simulate roles in one conversation)",
       "",
@@ -2177,16 +2256,16 @@ var MODE_META = {
       "never advance state merely because a report was requested or an agent was called.",
       "",
       "Step 1 \u2014 Scout: inspect the profile, existing implementation, dependencies, risks, and unknowns; write `scout-report.md`.",
-      "Step 2 \u2014 Clarify: ask at most two rounds; write answers, conservative defaults, and unresolved risks to `requirements.md`.",
-      "Step 3 \u2014 Plan: write `plan.md` with scope, reuse, exclusions, risks, completion criteria, and real validation. First plan is v1; revisions use `--plan-version <current+1>` and Active Plans is updated by the CLI.",
-      "Step 4 \u2014 Plan gate: the user chooses plan-only (`status planned`), continue to execution, or revise the plan. Do not implement before this choice.",
+      "Step 2 \u2014 Clarify by readiness, not a fixed round or question count. Ask every decision-changing question that cannot be resolved from project facts; use as many batches as needed without repeating confirmed answers. Classify unknowns as blocking, recommendable, or defaultable. When a good approach exists, present 2\u20133 options and make a clear recommendation. Create structured input with non-empty scope, exclusions, technical decisions, defaults, blocking unknowns, stable acceptance IDs, and explicit confirmed/defaulted/not-applicable coverage for platform, core scope, stack, data, performance, compatibility, and security. Run `mancode workflow requirements <taskId> finalize --file <input.json>`; only advance to Step 3 when the CLI returns ready.",
+      "Step 3 \u2014 Plan Coach first returns READY_FOR_PLAN or NEEDS_CLARIFICATION. Never hide blocking gaps inside assumptions. When ready, write `plan.md` with confirmed scope, technical choices and reasons, reuse, exclusions, behavior, risks/rollback, completion criteria, defaults, and real validation. First plan is v1; revisions use `--plan-version <current+1>`.",
+      "Step 4 \u2014 Plan gate: recommend based on risk and let the user choose (1) hand the confirmed plan to lightweight solo via `mancode workflow handoff <taskId> --to solo`, (2) continue full governed execution via `mancode workflow decide <taskId> --plan-decision governed_execution` before Step 5, (3) keep the plan only via `mancode workflow decide <taskId> --plan-decision plan_only`, or (4) revise. Do not implement before this choice. Before either execution path, echo the plan version, delivery, stack, inclusions, exclusions, validation, and residual assumptions.",
       "Step 5 \u2014 Implement the confirmed minimum change.",
-      "Step 6 \u2014 Run detected build/lint/typecheck/test and smoke checks. A real or complex diagnosis creates a linked manba child while the parent remains at Step 6. After a resolved child, restore a parent blocked by that child with `workflow update --status in_progress` before Step 7; never auto-resume manual_test_required. Then write `review-scope.md` from the actual diff, verification evidence, and hard-risk triggers. Initialize a targeted review for routine governed changes or a full review for auth, payment, sensitive data, migrations/deletion, public APIs, untrusted input, concurrency, cross-service, or infrastructure changes using `mancode workflow review <taskId> init ...`.",
+      "Step 6 \u2014 Run `workflow verify <taskId> init`, execute detected build/lint/typecheck/test and smoke checks, and record every required acceptance ID with reproducible evidence; automated passed/failed records include the command and exit code. Use require-manual when a foreground browser, device, or human judgment is necessary; stop for explicit user confirmation before confirm-manual. The CLI blocks Step 7 and review until all checks pass. Then write `review-scope.md` and initialize targeted or full review. An explicit user review skip uses `workflow review <taskId> skip --reason <reason>` at Step 6, never generic skipped metadata.",
       "Step 7 \u2014 Run one quality review limited to the changed diff and direct impact. Findings require changed-line evidence and user impact, with at most three new findings. Record stable blocker IDs through `workflow review ... complete`; do not fix yet.",
-      "Step 8 \u2014 Only full review runs the security/boundary reviewer. It must read Film #1, mark the same root cause duplicate, and stay within security, permissions, recovery, resources, and boundaries. A targeted review ends after Film #1.",
-      "Step 9 \u2014 If open blockers exist, fix them in one remediation round and record resolved IDs through `workflow review ... remediate`; with no blockers, do not create a remediation round. Re-run affected verification without re-running completed reviewers. Write `summary.md` and set completed only when required domains are complete and blockers are zero; otherwise set blocked+blockingReason.",
+      "Step 8 \u2014 Only full review runs the security/boundary reviewer. It must read Film #1, mark the same root cause duplicate, and stay within security, permissions, recovery, resources, and boundaries. A targeted review treats the second domain as not applicable; it is never recorded as a skipped step.",
+      "Step 9 \u2014 If open blockers exist, fix them in one remediation round and record resolved IDs through `workflow review ... remediate`; remediation invalidates all earlier acceptance evidence, so re-run and re-record every required check at Step 9 without re-running completed reviewers. Write `summary.md` and set completed only when verification and required review domains are complete and blockers are zero.",
       "",
-      "After planned/completed/abandoned, return state to solo. On blocked, preserve enough state to resume. A CLI rejection is a hard stop, never a reason to bypass metadata validation."
+      "A solo handoff keeps the workflow planned and stores activeSoloPlan in state; solo reads requirements.md and plan.md, implements the confirmed scope with narrow validation and one bounded self-check, and does not run the /man reviewers. After successful solo verification, run `mancode workflow handoff <taskId> --complete` to atomically clear the pointer, complete the workflow at Step 4, and remove it from Active Plans. After plan-only/completed/abandoned, return state to solo. On blocked, preserve enough state to resume. A CLI rejection is a hard stop, never a reason to bypass metadata validation."
     ].join("\n")
   },
   manteam: {
@@ -2288,6 +2367,9 @@ function renderProjectContext(state, tokens, profile, options) {
     `- UI library: ${uiLibrary}`,
     `- Project profile: ${currentProfile?.projectKind || "unknown"}; validation: ${currentProfile?.availableValidation?.join(", ") || "inspect project"}`,
     "- At the start of each session, read `.mancode/state.json` to check the current mode and project context.",
+    ...state?.activeSoloPlan?.taskId ? [
+      `- Active solo plan: ${state.activeSoloPlan.taskId} (plan v${state.activeSoloPlan.planVersion ?? 1}); read its requirements.md and plan.md before implementation.`
+    ] : [],
     "- Read `.mancode/project-profile.json` before choosing tools or validation. Only for a UI task in a profile with detected UI assets, read `.mancode/aesthetics/style-tokens.json`."
   ].join("\n");
 }
@@ -4382,6 +4464,7 @@ async function init(rootDir = process5.cwd(), options = {}) {
       currentTask: null,
       currentWorkflowMode: null,
       skippedSteps: [],
+      activeSoloPlan: null,
       teamModeAutoDetected: teamModeEnabled,
       contributors: team.contributors,
       projectMode: isGenericProject ? "generic" : "detected"
@@ -6584,23 +6667,225 @@ async function pathExists9(p) {
 // src/commands/status.ts
 import { spawn } from "child_process";
 import { promises as fs9 } from "fs";
-import path24 from "path";
+import path26 from "path";
 import process10 from "process";
 
 // src/system/workflow.ts
 import {
   mkdir as mkdir9,
-  readFile as readFile10,
+  readFile as readFile12,
   readdir as readdir5,
   rm as rm4,
   stat as stat4,
-  writeFile as writeFile11
+  writeFile as writeFile13
 } from "fs/promises";
-import path23 from "path";
+import path25 from "path";
 
-// src/system/review-ledger.ts
-import { mkdir as mkdir8, readFile as readFile9, stat as stat3, writeFile as writeFile10 } from "fs/promises";
+// src/system/requirements-ledger.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile9, writeFile as writeFile10 } from "fs/promises";
 import path22 from "path";
+var REQUIREMENTS_FILE = "requirements.json";
+var REQUIREMENTS_MARKDOWN_FILE = "requirements.md";
+var ACCEPTANCE_ID_PATTERN = /^AC-[A-Z0-9][A-Z0-9-]{0,27}$/;
+var REQUIREMENT_DIMENSIONS = [
+  "platform",
+  "core_scope",
+  "technical_stack",
+  "data_and_persistence",
+  "performance",
+  "compatibility",
+  "security"
+];
+function parseRequirementsLedger(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error("requirements input must be valid JSON");
+  }
+  if (!isRecord8(value) || value.version !== 1) {
+    throw new Error("requirements version must be 1");
+  }
+  const stringFields = [
+    "confirmedScope",
+    "excludedScope",
+    "technicalDecisions",
+    "defaults",
+    "blockingUnknowns"
+  ];
+  if (typeof value.goal !== "string" || !value.goal.trim()) {
+    throw new Error("requirements goal is required");
+  }
+  for (const field of stringFields) {
+    if (!isNonEmptyStringArray(value[field])) {
+      if (!Array.isArray(value[field]) || value[field].length > 0) {
+        throw new Error(`requirements ${field} must contain non-empty strings`);
+      }
+    }
+  }
+  if (!Array.isArray(value.coverage)) {
+    throw new Error("requirements coverage is required");
+  }
+  const coverageDimensions = /* @__PURE__ */ new Set();
+  const coverage = value.coverage.map((item) => {
+    if (!isRecord8(item) || !isRequirementDimension(item.dimension) || !isCoverageStatus(item.status) || typeof item.rationale !== "string" || !item.rationale.trim()) {
+      throw new Error("invalid requirements coverage item");
+    }
+    if (coverageDimensions.has(item.dimension)) {
+      throw new Error(`duplicate requirements coverage: ${item.dimension}`);
+    }
+    coverageDimensions.add(item.dimension);
+    return {
+      dimension: item.dimension,
+      status: item.status,
+      rationale: item.rationale.trim()
+    };
+  });
+  const missingDimensions = REQUIREMENT_DIMENSIONS.filter(
+    (dimension) => !coverageDimensions.has(dimension)
+  );
+  if (missingDimensions.length > 0) {
+    throw new Error(
+      `requirements coverage is missing: ${missingDimensions.join(", ")}`
+    );
+  }
+  if (value.confirmedScope.length === 0) {
+    throw new Error("requirements confirmedScope must not be empty");
+  }
+  const stackCoverage = coverage.find(
+    (item) => item.dimension === "technical_stack"
+  );
+  if (stackCoverage?.status !== "not_applicable" && value.technicalDecisions.length === 0) {
+    throw new Error(
+      "requirements technicalDecisions are required when technical_stack applies"
+    );
+  }
+  if (!Array.isArray(value.acceptanceCriteria) || value.acceptanceCriteria.length === 0) {
+    throw new Error("requirements need at least one acceptance criterion");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const acceptanceCriteria = value.acceptanceCriteria.map((item) => {
+    if (!isRecord8(item) || typeof item.id !== "string" || !ACCEPTANCE_ID_PATTERN.test(item.id) || typeof item.description !== "string" || !item.description.trim() || typeof item.required !== "boolean" || !isVerificationMethod(item.method)) {
+      throw new Error("invalid acceptance criterion");
+    }
+    if (ids.has(item.id)) {
+      throw new Error(`duplicate acceptance criterion: ${item.id}`);
+    }
+    ids.add(item.id);
+    return {
+      id: item.id,
+      description: item.description.trim(),
+      required: item.required,
+      method: item.method
+    };
+  });
+  if (!acceptanceCriteria.some((item) => item.required)) {
+    throw new Error(
+      "requirements need at least one required acceptance criterion"
+    );
+  }
+  return {
+    version: 1,
+    goal: value.goal.trim(),
+    confirmedScope: normalizeStrings(value.confirmedScope),
+    excludedScope: normalizeStrings(value.excludedScope),
+    technicalDecisions: normalizeStrings(value.technicalDecisions),
+    defaults: normalizeStrings(value.defaults),
+    blockingUnknowns: normalizeStrings(value.blockingUnknowns),
+    coverage,
+    acceptanceCriteria
+  };
+}
+function requirementsAreReady(ledger) {
+  return ledger.blockingUnknowns.length === 0;
+}
+function requirementsDigest(ledger) {
+  return createHash2("sha256").update(JSON.stringify(ledger)).digest("hex");
+}
+async function readRequirementsLedger(projectRoot, taskId) {
+  try {
+    const raw = await readFile9(requirementsPath(projectRoot, taskId), "utf-8");
+    return parseRequirementsLedger(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeRequirementsArtifacts(projectRoot, taskId, ledger) {
+  const dir = workflowDir(projectRoot, taskId);
+  await writeFile10(
+    path22.join(dir, REQUIREMENTS_FILE),
+    `${JSON.stringify(ledger, null, 2)}
+`,
+    "utf-8"
+  );
+  await writeFile10(
+    path22.join(dir, REQUIREMENTS_MARKDOWN_FILE),
+    renderRequirementsMarkdown(ledger),
+    "utf-8"
+  );
+}
+function renderRequirementsMarkdown(ledger) {
+  const section = (title, items) => `## ${title}
+
+${items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : "- \u65E0"}
+`;
+  const criteria = ledger.acceptanceCriteria.map(
+    (item) => `- **${item.id}** [${item.required ? "\u5FC5\u9700" : "\u53EF\u9009"} / ${item.method}] ${item.description}`
+  ).join("\n");
+  const coverage = ledger.coverage.map((item) => `- **${item.dimension}** [${item.status}] ${item.rationale}`).join("\n");
+  return `# Requirements
+
+## \u7528\u6237\u76EE\u6807
+
+${ledger.goal}
+
+${section("\u5DF2\u786E\u8BA4\u8303\u56F4", ledger.confirmedScope)}
+${section("\u660E\u786E\u6392\u9664\u9879", ledger.excludedScope)}
+${section("\u6280\u672F\u51B3\u7B56", ledger.technicalDecisions)}
+${section("\u9ED8\u8BA4\u503C\u4E0E\u7406\u7531", ledger.defaults)}
+## \u9700\u6C42\u8986\u76D6
+
+${coverage}
+
+## \u9A8C\u6536\u6807\u51C6
+
+${criteria}
+
+${section("\u963B\u585E\u6027\u672A\u51B3\u95EE\u9898", ledger.blockingUnknowns)}
+## Readiness
+
+${requirementsAreReady(ledger) ? "READY" : "NEEDS_CLARIFICATION"}
+`;
+}
+function requirementsPath(projectRoot, taskId) {
+  return path22.join(workflowDir(projectRoot, taskId), REQUIREMENTS_FILE);
+}
+function workflowDir(projectRoot, taskId) {
+  return path22.join(projectRoot, ".mancode", "workflows", taskId);
+}
+function normalizeStrings(value) {
+  return value.map((item) => item.trim());
+}
+function isNonEmptyStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string" && item.trim().length > 0);
+}
+function isVerificationMethod(value) {
+  return value === "automated" || value === "manual" || value === "hybrid";
+}
+function isRequirementDimension(value) {
+  return REQUIREMENT_DIMENSIONS.some((dimension) => dimension === value);
+}
+function isCoverageStatus(value) {
+  return value === "confirmed" || value === "defaulted" || value === "not_applicable";
+}
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/system/review-ledger.ts
+import { mkdir as mkdir8, readFile as readFile10, stat as stat3, writeFile as writeFile11 } from "fs/promises";
+import path23 from "path";
 var REVIEW_FILE = "review-ledger.json";
 var TASK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
 var BLOCKER_ID_PATTERN = /^[A-Z][A-Z0-9-]{0,31}$/;
@@ -6629,6 +6914,27 @@ async function initializeReview(projectRoot, taskId, depth, targetDomain) {
   await writeReviewLedger(projectRoot, taskId, ledger);
   return ledger;
 }
+async function initializeSkippedReview(projectRoot, taskId, reason) {
+  assertValidTaskId(taskId);
+  if (!reason.trim()) throw new Error("review skip reason is required");
+  const existing = await readReviewLedger(projectRoot, taskId);
+  if (existing) throw new Error(`review already initialized: ${taskId}`);
+  const ledger = {
+    version: "1.0",
+    depth: "targeted",
+    requiredDomains: [],
+    completedDomains: [],
+    reports: {},
+    blockers: [],
+    remediationRounds: 0,
+    skipped: {
+      reason: reason.trim(),
+      recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  await writeReviewLedger(projectRoot, taskId, ledger);
+  return ledger;
+}
 async function completeReviewDomain(projectRoot, taskId, domain, report, blockerIds) {
   const ledger = await requireReviewLedger(projectRoot, taskId);
   if (!ledger.requiredDomains.includes(domain)) {
@@ -6701,6 +7007,7 @@ async function remediateReviewBlockers(projectRoot, taskId, resolvedIds) {
 async function reviewCanComplete(projectRoot, taskId) {
   const ledger = await readReviewLedger(projectRoot, taskId);
   if (!ledger) return false;
+  if (ledger.skipped) return true;
   return ledger.requiredDomains.every(
     (domain) => ledger.completedDomains.includes(domain)
   ) && ledger.blockers.every((blocker) => blocker.status === "resolved");
@@ -6708,7 +7015,7 @@ async function reviewCanComplete(projectRoot, taskId) {
 async function readReviewLedger(projectRoot, taskId) {
   if (!TASK_ID_PATTERN.test(taskId)) return null;
   try {
-    const raw = await readFile9(reviewPath(projectRoot, taskId), "utf-8");
+    const raw = await readFile10(reviewPath(projectRoot, taskId), "utf-8");
     const value = JSON.parse(raw);
     return isReviewLedger(value) ? value : null;
   } catch {
@@ -6716,8 +7023,8 @@ async function readReviewLedger(projectRoot, taskId) {
   }
 }
 function isReviewLedger(value) {
-  if (!isRecord8(value)) return false;
-  if (value.version !== "1.0" || !isReviewDepth(value.depth) || !isDomainArray(value.requiredDomains) || !isDomainArray(value.completedDomains) || !isRecord8(value.reports) || !Array.isArray(value.blockers) || value.remediationRounds !== 0 && value.remediationRounds !== 1) {
+  if (!isRecord9(value)) return false;
+  if (value.version !== "1.0" || !isReviewDepth(value.depth) || !isDomainArray(value.requiredDomains) || !isDomainArray(value.completedDomains) || !isRecord9(value.reports) || !Array.isArray(value.blockers) || value.remediationRounds !== 0 && value.remediationRounds !== 1) {
     return false;
   }
   const requiredDomains = value.requiredDomains;
@@ -6725,6 +7032,9 @@ function isReviewLedger(value) {
   const reports = value.reports;
   const blockers = value.blockers;
   const expectedDomains = value.depth === "full" ? ["quality", "security"] : requiredDomains;
+  if (value.skipped !== void 0) {
+    return isRecord9(value.skipped) && typeof value.skipped.reason === "string" && value.skipped.reason.trim().length > 0 && typeof value.skipped.recordedAt === "string" && requiredDomains.length === 0 && completedDomains.length === 0 && Object.keys(reports).length === 0 && blockers.length === 0 && value.remediationRounds === 0;
+  }
   if (value.depth === "targeted" && requiredDomains.length !== 1 || requiredDomains.length !== expectedDomains.length || !expectedDomains.every((domain) => requiredDomains.includes(domain)) || new Set(completedDomains).size !== completedDomains.length || completedDomains.some((domain) => !requiredDomains.includes(domain)) || completedDomains.some((domain) => {
     const report = reports[domain];
     return typeof report !== "string" || !isSafeReportPath(report);
@@ -6733,13 +7043,13 @@ function isReviewLedger(value) {
   }
   const blockerIds = /* @__PURE__ */ new Set();
   return blockers.every(
-    (blocker) => isRecord8(blocker) && typeof blocker.id === "string" && BLOCKER_ID_PATTERN.test(blocker.id) && !blockerIds.has(blocker.id) && blockerIds.add(blocker.id) && isReviewDomain(blocker.domain) && completedDomains.includes(blocker.domain) && (blocker.status === "open" || blocker.status === "resolved")
+    (blocker) => isRecord9(blocker) && typeof blocker.id === "string" && BLOCKER_ID_PATTERN.test(blocker.id) && !blockerIds.has(blocker.id) && blockerIds.add(blocker.id) && isReviewDomain(blocker.domain) && completedDomains.includes(blocker.domain) && (blocker.status === "open" || blocker.status === "resolved")
   );
 }
 function isDomainArray(value) {
   return Array.isArray(value) && value.every(isReviewDomain);
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function requireReviewLedger(projectRoot, taskId) {
@@ -6749,17 +7059,21 @@ async function requireReviewLedger(projectRoot, taskId) {
   return ledger;
 }
 async function writeReviewLedger(projectRoot, taskId, ledger) {
-  const dir = path22.join(projectRoot, ".mancode", "workflows", taskId);
+  const dir = path23.join(projectRoot, ".mancode", "workflows", taskId);
   await mkdir8(dir, { recursive: true });
-  await writeFile10(
-    path22.join(dir, REVIEW_FILE),
+  await writeFile11(
+    path23.join(dir, REVIEW_FILE),
     `${JSON.stringify(ledger, null, 2)}
 `,
     "utf-8"
   );
 }
+function reviewLedgerPath(projectRoot, taskId) {
+  assertValidTaskId(taskId);
+  return reviewPath(projectRoot, taskId);
+}
 function reviewPath(projectRoot, taskId) {
-  return path22.join(projectRoot, ".mancode", "workflows", taskId, REVIEW_FILE);
+  return path23.join(projectRoot, ".mancode", "workflows", taskId, REVIEW_FILE);
 }
 function assertValidTaskId(taskId) {
   if (!TASK_ID_PATTERN.test(taskId)) {
@@ -6772,7 +7086,7 @@ function assertSafeReportPath(report) {
   }
 }
 async function assertReportExists(projectRoot, taskId, report) {
-  const reportPath = path22.join(
+  const reportPath = path23.join(
     projectRoot,
     ".mancode",
     "workflows",
@@ -6786,11 +7100,221 @@ async function assertReportExists(projectRoot, taskId, report) {
   throw new Error(`review report not found: ${report}`);
 }
 function isSafeReportPath(report) {
-  const normalized = path22.posix.normalize(report.replaceAll("\\", "/"));
+  const normalized = path23.posix.normalize(report.replaceAll("\\", "/"));
+  return Boolean(
+    report.trim() && !path23.isAbsolute(report) && normalized !== ".." && !normalized.startsWith("../") && normalized.endsWith(".md")
+  );
+}
+
+// src/system/verification-ledger.ts
+import { readFile as readFile11, writeFile as writeFile12 } from "fs/promises";
+import path24 from "path";
+var VERIFICATION_FILE = "verification-ledger.json";
+function initializeVerificationLedger(requirements, planVersion, remediationRound = 0) {
+  const checks = requirements.acceptanceCriteria.map((criterion) => ({
+    acceptanceId: criterion.id,
+    required: criterion.required,
+    ...criterion.method === "automated" || criterion.method === "hybrid" ? { automated: { status: "pending" } } : {},
+    ...criterion.method === "manual" || criterion.method === "hybrid" ? { manual: { status: "pending" } } : {}
+  }));
+  return {
+    version: 1,
+    planVersion,
+    requirementsDigest: requirementsDigest(requirements),
+    remediationRound,
+    status: deriveVerificationStatus(checks),
+    checks
+  };
+}
+function recordVerification(ledger, acceptanceId, component, result, evidence, automatedDetails) {
+  if (!evidence.trim()) throw new Error("verification evidence is required");
+  if (component === "automated" && result === "manual_required") {
+    throw new Error("automated verification cannot be manual_required");
+  }
+  if (component === "automated" && (result === "passed" || result === "failed")) {
+    if (!automatedDetails?.command.trim() || !Number.isInteger(automatedDetails.exitCode)) {
+      throw new Error(
+        "automated passed/failed verification requires command and exit code"
+      );
+    }
+    if (result === "passed" && automatedDetails.exitCode !== 0) {
+      throw new Error("passed verification requires exit code 0");
+    }
+    if (result === "failed" && automatedDetails.exitCode === 0) {
+      throw new Error("failed verification requires a non-zero exit code");
+    }
+  }
+  if (component === "manual" && result !== "manual_required") {
+    throw new Error(
+      "manual verification must use require-manual or confirm-manual"
+    );
+  }
+  const index = ledger.checks.findIndex(
+    (check2) => check2.acceptanceId === acceptanceId
+  );
+  if (index < 0)
+    throw new Error(`unknown acceptance criterion: ${acceptanceId}`);
+  const check = ledger.checks[index];
+  if (!check) throw new Error(`unknown acceptance criterion: ${acceptanceId}`);
+  if (!check[component]) {
+    throw new Error(
+      `${acceptanceId} does not require ${component} verification`
+    );
+  }
+  const checks = [...ledger.checks];
+  checks[index] = {
+    ...check,
+    [component]: {
+      status: result,
+      evidence: evidence.trim(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...component === "automated" && automatedDetails ? {
+        command: automatedDetails.command.trim(),
+        exitCode: automatedDetails.exitCode,
+        ...automatedDetails.evidenceFile ? { evidenceFile: automatedDetails.evidenceFile } : {}
+      } : {}
+    }
+  };
+  return { ...ledger, status: deriveVerificationStatus(checks), checks };
+}
+function resetVerificationForRemediation(ledger, remediationRound) {
+  if (!Number.isInteger(remediationRound) || remediationRound < ledger.remediationRound) {
+    throw new Error("invalid verification remediation round");
+  }
+  if (remediationRound === ledger.remediationRound) return ledger;
+  const checks = ledger.checks.map((check) => ({
+    acceptanceId: check.acceptanceId,
+    required: check.required,
+    ...check.automated ? { automated: { status: "pending" } } : {},
+    ...check.manual ? { manual: { status: "pending" } } : {}
+  }));
+  return {
+    ...ledger,
+    remediationRound,
+    status: deriveVerificationStatus(checks),
+    checks
+  };
+}
+function confirmManualVerification(ledger, acceptanceId, evidence) {
+  if (!evidence.trim())
+    throw new Error("manual confirmation evidence is required");
+  const index = ledger.checks.findIndex(
+    (check2) => check2.acceptanceId === acceptanceId
+  );
+  if (index < 0)
+    throw new Error(`unknown acceptance criterion: ${acceptanceId}`);
+  const check = ledger.checks[index];
+  if (!check) throw new Error(`unknown acceptance criterion: ${acceptanceId}`);
+  if (!check.manual) {
+    throw new Error(`${acceptanceId} does not require manual verification`);
+  }
+  if (check.manual.status !== "manual_required") {
+    throw new Error(`${acceptanceId} is not awaiting manual confirmation`);
+  }
+  const checks = [...ledger.checks];
+  checks[index] = {
+    ...check,
+    manual: {
+      status: "passed",
+      evidence: evidence.trim(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  return { ...ledger, status: deriveVerificationStatus(checks), checks };
+}
+function deriveVerificationStatus(checks) {
+  const statuses = checks.filter((check) => check.required).flatMap((check) => [check.automated?.status, check.manual?.status]).filter((status2) => Boolean(status2));
+  if (statuses.includes("blocked")) return "blocked";
+  if (statuses.includes("manual_required")) return "manual_required";
+  if (statuses.includes("failed")) return "failed";
+  if (statuses.every((status2) => status2 === "passed")) return "passed";
+  return "pending";
+}
+async function readVerificationLedger(projectRoot, taskId) {
+  try {
+    const raw = await readFile11(verificationPath(projectRoot, taskId), "utf-8");
+    const value = JSON.parse(raw);
+    return isVerificationLedger(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+async function writeVerificationLedger(projectRoot, taskId, ledger) {
+  await writeFile12(
+    verificationPath(projectRoot, taskId),
+    `${JSON.stringify(ledger, null, 2)}
+`,
+    "utf-8"
+  );
+}
+async function verificationCanAdvance(projectRoot, taskId, planVersion) {
+  const [ledger, requirements, review] = await Promise.all([
+    readVerificationLedger(projectRoot, taskId),
+    readRequirementsLedger(projectRoot, taskId),
+    readReviewLedger(projectRoot, taskId)
+  ]);
   return Boolean(
-    report.trim() && !path22.isAbsolute(report) && normalized !== ".." && !normalized.startsWith("../") && normalized.endsWith(".md")
+    ledger && requirements && ledger.status === "passed" && ledger.planVersion === planVersion && ledger.remediationRound === (review?.remediationRounds ?? 0) && ledger.requirementsDigest === requirementsDigest(requirements) && ledgerMatchesRequirements(ledger, requirements)
+  );
+}
+function verificationLedgerPath(projectRoot, taskId) {
+  return verificationPath(projectRoot, taskId);
+}
+function verificationPath(projectRoot, taskId) {
+  return path24.join(
+    projectRoot,
+    ".mancode",
+    "workflows",
+    taskId,
+    VERIFICATION_FILE
   );
 }
+function isVerificationLedger(value) {
+  if (typeof value !== "object" || value === null || !("version" in value) || value.version !== 1 || !("planVersion" in value) || !Number.isInteger(value.planVersion) || !("requirementsDigest" in value) || typeof value.requirementsDigest !== "string" || !("remediationRound" in value) || typeof value.remediationRound !== "number" || !Number.isInteger(value.remediationRound) || value.remediationRound < 0 || !("status" in value) || !isComponentStatus(value.status) || !("checks" in value) || !Array.isArray(value.checks)) {
+    return false;
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const validChecks = value.checks.every((check) => {
+    if (typeof check !== "object" || check === null || !("acceptanceId" in check) || typeof check.acceptanceId !== "string" || !("required" in check) || typeof check.required !== "boolean") {
+      return false;
+    }
+    if (ids.has(check.acceptanceId)) return false;
+    ids.add(check.acceptanceId);
+    return ["automated", "manual"].every((component) => {
+      const evidence = check[component];
+      if (evidence === void 0) return true;
+      const valid = typeof evidence === "object" && evidence !== null && "status" in evidence && isComponentStatus(evidence.status);
+      if (!valid) return false;
+      if (evidence.status === "pending") {
+        return !("evidence" in evidence) && !("updatedAt" in evidence);
+      }
+      const baseEvidenceIsValid = "evidence" in evidence && typeof evidence.evidence === "string" && evidence.evidence.trim().length > 0 && "updatedAt" in evidence && typeof evidence.updatedAt === "string";
+      if (!baseEvidenceIsValid) return false;
+      if (component === "automated" && (evidence.status === "passed" || evidence.status === "failed")) {
+        return "command" in evidence && typeof evidence.command === "string" && evidence.command.trim().length > 0 && "exitCode" in evidence && Number.isInteger(evidence.exitCode) && (evidence.status === "passed" ? evidence.exitCode === 0 : evidence.exitCode !== 0);
+      }
+      return true;
+    });
+  });
+  return validChecks && value.status === deriveVerificationStatus(value.checks);
+}
+function ledgerMatchesRequirements(ledger, requirements) {
+  if (ledger.checks.length !== requirements.acceptanceCriteria.length) {
+    return false;
+  }
+  return requirements.acceptanceCriteria.every((criterion) => {
+    const check = ledger.checks.find(
+      (candidate) => candidate.acceptanceId === criterion.id
+    );
+    if (!check || check.required !== criterion.required) return false;
+    const needsAutomated = criterion.method === "automated" || criterion.method === "hybrid";
+    const needsManual = criterion.method === "manual" || criterion.method === "hybrid";
+    return Boolean(check.automated) === needsAutomated && Boolean(check.manual) === needsManual;
+  });
+}
+function isComponentStatus(value) {
+  return value === "pending" || value === "passed" || value === "failed" || value === "manual_required" || value === "blocked";
+}
 
 // src/system/workflow.ts
 var METADATA_FILE = "metadata.json";
@@ -6812,7 +7336,7 @@ async function createWorkflow(projectRoot, task, mode, options = {}) {
   await validateParentTask(projectRoot, mode, options.parentTaskId, true);
   await mkdir9(workflowsRoot(projectRoot), { recursive: true });
   const taskId = await allocateTaskId(projectRoot, generateTaskId(task));
-  const dir = workflowDir(projectRoot, taskId);
+  const dir = workflowDir2(projectRoot, taskId);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const meta = {
     taskId,
@@ -6824,7 +7348,12 @@ async function createWorkflow(projectRoot, task, mode, options = {}) {
     updatedAt: now,
     status: "in_progress",
     ...options.parentTaskId ? { parentTaskId: options.parentTaskId } : {},
-    ...mode === "man" || mode === "manteam" ? { planVersion: 1, reviewPolicyVersion: 1 } : {}
+    ...mode === "man" || mode === "manteam" ? {
+      planVersion: 1,
+      reviewPolicyVersion: options.planningPolicyVersion === 2 ? 2 : 1,
+      ...options.planningPolicyVersion === 2 ? { verificationPolicyVersion: 1 } : {},
+      ...options.planningPolicyVersion ? { planningPolicyVersion: options.planningPolicyVersion } : {}
+    } : {}
   };
   await writeMetadata(dir, meta);
   return meta;
@@ -6833,7 +7362,7 @@ async function allocateTaskId(projectRoot, baseTaskId) {
   for (let attempt = 0; attempt < 1e3; attempt++) {
     const taskId = attempt === 0 ? baseTaskId : `${baseTaskId}-${attempt + 1}`;
     try {
-      await mkdir9(workflowDir(projectRoot, taskId));
+      await mkdir9(workflowDir2(projectRoot, taskId));
       return taskId;
     } catch (err) {
       if (isNodeError9(err) && err.code === "EEXIST") {
@@ -6848,13 +7377,13 @@ async function readWorkflow(projectRoot, taskId) {
   if (!isValidWorkflowTaskId(taskId)) return null;
   const file = metadataPath(projectRoot, taskId);
   try {
-    const raw = await readFile10(file, "utf-8");
+    const raw = await readFile12(file, "utf-8");
     return parseWorkflowMeta(raw, taskId);
   } catch {
     return null;
   }
 }
-async function updateWorkflow(projectRoot, taskId, patch) {
+async function updateWorkflow(projectRoot, taskId, patch, options = {}) {
   assertValidTaskId2(taskId);
   const existing = await readWorkflow(projectRoot, taskId);
   if (!existing) {
@@ -6874,8 +7403,8 @@ async function updateWorkflow(projectRoot, taskId, patch) {
   if (updated.status !== "blocked" && !explicitlyPatchedBlockingReason) {
     updated.blockingReason = void 0;
   }
-  await validateWorkflowMeta(projectRoot, updated, existing);
-  await writeMetadata(workflowDir(projectRoot, taskId), updated);
+  await validateWorkflowMeta(projectRoot, updated, existing, options);
+  await writeMetadata(workflowDir2(projectRoot, taskId), updated);
   if (updated.parentTaskId) {
     await propagateChildStatus(projectRoot, updated);
   }
@@ -6898,7 +7427,7 @@ async function listWorkflows(projectRoot) {
 }
 async function deleteWorkflow(projectRoot, taskId) {
   if (!isValidWorkflowTaskId(taskId)) return false;
-  const dir = workflowDir(projectRoot, taskId);
+  const dir = workflowDir2(projectRoot, taskId);
   try {
     await stat4(dir);
   } catch {
@@ -6912,19 +7441,19 @@ async function deleteWorkflow(projectRoot, taskId) {
   return true;
 }
 function workflowsRoot(projectRoot) {
-  return path23.join(projectRoot, ".mancode", "workflows");
+  return path25.join(projectRoot, ".mancode", "workflows");
 }
-function workflowDir(projectRoot, taskId) {
+function workflowDir2(projectRoot, taskId) {
   assertValidTaskId2(taskId);
-  return path23.join(workflowsRoot(projectRoot), taskId);
+  return path25.join(workflowsRoot(projectRoot), taskId);
 }
 function metadataPath(projectRoot, taskId) {
-  return path23.join(workflowDir(projectRoot, taskId), METADATA_FILE);
+  return path25.join(workflowDir2(projectRoot, taskId), METADATA_FILE);
 }
 async function writeMetadata(dir, meta) {
   const content = `${JSON.stringify(meta, null, 2)}
 `;
-  await writeFile11(path23.join(dir, METADATA_FILE), content, "utf-8");
+  await writeFile13(path25.join(dir, METADATA_FILE), content, "utf-8");
 }
 function parseWorkflowMeta(raw, taskId) {
   try {
@@ -6949,6 +7478,12 @@ function isWorkflowStatus(value) {
 function isWorkflowOutcome(value) {
   return value === "fixed" || value === "verified" || value === "no_repro" || value === "manual_test_required";
 }
+function isRequirementsStatus(value) {
+  return value === "ready" || value === "needs_clarification";
+}
+function isPlanDecision(value) {
+  return value === "plan_only" || value === "solo_handoff" || value === "governed_execution";
+}
 async function validateParentTask(projectRoot, mode, parentTaskId, requireStepSix = false) {
   if (!parentTaskId) return;
   if (mode !== "mamba") {
@@ -6964,7 +7499,7 @@ async function validateParentTask(projectRoot, mode, parentTaskId, requireStepSi
     );
   }
 }
-async function validateWorkflowMeta(projectRoot, updated, existing) {
+async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   if (updated.mode !== existing.mode) {
     throw new Error("workflow mode cannot be changed");
   }
@@ -6977,6 +7512,17 @@ async function validateWorkflowMeta(projectRoot, updated, existing) {
   if (updated.reviewPolicyVersion !== existing.reviewPolicyVersion) {
     throw new Error("workflow review policy version cannot be changed");
   }
+  if (updated.planningPolicyVersion !== existing.planningPolicyVersion) {
+    throw new Error("workflow planning policy version cannot be changed");
+  }
+  if (updated.requirementsDigest !== existing.requirementsDigest && existing.currentStep > 2) {
+    throw new Error(
+      "workflow requirements cannot change after planning starts"
+    );
+  }
+  if (updated.verificationPolicyVersion !== existing.verificationPolicyVersion) {
+    throw new Error("workflow verification policy version cannot be changed");
+  }
   if (!Number.isInteger(updated.currentStep) || updated.currentStep < 1 || updated.currentStep > maxWorkflowStep(updated.mode)) {
     throw new Error(`invalid workflow step: ${updated.currentStep}`);
   }
@@ -6986,6 +7532,13 @@ async function validateWorkflowMeta(projectRoot, updated, existing) {
   if (!Array.isArray(updated.skippedSteps) || updated.skippedSteps.some((step) => typeof step !== "string")) {
     throw new Error("workflow skipped steps must be strings");
   }
+  if (updated.reviewPolicyVersion === 2 && updated.skippedSteps.some(
+    (step) => step !== "clarification" && step !== "review"
+  )) {
+    throw new Error(
+      "workflow policy v2 only allows skipping clarification or review"
+    );
+  }
   if (!canTransition(existing.status, updated.status)) {
     throw new Error(
       `invalid workflow status transition: ${existing.status} -> ${updated.status}`
@@ -6997,7 +7550,7 @@ async function validateWorkflowMeta(projectRoot, updated, existing) {
   if (updated.status === "planned" && updated.currentStep !== 4) {
     throw new Error("planned workflows must be at step 4");
   }
-  if (updated.status === "completed" && updated.currentStep !== maxWorkflowStep(updated.mode)) {
+  if (updated.status === "completed" && updated.currentStep !== maxWorkflowStep(updated.mode) && !(updated.currentStep === 4 && updated.planDecision === "solo_handoff")) {
     throw new Error(
       `completed ${updated.mode === "mamba" ? "manba" : updated.mode} workflows must be at step ${maxWorkflowStep(updated.mode)}`
     );
@@ -7027,12 +7580,106 @@ async function validateWorkflowMeta(projectRoot, updated, existing) {
   if (updated.mode === "mamba" && updated.planVersion !== void 0) {
     throw new Error("manba workflows cannot have a plan version");
   }
-  if (updated.reviewPolicyVersion !== void 0 && updated.reviewPolicyVersion !== 1) {
+  if (updated.reviewPolicyVersion !== void 0 && updated.reviewPolicyVersion !== 1 && updated.reviewPolicyVersion !== 2) {
     throw new Error("invalid workflow review policy version");
   }
   if (updated.mode === "mamba" && updated.reviewPolicyVersion !== void 0) {
     throw new Error("manba workflows cannot have a review policy version");
   }
+  if (updated.planningPolicyVersion !== void 0 && updated.planningPolicyVersion !== 1 && updated.planningPolicyVersion !== 2) {
+    throw new Error("invalid workflow planning policy version");
+  }
+  if (updated.mode === "mamba" && updated.planningPolicyVersion !== void 0) {
+    throw new Error("manba workflows cannot have a planning policy version");
+  }
+  if (updated.verificationPolicyVersion !== void 0 && updated.verificationPolicyVersion !== 1) {
+    throw new Error("invalid workflow verification policy version");
+  }
+  if (updated.mode === "mamba" && updated.verificationPolicyVersion !== void 0) {
+    throw new Error(
+      "manba workflows cannot have a verification policy version"
+    );
+  }
+  if (updated.verificationStatus !== void 0 && !isVerificationStatus(updated.verificationStatus)) {
+    throw new Error("invalid workflow verification status");
+  }
+  if (updated.mode === "mamba" && updated.verificationStatus !== void 0) {
+    throw new Error("manba workflows cannot have a verification status");
+  }
+  if (updated.requirementsStatus !== void 0 && !isRequirementsStatus(updated.requirementsStatus)) {
+    throw new Error("invalid workflow requirements status");
+  }
+  if (updated.mode === "mamba" && updated.requirementsStatus !== void 0) {
+    throw new Error("manba workflows cannot have a requirements status");
+  }
+  if (updated.requirementsDigest !== void 0 && typeof updated.requirementsDigest !== "string") {
+    throw new Error("workflow requirements digest must be a string");
+  }
+  if (updated.mode === "mamba" && updated.requirementsDigest !== void 0) {
+    throw new Error("manba workflows cannot have a requirements digest");
+  }
+  if (updated.planDecision !== void 0 && !isPlanDecision(updated.planDecision)) {
+    throw new Error("invalid workflow plan decision");
+  }
+  if (updated.mode === "mamba" && updated.planDecision !== void 0) {
+    throw new Error("manba workflows cannot have a plan decision");
+  }
+  if (updated.planDecision !== existing.planDecision && existing.planDecision !== void 0) {
+    throw new Error("workflow plan decision cannot be changed");
+  }
+  if (updated.planDecision !== existing.planDecision && existing.currentStep !== 4) {
+    throw new Error("workflow plan decision can only be set at step 4");
+  }
+  if (updated.planningPolicyVersion === 1 || updated.planningPolicyVersion === 2) {
+    if (updated.currentStep >= 3) {
+      if (updated.requirementsStatus !== "ready") {
+        throw new Error("requirements must be ready before planning");
+      }
+      if (!await workflowArtifactExists(
+        projectRoot,
+        updated.taskId,
+        "requirements.md"
+      )) {
+        throw new Error("requirements.md is required before planning");
+      }
+      if (updated.planningPolicyVersion === 2) {
+        const requirements = await readRequirementsLedger(
+          projectRoot,
+          updated.taskId
+        );
+        if (!requirements || !requirementsAreReady(requirements) || updated.requirementsDigest !== requirementsDigest(requirements)) {
+          throw new Error(
+            "finalized requirements.json with no blocking unknowns is required before planning"
+          );
+        }
+      }
+    }
+    if (updated.currentStep >= 4 && !await workflowArtifactExists(projectRoot, updated.taskId, "plan.md")) {
+      throw new Error("plan.md is required before the plan gate");
+    }
+    if (updated.status === "planned" && updated.planDecision !== "plan_only" && updated.planDecision !== "solo_handoff") {
+      throw new Error(
+        "planned workflows require a plan-only or solo-handoff decision"
+      );
+    }
+    if (updated.currentStep >= 5 && updated.status === "in_progress" && updated.planDecision !== "governed_execution") {
+      throw new Error("governed execution must be confirmed before step 5");
+    }
+  }
+  if (updated.verificationPolicyVersion === 1 && updated.currentStep >= 7 && updated.planDecision !== "solo_handoff" && !options.allowIncompleteVerification && !await verificationCanAdvance(
+    projectRoot,
+    updated.taskId,
+    updated.planVersion ?? 1
+  )) {
+    throw new Error(
+      "workflow verification is incomplete, stale, or requires manual confirmation"
+    );
+  }
+  if (existing.status === "blocked" && existing.blockingReason?.startsWith("[verification]") && updated.status === "in_progress" && (updated.verificationStatus === "manual_required" || updated.verificationStatus === "blocked")) {
+    throw new Error(
+      "verification-blocked workflows must resume through verify"
+    );
+  }
   if (updated.planVersion !== void 0 && (!Number.isInteger(updated.planVersion) || updated.planVersion < 1)) {
     throw new Error("workflow plan version must be a positive integer");
   }
@@ -7046,16 +7693,22 @@ async function validateWorkflowMeta(projectRoot, updated, existing) {
   if ((isTerminalWorkflowStatus(updated.status) || updated.status === "planned") && (await listActiveMambaChildren(projectRoot, updated.taskId)).length > 0) {
     throw new Error("cannot finish workflow with an active manba child");
   }
-  if (updated.status === "completed" && updated.reviewPolicyVersion === 1 && !reviewWasExplicitlySkipped(updated) && !await reviewCanComplete(projectRoot, updated.taskId)) {
+  if (updated.status === "completed" && updated.reviewPolicyVersion === 1 && updated.planDecision !== "solo_handoff" && !reviewWasExplicitlySkipped(updated) && !await reviewCanComplete(projectRoot, updated.taskId)) {
+    throw new Error("workflow review is incomplete or still has open blockers");
+  }
+  if (updated.status === "completed" && updated.reviewPolicyVersion === 2 && updated.planDecision !== "solo_handoff" && !await reviewCanComplete(projectRoot, updated.taskId)) {
     throw new Error("workflow review is incomplete or still has open blockers");
   }
+  if (updated.status === "completed" && updated.verificationPolicyVersion === 1 && updated.planDecision !== "solo_handoff" && !await workflowArtifactExists(projectRoot, updated.taskId, "summary.md")) {
+    throw new Error("summary.md is required before workflow completion");
+  }
 }
 function canTransition(from, to) {
   if (from === to) return true;
   if (from === "in_progress") return true;
-  if (from === "planned" || from === "blocked") {
-    return to === "in_progress" || to === "abandoned";
-  }
+  if (from === "planned")
+    return to === "in_progress" || to === "completed" || to === "abandoned";
+  if (from === "blocked") return to === "in_progress" || to === "abandoned";
   return false;
 }
 function isTerminalWorkflowStatus(status2) {
@@ -7076,15 +7729,27 @@ function isWorkflowShape(obj) {
     return false;
   if (obj.planVersion !== void 0 && (!Number.isInteger(obj.planVersion) || obj.planVersion < 1))
     return false;
-  if (obj.reviewPolicyVersion !== void 0 && obj.reviewPolicyVersion !== 1)
+  if (obj.reviewPolicyVersion !== void 0 && obj.reviewPolicyVersion !== 1 && obj.reviewPolicyVersion !== 2)
     return false;
-  if (status2 === "blocked") {
-    if (!obj.blockingReason?.trim()) return false;
+  if (obj.planningPolicyVersion !== void 0 && obj.planningPolicyVersion !== 1 && obj.planningPolicyVersion !== 2)
+    return false;
+  if (obj.verificationPolicyVersion !== void 0 && obj.verificationPolicyVersion !== 1)
+    return false;
+  if (obj.requirementsStatus !== void 0 && !isRequirementsStatus(obj.requirementsStatus))
+    return false;
+  if (obj.requirementsDigest !== void 0 && typeof obj.requirementsDigest !== "string")
+    return false;
+  if (obj.planDecision !== void 0 && !isPlanDecision(obj.planDecision))
+    return false;
+  if (obj.verificationStatus !== void 0 && !isVerificationStatus(obj.verificationStatus))
+    return false;
+  if (status2 === "blocked") {
+    if (!obj.blockingReason?.trim()) return false;
   } else if (obj.blockingReason !== void 0) {
     return false;
   }
   if (mode === "mamba") {
-    if (status2 === "planned" || obj.planVersion !== void 0 || obj.reviewPolicyVersion !== void 0)
+    if (status2 === "planned" || obj.planVersion !== void 0 || obj.reviewPolicyVersion !== void 0 || obj.planningPolicyVersion !== void 0 || obj.verificationPolicyVersion !== void 0 || obj.requirementsStatus !== void 0 || obj.requirementsDigest !== void 0 || obj.planDecision !== void 0 || obj.verificationStatus !== void 0)
       return false;
     if (obj.parentTaskId !== void 0 && !isValidWorkflowTaskId(obj.parentTaskId))
       return false;
@@ -7095,9 +7760,20 @@ function isWorkflowShape(obj) {
   }
   return true;
 }
+async function workflowArtifactExists(projectRoot, taskId, filename) {
+  try {
+    await stat4(path25.join(workflowDir2(projectRoot, taskId), filename));
+    return true;
+  } catch {
+    return false;
+  }
+}
 function reviewWasExplicitlySkipped(meta) {
   return meta.skippedSteps.includes("review") || meta.skippedSteps.includes("film-1") && meta.skippedSteps.includes("film-2");
 }
+function isVerificationStatus(value) {
+  return value === "pending" || value === "passed" || value === "failed" || value === "manual_required" || value === "blocked";
+}
 async function listActiveMambaChildren(projectRoot, parentTaskId) {
   return (await listMambaChildren(projectRoot, parentTaskId)).filter(
     (workflow2) => workflow2.status === "in_progress" || workflow2.status === "blocked"
@@ -7116,7 +7792,7 @@ async function propagateChildStatus(projectRoot, child) {
   const parent = await readWorkflow(projectRoot, parentTaskId);
   if (!parent || parent.status !== "in_progress") return;
   const reason = child.status === "blocked" ? `manba child ${child.taskId} is blocked: ${child.blockingReason ?? "unknown reason"}` : `manba child ${child.taskId} requires manual testing`;
-  await writeMetadata(workflowDir(projectRoot, parent.taskId), {
+  await writeMetadata(workflowDir2(projectRoot, parent.taskId), {
     ...parent,
     status: "blocked",
     blockingReason: reason,
@@ -7145,7 +7821,7 @@ var EXIT_OK7 = 0;
 var EXIT_NOT_INITIALIZED5 = 1;
 var EXIT_CORRUPT_STATE2 = 2;
 async function status(rootDir = process10.cwd(), options = {}) {
-  const stateFile = path24.join(rootDir, ".mancode", "state.json");
+  const stateFile = path26.join(rootDir, ".mancode", "state.json");
   if (!await pathExists10(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` to get started.");
@@ -7196,6 +7872,7 @@ async function status(rootDir = process10.cwd(), options = {}) {
     hookInjection,
     team: effectiveTeam,
     currentWorkflow,
+    activeSoloPlan: state.activeSoloPlan ?? null,
     platformStatus: {},
     projectRefreshRecommended
   };
@@ -7209,10 +7886,10 @@ async function status(rootDir = process10.cwd(), options = {}) {
 }
 async function shouldRefreshProject(rootDir, state) {
   if (state.projectMode !== "generic") return false;
-  const hasGit = await pathExists10(path24.join(rootDir, ".git"));
+  const hasGit = await pathExists10(path26.join(rootDir, ".git"));
   if (hasGit) return true;
   for (const manifest of PROJECT_MANIFESTS) {
-    if (await pathExists10(path24.join(rootDir, manifest))) return true;
+    if (await pathExists10(path26.join(rootDir, manifest))) return true;
   }
   return false;
 }
@@ -7256,19 +7933,19 @@ async function getCurrentWorkflow(rootDir, taskId) {
 }
 async function getProjectName(rootDir) {
   try {
-    const raw = await fs9.readFile(path24.join(rootDir, "package.json"), "utf-8");
+    const raw = await fs9.readFile(path26.join(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.name && typeof pkg.name === "string") {
       return pkg.name;
     }
   } catch {
   }
-  return path24.basename(rootDir);
+  return path26.basename(rootDir);
 }
 async function readConfig2(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path24.join(rootDir, ".mancode", "config.json"),
+      path26.join(rootDir, ".mancode", "config.json"),
       "utf-8"
     );
     return JSON.parse(raw);
@@ -7296,9 +7973,9 @@ function getEffectiveTeamStatus(state, config, detected) {
 }
 async function checkHooks(rootDir) {
   const [sessionStart, userPromptSubmit, registered] = await Promise.all([
-    pathExists10(path24.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
+    pathExists10(path26.join(rootDir, ".mancode", "hooks", "session-start.mjs")),
     pathExists10(
-      path24.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
+      path26.join(rootDir, ".mancode", "hooks", "user-prompt-submit.mjs")
     ),
     isRegistered(rootDir)
   ]);
@@ -7307,7 +7984,7 @@ async function checkHooks(rootDir) {
 async function isRegistered(rootDir) {
   try {
     const raw = await fs9.readFile(
-      path24.join(rootDir, ".claude", "settings.json"),
+      path26.join(rootDir, ".claude", "settings.json"),
       "utf-8"
     );
     const settings = JSON.parse(raw);
@@ -7317,9 +7994,9 @@ async function isRegistered(rootDir) {
   }
 }
 function hooksRegistered2(settings) {
-  if (!isRecord9(settings)) return false;
+  if (!isRecord10(settings)) return false;
   const hooks = settings.hooks;
-  if (!isRecord9(hooks)) return false;
+  if (!isRecord10(hooks)) return false;
   return hasHookCommand2(hooks.SessionStart, ".mancode/hooks/session-start.mjs") && hasHookCommand2(
     hooks.UserPromptSubmit,
     ".mancode/hooks/user-prompt-submit.mjs"
@@ -7328,15 +8005,15 @@ function hooksRegistered2(settings) {
 function hasHookCommand2(value, needle) {
   if (!Array.isArray(value)) return false;
   return value.some((group) => {
-    if (!isRecord9(group) || !Array.isArray(group.hooks)) return false;
+    if (!isRecord10(group) || !Array.isArray(group.hooks)) return false;
     return group.hooks.some((hook) => {
-      if (!isRecord9(hook) || typeof hook.command !== "string") return false;
+      if (!isRecord10(hook) || typeof hook.command !== "string") return false;
       return hook.command.includes(needle);
     });
   });
 }
 async function estimateHookInjection(rootDir) {
-  const hookPath = path24.join(
+  const hookPath = path26.join(
     rootDir,
     ".mancode",
     "hooks",
@@ -7428,6 +8105,11 @@ function printText(r) {
       );
     }
   }
+  if (r.activeSoloPlan) {
+    console.log(
+      `Solo plan:   ${r.activeSoloPlan.taskId} (plan v${r.activeSoloPlan.planVersion})`
+    );
+  }
   console.log("");
   console.log("Installed platforms:");
   for (const p of r.platforms) {
@@ -7468,7 +8150,7 @@ function formatTeamStatus(team) {
 function workflowStepMax(mode) {
   return maxWorkflowStep(mode);
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null;
 }
 async function pathExists10(p) {
@@ -7481,14 +8163,14 @@ async function pathExists10(p) {
 }
 
 // src/commands/uninstall.ts
-import { access as access5, readFile as readFile11, rm as rm5, writeFile as writeFile12 } from "fs/promises";
-import path25 from "path";
+import { access as access5, readFile as readFile13, rm as rm5, writeFile as writeFile14 } from "fs/promises";
+import path27 from "path";
 import process11 from "process";
 var EXIT_OK8 = 0;
 var EXIT_NOT_INITIALIZED6 = 1;
 var EXIT_UNSUPPORTED_PLATFORM2 = 2;
 async function uninstall(rootDir = process11.cwd(), platform, options = {}) {
-  const stateFile = path25.join(rootDir, ".mancode", "state.json");
+  const stateFile = path27.join(rootDir, ".mancode", "state.json");
   if (!await pathExists11(stateFile)) {
     console.error("\u2717  mancode not initialized.");
     console.error("   Run `mancode init` first.");
@@ -7540,7 +8222,7 @@ async function uninstallAll(rootDir) {
     await uninstallPlatform(rootDir, p);
   }
   console.log("\u2713  Removing .mancode/ directory...");
-  await rm5(path25.join(rootDir, ".mancode"), {
+  await rm5(path27.join(rootDir, ".mancode"), {
     recursive: true,
     force: true
   });
@@ -7550,10 +8232,10 @@ async function uninstallClaudeCode(rootDir) {
   await cleanClaudeSettings(rootDir);
 }
 async function cleanClaudeSettings(rootDir) {
-  const settingsPath = path25.join(rootDir, ".claude", "settings.json");
+  const settingsPath = path27.join(rootDir, ".claude", "settings.json");
   let content;
   try {
-    content = await readFile11(settingsPath, "utf-8");
+    content = await readFile13(settingsPath, "utf-8");
   } catch {
     return;
   }
@@ -7564,14 +8246,14 @@ async function cleanClaudeSettings(rootDir) {
     return;
   }
   const cleanedHooks = {};
-  if (isRecord10(settings.hooks)) {
+  if (isRecord11(settings.hooks)) {
     for (const [event, value] of Object.entries(settings.hooks)) {
       const cleaned = cleanClaudeHookValue(value);
       if (cleaned !== void 0) cleanedHooks[event] = cleaned;
     }
     settings.hooks = Object.keys(cleanedHooks).length > 0 ? cleanedHooks : void 0;
   }
-  if (isRecord10(settings.skills)) {
+  if (isRecord11(settings.skills)) {
     const retainedSkills = Object.fromEntries(
       Object.entries(settings.skills).filter(
         ([name, value]) => LEGACY_CLAUDE_SKILL_SETTINGS[name] !== value
@@ -7579,7 +8261,7 @@ async function cleanClaudeSettings(rootDir) {
     );
     settings.skills = Object.keys(retainedSkills).length > 0 ? retainedSkills : void 0;
   }
-  await writeFile12(
+  await writeFile14(
     settingsPath,
     `${JSON.stringify(settings, null, 2)}
 `,
@@ -7591,7 +8273,7 @@ function cleanClaudeHookValue(value) {
     const entries2 = value.flatMap(cleanClaudeHookEntry);
     return entries2.length > 0 ? entries2 : void 0;
   }
-  if (!isRecord10(value)) return value;
+  if (!isRecord11(value)) return value;
   if (Array.isArray(value.hooks) || typeof value.command === "string") {
     const entries2 = cleanClaudeHookEntry(value);
     return entries2.length > 0 ? entries2 : void 0;
@@ -7605,7 +8287,7 @@ function cleanClaudeHookValue(value) {
 }
 function cleanClaudeHookEntry(entry) {
   if (Array.isArray(entry)) return entry.flatMap(cleanClaudeHookEntry);
-  if (!isRecord10(entry)) return [entry];
+  if (!isRecord11(entry)) return [entry];
   if (Array.isArray(entry.hooks)) {
     const hooks = entry.hooks.filter((hook) => !isMancodeHookEntry(hook));
     return hooks.length > 0 ? [{ ...entry, hooks }] : [];
@@ -7613,11 +8295,11 @@ function cleanClaudeHookEntry(entry) {
   return isMancodeHookEntry(entry) ? [] : [entry];
 }
 function isMancodeHookEntry(value) {
-  return isRecord10(value) && typeof value.command === "string" && isGeneratedMancodeHookCommand(value.command);
+  return isRecord11(value) && typeof value.command === "string" && isGeneratedMancodeHookCommand(value.command);
 }
 function containsLegacyMancodeHookPath2(value) {
   if (Array.isArray(value)) return value.some(containsLegacyMancodeHookPath2);
-  if (!isRecord10(value)) return false;
+  if (!isRecord11(value)) return false;
   if (typeof value.command === "string" && value.command.includes(".mancode/hooks/")) {
     return true;
   }
@@ -7628,12 +8310,12 @@ async function uninstallCursor(rootDir) {
   await removeCursorCommands(rootDir);
 }
 async function uninstallCodex(rootDir) {
-  const agentsPath = path25.join(rootDir, "AGENTS.md");
+  const agentsPath = path27.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile11(agentsPath, "utf-8");
+    const content = await readFile13(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile12(agentsPath, `${cleaned}
+      await writeFile14(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
       await rm5(agentsPath, { force: true });
@@ -7643,16 +8325,16 @@ async function uninstallCodex(rootDir) {
   await removeCodexSkills(rootDir);
 }
 async function uninstallCopilot(rootDir) {
-  const instructionsPath = path25.join(
+  const instructionsPath = path27.join(
     rootDir,
     ".github",
     "copilot-instructions.md"
   );
   try {
-    const content = await readFile11(instructionsPath, "utf-8");
+    const content = await readFile13(instructionsPath, "utf-8");
     const cleaned = removeManagedBlock(content);
     if (cleaned.trim()) {
-      await writeFile12(instructionsPath, `${cleaned}
+      await writeFile14(instructionsPath, `${cleaned}
 `, "utf-8");
     } else {
       await rm5(instructionsPath, { force: true });
@@ -7662,16 +8344,16 @@ async function uninstallCopilot(rootDir) {
   await removeCopilotPrompts(rootDir);
 }
 async function uninstallZcode(rootDir) {
-  const agentsPath = path25.join(rootDir, "AGENTS.md");
+  const agentsPath = path27.join(rootDir, "AGENTS.md");
   try {
-    const content = await readFile11(agentsPath, "utf-8");
+    const content = await readFile13(agentsPath, "utf-8");
     const cleaned = removeManagedBlock(
       content,
       ZCODE_MANCODE_START_MARKER,
       ZCODE_MANCODE_END_MARKER
     );
     if (cleaned.trim()) {
-      await writeFile12(agentsPath, `${cleaned}
+      await writeFile14(agentsPath, `${cleaned}
 `, "utf-8");
     } else {
       await rm5(agentsPath, { force: true });
@@ -7681,13 +8363,13 @@ async function uninstallZcode(rootDir) {
   await removeZcodeSkills(rootDir);
 }
 async function removeFromConfig(rootDir, platform) {
-  const configPath = path25.join(rootDir, ".mancode", "config.json");
+  const configPath = path27.join(rootDir, ".mancode", "config.json");
   try {
-    const raw = await readFile11(configPath, "utf-8");
+    const raw = await readFile13(configPath, "utf-8");
     const config = JSON.parse(raw);
     if (Array.isArray(config.platforms)) {
       config.platforms = config.platforms.filter((p) => p !== platform);
-      if (isRecord10(config.platformOptions)) {
+      if (isRecord11(config.platformOptions)) {
         const platformOptions = Object.fromEntries(
           Object.entries(config.platformOptions).filter(
             ([name]) => name !== platform
@@ -7695,7 +8377,7 @@ async function removeFromConfig(rootDir, platform) {
         );
         config.platformOptions = Object.keys(platformOptions).length > 0 ? platformOptions : void 0;
       }
-      await writeFile12(
+      await writeFile14(
         configPath,
         `${JSON.stringify(config, null, 2)}
 `,
@@ -7705,7 +8387,7 @@ async function removeFromConfig(rootDir, platform) {
   } catch {
   }
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function pathExists11(p) {
@@ -7728,13 +8410,13 @@ function version() {
 }
 
 // src/commands/workflow.ts
-import { access as access6 } from "fs/promises";
-import path26 from "path";
+import { access as access6, readFile as readFile14, rm as rm6, writeFile as writeFile15 } from "fs/promises";
+import path28 from "path";
 var EXIT_OK9 = 0;
 var EXIT_NOT_INITIALIZED7 = 1;
 var EXIT_INVALID_ARG2 = 2;
 async function workflow(rootDir, subcommand, args = [], options = {}) {
-  if (!await pathExists12(path26.join(rootDir, ".mancode", "state.json"))) {
+  if (!await pathExists12(path28.join(rootDir, ".mancode", "state.json"))) {
     if (options.json) {
       console.log(JSON.stringify({ error: "not initialized" }, null, 2));
     } else {
@@ -7752,8 +8434,16 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
       return workflowList(rootDir, options);
     case "show":
       return workflowShow(rootDir, args[0], options);
+    case "handoff":
+      return workflowHandoff(rootDir, args[0], options);
+    case "decide":
+      return workflowDecide(rootDir, args[0], options);
     case "review":
       return workflowReview(rootDir, args, options);
+    case "requirements":
+      return workflowRequirements(rootDir, args, options);
+    case "verify":
+      return workflowVerify(rootDir, args, options);
     case "clean":
       return workflowClean(rootDir, options);
     default:
@@ -7768,12 +8458,278 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
       } else {
         console.error(`\u2717  Invalid workflow subcommand: ${subcommand}`);
         console.error(
-          "   Use: create <man|manba|manteam> <task> | update <taskId> | review <taskId> <init|complete|remediate|show> | list | show <taskId> | clean"
+          "   Use: create <man|manba|manteam> <task> | requirements <taskId> finalize --file <path> | verify <taskId> <init|record|require-manual|confirm-manual|show> | decide <taskId> --plan-decision <plan_only|governed_execution> | handoff <taskId> --to solo | review <taskId> <init|complete|remediate|skip|show> | list | show <taskId> | clean"
         );
       }
       return EXIT_INVALID_ARG2;
   }
 }
+async function workflowRequirements(rootDir, args, options) {
+  const taskId = args[0];
+  const action = args[1];
+  if (!taskId || !isValidWorkflowTaskId(taskId)) {
+    return invalidArg(options, `invalid taskId: ${taskId ?? ""}`);
+  }
+  if (action !== "finalize" || !options.file) {
+    return invalidArg(options, "requirements requires finalize --file <path>");
+  }
+  const meta = await readWorkflow(rootDir, taskId);
+  if (!meta || meta.mode !== "man" && meta.mode !== "manteam" || meta.status !== "in_progress" || meta.currentStep > 2) {
+    return invalidArg(
+      options,
+      "requirements can only be finalized for an in-progress man or manteam workflow at step 1 or 2"
+    );
+  }
+  const workflowPath = path28.join(rootDir, ".mancode", "workflows", taskId);
+  const jsonPath = path28.join(workflowPath, "requirements.json");
+  const markdownPath = path28.join(workflowPath, "requirements.md");
+  const metadataPath2 = path28.join(workflowPath, "metadata.json");
+  let originalJson;
+  let originalMarkdown;
+  let originalMetadata;
+  try {
+    const inputPath = path28.isAbsolute(options.file) ? options.file : path28.resolve(rootDir, options.file);
+    const input = await readFile14(inputPath, "utf-8");
+    const requirements = parseRequirementsLedger(input);
+    [originalJson, originalMarkdown, originalMetadata] = await Promise.all([
+      readOptionalText2(jsonPath),
+      readOptionalText2(markdownPath),
+      readFile14(metadataPath2, "utf-8")
+    ]);
+    await writeRequirementsArtifacts(rootDir, taskId, requirements);
+    await updateWorkflow(rootDir, taskId, {
+      requirementsStatus: requirementsAreReady(requirements) ? "ready" : "needs_clarification",
+      requirementsDigest: requirementsDigest(requirements)
+    });
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            requirements,
+            requirementsStatus: requirementsAreReady(requirements) ? "ready" : "needs_clarification"
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(
+        `Finalized requirements: ${taskId} (${requirementsAreReady(requirements) ? "ready" : "needs_clarification"})`
+      );
+    }
+    return EXIT_OK9;
+  } catch (error) {
+    let rollbackIncomplete = false;
+    if (originalJson !== void 0 && originalMarkdown !== void 0 && originalMetadata !== void 0) {
+      const rollback = await Promise.allSettled([
+        restoreOptionalText(jsonPath, originalJson),
+        restoreOptionalText(markdownPath, originalMarkdown),
+        writeFile15(metadataPath2, originalMetadata, "utf-8")
+      ]);
+      rollbackIncomplete = rollback.some(
+        (result) => result.status === "rejected"
+      );
+    }
+    const message = error instanceof Error ? error.message : "unable to finalize requirements";
+    return invalidArg(
+      options,
+      rollbackIncomplete ? `${message}; rollback was incomplete` : message
+    );
+  }
+}
+async function workflowVerify(rootDir, args, options) {
+  const taskId = args[0];
+  const action = args[1];
+  if (!taskId || !isValidWorkflowTaskId(taskId)) {
+    return invalidArg(options, `invalid taskId: ${taskId ?? ""}`);
+  }
+  const meta = await readWorkflow(rootDir, taskId);
+  if (!meta || meta.mode !== "man" && meta.mode !== "manteam") {
+    return invalidArg(options, `verification is not valid for: ${taskId}`);
+  }
+  if (action === "show") {
+    const ledger = await readVerificationLedger(rootDir, taskId);
+    if (!ledger) {
+      return invalidArg(options, `verification not initialized: ${taskId}`);
+    }
+    outputVerificationLedger(ledger, options);
+    return EXIT_OK9;
+  }
+  if (meta.verificationPolicyVersion !== 1 || (action === "init" ? meta.currentStep !== 6 : meta.currentStep !== 6 && meta.currentStep !== 9) || meta.planDecision !== "governed_execution" || meta.status !== "in_progress" && meta.status !== "blocked") {
+    return invalidArg(
+      options,
+      "verification requires a governed policy-v2 workflow at step 6, or step 9 when refreshing evidence"
+    );
+  }
+  try {
+    let ledger;
+    if (action === "init") {
+      if (await readVerificationLedger(rootDir, taskId)) {
+        return invalidArg(
+          options,
+          `verification already initialized: ${taskId}`
+        );
+      }
+      const requirements = await readRequirementsLedger(rootDir, taskId);
+      if (!requirements || !requirementsAreReady(requirements)) {
+        return invalidArg(options, "ready requirements.json is required");
+      }
+      ledger = initializeVerificationLedger(
+        requirements,
+        meta.planVersion ?? 1,
+        0
+      );
+    } else {
+      let existing = await readVerificationLedger(rootDir, taskId);
+      if (!existing) {
+        return invalidArg(options, `verification not initialized: ${taskId}`);
+      }
+      const review = await readReviewLedger(rootDir, taskId);
+      existing = resetVerificationForRemediation(
+        existing,
+        review?.remediationRounds ?? 0
+      );
+      if (!options.acceptance || !options.evidence) {
+        return invalidArg(
+          options,
+          `${action ?? "verification"} requires --acceptance and --evidence`
+        );
+      }
+      if (action === "record") {
+        if (options.method !== "automated" || options.result !== "passed" && options.result !== "failed" && options.result !== "blocked") {
+          return invalidArg(
+            options,
+            "record requires --method automated and --result passed|failed|blocked"
+          );
+        }
+        let automatedDetails;
+        if (options.result === "passed" || options.result === "failed") {
+          const exitCode = parseExactInteger(options.exitCode);
+          if (!options.command?.trim() || exitCode === null) {
+            return invalidArg(
+              options,
+              "automated passed/failed verification requires --command and --exit-code"
+            );
+          }
+          if (options.evidenceFile) {
+            const evidencePath = path28.isAbsolute(options.evidenceFile) ? options.evidenceFile : path28.resolve(rootDir, options.evidenceFile);
+            if (!await pathExists12(evidencePath)) {
+              return invalidArg(
+                options,
+                `verification evidence file not found: ${options.evidenceFile}`
+              );
+            }
+          }
+          automatedDetails = {
+            command: options.command,
+            exitCode,
+            ...options.evidenceFile ? { evidenceFile: options.evidenceFile } : {}
+          };
+        }
+        ledger = recordVerification(
+          existing,
+          options.acceptance,
+          "automated",
+          options.result,
+          options.evidence,
+          automatedDetails
+        );
+      } else if (action === "require-manual") {
+        ledger = recordVerification(
+          existing,
+          options.acceptance,
+          "manual",
+          "manual_required",
+          options.evidence
+        );
+      } else if (action === "confirm-manual") {
+        ledger = confirmManualVerification(
+          existing,
+          options.acceptance,
+          options.evidence
+        );
+      } else {
+        return invalidArg(
+          options,
+          `invalid verification action: ${action ?? ""}`
+        );
+      }
+    }
+    const transitionError = await commitVerificationTransition(
+      rootDir,
+      meta,
+      ledger
+    );
+    if (transitionError) return invalidArg(options, transitionError);
+    outputVerificationLedger(ledger, options);
+    return EXIT_OK9;
+  } catch (error) {
+    return invalidArg(
+      options,
+      error instanceof Error ? error.message : "unable to update verification"
+    );
+  }
+}
+async function commitVerificationTransition(rootDir, meta, ledger) {
+  const ledgerPath = verificationLedgerPath(rootDir, meta.taskId);
+  const metadataPath2 = path28.join(
+    rootDir,
+    ".mancode",
+    "workflows",
+    meta.taskId,
+    "metadata.json"
+  );
+  const specPath = path28.join(rootDir, ".mancode", "memory", "spec.md");
+  const [originalLedger, originalMetadata, originalSpec] = await Promise.all([
+    readOptionalText2(ledgerPath),
+    readFile14(metadataPath2, "utf-8"),
+    readOptionalText2(specPath)
+  ]);
+  const wasVerificationBlocked = meta.status === "blocked" && meta.blockingReason?.startsWith("[verification]");
+  const shouldBlock = ledger.status === "manual_required" || ledger.status === "blocked";
+  const workflowPatch = {
+    verificationStatus: ledger.status,
+    ...shouldBlock ? {
+      status: "blocked",
+      blockingReason: `[verification] ${ledger.status === "manual_required" ? "manual confirmation required" : "verification blocked"}`
+    } : wasVerificationBlocked ? { status: "in_progress", blockingReason: void 0 } : {}
+  };
+  try {
+    await writeVerificationLedger(rootDir, meta.taskId, ledger);
+    await updateWorkflow(rootDir, meta.taskId, workflowPatch, {
+      allowIncompleteVerification: true
+    });
+    const updated = await readWorkflow(rootDir, meta.taskId);
+    if (updated) {
+      await upsertActivePlan(rootDir, {
+        taskId: updated.taskId,
+        status: updated.status,
+        planVersion: updated.planVersion ?? 1
+      });
+    }
+    return null;
+  } catch (error) {
+    const rollback = await Promise.allSettled([
+      restoreOptionalText(ledgerPath, originalLedger),
+      writeFile15(metadataPath2, originalMetadata, "utf-8"),
+      restoreOptionalText(specPath, originalSpec)
+    ]);
+    const message = error instanceof Error ? error.message : "verification transition failed";
+    return rollback.some((result) => result.status === "rejected") ? `${message}; rollback was incomplete` : message;
+  }
+}
+function outputVerificationLedger(ledger, options) {
+  if (options.json) {
+    console.log(JSON.stringify(ledger, null, 2));
+    return;
+  }
+  const passed = ledger.checks.filter(
+    (check) => [check.automated, check.manual].filter(Boolean).every((component) => component?.status === "passed")
+  ).length;
+  console.log(
+    `Verification: ${ledger.status}; criteria ${passed}/${ledger.checks.length}; plan v${ledger.planVersion}`
+  );
+}
 async function workflowReview(rootDir, args, options) {
   const taskId = args[0];
   const action = args[1];
@@ -7798,6 +8754,36 @@ async function workflowReview(rootDir, args, options) {
       "review requires an in_progress workflow at step 6 or later"
     );
   }
+  if ((action === "init" || action === "skip") && meta.verificationPolicyVersion === 1 && !await verificationCanAdvance(rootDir, taskId, meta.planVersion ?? 1)) {
+    return invalidArg(
+      options,
+      "workflow verification must pass before review can start"
+    );
+  }
+  if (action === "skip") {
+    if (meta.reviewPolicyVersion !== 2 || meta.currentStep !== 6 || meta.planDecision !== "governed_execution" || !options.reason?.trim()) {
+      return invalidArg(
+        options,
+        "review skip requires a governed policy-v2 workflow at step 6 and --reason"
+      );
+    }
+    try {
+      const error = await commitReviewSkip(
+        rootDir,
+        meta,
+        options.reason.trim()
+      );
+      if (error) return invalidArg(options, error);
+      const ledger = await readReviewLedger(rootDir, taskId);
+      outputReviewLedger(ledger, options);
+      return EXIT_OK9;
+    } catch (error) {
+      return invalidArg(
+        options,
+        error instanceof Error ? error.message : "unable to skip review"
+      );
+    }
+  }
   try {
     let ledger;
     if (action === "init") {
@@ -7843,7 +8829,7 @@ async function workflowReview(rootDir, args, options) {
       return invalidArg(
         options,
         `invalid review action: ${action ?? ""}`,
-        "Use: mancode workflow review <taskId> <init|complete|remediate|show>"
+        "Use: mancode workflow review <taskId> <init|complete|remediate|skip|show>"
       );
     }
     outputReviewLedger(ledger, options);
@@ -7855,12 +8841,44 @@ async function workflowReview(rootDir, args, options) {
     );
   }
 }
+async function commitReviewSkip(rootDir, meta, reason) {
+  const ledgerPath = reviewLedgerPath(rootDir, meta.taskId);
+  const metadataPath2 = path28.join(
+    rootDir,
+    ".mancode",
+    "workflows",
+    meta.taskId,
+    "metadata.json"
+  );
+  const [originalLedger, originalMetadata] = await Promise.all([
+    readOptionalText2(ledgerPath),
+    readFile14(metadataPath2, "utf-8")
+  ]);
+  try {
+    await initializeSkippedReview(rootDir, meta.taskId, reason);
+    await updateWorkflow(rootDir, meta.taskId, {
+      skippedSteps: [.../* @__PURE__ */ new Set([...meta.skippedSteps, "review"])]
+    });
+    return null;
+  } catch (error) {
+    const rollback = await Promise.allSettled([
+      restoreOptionalText(ledgerPath, originalLedger),
+      writeFile15(metadataPath2, originalMetadata, "utf-8")
+    ]);
+    const message = error instanceof Error ? error.message : "review skip failed";
+    return rollback.some((result) => result.status === "rejected") ? `${message}; rollback was incomplete` : message;
+  }
+}
 function outputReviewLedger(ledger, options) {
   if (options.json) {
     console.log(JSON.stringify(ledger, null, 2));
     return;
   }
   if (!ledger) return;
+  if (ledger.skipped) {
+    console.log(`Review: skipped; reason ${ledger.skipped.reason}`);
+    return;
+  }
   const openBlockers = ledger.blockers.filter(
     (blocker) => blocker.status === "open"
   );
@@ -7891,7 +8909,8 @@ async function workflowCreate(rootDir, args, options) {
   }
   try {
     const meta = await createWorkflow(rootDir, task, mode, {
-      parentTaskId: options.parentTask
+      parentTaskId: options.parentTask,
+      planningPolicyVersion: mode === "man" || mode === "manteam" ? 2 : void 0
     });
     if (options.json) {
       console.log(JSON.stringify(meta, null, 2));
@@ -7911,7 +8930,7 @@ async function workflowUpdate(rootDir, taskId, options) {
     return invalidArg(
       options,
       "missing taskId",
-      "Use: mancode workflow update <taskId> [--step N] [--status in_progress|planned|completed|blocked|abandoned] [--blocking-reason <reason>] [--outcome <outcome>] [--plan-version N] [--skipped a,b]"
+      "Use: mancode workflow update <taskId> [--step N] [--status in_progress|planned|completed|blocked|abandoned] [--requirements-status ready|needs_clarification] [--blocking-reason <reason>] [--outcome <outcome>] [--plan-version N] [--skipped clarification]"
     );
   }
   if (!isValidWorkflowTaskId(taskId)) {
@@ -7972,8 +8991,45 @@ async function workflowUpdate(rootDir, taskId, options) {
     }
     patch.planVersion = planVersion;
   }
+  if (options.requirementsStatus !== void 0) {
+    if (!isRequirementsStatus(options.requirementsStatus) || existing.mode !== "man" && existing.mode !== "manteam") {
+      return invalidArg(
+        options,
+        `invalid --requirements-status: ${options.requirementsStatus}`
+      );
+    }
+    patch.requirementsStatus = options.requirementsStatus;
+  }
+  if (options.planDecision !== void 0) {
+    if (options.planDecision !== "governed_execution" || existing.mode !== "man" && existing.mode !== "manteam") {
+      return invalidArg(
+        options,
+        `invalid --plan-decision: ${options.planDecision}`
+      );
+    }
+    patch.planDecision = options.planDecision;
+  }
   if (options.skipped !== void 0) {
-    patch.skippedSteps = options.skipped.split(",").map((item) => item.trim()).filter(Boolean);
+    const requestedSkipped = options.skipped.split(",").map((item) => item.trim()).filter(Boolean);
+    if (existing.reviewPolicyVersion === 2) {
+      if (requestedSkipped.includes("review")) {
+        return invalidArg(
+          options,
+          "policy-v2 review skips require workflow review <taskId> skip --reason <reason>"
+        );
+      }
+      if (existing.currentStep > 2 || requestedSkipped.some((item) => item !== "clarification")) {
+        return invalidArg(
+          options,
+          "policy-v2 clarification can only be skipped at step 1 or 2"
+        );
+      }
+      patch.skippedSteps = [
+        .../* @__PURE__ */ new Set([...existing.skippedSteps, ...requestedSkipped])
+      ];
+    } else {
+      patch.skippedSteps = requestedSkipped;
+    }
   }
   if (Object.keys(patch).length === 0) {
     return invalidArg(options, "missing update fields");
@@ -8004,6 +9060,307 @@ async function workflowUpdate(rootDir, taskId, options) {
   }
   return EXIT_OK9;
 }
+async function workflowHandoff(rootDir, taskId, options) {
+  if (!taskId || !isValidWorkflowTaskId(taskId)) {
+    return invalidArg(options, `invalid taskId: ${taskId ?? ""}`);
+  }
+  if (options.complete) {
+    if (options.to !== void 0) {
+      return invalidArg(options, "--complete cannot be combined with --to");
+    }
+    return workflowCompleteHandoff(rootDir, taskId, options);
+  }
+  if (options.to !== "solo") {
+    return invalidArg(options, "handoff requires --to solo");
+  }
+  const meta = await readWorkflow(rootDir, taskId);
+  if (!meta || meta.mode !== "man" && meta.mode !== "manteam") {
+    return invalidArg(options, `workflow cannot be handed off: ${taskId}`);
+  }
+  if (meta.status !== "in_progress" || meta.currentStep !== 4 || meta.requirementsStatus !== "ready" || meta.planDecision !== void 0) {
+    return invalidArg(
+      options,
+      "solo handoff requires an undecided in-progress workflow at step 4 with ready requirements"
+    );
+  }
+  const workflowPath = path28.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists12(path28.join(workflowPath, "requirements.md")) || !await pathExists12(path28.join(workflowPath, "plan.md"))) {
+    return invalidArg(
+      options,
+      "solo handoff requires requirements.md and plan.md"
+    );
+  }
+  const statePath = path28.join(rootDir, ".mancode", "state.json");
+  let originalState;
+  let state;
+  try {
+    originalState = await readFile14(statePath, "utf-8");
+    state = JSON.parse(originalState);
+  } catch {
+    return invalidArg(
+      options,
+      "unable to read .mancode/state.json for handoff"
+    );
+  }
+  if (state.currentTask !== taskId) {
+    return invalidArg(
+      options,
+      "current workflow state does not match the handoff task"
+    );
+  }
+  const activeSoloPlan = readActiveSoloPlan(state.activeSoloPlan);
+  if (activeSoloPlan && activeSoloPlan.taskId !== taskId) {
+    return invalidArg(
+      options,
+      `another solo plan is active: ${activeSoloPlan.taskId}; complete or abandon it before handoff`
+    );
+  }
+  const nextState = {
+    ...state,
+    currentMode: "solo",
+    lastMode: typeof state.currentMode === "string" ? state.currentMode : meta.mode,
+    currentTask: null,
+    currentWorkflowMode: null,
+    skippedSteps: [],
+    activeSoloPlan: {
+      taskId,
+      planVersion: meta.planVersion ?? 1
+    }
+  };
+  const transitionError = await commitPlanningTransition({
+    rootDir,
+    taskId,
+    statePath,
+    originalState,
+    nextState,
+    workflowPatch: {
+      status: "planned",
+      planDecision: "solo_handoff"
+    },
+    activePlanStatus: "planned",
+    planVersion: meta.planVersion ?? 1
+  });
+  if (transitionError) {
+    return invalidArg(options, transitionError);
+  }
+  const result = await readWorkflow(rootDir, taskId);
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        { workflow: result, activeSoloPlan: nextState.activeSoloPlan },
+        null,
+        2
+      )
+    );
+  } else {
+    console.log(`Handed off plan to solo: ${taskId}`);
+  }
+  return EXIT_OK9;
+}
+async function workflowCompleteHandoff(rootDir, taskId, options) {
+  const meta = await readWorkflow(rootDir, taskId);
+  if (!meta || meta.mode !== "man" && meta.mode !== "manteam" || meta.status !== "planned" || meta.currentStep !== 4 || meta.planDecision !== "solo_handoff") {
+    return invalidArg(
+      options,
+      `workflow is not an active solo handoff: ${taskId}`
+    );
+  }
+  const statePath = path28.join(rootDir, ".mancode", "state.json");
+  let originalState;
+  let state;
+  try {
+    originalState = await readFile14(statePath, "utf-8");
+    state = JSON.parse(originalState);
+  } catch {
+    return invalidArg(
+      options,
+      "unable to read .mancode/state.json for handoff completion"
+    );
+  }
+  const activeSoloPlan = readActiveSoloPlan(state.activeSoloPlan);
+  if (activeSoloPlan?.taskId !== taskId) {
+    return invalidArg(
+      options,
+      "active solo plan does not match the handoff task"
+    );
+  }
+  const nextState = {
+    ...state,
+    activeSoloPlan: null
+  };
+  const transitionError = await commitPlanningTransition({
+    rootDir,
+    taskId,
+    statePath,
+    originalState,
+    nextState,
+    workflowPatch: { status: "completed" },
+    activePlanStatus: "completed",
+    planVersion: meta.planVersion ?? 1
+  });
+  if (transitionError) return invalidArg(options, transitionError);
+  const result = await readWorkflow(rootDir, taskId);
+  if (options.json) {
+    console.log(
+      JSON.stringify({ workflow: result, activeSoloPlan: null }, null, 2)
+    );
+  } else {
+    console.log(`Completed solo handoff: ${taskId}`);
+  }
+  return EXIT_OK9;
+}
+async function workflowDecide(rootDir, taskId, options) {
+  if (!taskId || !isValidWorkflowTaskId(taskId)) {
+    return invalidArg(options, `invalid taskId: ${taskId ?? ""}`);
+  }
+  if (!isPlanDecision(options.planDecision) || options.planDecision === "solo_handoff") {
+    return invalidArg(
+      options,
+      "decide requires --plan-decision plan_only or governed_execution"
+    );
+  }
+  if (options.planDecision === "governed_execution") {
+    return workflowUpdate(rootDir, taskId, {
+      ...options,
+      planDecision: "governed_execution"
+    });
+  }
+  const meta = await readWorkflow(rootDir, taskId);
+  if (!meta || meta.mode !== "man" && meta.mode !== "manteam" || meta.status !== "in_progress" || meta.currentStep !== 4 || meta.requirementsStatus !== "ready" || meta.planDecision !== void 0) {
+    return invalidArg(
+      options,
+      `workflow is not ready for a plan-only decision: ${taskId}`
+    );
+  }
+  const workflowPath = path28.join(rootDir, ".mancode", "workflows", taskId);
+  if (!await pathExists12(path28.join(workflowPath, "requirements.md")) || !await pathExists12(path28.join(workflowPath, "plan.md"))) {
+    return invalidArg(
+      options,
+      "plan-only requires requirements.md and plan.md"
+    );
+  }
+  const statePath = path28.join(rootDir, ".mancode", "state.json");
+  let originalState;
+  let state;
+  try {
+    originalState = await readFile14(statePath, "utf-8");
+    state = JSON.parse(originalState);
+  } catch {
+    return invalidArg(
+      options,
+      "unable to read .mancode/state.json for decision"
+    );
+  }
+  if (state.currentTask !== taskId) {
+    return invalidArg(
+      options,
+      "current workflow state does not match the decision task"
+    );
+  }
+  const activeSoloPlan = readActiveSoloPlan(state.activeSoloPlan);
+  if (activeSoloPlan) {
+    return invalidArg(
+      options,
+      `another solo plan is active: ${activeSoloPlan.taskId}; resolve it before plan-only`
+    );
+  }
+  const nextState = {
+    ...state,
+    currentMode: "solo",
+    lastMode: typeof state.currentMode === "string" ? state.currentMode : meta.mode,
+    currentTask: null,
+    currentWorkflowMode: null,
+    skippedSteps: [],
+    activeSoloPlan: null
+  };
+  const transitionError = await commitPlanningTransition({
+    rootDir,
+    taskId,
+    statePath,
+    originalState,
+    nextState,
+    workflowPatch: { status: "planned", planDecision: "plan_only" },
+    activePlanStatus: "planned",
+    planVersion: meta.planVersion ?? 1
+  });
+  if (transitionError) return invalidArg(options, transitionError);
+  const result = await readWorkflow(rootDir, taskId);
+  if (options.json) {
+    console.log(
+      JSON.stringify({ workflow: result, state: nextState }, null, 2)
+    );
+  } else {
+    console.log(`Saved plan without execution: ${taskId}`);
+  }
+  return EXIT_OK9;
+}
+async function commitPlanningTransition(args) {
+  const metadataPath2 = path28.join(
+    args.rootDir,
+    ".mancode",
+    "workflows",
+    args.taskId,
+    "metadata.json"
+  );
+  const specPath = path28.join(args.rootDir, ".mancode", "memory", "spec.md");
+  let originalMetadata;
+  let originalSpec;
+  try {
+    originalMetadata = await readFile14(metadataPath2, "utf-8");
+    originalSpec = await readOptionalText2(specPath);
+  } catch (error) {
+    return error instanceof Error ? `unable to prepare planning transition: ${error.message}` : "unable to prepare planning transition";
+  }
+  try {
+    await updateWorkflow(args.rootDir, args.taskId, args.workflowPatch);
+    await writeFile15(
+      args.statePath,
+      `${JSON.stringify(args.nextState, null, 2)}
+`,
+      "utf-8"
+    );
+    await upsertActivePlan(args.rootDir, {
+      taskId: args.taskId,
+      status: args.activePlanStatus,
+      planVersion: args.planVersion
+    });
+    return null;
+  } catch (error) {
+    const rollback = await Promise.allSettled([
+      writeFile15(metadataPath2, originalMetadata, "utf-8"),
+      writeFile15(args.statePath, args.originalState, "utf-8"),
+      originalSpec === null ? rm6(specPath, { force: true }) : writeFile15(specPath, originalSpec, "utf-8")
+    ]);
+    const message = error instanceof Error ? error.message : "planning transition failed";
+    return rollback.some((result) => result.status === "rejected") ? `${message}; rollback was incomplete` : message;
+  }
+}
+async function readOptionalText2(filePath) {
+  try {
+    return await readFile14(filePath, "utf-8");
+  } catch (error) {
+    if (isNodeError10(error) && error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function restoreOptionalText(filePath, content) {
+  if (content === null) {
+    await rm6(filePath, { force: true });
+    return;
+  }
+  await writeFile15(filePath, content, "utf-8");
+}
+function readActiveSoloPlan(value) {
+  if (!value || typeof value !== "object") return null;
+  const plan = value;
+  if (typeof plan.taskId !== "string" || !Number.isInteger(plan.planVersion)) {
+    return null;
+  }
+  return { taskId: plan.taskId, planVersion: plan.planVersion };
+}
+function isNodeError10(error) {
+  return error instanceof Error && "code" in error;
+}
 async function workflowList(rootDir, options) {
   const workflows = await listWorkflows(rootDir);
   const views = attachActiveChildren(workflows);
@@ -8075,6 +9432,11 @@ async function workflowShow(rootDir, taskId, options) {
   if (meta.parentTaskId) console.log(`Parent:      ${meta.parentTaskId}`);
   if (meta.planVersion !== void 0)
     console.log(`Plan version: ${meta.planVersion}`);
+  if (meta.requirementsStatus)
+    console.log(`Requirements: ${meta.requirementsStatus}`);
+  if (meta.verificationStatus)
+    console.log(`Verification: ${meta.verificationStatus}`);
+  if (meta.planDecision) console.log(`Plan choice: ${meta.planDecision}`);
   if (meta.outcome) console.log(`Outcome:     ${meta.outcome}`);
   if (meta.blockingReason) console.log(`Blocked:     ${meta.blockingReason}`);
   if (children !== void 0) {
@@ -8193,6 +9555,11 @@ function parseExactPositiveInteger(value) {
   const parsed = Number(value);
   return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
 }
+function parseExactInteger(value) {
+  if (!value || !/^-?\d+$/.test(value)) return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
 function parseOlderThan(value) {
   if (!value) return void 0;
   const match = /^(\d+)([dhm])$/.exec(value);
@@ -8267,13 +9634,22 @@ program.command("uninstall [platform]").description("Remove platform adapter or
 program.command("workflow <subcommand> [args...]").description("Manage mancode workflows").option("--dry-run", "Preview clean without deleting").option("--older-than <duration>", "Clean workflows older than (e.g. 30d)").option("--step <n>", "Update workflow current step").option("--status <status>", "Update workflow status").option(
   "--parent-task <taskId>",
   "Parent /man or /manteam workflow for manba"
-).option("--blocking-reason <reason>", "Explain why a workflow is blocked").option("--outcome <outcome>", "Set manba outcome").option("--plan-version <n>", "Set the next man/manteam plan revision").option("--skipped <steps>", "Update skipped steps as comma-separated values").option("--review-depth <depth>", "Review depth: targeted or full").option("--review-domain <domain>", "Review domain: quality or security").option(
+).option("--blocking-reason <reason>", "Explain why a workflow is blocked").option("--outcome <outcome>", "Set manba outcome").option("--plan-version <n>", "Set the next man/manteam plan revision").option(
+  "--requirements-status <status>",
+  "Planning readiness: ready or needs_clarification"
+).option(
+  "--plan-decision <decision>",
+  "Plan gate choice: plan_only or governed_execution"
+).option("--to <mode>", "Workflow handoff target (solo)").option("--complete", "Complete an active solo handoff").option(
+  "--skipped <steps>",
+  "Policy v2: clarification only; use workflow review skip for review"
+).option("--review-depth <depth>", "Review depth: targeted or full").option("--review-domain <domain>", "Review domain: quality or security").option(
   "--report <path>",
   "Relative Markdown report path for a review domain"
 ).option("--blockers <ids>", "Comma-separated blocker ids found by a review").option(
   "--resolved <ids>",
   "Comma-separated blocker ids resolved in remediation"
-).option("--json", "Output as JSON (for scripts)").action(async (subcommand, args, options) => {
+).option("--file <path>", "Structured requirements JSON input file").option("--acceptance <id>", "Acceptance criterion id (for example AC-1)").option("--method <method>", "Verification method: automated or manual").option("--result <result>", "Verification result").option("--evidence <text>", "Verification evidence or user confirmation").option("--command <command>", "Command used for automated verification").option("--exit-code <code>", "Exit code from automated verification").option("--evidence-file <path>", "Existing verification report or artifact").option("--reason <reason>", "Reason for an explicit review skip").option("--json", "Output as JSON (for scripts)").action(async (subcommand, args, options) => {
   const code = await workflow(process.cwd(), subcommand, args ?? [], options);
   process.exitCode = code;
 });