mancode 0.5.4 → 0.5.6

package/dist/cli.js

@@ -8,6 +8,7 @@ import {
   assertActivationRollbackManifestTransition,
   assertClaimTransition,
   assertConfigPolicyConsistency,
+  assertExecutableImplementationScope,
   assertHandoffTransition,
   assertKnownKeys,
   assertOperationJournalTransition,
@@ -17,6 +18,7 @@ import {
   assertRecord,
   assertRepairUsesOriginalAuthorization,
   assertRequirementsLedgerTransition,
+  assertRequirementsScopeConsistent,
   assertReviewLedgerAgainstContext,
   assertReviewLedgerTransition,
   assertSafeSharedRelativePath,
@@ -49,6 +51,7 @@ import {
   formatTaskRef,
   gitRefWorkflowRepairJournalPath,
   handoffDirectory,
+  implementationScopeIsExecutable,
   isUlid,
   listGitRefWorkflowRepairJournalSummaries,
   listUnfinishedGitRefWorkflowRepairs,
@@ -111,7 +114,7 @@ import {
   workflowMetadataDigest,
   writeOperationReservation,
   writeProjectFacts
-} from "./chunk-VHZI2WKD.js";
+} from "./chunk-M5CWWECP.js";
 import {
   DEFAULT_MANCODE_END_MARKER,
   DEFAULT_MANCODE_START_MARKER,
@@ -136,10 +139,12 @@ import {
   stageV3AdapterUpgradeFiles,
   v3AdapterTargetPath,
   v3AdapterVersionsFromStatuses
-} from "./chunk-PQDAFZYS.js";
+} from "./chunk-AWOIP2LC.js";
 
 // src/cli.ts
-import { Option, program } from "commander";
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { Command, Option } from "commander";
 
 // src/installers/adapter-upgrade.ts
 import {
@@ -1154,6 +1159,11 @@ var OPERATION_DEFINITIONS = {
         expectedRevisionPrefixes: ["claim:"],
         requiredLockPrefixes: ["claim:"]
       }),
+      write(
+        "mark-review-verification-stale",
+        ["review:", "verification:", "task:"],
+        ["task:"]
+      ),
       write("update-metadata-scope", ["task:"], ["task:"]),
       write("activate-successor-claims", ["task:"], ["task:"], {
         expectedRevisionPrefixes: ["claim:"],
@@ -5694,11 +5704,13 @@ function parseRequirementsLedger2(raw, options = {}) {
       "requirements need at least one required acceptance criterion"
     );
   }
+  const confirmedScope = normalizeStrings(value.confirmedScope);
+  const excludedScope = normalizeStrings(value.excludedScope);
   return {
     version: 1,
     goal: value.goal.trim(),
-    confirmedScope: normalizeStrings(value.confirmedScope),
-    excludedScope: normalizeStrings(value.excludedScope),
+    confirmedScope,
+    excludedScope,
     technicalDecisions: normalizeStrings(value.technicalDecisions),
     defaults: normalizeStrings(value.defaults),
     blockingUnknowns: normalizeStrings(value.blockingUnknowns),
@@ -5706,6 +5718,12 @@ function parseRequirementsLedger2(raw, options = {}) {
     acceptanceCriteria
   };
 }
+function assertRequirementsScopeConsistent2(ledger) {
+  const confirmed = new Set(ledger.confirmedScope);
+  if (ledger.excludedScope.some((item) => confirmed.has(item))) {
+    throw new Error("requirements scope cannot be both confirmed and excluded");
+  }
+}
 function requirementsAreReady2(ledger) {
   return ledger.blockingUnknowns.length === 0;
 }
@@ -6535,6 +6553,20 @@ async function validateParentTask(projectRoot, mode, parentTaskId, requireStepSi
   }
 }
 async function validateWorkflowMeta(projectRoot, updated, existing, options) {
+  validateImmutableWorkflowFields(updated, existing);
+  validateWorkflowShapeAndSkipPolicy(updated);
+  validateWorkflowLifecycle(updated, existing);
+  validateWorkflowOutcome(updated);
+  validateWorkflowPolicyVersions(updated);
+  validateWorkflowPolicyState(updated);
+  validatePlanDecisionTransition(updated, existing);
+  await validatePlanningArtifactGate(projectRoot, updated);
+  await validateVerificationGate(projectRoot, updated, existing, options);
+  validatePlanVersionTransition(updated, existing);
+  await validateWorkflowFamilyState(projectRoot, updated);
+  await validateWorkflowCompletionGates(projectRoot, updated);
+}
+function validateImmutableWorkflowFields(updated, existing) {
   if (updated.mode !== existing.mode) {
     throw new Error("workflow mode cannot be changed");
   }
@@ -6558,6 +6590,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   if (updated.verificationPolicyVersion !== existing.verificationPolicyVersion) {
     throw new Error("workflow verification policy version cannot be changed");
   }
+}
+function validateWorkflowShapeAndSkipPolicy(updated) {
   if (!Number.isInteger(updated.currentStep) || updated.currentStep < 1 || updated.currentStep > maxWorkflowStep(updated.mode)) {
     throw new Error(`invalid workflow step: ${updated.currentStep}`);
   }
@@ -6574,6 +6608,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
       "workflow policy v2 only allows skipping clarification or review"
     );
   }
+}
+function validateWorkflowLifecycle(updated, existing) {
   if (!canTransition(existing.status, updated.status)) {
     throw new Error(
       `invalid workflow status transition: ${existing.status} -> ${updated.status}`
@@ -6600,6 +6636,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   } else if (updated.blockingReason !== void 0) {
     throw new Error("only blocked workflows can have a blocking reason");
   }
+}
+function validateWorkflowOutcome(updated) {
   if (updated.mode !== "mamba" && updated.outcome !== void 0) {
     throw new Error("only manba workflows can have an outcome");
   }
@@ -6612,6 +6650,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   if (updated.mode === "mamba" && updated.status === "completed" && !updated.outcome) {
     throw new Error("completed manba workflows require an outcome");
   }
+}
+function validateWorkflowPolicyVersions(updated) {
   if (updated.mode === "mamba" && updated.planVersion !== void 0) {
     throw new Error("manba workflows cannot have a plan version");
   }
@@ -6635,6 +6675,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
       "manba workflows cannot have a verification policy version"
     );
   }
+}
+function validateWorkflowPolicyState(updated) {
   if (updated.verificationStatus !== void 0 && !isVerificationStatus(updated.verificationStatus)) {
     throw new Error("invalid workflow verification status");
   }
@@ -6659,12 +6701,16 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   if (updated.mode === "mamba" && updated.planDecision !== void 0) {
     throw new Error("manba workflows cannot have a plan decision");
   }
+}
+function validatePlanDecisionTransition(updated, existing) {
   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");
   }
+}
+async function validatePlanningArtifactGate(projectRoot, updated) {
   if (updated.planningPolicyVersion === 1 || updated.planningPolicyVersion === 2) {
     if (updated.currentStep >= 3) {
       if (updated.requirementsStatus !== "ready") {
@@ -6701,6 +6747,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
       throw new Error("governed execution must be confirmed before step 5");
     }
   }
+}
+async function validateVerificationGate(projectRoot, updated, existing, options) {
   if (updated.verificationPolicyVersion === 1 && updated.currentStep >= 7 && updated.planDecision !== "solo_handoff" && !options.allowIncompleteVerification && !await verificationCanAdvance(
     projectRoot,
     updated.taskId,
@@ -6715,6 +6763,8 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
       "verification-blocked workflows must resume through verify"
     );
   }
+}
+function validatePlanVersionTransition(updated, existing) {
   if (updated.planVersion !== void 0 && (!Number.isInteger(updated.planVersion) || updated.planVersion < 1)) {
     throw new Error("workflow plan version must be a positive integer");
   }
@@ -6724,10 +6774,14 @@ async function validateWorkflowMeta(projectRoot, updated, existing, options) {
   if (updated.planVersion !== existing.planVersion && updated.currentStep !== 4) {
     throw new Error("workflow plan version can only change at step 4");
   }
+}
+async function validateWorkflowFamilyState(projectRoot, updated) {
   await validateParentTask(projectRoot, updated.mode, updated.parentTaskId);
   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");
   }
+}
+async function validateWorkflowCompletionGates(projectRoot, updated) {
   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");
   }
@@ -9622,7 +9676,7 @@ async function activateLegacyMigration(input) {
     if (session === null || session.status !== "active") {
       throw new Error("MANCODE_SESSION_NOT_FOUND");
     }
-    const store = new (await import("./store-EEWJJANB.js")).V3ContextStore(root);
+    const store = new (await import("./store-Z53OE53A.js")).V3ContextStore(root);
     const project = await store.readProjectSnapshot();
     const stage = await readMigrationStage(root, input.stageId);
     if (stage.state !== "staged" || stage.revision !== input.expectedStageRevision) {
@@ -9885,7 +9939,7 @@ async function activateLegacyMigration(input) {
       for (const action of payload.actions.filter(
         (action2) => action2.kind === "v3_adapter_file"
       )) {
-        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-NEN5F32W.js");
+        const { applyV3AdapterFilePlan: applyV3AdapterFilePlan2 } = await import("./v3-adapter-TCEFETAG.js");
         await applyV3AdapterFilePlan2(root, action);
       }
       journal = await completeActivationStep(
@@ -13741,7 +13795,7 @@ async function upgradeV3Adapters(input) {
   if (unfinished.length > 0) {
     throw new Error("MANCODE_ADAPTER_UPGRADE_OPERATION_PENDING");
   }
-  const actualVersions = await import("./v3-adapter-NEN5F32W.js").then(
+  const actualVersions = await import("./v3-adapter-TCEFETAG.js").then(
     ({ inspectV3AdapterVersions: inspectV3AdapterVersions2 }) => inspectV3AdapterVersions2(
       root,
       managedAdapterNames(project.manifest.managedAdapters)
@@ -14332,7 +14386,7 @@ import path26 from "path";
 var SCOUT_AGENT = {
   name: "scout",
   description: "Investigates the codebase for mancode /man workflows. Finds similar implementations, reusable modules, files to change, and risks. Does not write code.",
-  tools: ["Read", "Grep", "Glob", "Bash"],
+  tools: ["Read", "Grep", "Glob"],
   body: `\u4F60\u662F mancode \u6559\u7EC3\u7EC4\u7684 Scout\uFF08\u7403\u63A2\uFF09\u3002
 
 \u4F60\u7684\u804C\u8D23\uFF1A\u8C03\u7814\u4EE3\u7801\u5E93\uFF0C\u4E3A Head Coach \u51C6\u5907\u6218\u672F\u4FE1\u606F\u3002
@@ -14343,6 +14397,8 @@ var SCOUT_AGENT = {
 - \u53EA\u5217\u5BF9\u5B9E\u65BD\u6709\u7528\u7684\u4FE1\u606F
 - \u627E\u5230\u98CE\u9669\u70B9\u8981\u6807\u6CE8\uFF08\u26A0\uFE0F\uFF09
 - \u4E0D\u786E\u5B9A\u7684\u8981\u660E\u8BF4\uFF0C\u4E0D\u731C
+- \u4E3B\u52A8\u6838\u9A8C\u7528\u6237\u524D\u63D0\uFF0C\u5E76\u4ECE\u7AEF\u5230\u7AEF\u7528\u6237\u76EE\u6807\u3001\u5E38\u89C1\u9886\u57DF\u5931\u8D25\u8DEF\u5F84\u548C\u8FB9\u754C\u6761\u4EF6\u5BFB\u627E\u4F1A\u6539\u53D8\u65B9\u6848\u7684\u76F2\u70B9\uFF1B\u6700\u591A\u4FDD\u7559 3 \u4E2A\u6700\u9AD8\u5F71\u54CD\u9879\u3002\u4ED3\u5E93\u4E8B\u5B9E\u5FC5\u987B\u6709\u8BC1\u636E\uFF1B\u65E0\u6CD5\u5728\u4ED3\u5E93\u6838\u9A8C\u7684\u884C\u4E1A\u5224\u65AD\u5FC5\u987B\u6807\u4E3A domain_hypothesis\uFF0C\u53EA\u80FD\u5F62\u6210\u805A\u7126\u95EE\u9898\uFF0C\u4E0D\u80FD\u5199\u6210\u4E8B\u5B9E
+- \u53D1\u73B0\u53EA\u63D0\u4F9B\u8BC1\u636E\u548C\u5EFA\u8BAE\u6743\uFF0C\u4E0D\u4EA7\u751F\u4FEE\u6539\u6743\uFF1B\u4E0D\u628A\u5EFA\u8BAE\u5199\u6210\u5DF2\u786E\u8BA4\u8303\u56F4\u6216\u6280\u672F\u51B3\u7B56
 - \u5B58\u5728 \`.mancode/shared/context/glossary.json\` \u65F6\uFF0C\u62A5\u544A\u4F18\u5148\u4F7F\u7528\u5176\u4E2D\u672F\u8BED\uFF1B\u53D1\u73B0\u65B0\u7684\u9AD8\u9891\u9886\u57DF\u8BCD\u53EF\u5728\u62A5\u544A\u4E2D\u5217\u4E3A\u5EFA\u8BAE\u8BCD\u6761\uFF08\u4EC5\u5EFA\u8BAE\uFF0C\u4E0D\u5199\u5165\u672F\u8BED\u8868\uFF09
 - \u5F15\u7528\u6587\u4EF6\u7528 \`path:line\` \u683C\u5F0F\uFF0C\u8BA9 Head Coach \u4E00\u79D2\u8DF3\u8FC7\u53BB
 
@@ -14408,6 +14464,16 @@ var SCOUT_AGENT = {
 - Transport/platform: <\u5F71\u54CD\u6216 no change>
 - Migration/rollback: <\u9700\u8981\u7684\u8BC1\u636E\u6216 no change>
 
+## Decision-impact Findings
+- Finding ID: F-1\uFF08\u540E\u7EED\u4F9D\u6B21 F-2\u3001F-3\uFF1B\u6700\u591A\u4E09\u9879\uFF09
+- Type: premise | scope | technical | risk | acceptance
+- Status: repository_fact | domain_hypothesis
+- Finding: <\u4E0E\u7528\u6237\u524D\u63D0\u51B2\u7A81\u7684\u4E8B\u5B9E\u3001\u5173\u952E\u76F2\u70B9\u6216\u53EF\u884C\u7684\u8303\u56F4\u5EFA\u8BAE\uFF1B\u6CA1\u6709\u5219\u5199 none>
+- Evidence/Basis: \`<repository test/file:line/caller-provided output\uFF0C\u6216\u660E\u786E\u6807\u6CE8\u7684\u9886\u57DF\u63A8\u7406\u4F9D\u636E>\`
+- Class: blocking | recommendable | defaultable
+- Impact: <\u4F1A\u6539\u53D8\u7684\u76EE\u6807\u3001\u8303\u56F4\u3001\u884C\u4E3A\u3001\u9A8C\u6536\u3001\u67B6\u6784\u3001\u6570\u636E\u3001\u517C\u5BB9\u6027\u3001\u5B89\u5168\u6216 owner>
+- Recommendation: <\u4E00\u4E2A\u6700\u5C0F\u3001\u76F4\u63A5\u7684\u5EFA\u8BAE\uFF1B\u4E0D\u66FF\u7528\u6237\u786E\u8BA4>
+
 ## \u76F8\u4F3C\u5B9E\u73B0
 - \`<detected-source-root>/<relevant-file>:<line>\` \u2014 \u7B80\u8FF0\u53EF\u590D\u7528\u7684\u903B\u8F91
 
@@ -14443,8 +14509,8 @@ trigger: <\u88AB\u65B0\u8BC1\u636E\u63A8\u7FFB\u6216\u8D85\u51FA\u5F53\u524D req
 
 - \u7528 Grep / Glob \u627E\u4EE3\u7801\uFF0C\u4E0D\u8981 cat \u6574\u4E2A\u6587\u4EF6
 - \u7528 Read \u770B file:line \u9644\u8FD1\u7684\u4E0A\u4E0B\u6587
-- \u7528 Bash \u8DD1 \`git log --oneline -5\` \u4E86\u89E3\u6700\u8FD1\u6539\u52A8
-- **\u4E0D\u8981** Edit / Write \u2014 \u90A3\u662F Head Coach \u7684\u6D3B
+- \u53EA\u5F15\u7528\u5F53\u524D\u53EA\u8BFB\u5DE5\u5177\u80FD\u591F\u6838\u9A8C\u7684\u8BC1\u636E\uFF1B\u9700\u8981\u8FD0\u884C\u547D\u4EE4\u65F6\uFF0C\u628A\u547D\u4EE4\u5217\u4E3A\u4EA4\u7ED9\u8C03\u7528\u65B9\u7684\u9A8C\u8BC1\u5EFA\u8BAE\uFF0C\u4E0D\u81EA\u884C\u6267\u884C
+- **\u4E0D\u8981** Edit / Write / Bash \u2014 \u90A3\u662F\u6267\u884C\u9636\u6BB5\u7684\u6D3B
 
 \u6536\u5230\u4EFB\u52A1\u540E\u7ACB\u5373\u5F00\u59CB\u8C03\u7814\u3002\u62A5\u544A\u5B8C\u6574\u5373\u53EF\uFF0C\u4E0D\u9700\u8981\u7B49\u7528\u6237\u786E\u8BA4\u3002`
 };
@@ -14468,7 +14534,11 @@ var PLAN_COACH_AGENT = {
 
 ## \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
+\u5148\u8BFB\u53D6 \`requirements.json\`\u3002V3 \u4EE5 \`functionalScope.inScope\`\u3001\`functionalScope.outOfScope\`\u3001\`technicalDecisions\`\u3001\`defaults\`\u3001\`blockingUnknowns\`\u3001\`coverage\` \u548C \`acceptanceCriteria\` \u4E3A\u6743\u5A01\u8F93\u5165\uFF1Blegacy \u8F93\u5165\u4E2D\u7684\u8BED\u4E49\u5BF9\u5E94\u5B57\u6BB5\u662F \`confirmedScope\` \u4E0E \`excludedScope\`\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
+
+\u9010\u9879\u6838\u5BF9 Scout \u7684 F-1\u2026F-3 \u662F\u5426\u5DF2\u6709\u6309\u7C7B\u578B\u5904\u7F6E\uFF1A\`repository_fact\` \u53EF\u4EE5\u7EA0\u6B63\u9519\u8BEF\u524D\u63D0\uFF1B\`domain_hypothesis\` \u5FC5\u987B\u5148\u8F6C\u6210\u805A\u7126\u95EE\u9898\uFF0C\u4E0D\u80FD\u5F53\u6210\u5DF2\u786E\u8BA4\u4E8B\u5B9E\u3002blocking \u5199\u5165 \`blockingUnknowns\`\uFF1B\u7528\u6237\u63A5\u53D7\u7684\u8303\u56F4\u6216\u884C\u4E3A finding \u5199\u5165 \`confirmedScope\`\uFF08V3 \u4E3A \`functionalScope.inScope\`\uFF09\u5E76\u8865\u4E0A\u5339\u914D\u7684\u9A8C\u6536 \`acceptanceCriteria\`\uFF1B\u7528\u6237\u63A5\u53D7\u7684\u6280\u672F\u9009\u62E9\u5199\u5165 \`technicalDecisions\`\uFF1B\u4F4E\u5F71\u54CD\u3001\u53EF\u9006\u7684\u5B9E\u73B0\u7EC6\u8282\u624D\u5199\u5165 \`defaults\`\uFF1B\u53EA\u6709\u7528\u6237\u660E\u786E\u6392\u9664\u7684\u884C\u4E3A\u5199\u5165 \`excludedScope\`\uFF08V3 \u4E3A \`functionalScope.outOfScope\`\uFF09\u3002\u672A\u63A5\u53D7\u7684\u5EFA\u8BAE\u4ECD\u7136\u6CA1\u6709\u6267\u884C\u6743\uFF0C\u4F46\u4E0D\u5F97\u81EA\u52A8\u585E\u5165 excludedScope\uFF0C\u66F4\u4E0D\u80FD\u590D\u5236\u8FDB\u6240\u6709\u5B57\u6BB5\u3002\u9519\u8BEF\u524D\u63D0\u6216\u98CE\u9669\u82E5\u4F1A\u6539\u53D8\u8BA1\u5212\uFF0C\u5FC5\u987B\u5148\u4F5C\u4E3A blocking \u6F84\u6E05\uFF0C\u518D\u6309\u6700\u7EC8\u8BED\u4E49\u843D\u5165\u4E0A\u8FF0\u552F\u4E00\u5408\u9002\u4F4D\u7F6E\u3002\u53D1\u73B0\u53EA\u4EA7\u751F\u5EFA\u8BAE\u6743\uFF0Cconfirmed requirements \u624D\u4EA7\u751F\u884C\u4E3A\u6388\u6743\u3002
+
+\u8BA1\u5212\u8FD8\u5FC5\u987B\u8BFB\u53D6\u6216\u63D0\u51FA\u4E00\u4EFD\u7528\u6237\u53EF\u89C1\u7684 \`implementationScope\`\uFF08repo-relative \`include\`\u3001\`exclude\`\u3001\`modules\`\uFF09\uFF0C\u4F5C\u4E3A\u6587\u4EF6\u6539\u52A8\u4E0A\u9650\u3002\u5B83\u4E0D\u80FD\u7531 Scout \u5EFA\u8BAE\u81EA\u52A8\u751F\u6210\u6388\u6743\uFF0C\u4E5F\u4E0D\u80FD\u7528\u6A21\u5757\u6807\u7B7E\u4EE3\u66FF\u975E\u7A7A include\uFF1B\u5B83\u4E0E\u884C\u4E3A\u9700\u6C42\u5171\u540C\u7EA6\u675F\u6267\u884C\u3002
 
 \u540C\u65F6\u6267\u884C\u65B9\u6848\u5B8C\u6574\u6027\u68C0\u67E5\uFF1A
 
@@ -14476,6 +14546,7 @@ var PLAN_COACH_AGENT = {
 2. \u6BCF\u4E2A\u65B9\u6848\u5FC5\u987B\u8BF4\u660E\u590D\u6742\u5EA6\u7531\u8C01\u627F\u62C5\u4EE5\u53CA\u53EF\u89C2\u5BDF\u6210\u672C\uFF0C\u627F\u62C5\u8005\u53EF\u4EE5\u662F\u5B9E\u73B0\u4EE3\u7801\u3001\u8FC1\u79FB\u3001\u8FD0\u884C\u7EF4\u62A4\u3001\u7528\u6237\u64CD\u4F5C\u3001\u517C\u5BB9\u5C42\u6216\u6D4B\u8BD5\uFF1B\u4E0D\u80FD\u53EA\u5199\u201C\u66F4\u7B80\u5355\u201D\u3002
 3. \u5FC5\u987B\u7ED9\u51FA\u552F\u4E00 recommendation\uFF0C\u5E76\u8BF4\u660E\u62D2\u7EDD\u5176\u4ED6\u65B9\u5411\u7684\u4E3B\u8981\u7406\u7531\uFF1B\u4E0D\u80FD\u628A\u591A\u4E2A\u672A\u51B3\u65B9\u5411\u539F\u6837\u4EA4\u7ED9\u7528\u6237\u3002
 4. \u7B80\u5355\u4EFB\u52A1\u6CA1\u6709\u771F\u5B9E\u66FF\u4EE3\u65B9\u6848\u65F6\u53EA\u5217\u4E00\u4E2A\u660E\u663E\u53EF\u884C\u65B9\u5411\uFF0C\u5E76\u89E3\u91CA\u4E3A\u4EC0\u4E48\u4E0D\u5B58\u5728\u771F\u5B9E\u66FF\u4EE3\uFF1B\u4E0D\u5F97\u5236\u9020\u4F2A\u9009\u9879\u3002\u8FD9\u4E2A\u5355\u4E00\u65B9\u5411\u4ECD\u5FC5\u987B\u6210\u4E3A recommendation \u5E76\u6709 stop conditions\u3002
+5. \u6BCF\u4E2A\u5B9E\u65BD\u6B65\u9AA4\u5FC5\u987B\u6620\u5C04\u5230\u5DF2\u786E\u8BA4\u8303\u56F4\u6216\u9A8C\u6536 ID\u3002\u4F18\u5148\u590D\u7528\u73B0\u6709\u5B9E\u73B0\u548C\u4F9D\u8D56\uFF0C\u9009\u62E9\u80FD\u6EE1\u8DB3\u9A8C\u6536\u7684\u6700\u5C0F\u76F4\u63A5\u65B9\u6848\uFF1B\u4E0D\u4E3A\u5355\u6B21\u7528\u9014\u589E\u52A0\u62BD\u8C61\u3001\u53EF\u914D\u7F6E\u6027\u3001\u76F8\u90BB\u6E05\u7406\u6216\u63A8\u6D4B\u6027\u9632\u5FA1\u3002
 
 Scout \u82E5\u7ED9\u51FA\u4E24\u4E2A\u540C\u7B49\u5019\u9009 semantic owner\u3001\u65E0\u6CD5\u786E\u5B9A authority/writer\uFF0C\u6216 evidence \u4E0E confirmed requirements \u51B2\u7A81\uFF0C\u4E0D\u80FD\u81EA\u884C\u9009\u4E00\u4E2A\u7EE7\u7EED\u3002
 
@@ -14509,6 +14580,10 @@ stop_conditions: <conditions that invalidate this plan>
 ## \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
 - \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
+## \u6267\u884C\u8FB9\u754C\uFF08implementationScope\uFF09
+- include\uFF1A<\u5141\u8BB8\u4FEE\u6539\u7684 repo-relative \u8DEF\u5F84/glob>
+- exclude\uFF1A<\u5373\u4F7F\u5339\u914D include \u4E5F\u4E0D\u5F97\u4FEE\u6539\u7684\u8DEF\u5F84/glob>
+- modules\uFF1A<\u8BED\u4E49\u5F52\u5C5E\u6807\u7B7E\uFF1B\u4E0D\u5355\u72EC\u6388\u6743\u6587\u4EF6\u5199\u5165>
 ## \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
@@ -14764,6 +14839,7 @@ var FILM_ANALYST_OFFENSE_AGENT = {
 - \u6700\u540E\u7ED9\u8BC4\u5206\uFF081-10\uFF09+ \u901A\u8FC7 / \u4E0D\u901A\u8FC7
 - \u53EA\u5BA1\u67E5\u672C\u6B21 diff\u3001\u7528\u6237\u9700\u6C42\u548C\u76F4\u63A5\u53D7\u5F71\u54CD\u8DEF\u5F84\uFF1B\u6700\u591A 3 \u4E2A\u65B0\u95EE\u9898
 - \u6BCF\u4E2A\u95EE\u9898\u5FC5\u987B\u5305\u542B\u6539\u52A8\u884C\u3001\u53EF\u6838\u67E5\u8BC1\u636E\u548C\u7528\u6237\u5F71\u54CD\u3002\u6CA1\u6709\u8BC1\u636E\u7684 checklist \u9879\u4E0D\u8F93\u51FA
+- \u5148\u505A\u6388\u6743\u4E00\u81F4\u6027\u5BA1\u67E5\uFF1AV3 \u5BF9\u7167 requirements \u7684 \`functionalScope.inScope\` / \`functionalScope.outOfScope\`\u3001\`technicalDecisions\`\u3001\`defaults\` \u548C \`acceptanceCriteria\`\uFF1Blegacy \u5BF9\u7167\u8BED\u4E49\u7B49\u4EF7\u7684 \`confirmedScope\` / \`excludedScope\`\u3002\u540C\u65F6\u8BFB\u53D6 Context Pack \u7684 \`activeTask.implementationScope\`\uFF0C\u9010\u4E2A\u68C0\u67E5\u5B9E\u9645\u6539\u52A8\u8DEF\u5F84\u662F\u5426\u843D\u5728 include \u4E14\u4E0D\u5339\u914D exclude\uFF1Bmodules \u53EA\u662F\u5F52\u5C5E\u6807\u7B7E\uFF0C\u4E0D\u5355\u72EC\u6388\u6743\u6587\u4EF6\u5199\u5165\u3002\u4EFB\u4F55\u672A\u7ECF\u6388\u6743\u3001\u89E6\u78B0\u884C\u4E3A\u6392\u9664\u9879\u3001\u8D85\u51FA\u6587\u4EF6\u8FB9\u754C\u6216\u65E0\u6CD5\u8FFD\u6EAF\u5230\u9A8C\u6536\u7684\u6539\u52A8\u4E00\u5F8B\u8BB0\u4E3A \u{1F534} scope blocker
 
 ## \u4F60\u4E0D\u5199\u4EE3\u7801
 
@@ -14773,6 +14849,7 @@ var FILM_ANALYST_OFFENSE_AGENT = {
 
 | \u7EF4\u5EA6 | \u68C0\u67E5\u4EC0\u4E48 |
 |---|---|
+| **\u6388\u6743\u4E00\u81F4\u6027** | \u6BCF\u4E00\u5904\u6539\u52A8\u80FD\u5426\u540C\u65F6\u8FFD\u6EAF\u5230\u5DF2\u786E\u8BA4\u884C\u4E3A/\u9A8C\u6536 ID\uFF0C\u5E76\u4F4D\u4E8E implementationScope \u6587\u4EF6\u8FB9\u754C\u5185\uFF1B\u662F\u5426\u5B9E\u73B0\u4E86\u88AB\u62D2\u7EDD\u3001\u5EF6\u671F\u6216\u672A\u8BA8\u8BBA\u7684\u5EFA\u8BAE |
 | **\u53EF\u8BFB\u6027** | \u547D\u540D\u6E05\u6670\u3001\u7ED3\u6784\u5408\u7406\u3001\u6CE8\u91CA\u6070\u5F53\uFF08\u53EA\u5728 WHY \u975E\u663E\u7136\u65F6\uFF09 |
 | **\u53EF\u7EF4\u62A4\u6027** | \u6A21\u5757\u8FB9\u754C\u3001\u8026\u5408\u5EA6\u3001\u6269\u5C55\u6027 |
 | **\u98CE\u683C\u4E00\u81F4\u6027** | \u662F\u5426\u5339\u914D\u9879\u76EE\u5DF2\u6709\u98CE\u683C\uFF08\u5373\u4F7F\u4F60\u4E0D\u8BA4\u540C\uFF09 |
@@ -15321,11 +15398,11 @@ trigger: <\u5177\u4F53\u4E8B\u5B9E>
 // src/templates/skills/principles.ts
 var CORE_CODING_PRINCIPLES = `## \u94C1\u5F8B\uFF08\u6C38\u4E0D\u8FDD\u53CD\uFF09
 
-1. **\u4E0D\u505A\u65E0\u5173\u4FEE\u6539** \u2014 \u53EA\u6539 plan \u8303\u56F4\u5185\u7684
-2. **\u5148\u9A8C\u8BC1\u518D\u58F0\u79F0\u5B8C\u6210** \u2014 build/lint/test \u5FC5\u987B\u5B9E\u9645\u8DD1
+1. **\u4E0D\u505A\u65E0\u5173\u4FEE\u6539** \u2014 \u53EA\u6539\u7528\u6237\u5DF2\u786E\u8BA4\u7684 plan \u4E0E implementationScope\uFF1B\u6BCF\u4E00\u5904\u6539\u52A8\u90FD\u80FD\u8FFD\u6EAF\u5230\u8303\u56F4\u6216\u9A8C\u6536
+2. **\u5148\u9A8C\u8BC1\u518D\u58F0\u79F0\u5B8C\u6210** \u2014 \u5F00\u5DE5\u524D\u5199\u660E\u5B9E\u8D28\u5047\u8BBE\u548C\u53EF\u9A8C\u8BC1\u6210\u529F\u6807\u51C6\uFF1Bbuild/lint/test \u5FC5\u987B\u5B9E\u9645\u8DD1
 3. **\u5931\u8D25\u4E24\u6B21\u5FC5\u987B\u505C\u4E0B** \u2014 \u4E0D\u76F2\u8BD5
 4. **\u4E0D\u53EF\u9006\u64CD\u4F5C\u5148\u95EE** \u2014 \u5220\u9664\u3001force push\u3001worktree \u5408\u5E76
-5. **\u53EA\u89E3\u51B3\u88AB\u95EE\u5230\u7684\u95EE\u9898** \u2014 \u4E0D\u52A0\u63A8\u6D4B\u6027\u529F\u80FD`;
+5. **\u53EA\u89E3\u51B3\u88AB\u95EE\u5230\u7684\u95EE\u9898** \u2014 \u4F18\u5148\u590D\u7528\u73B0\u6709\u5B9E\u73B0\uFF0C\u9009\u62E9\u6EE1\u8DB3\u9A8C\u6536\u7684\u6700\u5C0F\u76F4\u63A5\u6539\u52A8\uFF1B\u4E0D\u52A0\u63A8\u6D4B\u6027\u529F\u80FD\u3001\u4E00\u6B21\u6027\u62BD\u8C61\u3001\u65E0\u5173\u6E05\u7406\u6216\u591A\u4F59\u914D\u7F6E`;
 
 // src/templates/skills/man.ts
 var MAN_SKILL = {
@@ -15345,7 +15422,7 @@ var MAN_SKILL = {
 
 ### Step 1: Scout \u8C03\u7814
 
-\u5148\u8BFB \`.mancode/shared/context/glossary.json\`\uFF08\u82E5\u5B58\u5728\uFF09\uFF0C\u8C03\u7814\u3001\u62A5\u544A\u4E0E\u540E\u7EED\u6C9F\u901A\u4F18\u5148\u4F7F\u7528\u5176\u4E2D\u5DF2\u786E\u8BA4\u672F\u8BED\u3002\u8C03\u7528 \`scout\`\uFF0C\u5199 \`scout-report.md\`\u3002\u62A5\u544A\u5FC5\u987B\u5305\u542B\u201C**\u4E0D\u786E\u5B9A\u7684\u5730\u65B9**\u201D\uFF0C\u5E76\u6309\u53EF\u9A8C\u8BC1\u4E8B\u5B9E\u8865\u5145 Current Behavior Evidence\u3001Candidate Semantic Owner\u3001Source of Truth\u3001Historical / Compatibility Impact\uFF1B\u5B57\u6BB5\u4E0D\u76F8\u5173\u6216\u65E0\u6CD5\u9A8C\u8BC1\u65F6\u53EF\u4EE5\u7701\u7565\uFF0C\u4E0D\u80FD\u7F16\u9020\u3002Current Behavior Evidence \u81F3\u5C11\u6709\u4E00\u4E2A\u53EF\u590D\u73B0\u89C2\u5BDF\u548C\u4ED3\u5E93\u8DEF\u5F84\u3001\u6D4B\u8BD5\u6216\u547D\u4EE4\u8BC1\u636E\uFF1Bowner \u5199\u7F6E\u4FE1\u5EA6\u4E0E\u51B2\u7A81\uFF1Bsource of truth \u533A\u5206 authority \u548C derived copy\uFF1B\u517C\u5BB9\u5F71\u54CD\u8986\u76D6\u65E7 workflow\u3001legacy fixture\u3001transport\u3001\u8FC1\u79FB\u548C rollback\u3002\u8FD0\u884C \`mancode workflow update <taskId> --step 2\`\u3002
+\u5148\u8BFB \`.mancode/shared/context/glossary.json\`\uFF08\u82E5\u5B58\u5728\uFF09\uFF0C\u8C03\u7814\u3001\u62A5\u544A\u4E0E\u540E\u7EED\u6C9F\u901A\u4F18\u5148\u4F7F\u7528\u5176\u4E2D\u5DF2\u786E\u8BA4\u672F\u8BED\u3002\u8C03\u7528\u53EA\u8BFB \`scout\`\uFF0C\u5199 \`scout-report.md\`\u3002\u62A5\u544A\u5FC5\u987B\u5305\u542B\u201C**\u4E0D\u786E\u5B9A\u7684\u5730\u65B9**\u201D\u548C\u6700\u591A 3 \u4E2A\u4F1A\u6539\u53D8\u51B3\u7B56\u7684 Decision-impact Findings\uFF1B\u4F7F\u7528\u7A33\u5B9A ID F-1\u2026F-3\uFF0C\u6807\u6CE8 Type\uFF1Apremise / scope / technical / risk / acceptance\uFF0C\u5E76\u533A\u5206 repository_fact \u4E0E domain_hypothesis\u3002\u524D\u8005\u5FC5\u987B\u6709\u4ED3\u5E93\u8BC1\u636E\uFF1B\u540E\u8005\u53EA\u6839\u636E\u7AEF\u5230\u7AEF\u76EE\u6807\u548C\u5E38\u89C1\u9886\u57DF\u5931\u8D25/\u8FB9\u754C\u8DEF\u5F84\u63D0\u51FA\u805A\u7126\u95EE\u9898\uFF0C\u4E0D\u80FD\u5199\u6210\u4E8B\u5B9E\u3002\u6309\u53EF\u9A8C\u8BC1\u4E8B\u5B9E\u8865\u5145 Current Behavior Evidence\u3001Candidate Semantic Owner\u3001Source of Truth\u3001Historical / Compatibility Impact\uFF1B\u5B57\u6BB5\u4E0D\u76F8\u5173\u6216\u65E0\u6CD5\u9A8C\u8BC1\u65F6\u53EF\u4EE5\u7701\u7565\uFF0C\u4E0D\u80FD\u7F16\u9020\u3002Current Behavior Evidence \u81F3\u5C11\u6709\u4E00\u4E2A\u53EF\u590D\u73B0\u89C2\u5BDF\u548C\u4ED3\u5E93\u8DEF\u5F84\u3001\u6D4B\u8BD5\u6216\u8C03\u7528\u65B9\u63D0\u4F9B\u7684\u547D\u4EE4\u8BC1\u636E\uFF1Bowner \u5199\u7F6E\u4FE1\u5EA6\u4E0E\u51B2\u7A81\uFF1Bsource of truth \u533A\u5206 authority \u548C derived copy\uFF1B\u517C\u5BB9\u5F71\u54CD\u8986\u76D6\u65E7 workflow\u3001legacy fixture\u3001transport\u3001\u8FC1\u79FB\u548C rollback\u3002\u4E3B\u52A8\u6838\u9A8C\u7528\u6237\u524D\u63D0\u5E76\u6307\u51FA\u5173\u952E\u76F2\u70B9\uFF0C\u4F46\u53D1\u73B0\u53EA\u4EA7\u751F\u5EFA\u8BAE\u6743\uFF0C\u4E0D\u4EA7\u751F\u6267\u884C\u6743\u3002\u8FD0\u884C \`mancode workflow update <taskId> --step 2\`\u3002
 
 ### Step 2: \u9700\u6C42\u6F84\u6E05
 
@@ -15356,6 +15433,8 @@ var MAN_SKILL = {
 - **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
 
+\u4E3A\u6BCF\u4E2A F-1\u2026F-3 \u660E\u786E\u4E14\u6309\u7C7B\u578B\u5904\u7F6E\uFF1Ablocking \u5199\u5165 \`blockingUnknowns\`\uFF1B\u7528\u6237\u63A5\u53D7\u7684\u8303\u56F4\u6216\u884C\u4E3A\u5199\u5165 \`confirmedScope\` \u5E76\u8865\u4E0A\u76F8\u5E94 \`acceptanceCriteria\`\uFF1B\u7528\u6237\u63A5\u53D7\u7684\u6280\u672F\u9009\u62E9\u5199\u5165 \`technicalDecisions\`\uFF1B\u53EA\u6709\u7528\u6237\u660E\u786E\u6392\u9664\u7684\u884C\u4E3A\u5199\u5165 \`excludedScope\`\uFF1B\`defaults\` \u53EA\u80FD\u63CF\u8FF0\u5DF2\u786E\u8BA4\u8303\u56F4\u5185\u4F4E\u5F71\u54CD\u3001\u53EF\u9006\u4E14\u7B26\u5408\u4ED3\u5E93\u7EA6\u5B9A\u7684\u5B9E\u73B0\u7EC6\u8282\uFF0C\u4E0D\u80FD\u6269\u5927\u8303\u56F4\u3002\u672A\u63A5\u53D7\u7684\u5EFA\u8BAE\u4ECD\u65E0\u6267\u884C\u6743\uFF0C\u4F46\u4E0D\u5F97\u81EA\u52A8\u585E\u5165 \`excludedScope\`\uFF0C\u4E5F\u4E0D\u5F97\u590D\u5236\u8FDB\u6240\u6709\u5B57\u6BB5\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
@@ -15366,7 +15445,7 @@ var MAN_SKILL = {
 
 Plan Coach \u5FC5\u987B\u8BC1\u660E\u6240\u6709\u9009\u9879\u89E3\u51B3\u540C\u4E00\u4E2A goal\u3001\u9A8C\u6536\u8FB9\u754C\u548C scope\uFF1B\u9010\u9879\u5199\u660E complexity bearer \u53CA\u53EF\u89C2\u5BDF\u6210\u672C\uFF1B\u7ED9\u51FA\u4E14\u53EA\u7ED9\u51FA\u4E00\u4E2A recommendation\u3001\u62D2\u7EDD\u5176\u4ED6\u65B9\u5411\u7684\u4E3B\u8981\u7406\u7531\u548C stop conditions\u3002\u7B80\u5355\u4EFB\u52A1\u6CA1\u6709\u771F\u5B9E\u66FF\u4EE3\u65F6\u53EA\u5217\u4E00\u4E2A\u65B9\u5411\u5E76\u8BF4\u660E\u539F\u56E0\uFF0C\u4E0D\u5236\u9020\u4F2A\u9009\u9879\u3002\u4E24\u4E2A\u540C\u7B49 owner \u5019\u9009\u6216 authority writer \u672A\u51B3\u65F6\u8FD4\u56DE \`NEEDS_CLARIFICATION\`\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\u5165\u53E3/\u6D41\u7A0B\u8DE8\u5E73\u53F0\u4E0D\u4E00\u81F4\u3001owner/source of truth \u4E0D\u6E05\u3001\u72B6\u6001\u6216 contract \u8BED\u4E49\u53D8\u5316\u3001\u8DE8 workflow/child/team/transport\uFF0C\u6216\u8FC1\u79FB/\u517C\u5BB9\u5F71\u54CD\u8D85\u8FC7\u4E00\u4E2A\u7248\u672C\u65F6\uFF0C\u5728 \`plan.md\` \u5185\u52A0\u5165\u53EF\u9009 Domain Matrix\uFF0C\u5217\u51FA Domain\u3001\u5F53\u524D\u884C\u4E3A/\u8BC1\u636E\u3001\u5019\u9009 owner\u3001source of truth\u3001contract/state \u5F71\u54CD\u3001compatibility/history\u3001validation \u548C rollback/stop\uFF1B\u5B83\u4E0D\u662F\u65B0\u7684 authority\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
+\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\uFF0C\u8FD8\u8981\u6709\u7528\u6237\u53EF\u89C1\u7684 \`implementationScope\`\uFF1Arepo-relative \`include\`\u3001\`exclude\`\u3001\`modules\`\u3002include \u662F\u6587\u4EF6\u5199\u5165\u4E0A\u9650\u4E14\u5FC5\u987B\u975E\u7A7A\uFF0Cexclude \u4F18\u5148\uFF0Cmodules \u53EA\u63CF\u8FF0\u5F52\u5C5E\u3001\u4E0D\u5355\u72EC\u6388\u6743\u3002\u6BCF\u4E2A\u5B9E\u65BD\u6B65\u9AA4\u5FC5\u987B\u6620\u5C04\u5230\u5DF2\u786E\u8BA4\u8303\u56F4\u6216\u9A8C\u6536 ID\uFF1B\u4F18\u5148\u590D\u7528\u5DF2\u6709\u4EE3\u7801\u548C\u4F9D\u8D56\uFF0C\u9009\u62E9\u80FD\u6EE1\u8DB3\u9A8C\u6536\u7684\u6700\u5C0F\u3001\u76F4\u63A5\u3001\u53EF\u9A8C\u8BC1\u65B9\u6848\uFF0C\u4E0D\u4E3A\u5355\u6B21\u7528\u9014\u65B0\u589E\u62BD\u8C61\u3001\u53EF\u914D\u7F6E\u6027\u6216\u63A8\u6D4B\u6027\u9632\u5FA1\u3002\u5165\u53E3/\u6D41\u7A0B\u8DE8\u5E73\u53F0\u4E0D\u4E00\u81F4\u3001owner/source of truth \u4E0D\u6E05\u3001\u72B6\u6001\u6216 contract \u8BED\u4E49\u53D8\u5316\u3001\u8DE8 workflow/child/team/transport\uFF0C\u6216\u8FC1\u79FB/\u517C\u5BB9\u5F71\u54CD\u8D85\u8FC7\u4E00\u4E2A\u7248\u672C\u65F6\uFF0C\u5728 \`plan.md\` \u5185\u52A0\u5165\u53EF\u9009 Domain Matrix\uFF0C\u5217\u51FA Domain\u3001\u5F53\u524D\u884C\u4E3A/\u8BC1\u636E\u3001\u5019\u9009 owner\u3001source of truth\u3001contract/state \u5F71\u54CD\u3001compatibility/history\u3001validation \u548C rollback/stop\uFF1B\u5B83\u4E0D\u662F\u65B0\u7684 authority\u3002\u9996\u6B21\u8BA1\u5212\u4E0E\u8FB9\u754C\u901A\u8FC7 CLI \u4E00\u8D77\u5199\u5165\u540E\u8FD0\u884C \`mancode workflow update <taskId> --step 4\`\uFF1B\u517C\u5BB9\u65E7\u5165\u53E3\u91CD\u5199\u8BA1\u5212\u65F6\u4FDD\u6301 Step 4\uFF0C\u4F7F\u7528 \`--plan-version <\u5F53\u524D\u7248\u672C+1>\`\uFF0C\u5E76\u8BA9\u65E7\u5BA1\u67E5/\u9A8C\u8BC1\u5931\u6548\uFF0C\u4E0D\u5F97\u76F4\u63A5\u7F16\u8F91 planVersion\u3002
 
 ### Step 4: \u8BA1\u5212\u5173\u5361
 
@@ -15388,7 +15467,9 @@ Plan Coach \u5FC5\u987B\u8BC1\u660E\u6240\u6709\u9009\u9879\u89E3\u51B3\u540C\u4
 
 ### Step 5: \u5B9E\u65BD
 
-\u8C03\u7528 \`head-coach\` \u6309\u786E\u8BA4\u8BA1\u5212\u5B9E\u65BD\u3002\u591A\u6587\u4EF6\u3001\u65B0\u6A21\u5757\u6216\u9AD8\u98CE\u9669\u4EFB\u52A1\u53EF\u5EFA\u8BAE worktree\uFF0C\u5FC5\u987B\u5148\u83B7\u7528\u6237\u540C\u610F\u3002\u5B9E\u65BD\u5B8C\u6210\u540E\u901A\u8FC7 CLI \u66F4\u65B0\u81F3 Step 6\u3002
+\u8C03\u7528 \`head-coach\` \u6309\u786E\u8BA4\u8BA1\u5212\u5B9E\u65BD\u3002\u5148\u660E\u786E\u4ECD\u5B58\u5728\u7684\u5B9E\u8D28\u5047\u8BBE\u548C\u53EF\u9A8C\u8BC1\u6210\u529F\u6807\u51C6\uFF1B\u6BCF\u4E00\u5904\u6539\u52A8\u90FD\u5FC5\u987B\u8FFD\u6EAF\u5230\u5DF2\u786E\u8BA4\u8303\u56F4\u3001\u6280\u672F\u51B3\u7B56\u6216\u9A8C\u6536 ID\u3002\u53EA\u6539\u4E3A\u6EE1\u8DB3\u8BA1\u5212\u6240\u5FC5\u9700\u7684\u6587\u4EF6\uFF0C\u4E0D\u987A\u624B\u91CD\u6784\u3001\u683C\u5F0F\u5316\u3001\u6E05\u7406\u76F8\u90BB\u4EE3\u7801\u6216\u589E\u52A0\u672A\u8BF7\u6C42\u529F\u80FD\u3002\u591A\u6587\u4EF6\u3001\u65B0\u6A21\u5757\u6216\u9AD8\u98CE\u9669\u4EFB\u52A1\u53EF\u5EFA\u8BAE worktree\uFF0C\u5FC5\u987B\u5148\u83B7\u7528\u6237\u540C\u610F\u3002\u5B9E\u65BD\u5B8C\u6210\u540E\u901A\u8FC7 CLI \u66F4\u65B0\u81F3 Step 6\u3002
+
+\u82E5\u5347\u7EA7\u524D\u5DF2\u7ECF\u8FDB\u5165\u6267\u884C\u9636\u6BB5\u7684\u672C\u5730 Man \u4EFB\u52A1\u7F3A\u5C11\u53EF\u6267\u884C \`implementationScope\`\uFF0C\u5B8C\u6210\u95E8\u4ECD\u4F1A\u62D2\u7EDD\u3002\u5148\u5411\u7528\u6237\u5C55\u793A\u5B8C\u6574\u8FB9\u754C\u5E76\u7B49\u5F85\u660E\u786E\u786E\u8BA4\uFF0C\u518D\u4F7F\u7528\u5185\u5BB9\u5B8C\u5168\u4E0D\u53D8\u7684\u5F53\u524D plan \u548C \`--scope-file\` \u91CD\u65B0\u6267\u884C plan revise\u3002\u8FD9\u4E2A\u517C\u5BB9\u8865\u7ED1\u53EA\u5141\u8BB8\u9012\u589E plan authority \u5E76\u4F7F\u65E7 review/verification \u5931\u6548\uFF1B\u4E0D\u5F97\u4FEE\u6539 plan\u3001\u884C\u4E3A\u3001\u9A8C\u6536\u6216\u5DF2\u7ECF\u53EF\u6267\u884C\u7684\u8FB9\u754C\u3002
 
 ### Step 6: \u81EA\u6D4B\u3001\u8BCA\u65AD\u4E0E\u56DE\u5F52
 
@@ -15400,7 +15481,7 @@ Plan Coach \u5FC5\u987B\u8BC1\u660E\u6240\u6709\u9009\u9879\u89E3\u51B3\u540C\u4
 
 ### Step 7: Film #1 \u4EE3\u7801\u8D28\u91CF\u5BA1\u67E5\u4E0E\u4FEE\u590D
 
-\u672A\u8DF3\u8FC7 review \u65F6\u8C03\u7528 \`film-analyst-offense\`\uFF0C\u53EA\u5BA1\u67E5\u672C\u6B21 diff \u7684\u884C\u4E3A\u6B63\u786E\u6027\u3001\u590D\u7528\u3001\u590D\u6742\u5EA6\u548C\u6D4B\u8BD5\uFF0C\u5199 \`film-report-1.md\`\u3002\u6BCF\u6761 finding \u5FC5\u987B\u5F15\u7528\u6539\u52A8\u884C\u3001\u7ED9\u51FA\u8BC1\u636E\u548C\u7528\u6237\u5F71\u54CD\uFF1B\u6700\u591A 3 \u4E2A\u65B0 finding\u3002\u7528\u7A33\u5B9A ID\uFF08\u5982 Q1\uFF09\u6807\u8BB0 \u{1F534} blocker\uFF0C\u5E76\u8FD0\u884C \`mancode workflow review <taskId> complete --review-domain quality --report film-report-1.md --blockers Q1,Q2\`\uFF1B\u6CA1\u6709 blocker \u65F6\u4F20\u7A7A\u5B57\u7B26\u4E32\u3002\u6B64\u65F6\u4E0D\u4FEE\u590D\uFF0C\u5148\u5B8C\u6210\u6240\u9700\u5BA1\u67E5\u9886\u57DF\uFF0C\u518D\u66F4\u65B0\u81F3 Step 8\u3002
+\u672A\u8DF3\u8FC7 review \u65F6\u8C03\u7528 \`film-analyst-offense\`\uFF0C\u5148\u628A\u5B9E\u9645 diff \u5BF9\u7167 \`confirmedScope\`\u3001\`excludedScope\`\u3001\`technicalDecisions\`\u3001\`acceptanceCriteria\` \u548C \`implementationScope\` \u505A\u6388\u6743\u4E00\u81F4\u6027\u5BA1\u67E5\uFF0C\u518D\u68C0\u67E5\u884C\u4E3A\u6B63\u786E\u6027\u3001\u590D\u7528\u3001\u590D\u6742\u5EA6\u548C\u6D4B\u8BD5\uFF0C\u5199 \`film-report-1.md\`\u3002\u5B9E\u73B0\u88AB\u62D2\u7EDD\u3001\u5EF6\u671F\u3001\u672A\u8BA8\u8BBA\u3001\u65E0\u6CD5\u8FFD\u6EAF\u5230\u5DF2\u786E\u8BA4\u884C\u4E3A\uFF0C\u6216\u6539\u52A8\u8DEF\u5F84\u843D\u5728 include \u5916 / \u5339\u914D exclude \u7684\u5185\u5BB9\u4E00\u5F8B\u4F5C\u4E3A \u{1F534} scope blocker\u3002\u6BCF\u6761 finding \u5FC5\u987B\u5F15\u7528\u6539\u52A8\u884C\u3001\u7ED9\u51FA\u8BC1\u636E\u548C\u7528\u6237\u5F71\u54CD\uFF1B\u6700\u591A 3 \u4E2A\u65B0 finding\u3002\u7528\u7A33\u5B9A ID\uFF08\u5982 Q1\uFF09\u6807\u8BB0 \u{1F534} blocker\uFF0C\u5E76\u8FD0\u884C \`mancode workflow review <taskId> complete --review-domain quality --report film-report-1.md --blockers Q1,Q2\`\uFF1B\u6CA1\u6709 blocker \u65F6\u4F20\u7A7A\u5B57\u7B26\u4E32\u3002\u6B64\u65F6\u4E0D\u4FEE\u590D\uFF0C\u5148\u5B8C\u6210\u6240\u9700\u5BA1\u67E5\u9886\u57DF\uFF0C\u518D\u66F4\u65B0\u81F3 Step 8\u3002
 
 ### Step 8: Film #2 \u5B89\u5168\u4E0E\u8FB9\u754C\u5BA1\u67E5
 
@@ -15734,16 +15815,18 @@ 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\uFF0C\u5E76\u6309\u4E8B\u5B9E\u8865\u5145 Current Behavior Evidence\u3001Candidate Semantic Owner\u3001Source of Truth\u3001Historical / Compatibility Impact\uFF1Bauthority \u4E0E Markdown/adapter \u7B49 derived copy \u5FC5\u987B\u533A\u5206\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\u6240\u6709\u9009\u9879\u5FC5\u987B\u89E3\u51B3\u540C\u4E00\u76EE\u6807\u548C\u9A8C\u6536\u8FB9\u754C\uFF0C\u5199\u660E complexity bearer\uFF0C\u53EA\u4FDD\u7559\u4E00\u4E2A recommendation \u548C stop conditions\uFF1B\u7B80\u5355\u4EFB\u52A1\u53EF\u4EE5\u53EA\u6709\u4E00\u4E2A\u771F\u5B9E\u65B9\u5411\u3002\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\uFF1B\u9AD8\u98CE\u9669\u6216\u8DE8 team/transport/owner/authority \u7684\u4EFB\u52A1\u5728 plan.md \u5185\u52A0\u5165\u975E\u6743\u5A01 Domain Matrix\u3002\u7981\u6B62\u63D0\u524D\u4FEE\u6539\u4E1A\u52A1\u6587\u4EF6\u6216\u56E2\u961F memory\u3002
+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\uFF0C\u5E76\u6309\u4E8B\u5B9E\u8865\u5145 Current Behavior Evidence\u3001Candidate Semantic Owner\u3001Source of Truth\u3001Historical / Compatibility Impact\uFF1Bauthority \u4E0E Markdown/adapter \u7B49 derived copy \u5FC5\u987B\u533A\u5206\u3002\u6700\u591A\u4FDD\u7559\u4E09\u4E2A\u4F1A\u6539\u53D8\u51B3\u7B56\u7684 finding\uFF0C\u4F7F\u7528\u7A33\u5B9A ID F-1\u2026F-3 \u548C Type\uFF1Apremise / scope / technical / risk / acceptance\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\u53D1\u73B0\u53EA\u4EA7\u751F\u5EFA\u8BAE\u6743\uFF0C\u4E0D\u4EA7\u751F\u6267\u884C\u6743\uFF1A\u63A5\u53D7\u7684\u8303\u56F4\u6216\u884C\u4E3A\u8FDB\u5165 confirmedScope \u548C\u5339\u914D\u7684 acceptanceCriteria\uFF1B\u63A5\u53D7\u7684\u6280\u672F\u9009\u62E9\u8FDB\u5165 technicalDecisions\uFF1B\u53EA\u6709\u660E\u786E\u6392\u9664\u7684\u884C\u4E3A\u8FDB\u5165 excludedScope\uFF1B\u672A\u63A5\u53D7\u7684\u5EFA\u8BAE\u4ECD\u65E0\u6267\u884C\u6743\uFF0C\u4F46\u4E0D\u5F97\u81EA\u52A8\u585E\u5165 excludedScope\uFF1B\u4F4E\u5F71\u54CD\u53EF\u9006\u9ED8\u8BA4\u503C\u8FDB\u5165 defaults \u4E14\u4E0D\u5F97\u6269\u5F20\u8303\u56F4\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\u6240\u6709\u9009\u9879\u5FC5\u987B\u89E3\u51B3\u540C\u4E00\u76EE\u6807\u548C\u9A8C\u6536\u8FB9\u754C\uFF0C\u5199\u660E complexity bearer\uFF0C\u53EA\u4FDD\u7559\u4E00\u4E2A recommendation \u548C stop conditions\uFF1B\u7B80\u5355\u4EFB\u52A1\u53EF\u4EE5\u53EA\u6709\u4E00\u4E2A\u771F\u5B9E\u65B9\u5411\u3002\u8BA1\u5212\u91CC\u5FC5\u987B\u5305\u542B\u7528\u6237\u53EF\u89C1\u7684 \`implementationScope\`\uFF08repo-relative include/exclude/modules\uFF09\u3001\u6280\u672F\u9009\u62E9\u7406\u7531\u3001\u517C\u5BB9\u6027\u98CE\u9669\u3001\u56DE\u6EDA\u65B9\u5F0F\uFF1Binclude \u662F\u6587\u4EF6\u5199\u5165\u4E0A\u9650\uFF0Cmodules \u4E0D\u5355\u72EC\u6388\u6743\u3002\u9AD8\u98CE\u9669\u6216\u8DE8 team/transport/owner/authority \u7684\u4EFB\u52A1\u5728 plan.md \u5185\u52A0\u5165\u975E\u6743\u5A01 Domain Matrix\u3002\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\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
+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\u5148\u68C0\u67E5\u6BCF\u4E00\u5904\u6539\u52A8\u662F\u5426\u80FD\u8FFD\u6EAF\u5230\u5DF2\u786E\u8BA4\u8303\u56F4\u4E14\u540C\u65F6\u4F4D\u4E8E \`implementationScope\` include \u5185\u3001\u4E0D\u5339\u914D exclude\uFF0C\u672A\u7ECF\u6388\u6743\u7684\u6539\u52A8\u4F5C\u4E3A blocker\uFF0C\u518D\u5BA1\u67E5\u884C\u4E3A\u3001\u53EF\u7EF4\u62A4\u6027\u3001\u56E2\u961F\u98CE\u683C\u4E0E\u6D4B\u8BD5\uFF1Bfinding \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\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
 
+\u5B9E\u65BD\u671F\u95F4\u82E5\u53EA\u9700\u8C03\u6574\u6587\u4EF6\u8FB9\u754C\u3001\u4E0D\u6539\u53D8\u5DF2\u786E\u8BA4\u884C\u4E3A\u6216\u9A8C\u6536\uFF0C\u5148\u5411\u7528\u6237\u5C55\u793A\u5B8C\u6574\u65B0\u8FB9\u754C\u5E76\u53D6\u5F97\u660E\u786E\u540C\u610F\uFF0C\u518D\u901A\u8FC7\u4E13\u7528 \`workflow scope change\` mutation \u66F4\u65B0\uFF1B\u5B83\u5FC5\u987B\u9012\u589E plan authority\u3001\u4F7F\u65E7 review/verification \u5931\u6548\u5E76\u91CD\u7B7E\u517C\u5BB9 claim\u3002\u884C\u4E3A\u6216\u9A8C\u6536\u53D8\u5316\u4ECD\u8D70 reframe\uFF0C\u4E0D\u80FD\u7528 scope change \u7ED5\u8FC7\u9700\u6C42\u786E\u8BA4\u3002
+
 \u5B9E\u65BD\u4E2D\u65B0\u8BC1\u636E\u82E5\u63A8\u7FFB\u5DF2\u786E\u8BA4\u7684\u76EE\u6807\u3001owner\u3001source of truth \u6216\u9A8C\u6536\uFF0C\u5165\u53E3/\u6D41\u7A0B\u4F1A\u4EA7\u751F\u4E0D\u540C\u8BED\u4E49\uFF0Cstatus/contract/policy/transition \u542B\u4E49\u8981\u53D8\uFF0C\u53D1\u73B0 stale adapter\u3001writer \u4E0D\u517C\u5BB9\u3001\u672A\u5B8C\u6210 operation\u3001active child/open handoff/active solo assignment\uFF0C\u6216\u53D8\u5316\u8D85\u51FA requirements/plan scope\uFF0C\u7ACB\u5373\u505C\u6B62\uFF0C\u53EA\u8FD4\u56DE \`NEEDS_REALIGNMENT\` \u548C \`MANCODE_REFRAME_REQUIRED\`\u3002\u8FD9\u662F\u53EA\u8BFB\u8BCA\u65AD\uFF1A\u4E0D\u5F97\u8C03\u7528\u901A\u7528 workflow update \u5199 blocker\uFF0C\u4E0D\u6539 metadata/step/policy/requirements/plan/claims/handoff\uFF0C\u4E0D\u5F52\u6863\u6216\u91CA\u653E authority\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
@@ -16707,13 +16790,13 @@ var MODE_META = {
       "After each completed phase, advance through the CLI to the next numbered step;",
       "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`. When relevant and verifiable, include Current Behavior Evidence, Candidate Semantic Owner with confidence/conflict, Source of Truth split into authority/readers/writer/derived copies, and Historical / Compatibility Impact for existing workflows, legacy fixtures, transport, migration, and rollback. Never invent fields to fill the template.",
-      "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. Every option must solve the same goal, acceptance boundary, and scope; name its complexity bearer and observable cost; return exactly one recommendation with rejection reasons and stop conditions. A simple task may have one real direction and must not manufacture alternatives. When ready, write `plan.md` with confirmed scope, technical choices and reasons, reuse, exclusions, behavior, risks/rollback, completion criteria, defaults, and real validation. For cross-platform entry differences, unclear owner/source of truth, contract/state changes, cross-workflow/team/transport work, or multi-version compatibility, add an optional Domain Matrix inside plan.md; it is not authority. First plan is v1; revisions use `--plan-version <current+1>`.",
+      "Step 1 \u2014 Scout: run a bounded, read-only decision-impact discovery; test the user premise against repository evidence, inspect the end-to-end user goal and common domain failure/edge paths, and retain at most three material findings with stable IDs F-1 through F-3 and type premise, scope, technical, risk, or acceptance. Mark each repository_fact or domain_hypothesis; an unverified domain hypothesis becomes a focused question, never a fact. Discovery produces evidence and recommendations, never execution authority. Write `scout-report.md` with the profile, implementation, dependencies, risks, unknowns, and\u2014when verifiable\u2014Current Behavior Evidence, Candidate Semantic Owner with confidence/conflict, Source of Truth split into authority/readers/writer/derived copies, and Historical / Compatibility Impact for existing workflows, legacy fixtures, transport, migration, and rollback. Never invent fields to fill the template.",
+      "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. Give every F-ID one type-directed disposition: blocking findings stay in blockingUnknowns; accepted scope or behavior enters confirmedScope plus matching acceptanceCriteria; accepted technical choices enter technicalDecisions; only explicitly excluded behavior enters excludedScope; low-impact reversible details may enter defaults. An unaccepted proposal remains unauthorized and is not copied into every field. 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. Every option must solve the same goal, acceptance boundary, and scope; name its complexity bearer and observable cost; return exactly one recommendation with rejection reasons and stop conditions. A simple task may have one real direction and must not manufacture alternatives. When ready, write `plan.md` with confirmed scope, technical choices and reasons, reuse, exclusions, behavior, risks/rollback, completion criteria, defaults, and real validation. Add a user-visible implementation scope with non-empty repo-relative include, exclude, and module labels; include is the file-write upper bound, exclude wins, and modules do not authorize files. For cross-platform entry differences, unclear owner/source of truth, contract/state changes, cross-workflow/team/transport work, or multi-version compatibility, add an optional Domain Matrix inside plan.md; it is not authority. 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 5 \u2014 State material assumptions and verifiable success criteria, then implement the smallest direct change inside both the confirmed plan and implementation scope. Reuse existing code and dependencies; do not add speculative features, one-off abstractions, configurability, adjacent cleanup, or unrelated defenses. A newly discovered out-of-scope need authorizes only NEEDS_REALIGNMENT until the user approves reframe. If an upgraded already-running local man task has no executable scope, show the complete boundary and wait for explicit approval, then rerun plan revise with the exact unchanged current plan plus --scope-file; this compatibility bind stales old evidence and cannot change behavior or an already executable boundary.",
       "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 7 \u2014 Run one quality review limited to the changed diff and direct impact. Compare every changed path and behavior with confirmed requirements, acceptance IDs, and implementation scope; any unauthorized behavior, path outside include, or path matching exclude is a blocker. 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 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.",
       "",
@@ -16733,6 +16816,10 @@ var MODE_META = {
       "and currentWorkflowMode to manteam. First collect branch, dirty-worktree, contributor,",
       "shared-module, and handoff risks in `team-context.md`.",
       "",
+      "Run the same bounded Scout discovery as /man with stable F-IDs and typed findings. Discovery produces evidence and recommendations, never execution authority.",
+      "Use the same type-directed disposition as /man, bind the confirmed plan to a user-visible implementation scope, and treat that scope as the file-write upper bound for claims, implementation, and review.",
+      "After explicit user approval, a file-boundary-only adjustment may use `workflow scope change`; it versions plan authority, stales prior evidence, and reissues compatible claims. A behavior or acceptance change still requires reframe.",
+      "",
       "Then execute every /man Step 1 through Step 9, including clarification,",
       "plan gate, validation, bounded risk-based review, conditional completion, planVersion,",
       "Active Plans, and linked manba child behavior. Add compatibility, rollback,",
@@ -23051,7 +23138,7 @@ async function planContextCompaction(input) {
     ...gitRefWorkflowRepairPlan.protectedTaskRefs
   ]);
   const taskRefs = input.taskRef === void 0 ? await listTaskRefs(root) : [parseTaskRefValue(input.taskRef)];
-  const [checkpointPlan, sessions, overlays, cache] = await Promise.all([
+  const [checkpointPlan, sessions, cache] = await Promise.all([
     planCheckpointCompaction(
       store,
       coordinationStore,
@@ -23064,13 +23151,6 @@ async function planContextCompaction(input) {
       now,
       protectedSessionIds
     ),
-    planLocalOverlayRetention(
-      root,
-      store,
-      taskRefs,
-      project.policy.retention.localRawArtifactDays,
-      now
-    ),
     planLocalCacheRetention(root, project.policy.retention.localCacheDays, now)
   ]);
   return {
@@ -23081,7 +23161,6 @@ async function planContextCompaction(input) {
       ...operationPlan.candidates,
       ...gitRefWorkflowRepairPlan.candidates,
       ...checkpointPlan.candidates,
-      ...overlays,
       ...cache
     ].sort(
       (left, right) => Buffer.from(left.target, "utf8").compare(
@@ -23091,37 +23170,6 @@ async function planContextCompaction(input) {
     skippedReferencedCheckpoints: checkpointPlan.skippedReferencedCheckpoints
   };
 }
-async function planLocalOverlayRetention(root, store, taskRefs, localRawArtifactDays, now) {
-  const threshold = now.getTime() - localRawArtifactDays * 864e5;
-  const candidates = [];
-  for (const taskRef of taskRefs) {
-    if (taskRef.namespace !== "shared") continue;
-    const task = await store.readTaskSnapshot(taskRef);
-    if (!isTerminalTaskStatus(task.metadata.status)) continue;
-    const directory = path41.join(
-      root,
-      ".mancode",
-      "local",
-      "overlays",
-      taskRef.taskId,
-      "artifacts"
-    );
-    for (const entry of await readDirectoryOrEmpty(directory)) {
-      const target = path41.join(directory, entry);
-      const metadata = await regularFileMetadataOrNull(target);
-      if (metadata === null || metadata.mtimeMs >= threshold) continue;
-      candidates.push({
-        kind: "local_overlay_artifact",
-        target,
-        reason: `terminal task raw artifact exceeds ${localRawArtifactDays} day retention`,
-        // The artifact is local-only even though it is grouped by shared task.
-        taskRef: null,
-        relatedTargets: []
-      });
-    }
-  }
-  return candidates;
-}
 async function planLocalCacheRetention(root, localCacheDays, now) {
   const threshold = now.getTime() - localCacheDays * 864e5;
   const directory = path41.join(root, ".mancode", "local", "cache");
@@ -23306,9 +23354,6 @@ function taskRefKeyFromEntityKey(entityKey) {
   );
   return match === null ? null : `${match[1]}:${match[2]}`;
 }
-function isTerminalTaskStatus(status2) {
-  return status2 === "completed" || status2 === "abandoned" || status2 === "superseded";
-}
 async function listTaskRefs(root) {
   const refs = [];
   for (const namespace of ["local", "shared"]) {
@@ -28012,7 +28057,6 @@ async function writeGreenfieldLayout(stagingRoot, manifest, config, policy, proj
       recursive: true
     }),
     mkdir35(path53.join(stagingRoot, "local", "workflows"), { recursive: true }),
-    mkdir35(path53.join(stagingRoot, "local", "overlays"), { recursive: true }),
     mkdir35(path53.join(stagingRoot, "local", "quarantine"), { recursive: true }),
     mkdir35(path53.join(stagingRoot, "local", "publish"), { recursive: true }),
     mkdir35(path53.join(stagingRoot, "local", "cache"), { recursive: true }),
@@ -41491,6 +41535,30 @@ function version() {
   console.log(platform);
 }
 
+// src/commands/workflow-subcommands.ts
+var WORKFLOW_SUBCOMMANDS = [
+  "create",
+  "list",
+  "show",
+  "update",
+  "requirements",
+  "plan",
+  "review",
+  "verify",
+  "complete",
+  "scope",
+  "reframe",
+  "archive",
+  "checkpoint",
+  "child",
+  "promote",
+  "handoff"
+];
+var WORKFLOW_SUBCOMMAND_SET = new Set(
+  WORKFLOW_SUBCOMMANDS
+);
+var CONTINUITY_COMPATIBILITY_SUBCOMMANDS = /* @__PURE__ */ new Set(["clean"]);
+
 // src/commands/workflow.ts
 import { access as access6, readFile as readFile48, rm as rm23, writeFile as writeFile50 } from "fs/promises";
 import path69 from "path";
@@ -41821,175 +41889,289 @@ function assertPositiveRevision6(value, label) {
   }
 }
 
-// src/context/plan-revision.ts
-async function reviseV3Plan(input) {
+// src/context/scope-change.ts
+import { createHash as createHash11 } from "crypto";
+async function changeV3WorkflowScope(input) {
   const taskRef = parseTaskRefValue(input.taskRef);
-  const plan = requirePlan(input.plan);
-  const planDecision = parsePlanDecision(input.planDecision);
-  if (taskRef.namespace === "shared") {
-    assertSharedTextSafe(plan, "plan");
+  if (taskRef.namespace !== "shared") {
+    throw new Error("MANCODE_SCOPE_CHANGE_REQUIRES_SHARED_TASK");
   }
-  const context = await openV3TaskOperation({
+  const scope = normalizeImplementationScope(input.scope);
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const timestamp4 = now.toISOString();
+  const checkpointId = input.checkpointId ?? createUlid(now.getTime());
+  const operationId = input.operationId ?? createUlid(now.getTime());
+  assertUlid(checkpointId, "scope change checkpointId");
+  assertUlid(operationId, "scope change operationId");
+  const opened = await openScopeChangeContext({
     projectRoot: input.projectRoot,
     taskRef,
     sessionId: input.sessionId,
     expectedTaskRevision: input.expectedTaskRevision,
-    operationId: input.operationId,
-    extraEntityLocks: taskRef.namespace === "shared" ? [taskHeadEntityKey(taskRef)] : [],
-    now: input.now
+    scope,
+    checkpointId,
+    successorClaimIds: input.successorClaimIds,
+    operationId,
+    now
   });
+  const { context, activeClaims: activeClaims2, successorClaimIds, successorPredecessors } = opened;
   let journal = null;
   try {
-    assertPlanRevisionEligible(
+    assertScopeChangeEligible(context, scope);
+    assertClaimsFreshForScopeChange(context, activeClaims2);
+    const pendingMetadata = markScopeChangeOperationPending(
       context.task.metadata,
-      context.task.requirements
+      context.operationId,
+      timestamp4
     );
-    if (context.task.metadata.workflowMode === "manteam" && planDecision === "governed_execution") {
-      assertManteamPlanContent(plan);
-    }
-    if (context.task.plan?.content === plan && planDecision === null) {
-      throw new Error("MANCODE_PLAN_CONTENT_UNCHANGED");
-    }
-    const planChanged = context.task.plan?.content !== plan;
-    const timestamp4 = context.now.toISOString();
-    const planDigest = planChanged ? digestCanonicalJson({
-      artifactRef: { taskRef, kind: "plan" },
-      content: plan
-    }) : context.task.plan?.digest;
-    if (planDigest === void 0) {
-      throw new Error("MANCODE_PLAN_FILE_REQUIRED");
-    }
-    const review = planChanged ? markTaskReviewStale(context.task.review, context.operationId, timestamp4) : context.task.review;
-    const verification = planChanged ? markTaskVerificationStale(
+    const review = markTaskReviewStale(
+      context.task.review,
+      context.operationId,
+      timestamp4
+    );
+    const verification = markTaskVerificationStale(
       context.task.verification,
       context.operationId,
       timestamp4
-    ) : context.task.verification;
-    const metadata = updateMetadata(
-      context.task.metadata,
-      context.task.requirements,
-      review,
-      verification,
-      planChanged,
-      planDecision,
+    );
+    const branch = await readCheckoutBranch(context.projectRoot) ?? "HEAD";
+    const checkpoint = buildScopeChangedCheckpoint(
+      context,
+      pendingMetadata,
+      checkpointId,
+      input.checkpointSummary,
+      input.checkpointNextAction,
+      branch,
+      pendingMetadata.governance.planVersion + 1,
+      review.contentDigest,
+      verification.contentDigest,
+      timestamp4
+    );
+    const metadata = completeScopeChangeMetadata(
+      pendingMetadata,
+      scope,
+      checkpoint,
+      review.contentDigest,
+      verification.contentDigest,
       context.operationId,
       timestamp4
     );
+    const pendingSuccessorClaims = buildPendingSuccessorClaims2(
+      successorPredecessors,
+      successorClaimIds,
+      metadata,
+      branch,
+      requireCodeHead3(context),
+      context.operationId,
+      timestamp4,
+      capabilitiesFromProjectConfig(context.project.config)
+    );
+    const successorByPredecessor = new Map(
+      successorPredecessors.map((claim, index) => {
+        const successorClaimId = successorClaimIds[index];
+        if (successorClaimId === void 0) {
+          throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_COUNT_INVALID");
+        }
+        return [claim.claimId, successorClaimId];
+      })
+    );
+    const terminatedClaims = activeClaims2.map(
+      (claim) => terminateClaimForScopeChange(
+        claim,
+        successorByPredecessor.get(claim.claimId) ?? null,
+        context.operationId,
+        timestamp4
+      )
+    );
+    const activeSuccessorClaims = pendingSuccessorClaims.map(
+      (claim) => activateSuccessorClaim3(claim, context.operationId, timestamp4)
+    );
     const aggregate = buildTaskAggregateManifest({
       metadata,
       requirements: context.task.requirements,
       review,
       verification,
-      planDigest,
-      latestCheckpoint: context.task.latestCheckpoint
+      planDigest: context.task.plan?.digest ?? null,
+      latestCheckpoint: checkpoint
     });
     const taskHeadFence = nextTaskHeadFence(context, aggregate, timestamp4);
-    if (planDecision === "plan_only") {
-      await enqueueSessionPointerProjection(context.projectRoot, {
-        operationId: context.operationId,
-        action: "clear",
-        sessionId: context.session.sessionId,
-        expectedPreviousTaskRef: context.session.activeTaskRef,
-        taskRef,
-        workflowMode: metadata.workflowMode,
-        taskRevision: metadata.revision,
-        now: context.now
-      });
+    if (taskHeadFence === null) {
+      throw new Error("MANCODE_TASK_HEAD_FENCE_MISSING");
     }
     journal = await createTaskOperationJournal(context, {
-      type: "plan_revision",
-      action: taskRef.namespace === "shared" ? "shared_metadata_plan_mutation" : "local_workflow_mutation",
-      expectedRevisions: taskMutationExpectedRevisions(context, [
-        "plan",
-        "review",
-        "verification"
-      ]),
+      type: "scope_change_reclaim",
+      action: "task_complete_scope_change_child_merge",
+      expectedRevisions: scopeChangeExpectedRevisions(
+        context,
+        checkpointId,
+        activeClaims2,
+        successorClaimIds
+      ),
+      conditions: { completionGateSatisfied: true },
       recovery: {
         actions: [
-          ...planChanged ? [
-            createTaskAuthorityFileRecoveryAction({
-              stepId: "write-plan",
-              taskRef,
-              fileName: "plan.md",
-              beforeContent: context.task.plan?.content ?? null,
-              targetContent: plan
-            })
-          ] : [],
           createTaskAuthorityFileRecoveryAction({
-            stepId: "update-metadata",
+            stepId: "mark-task-operation-pending",
             taskRef,
             fileName: "metadata.json",
             beforeContent: serializeTaskAuthority(context.task.metadata),
-            targetContent: serializeTaskAuthority(metadata)
+            targetContent: serializeTaskAuthority(pendingMetadata)
           }),
-          ...planChanged ? [
-            createTaskAuthorityFileRecoveryAction({
-              stepId: "mark-review-verification-stale",
-              taskRef,
-              fileName: "review-ledger.json",
-              beforeContent: serializeTaskAuthority(context.task.review),
-              targetContent: serializeTaskAuthority(review)
-            }),
-            createTaskAuthorityFileRecoveryAction({
-              stepId: "mark-review-verification-stale",
-              taskRef,
-              fileName: "verification-ledger.json",
-              beforeContent: serializeTaskAuthority(
-                context.task.verification
-              ),
-              targetContent: serializeTaskAuthority(verification)
-            })
-          ] : [],
-          ...taskHeadFence === null ? [] : [
-            createTaskHeadFenceRecoveryAction({
-              stepId: "update-task-head-fence",
-              before: context.coordination.taskHeadFence,
-              fence: taskHeadFence
+          createCheckpointRecoveryAction({
+            stepId: "write-scope-changed-checkpoint",
+            before: null,
+            checkpoint
+          }),
+          ...pendingSuccessorClaims.map(
+            (claim) => createClaimRecoveryAction({
+              stepId: "create-pending-successor-claims",
+              before: null,
+              claim
             })
-          ]
+          ),
+          ...terminatedClaims.map((claim, index) => {
+            const before = activeClaims2[index];
+            if (before === void 0) {
+              throw new Error("MANCODE_CLAIM_SET_CHANGED");
+            }
+            return createClaimRecoveryAction({
+              stepId: "terminate-old-claims",
+              before,
+              claim
+            });
+          }),
+          createTaskAuthorityFileRecoveryAction({
+            stepId: "mark-review-verification-stale",
+            taskRef,
+            fileName: "review-ledger.json",
+            beforeContent: serializeTaskAuthority(context.task.review),
+            targetContent: serializeTaskAuthority(review)
+          }),
+          createTaskAuthorityFileRecoveryAction({
+            stepId: "mark-review-verification-stale",
+            taskRef,
+            fileName: "verification-ledger.json",
+            beforeContent: serializeTaskAuthority(context.task.verification),
+            targetContent: serializeTaskAuthority(verification)
+          }),
+          createTaskAuthorityFileRecoveryAction({
+            stepId: "update-metadata-scope",
+            taskRef,
+            fileName: "metadata.json",
+            beforeContent: serializeTaskAuthority(pendingMetadata),
+            targetContent: serializeTaskAuthority(metadata)
+          }),
+          ...activeSuccessorClaims.map((claim, index) => {
+            const before = pendingSuccessorClaims[index];
+            if (before === void 0) {
+              throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_COUNT_INVALID");
+            }
+            return createClaimRecoveryAction({
+              stepId: "activate-successor-claims",
+              before,
+              claim
+            });
+          }),
+          createTaskHeadFenceRecoveryAction({
+            stepId: "update-task-head-fence",
+            before: context.coordination.taskHeadFence,
+            fence: taskHeadFence
+          })
         ],
         noOpStepIds: [
-          ...planChanged ? [] : ["write-plan", "mark-review-verification-stale"],
-          ...taskHeadFence === null ? ["update-task-head-fence"] : []
+          ...pendingSuccessorClaims.length === 0 ? ["create-pending-successor-claims"] : [],
+          ...terminatedClaims.length === 0 ? ["terminate-old-claims"] : [],
+          ...activeSuccessorClaims.length === 0 ? ["activate-successor-claims"] : []
         ]
       }
     });
     journal = await advanceTaskOperation(context, journal, "validate", true);
-    journal = await advanceTaskOperation(context, journal, "write-plan", false);
-    if (planChanged) {
-      await writeTaskAuthorityFile(context, "plan.md", plan);
-    }
     journal = await advanceTaskOperation(
       context,
       journal,
-      "update-metadata",
+      "mark-task-operation-pending",
       false
     );
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
     await writeTaskAuthorityFile(
       context,
       "metadata.json",
-      `${JSON.stringify(metadata, null, 2)}
+      `${JSON.stringify(pendingMetadata, null, 2)}
 `
     );
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "write-scope-changed-checkpoint",
+      false
+    );
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+    await writeTaskCheckpoint(context, checkpoint);
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "create-pending-successor-claims",
+      false
+    );
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+    for (const claim of pendingSuccessorClaims) {
+      await createClaim(context.homeStore, claim);
+    }
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "terminate-old-claims",
+      false
+    );
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+    for (const [index, claim] of terminatedClaims.entries()) {
+      const previous = activeClaims2[index];
+      if (previous === void 0) {
+        throw new Error("MANCODE_CLAIM_SET_CHANGED");
+      }
+      await updateClaim(context.homeStore, claim, previous.revision);
+    }
     journal = await advanceTaskOperation(
       context,
       journal,
       "mark-review-verification-stale",
       false
     );
-    if (planChanged) {
-      await writeTaskAuthorityFile(
-        context,
-        "review-ledger.json",
-        `${JSON.stringify(review, null, 2)}
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+    await writeTaskAuthorityFile(
+      context,
+      "review-ledger.json",
+      `${JSON.stringify(review, null, 2)}
 `
-      );
-      await writeTaskAuthorityFile(
-        context,
-        "verification-ledger.json",
-        `${JSON.stringify(verification, null, 2)}
+    );
+    await writeTaskAuthorityFile(
+      context,
+      "verification-ledger.json",
+      `${JSON.stringify(verification, null, 2)}
 `
-      );
+    );
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "update-metadata-scope",
+      false
+    );
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+    await writeTaskAuthorityFile(
+      context,
+      "metadata.json",
+      `${JSON.stringify(metadata, null, 2)}
+`
+    );
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "activate-successor-claims",
+      false
+    );
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+    for (const claim of activeSuccessorClaims) {
+      await updateClaim(context.homeStore, claim, 1);
     }
     journal = await advanceTaskOperation(
       context,
@@ -41997,26 +42179,14 @@ async function reviseV3Plan(input) {
       "update-task-head-fence",
       false
     );
-    if (taskHeadFence !== null) {
-      await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-      await replaceTaskHeadFence(context.homeStore, taskHeadFence);
-    }
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+    await replaceTaskHeadFence(context.homeStore, taskHeadFence);
     const operation = await commitTaskOperation(context, journal);
-    if (planDecision === "plan_only") {
-      try {
-        await reconcileProjectionIntents(
-          context.projectRoot,
-          context.operationId,
-          context.now
-        );
-      } catch {
-      }
-    }
     return {
       metadata,
-      review,
-      verification,
-      planDigest,
+      checkpoint,
+      terminatedClaims,
+      successorClaims: activeSuccessorClaims,
       aggregate,
       taskHeadFence,
       operation
@@ -42033,65 +42203,665 @@ async function reviseV3Plan(input) {
     await context.release();
   }
 }
-function requirePlan(value) {
-  if (typeof value !== "string" || !value.trim() || value.includes("\0")) {
-    throw new Error("MANCODE_PLAN_CONTENT_REQUIRED");
+async function openScopeChangeContext(input) {
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const runtime = await readProjectRuntimeContext(input.projectRoot);
+    const store = new V3ContextStore(input.projectRoot);
+    const homeStore = resolveTaskEntityHomeStore(
+      runtime.entityHomeStoreContext,
+      input.taskRef
+    );
+    const preflight = await store.readCoordinationSnapshot(
+      input.taskRef,
+      homeStore
+    );
+    const preflightClaims = activeClaims(preflight.claims);
+    const preflightSuccessors = claimsWithinScope(preflightClaims, input.scope);
+    const preflightSuccessorIds = resolveSuccessorClaimIds2(
+      preflightSuccessors,
+      input.successorClaimIds,
+      input.operationId,
+      input.now.toISOString()
+    );
+    const context = await openV3TaskOperation({
+      projectRoot: input.projectRoot,
+      taskRef: input.taskRef,
+      sessionId: input.sessionId,
+      expectedTaskRevision: input.expectedTaskRevision,
+      operationId: input.operationId,
+      extraEntityLocks: [
+        `checkpoint:${input.checkpointId}`,
+        taskHeadEntityKey(input.taskRef),
+        ...preflightClaims.map((claim) => `claim:${claim.claimId}`),
+        ...preflightSuccessorIds.map((claimId) => `claim:${claimId}`)
+      ],
+      now: input.now
+    });
+    const lockedClaims = activeClaims(context.coordination.claims);
+    if (sameClaimIdSet(preflightClaims, lockedClaims)) {
+      const successors = claimsWithinScope(lockedClaims, input.scope);
+      const successorIds = resolveSuccessorClaimIds2(
+        successors,
+        input.successorClaimIds,
+        input.operationId,
+        input.now.toISOString()
+      );
+      return {
+        context,
+        activeClaims: lockedClaims,
+        successorPredecessors: successors,
+        successorClaimIds: successorIds
+      };
+    }
+    await context.release();
   }
-  return value;
+  throw new Error("MANCODE_CLAIM_SET_CHANGED");
 }
-function parsePlanDecision(value) {
-  if (value === void 0) return null;
-  if (value !== "plan_only" && value !== "governed_execution") {
-    throw new Error("MANCODE_PLAN_DECISION_INVALID");
+function assertScopeChangeEligible(context, scope) {
+  const metadata = context.task.metadata;
+  if (context.project.config.transport.mode !== "local") {
+    throw new Error("MANCODE_GIT_REF_TRANSPORT_NOT_IMPLEMENTED");
   }
-  return value;
-}
-function assertPlanRevisionEligible(metadata, requirements) {
-  if (metadata.workflowMode !== "man" && metadata.workflowMode !== "manteam") {
-    throw new Error("MANCODE_PLAN_WORKFLOW_MODE_INVALID");
+  if (metadata.workflowMode !== "manteam") {
+    throw new Error("MANCODE_SCOPE_CHANGE_WORKFLOW_MODE_INVALID");
   }
   if (metadata.status !== "in_progress") {
-    throw new Error("MANCODE_PLAN_WORKFLOW_NOT_ACTIVE");
+    throw new Error("MANCODE_SCOPE_CHANGE_WORKFLOW_NOT_ACTIVE");
   }
-  if (metadata.currentStep < 2 || metadata.currentStep > 4) {
-    throw new Error("MANCODE_PLAN_STEP_INVALID");
+  if (metadata.ownerActorId !== context.session.actorId) {
+    throw new Error("MANCODE_TASK_OWNER_REQUIRED");
   }
-  if (metadata.governance.planDecision !== null || metadata.governance.requirementsStatus !== "ready" || metadata.governance.requirementsDigest !== requirements.contentDigest || requirements.status !== "confirmed" || !requirementsAreReady(requirements)) {
-    throw new Error("MANCODE_PLAN_REQUIREMENTS_OR_DECISION_INVALID");
+  if (metadata.parent !== null) {
+    throw new Error("MANCODE_PARENT_SCOPE_INHERITANCE_REQUIRED");
+  }
+  if (metadata.implementationScope.digest === scope.digest) {
+    throw new Error("MANCODE_SCOPE_CHANGE_NOOP");
   }
 }
-function updateMetadata(previous, requirements, review, verification, planChanged, planDecision, operationId, updatedAt) {
-  const status2 = planDecision === "plan_only" ? "planned" : "in_progress";
-  const currentStep = planDecision === "governed_execution" ? 5 : 4;
-  const next = parseWorkflowMetadata({
-    ...previous,
-    status: status2,
-    currentStep,
-    revision: previous.revision + 1,
-    transitionState: "stable",
-    lastOperationId: operationId,
-    governance: {
-      ...previous.governance,
-      requirementsStatus: "ready",
-      requirementsDigest: requirements.contentDigest,
-      planVersion: previous.governance.planVersion + (planChanged ? 1 : 0),
-      planDecision,
-      reviewStatus: planChanged ? "stale" : previous.governance.reviewStatus,
-      reviewLedgerDigest: review.contentDigest,
-      verificationStatus: planChanged ? "stale" : previous.governance.verificationStatus,
-      verificationLedgerDigest: verification.contentDigest
-    },
-    updatedAt
-  });
-  assertWorkflowMetadataTransition(previous, next, "ordinary");
-  return next;
-}
-
-// src/context/reframe.ts
-async function reframeV3Workflow(input) {
-  const taskRef = parseTaskRefValue(input.taskRef);
-  assertUlid(input.checkpointId, "reframe checkpointId");
-  const now = input.now ?? /* @__PURE__ */ new Date();
+function assertClaimsFreshForScopeChange(context, claims) {
+  const codeHead = requireCodeHead3(context);
+  for (const claim of claims) {
+    if (claim.authority.mode !== "local") {
+      throw new Error("MANCODE_OPERATION_REPAIR_REQUIRED");
+    }
+    const validity = deriveClaimValidity(claim, {
+      taskRef: context.taskRef,
+      taskRevision: context.task.metadata.revision,
+      implementationScopeDigest: context.task.metadata.implementationScope.digest,
+      ownershipEpoch: context.task.metadata.ownershipEpoch,
+      codeRefHead: codeHead,
+      now: context.now,
+      transportFreshness: "fresh"
+    });
+    if (validity !== "fresh") {
+      throw new Error("MANCODE_CLAIM_REVALIDATION_REQUIRED");
+    }
+  }
+}
+function normalizeImplementationScope(value) {
+  assertRecord(value, "workflow scope change");
+  assertKnownKeys(
+    value,
+    ["include", "exclude", "modules"],
+    "workflow scope change"
+  );
+  const scope = {
+    source: "explicit",
+    include: normalizeScopeValues(value.include, "include", true),
+    exclude: normalizeScopeValues(value.exclude, "exclude", true),
+    modules: normalizeScopeValues(value.modules, "modules", false)
+  };
+  const included = new Set(scope.include);
+  if (scope.exclude.some((item) => included.has(item))) {
+    throw new Error("MANCODE_SCOPE_INCLUDE_EXCLUDE_CONFLICT");
+  }
+  return { ...scope, digest: digestCanonicalJson(scope) };
+}
+function normalizeScopeValues(value, label, paths) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.trim())) {
+    throw new Error(`MANCODE_SCOPE_${label.toUpperCase()}_INVALID`);
+  }
+  const values = value.map((item) => item.trim());
+  const normalized = sortUtf8StringSet(values);
+  if (normalized.length !== values.length) {
+    throw new Error(`MANCODE_SCOPE_${label.toUpperCase()}_DUPLICATE`);
+  }
+  for (const item of normalized) {
+    assertSharedTextSafe(item, `workflow scope ${label}`);
+    if (paths) assertScopePath(item);
+  }
+  return normalized;
+}
+function assertScopePath(value) {
+  if (value.startsWith("/") || value.startsWith("~") || /^[A-Za-z]:/.test(value) || value.includes("\\") || value.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new Error("MANCODE_SCOPE_PATH_INVALID");
+  }
+}
+function markScopeChangeOperationPending(previous, operationId, updatedAt) {
+  const next = parseWorkflowMetadata({
+    ...previous,
+    revision: previous.revision + 1,
+    transitionState: "operation_pending",
+    lastOperationId: operationId,
+    updatedAt
+  });
+  assertWorkflowMetadataTransition(previous, next, "ordinary");
+  return next;
+}
+function completeScopeChangeMetadata(previous, scope, checkpoint, reviewLedgerDigest2, verificationLedgerDigest2, operationId, updatedAt) {
+  const next = parseWorkflowMetadata({
+    ...previous,
+    revision: previous.revision + 1,
+    transitionState: "stable",
+    implementationScope: scope,
+    governance: {
+      ...previous.governance,
+      planVersion: previous.governance.planVersion + 1,
+      reviewStatus: "stale",
+      reviewLedgerDigest: reviewLedgerDigest2,
+      verificationStatus: "stale",
+      verificationLedgerDigest: verificationLedgerDigest2
+    },
+    latestCheckpointRef: {
+      taskRef: checkpoint.taskRef,
+      kind: "checkpoint",
+      artifactId: checkpoint.checkpointId
+    },
+    lastOperationId: operationId,
+    updatedAt
+  });
+  assertWorkflowMetadataTransition(previous, next, "ordinary");
+  return next;
+}
+function buildScopeChangedCheckpoint(context, pendingMetadata, checkpointId, summary, nextAction, branch, planVersion, reviewLedgerDigest2, verificationLedgerDigest2, timestamp4) {
+  return parseCheckpoint({
+    schemaVersion: 1,
+    checkpointId,
+    operationId: context.operationId,
+    taskRef: context.taskRef,
+    taskRevision: pendingMetadata.revision,
+    ownershipEpochAtOffer: pendingMetadata.ownershipEpoch,
+    kind: "scope_changed",
+    git: {
+      branch,
+      head: requireCodeHead3(context),
+      base: pendingMetadata.base?.head ?? null
+    },
+    summary: summary ?? "Changed the implementation scope and replaced affected coordination claims.",
+    governance: {
+      requirementsDigest: context.task.requirements.contentDigest,
+      planVersion,
+      reviewLedgerDigest: reviewLedgerDigest2,
+      verificationLedgerDigest: verificationLedgerDigest2
+    },
+    nextAction: nextAction ?? "Re-read the updated scope and continue only with the successor claim.",
+    createdBy: {
+      actorId: context.session.actorId,
+      client: context.session.client
+    },
+    createdAt: timestamp4
+  });
+}
+function buildPendingSuccessorClaims2(predecessors, successorClaimIds, metadata, branch, codeHead, operationId, timestamp4, capabilities) {
+  return predecessors.map((previous, index) => {
+    const claimId = successorClaimIds[index];
+    if (claimId === void 0) {
+      throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_COUNT_INVALID");
+    }
+    return parseClaim({
+      ...previous,
+      claimId,
+      authority: { mode: "local", remoteRevision: null },
+      taskRevisionAtAcquire: metadata.revision,
+      lastValidatedTaskRevision: metadata.revision,
+      implementationScopeDigest: metadata.implementationScope.digest,
+      ownershipEpochAtAcquire: metadata.ownershipEpoch,
+      state: "pending",
+      revision: 1,
+      codeRefAtAcquire: { branch, head: codeHead },
+      lastValidatedCodeRef: { branch, head: codeHead },
+      acquisitionEnforcement: capabilities.claimAcquisition,
+      writeGuard: capabilities.writeGuard,
+      predecessorClaimId: previous.claimId,
+      successorClaimId: null,
+      lastOperationId: operationId,
+      createdAt: timestamp4,
+      updatedAt: timestamp4
+    });
+  });
+}
+function terminateClaimForScopeChange(previous, successorClaimId, operationId, timestamp4) {
+  const next = parseClaim({
+    ...previous,
+    state: successorClaimId === null ? "released" : "transferred",
+    revision: previous.revision + 1,
+    successorClaimId,
+    lastOperationId: operationId,
+    updatedAt: timestamp4
+  });
+  assertClaimTransition(previous, next);
+  return next;
+}
+function activateSuccessorClaim3(previous, operationId, timestamp4) {
+  const next = parseClaim({
+    ...previous,
+    state: "active",
+    revision: previous.revision + 1,
+    lastOperationId: operationId,
+    updatedAt: timestamp4
+  });
+  assertClaimTransition(previous, next);
+  return next;
+}
+function scopeChangeExpectedRevisions(context, checkpointId, predecessors, successorClaimIds) {
+  const expected = {
+    [taskEntityKey(context.taskRef)]: context.task.metadata.revision,
+    [`review:${context.taskRef.taskId}`]: context.task.review.revision,
+    [`verification:${context.taskRef.taskId}`]: context.task.verification.revision,
+    [`checkpoint:${checkpointId}`]: 0
+  };
+  for (const claim of predecessors) {
+    expected[`claim:${claim.claimId}`] = claim.revision;
+  }
+  for (const claimId of successorClaimIds) {
+    expected[`claim:${claimId}`] = 0;
+  }
+  const fence = context.coordination.taskHeadFence;
+  if (fence === null) throw new Error("MANCODE_TASK_HEAD_FENCE_MISSING");
+  expected[taskHeadEntityKey(context.taskRef)] = fence.fenceRevision;
+  return expected;
+}
+function activeClaims(claims) {
+  return claims.filter((claim) => claim.state === "active").sort((left, right) => compareUtf815(left.claimId, right.claimId));
+}
+function claimsWithinScope(claims, scope) {
+  return claims.filter(
+    (claim) => evaluateClaimScopeSubset(claim.scope, {
+      source: scope.source,
+      include: scope.include,
+      exclude: scope.exclude,
+      modules: scope.modules
+    }).allowed
+  );
+}
+function resolveSuccessorClaimIds2(predecessors, requested, operationId, timestamp4) {
+  const ids = requested ?? predecessors.map(
+    (claim) => scopeSuccessorClaimId(operationId, claim.claimId, timestamp4)
+  );
+  if (ids.length !== predecessors.length) {
+    throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_COUNT_INVALID");
+  }
+  const predecessorIds = new Set(predecessors.map((claim) => claim.claimId));
+  const seen = /* @__PURE__ */ new Set();
+  for (const claimId of ids) {
+    assertUlid(claimId, "scope successor claimId");
+    if (predecessorIds.has(claimId) || seen.has(claimId)) {
+      throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_INVALID");
+    }
+    seen.add(claimId);
+  }
+  return ids;
+}
+function scopeSuccessorClaimId(operationId, predecessorClaimId, timestamp4) {
+  assertUlid(operationId, "scope change operationId");
+  assertUlid(predecessorClaimId, "scope predecessor claimId");
+  const milliseconds = Date.parse(timestamp4);
+  if (Number.isNaN(milliseconds)) {
+    throw new Error("MANCODE_SCOPE_TIMESTAMP_INVALID");
+  }
+  const entropy = createHash11("sha256").update(`scope-change:${operationId}:${predecessorClaimId}`, "utf8").digest().subarray(0, 10);
+  return createUlid(milliseconds, entropy);
+}
+function requireCodeHead3(context) {
+  if (context.codeHead === null) {
+    throw new Error("MANCODE_TASK_HEAD_CODE_REF_UNAVAILABLE");
+  }
+  return context.codeHead;
+}
+function sameClaimIdSet(left, right) {
+  return left.length === right.length && left.every((claim, index) => claim.claimId === right[index]?.claimId);
+}
+function compareUtf815(left, right) {
+  return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
+}
+
+// src/context/plan-revision.ts
+async function reviseV3Plan(input) {
+  const taskRef = parseTaskRefValue(input.taskRef);
+  const plan = requirePlan(input.plan);
+  const planDecision = parsePlanDecision(input.planDecision);
+  const submittedScope = input.implementationScope === void 0 ? null : normalizeImplementationScope(input.implementationScope);
+  if (taskRef.namespace === "shared") {
+    assertSharedTextSafe(plan, "plan");
+  }
+  const context = await openV3TaskOperation({
+    projectRoot: input.projectRoot,
+    taskRef,
+    sessionId: input.sessionId,
+    expectedTaskRevision: input.expectedTaskRevision,
+    operationId: input.operationId,
+    extraEntityLocks: taskRef.namespace === "shared" ? [taskHeadEntityKey(taskRef)] : [],
+    now: input.now
+  });
+  let journal = null;
+  try {
+    const planChanged = context.task.plan?.content !== plan;
+    const executionScopeBinding = assertExecutionScopeBindingAttempt({
+      metadata: context.task.metadata,
+      currentPlan: context.task.plan?.content ?? null,
+      submittedPlan: plan,
+      submittedScope,
+      planDecisionSupplied: input.planDecision !== void 0,
+      sessionActorId: context.session.actorId
+    });
+    assertPlanRevisionEligible(
+      context.task.metadata,
+      context.task.requirements,
+      executionScopeBinding
+    );
+    const implementationScope = submittedScope ?? context.task.metadata.implementationScope;
+    const scopeChanged = submittedScope !== null && submittedScope.digest !== context.task.metadata.implementationScope.digest;
+    if (planDecision === "governed_execution") {
+      assertExecutableImplementationScope(implementationScope);
+    }
+    if (executionScopeBinding) {
+      assertExecutableImplementationScope(implementationScope);
+    }
+    if (context.task.metadata.workflowMode === "manteam" && planDecision === "governed_execution") {
+      assertManteamPlanContent(plan);
+    }
+    if (context.task.plan?.content === plan && planDecision === null && !scopeChanged) {
+      throw new Error("MANCODE_PLAN_CONTENT_UNCHANGED");
+    }
+    const authorityChanged = planChanged || scopeChanged;
+    const timestamp4 = context.now.toISOString();
+    const planDigest = planChanged ? digestCanonicalJson({
+      artifactRef: { taskRef, kind: "plan" },
+      content: plan
+    }) : context.task.plan?.digest;
+    if (planDigest === void 0) {
+      throw new Error("MANCODE_PLAN_FILE_REQUIRED");
+    }
+    const review = authorityChanged ? markTaskReviewStale(context.task.review, context.operationId, timestamp4) : context.task.review;
+    const verification = authorityChanged ? markTaskVerificationStale(
+      context.task.verification,
+      context.operationId,
+      timestamp4
+    ) : context.task.verification;
+    const metadata = updateMetadata(
+      context.task.metadata,
+      context.task.requirements,
+      review,
+      verification,
+      implementationScope,
+      authorityChanged,
+      planDecision,
+      executionScopeBinding,
+      context.operationId,
+      timestamp4
+    );
+    const aggregate = buildTaskAggregateManifest({
+      metadata,
+      requirements: context.task.requirements,
+      review,
+      verification,
+      planDigest,
+      latestCheckpoint: context.task.latestCheckpoint
+    });
+    const taskHeadFence = nextTaskHeadFence(context, aggregate, timestamp4);
+    if (planDecision === "plan_only") {
+      await enqueueSessionPointerProjection(context.projectRoot, {
+        operationId: context.operationId,
+        action: "clear",
+        sessionId: context.session.sessionId,
+        expectedPreviousTaskRef: context.session.activeTaskRef,
+        taskRef,
+        workflowMode: metadata.workflowMode,
+        taskRevision: metadata.revision,
+        now: context.now
+      });
+    }
+    journal = await createTaskOperationJournal(context, {
+      type: "plan_revision",
+      action: taskRef.namespace === "shared" ? "shared_metadata_plan_mutation" : "local_workflow_mutation",
+      expectedRevisions: taskMutationExpectedRevisions(context, [
+        "plan",
+        "review",
+        "verification"
+      ]),
+      recovery: {
+        actions: [
+          ...planChanged ? [
+            createTaskAuthorityFileRecoveryAction({
+              stepId: "write-plan",
+              taskRef,
+              fileName: "plan.md",
+              beforeContent: context.task.plan?.content ?? null,
+              targetContent: plan
+            })
+          ] : [],
+          createTaskAuthorityFileRecoveryAction({
+            stepId: "update-metadata",
+            taskRef,
+            fileName: "metadata.json",
+            beforeContent: serializeTaskAuthority(context.task.metadata),
+            targetContent: serializeTaskAuthority(metadata)
+          }),
+          ...authorityChanged ? [
+            createTaskAuthorityFileRecoveryAction({
+              stepId: "mark-review-verification-stale",
+              taskRef,
+              fileName: "review-ledger.json",
+              beforeContent: serializeTaskAuthority(context.task.review),
+              targetContent: serializeTaskAuthority(review)
+            }),
+            createTaskAuthorityFileRecoveryAction({
+              stepId: "mark-review-verification-stale",
+              taskRef,
+              fileName: "verification-ledger.json",
+              beforeContent: serializeTaskAuthority(
+                context.task.verification
+              ),
+              targetContent: serializeTaskAuthority(verification)
+            })
+          ] : [],
+          ...taskHeadFence === null ? [] : [
+            createTaskHeadFenceRecoveryAction({
+              stepId: "update-task-head-fence",
+              before: context.coordination.taskHeadFence,
+              fence: taskHeadFence
+            })
+          ]
+        ],
+        noOpStepIds: [
+          ...planChanged ? [] : ["write-plan"],
+          ...authorityChanged ? [] : ["mark-review-verification-stale"],
+          ...taskHeadFence === null ? ["update-task-head-fence"] : []
+        ]
+      }
+    });
+    journal = await advanceTaskOperation(context, journal, "validate", true);
+    journal = await advanceTaskOperation(context, journal, "write-plan", false);
+    if (planChanged) {
+      await writeTaskAuthorityFile(context, "plan.md", plan);
+    }
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "update-metadata",
+      false
+    );
+    await writeTaskAuthorityFile(
+      context,
+      "metadata.json",
+      `${JSON.stringify(metadata, null, 2)}
+`
+    );
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "mark-review-verification-stale",
+      false
+    );
+    if (authorityChanged) {
+      await writeTaskAuthorityFile(
+        context,
+        "review-ledger.json",
+        `${JSON.stringify(review, null, 2)}
+`
+      );
+      await writeTaskAuthorityFile(
+        context,
+        "verification-ledger.json",
+        `${JSON.stringify(verification, null, 2)}
+`
+      );
+    }
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "update-task-head-fence",
+      false
+    );
+    if (taskHeadFence !== null) {
+      await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+      await replaceTaskHeadFence(context.homeStore, taskHeadFence);
+    }
+    const operation = await commitTaskOperation(context, journal);
+    if (planDecision === "plan_only") {
+      try {
+        await reconcileProjectionIntents(
+          context.projectRoot,
+          context.operationId,
+          context.now
+        );
+      } catch {
+      }
+    }
+    return {
+      metadata,
+      review,
+      verification,
+      planDigest,
+      aggregate,
+      taskHeadFence,
+      operation
+    };
+  } catch (error) {
+    if (journal !== null) {
+      try {
+        await handleTaskOperationFailure(context, journal);
+      } catch {
+      }
+    }
+    throw error;
+  } finally {
+    await context.release();
+  }
+}
+function requirePlan(value) {
+  if (typeof value !== "string" || !value.trim() || value.includes("\0")) {
+    throw new Error("MANCODE_PLAN_CONTENT_REQUIRED");
+  }
+  return value;
+}
+function parsePlanDecision(value) {
+  if (value === void 0) return null;
+  if (value !== "plan_only" && value !== "governed_execution") {
+    throw new Error("MANCODE_PLAN_DECISION_INVALID");
+  }
+  return value;
+}
+function assertPlanRevisionEligible(metadata, requirements, executionScopeBinding) {
+  if (executionScopeBinding) {
+    assertReadyPlanRequirements(metadata, requirements);
+    return;
+  }
+  if (metadata.workflowMode !== "man" && metadata.workflowMode !== "manteam") {
+    throw new Error("MANCODE_PLAN_WORKFLOW_MODE_INVALID");
+  }
+  if (metadata.status !== "in_progress") {
+    throw new Error("MANCODE_PLAN_WORKFLOW_NOT_ACTIVE");
+  }
+  if (metadata.currentStep < 2 || metadata.currentStep > 4) {
+    throw new Error("MANCODE_PLAN_STEP_INVALID");
+  }
+  if (metadata.governance.planDecision !== null) {
+    throw new Error("MANCODE_PLAN_REQUIREMENTS_OR_DECISION_INVALID");
+  }
+  assertReadyPlanRequirements(metadata, requirements);
+}
+function assertReadyPlanRequirements(metadata, requirements) {
+  if (metadata.governance.requirementsStatus !== "ready" || metadata.governance.requirementsDigest !== requirements.contentDigest || requirements.status !== "confirmed" || !requirementsAreReady(requirements)) {
+    throw new Error("MANCODE_PLAN_REQUIREMENTS_OR_DECISION_INVALID");
+  }
+  assertRequirementsScopeConsistent(requirements);
+}
+function assertExecutionScopeBindingAttempt(input) {
+  const decision = input.metadata.governance.planDecision;
+  if (decision !== "governed_execution" && decision !== "solo_handoff") {
+    return false;
+  }
+  if (input.metadata.workflowMode !== "man" || input.metadata.coordination !== "single" || input.metadata.taskRef.namespace !== "local") {
+    throw new Error("MANCODE_EXECUTION_SCOPE_BINDING_LOCAL_MAN_ONLY");
+  }
+  const activeExecution = decision === "governed_execution" && input.metadata.status === "in_progress" && input.metadata.currentStep >= 5 || decision === "solo_handoff" && input.metadata.status === "planned" && input.metadata.currentStep === 4 && input.metadata.soloExecution?.state === "active";
+  if (!activeExecution) {
+    throw new Error("MANCODE_EXECUTION_SCOPE_BINDING_NOT_ACTIVE");
+  }
+  if (input.metadata.ownerActorId !== input.sessionActorId) {
+    throw new Error("MANCODE_TASK_OWNER_REQUIRED");
+  }
+  if (implementationScopeIsExecutable(input.metadata.implementationScope)) {
+    throw new Error("MANCODE_EXECUTION_SCOPE_ALREADY_BOUND");
+  }
+  if (input.submittedScope === null) {
+    throw new Error("MANCODE_IMPLEMENTATION_SCOPE_REQUIRED");
+  }
+  if (input.currentPlan === null || input.currentPlan !== input.submittedPlan) {
+    throw new Error("MANCODE_EXECUTION_SCOPE_BINDING_PLAN_CHANGED");
+  }
+  if (input.planDecisionSupplied) {
+    throw new Error("MANCODE_EXECUTION_SCOPE_BINDING_DECISION_INVALID");
+  }
+  assertExecutableImplementationScope(input.submittedScope);
+  return true;
+}
+function updateMetadata(previous, requirements, review, verification, implementationScope, authorityChanged, planDecision, executionScopeBinding, operationId, updatedAt) {
+  const status2 = executionScopeBinding ? previous.status : planDecision === "plan_only" ? "planned" : "in_progress";
+  const currentStep = executionScopeBinding ? previous.currentStep : planDecision === "governed_execution" ? 5 : 4;
+  const nextPlanVersion = previous.governance.planVersion + (authorityChanged ? 1 : 0);
+  const next = parseWorkflowMetadata({
+    ...previous,
+    status: status2,
+    currentStep,
+    revision: previous.revision + 1,
+    transitionState: "stable",
+    lastOperationId: operationId,
+    implementationScope,
+    governance: {
+      ...previous.governance,
+      requirementsStatus: "ready",
+      requirementsDigest: requirements.contentDigest,
+      planVersion: nextPlanVersion,
+      planDecision: executionScopeBinding ? previous.governance.planDecision : planDecision,
+      reviewStatus: authorityChanged ? "stale" : previous.governance.reviewStatus,
+      reviewLedgerDigest: review.contentDigest,
+      verificationStatus: authorityChanged ? "stale" : previous.governance.verificationStatus,
+      verificationLedgerDigest: verification.contentDigest
+    },
+    soloExecution: executionScopeBinding && previous.soloExecution !== null ? { ...previous.soloExecution, planVersion: nextPlanVersion } : previous.soloExecution,
+    updatedAt
+  });
+  assertWorkflowMetadataTransition(previous, next, "ordinary");
+  return next;
+}
+
+// src/context/reframe.ts
+async function reframeV3Workflow(input) {
+  const taskRef = parseTaskRefValue(input.taskRef);
+  assertUlid(input.checkpointId, "reframe checkpointId");
+  const now = input.now ?? /* @__PURE__ */ new Date();
   const operationId = input.operationId ?? createUlid(now.getTime());
   assertUlid(operationId, "reframe operationId");
   const opened = await openReframeContext({
@@ -42658,6 +43428,9 @@ async function writeV3Requirements(input, action) {
   if (action === "finalize" && submitted.status !== "confirmed") {
     throw new Error("MANCODE_REQUIREMENTS_CONFIRMATION_REQUIRED");
   }
+  if (action === "finalize") {
+    assertRequirementsScopeConsistent(submitted);
+  }
   if (action === "draft" && submitted.status !== "draft") {
     throw new Error("MANCODE_REQUIREMENTS_DRAFT_REQUIRED");
   }
@@ -43128,580 +43901,6 @@ function reviewAuthorization(context, next) {
   };
 }
 
-// src/context/scope-change.ts
-import { createHash as createHash11 } from "crypto";
-async function changeV3WorkflowScope(input) {
-  const taskRef = parseTaskRefValue(input.taskRef);
-  if (taskRef.namespace !== "shared") {
-    throw new Error("MANCODE_SCOPE_CHANGE_REQUIRES_SHARED_TASK");
-  }
-  const scope = normalizeImplementationScope(input.scope);
-  const now = input.now ?? /* @__PURE__ */ new Date();
-  const timestamp4 = now.toISOString();
-  const checkpointId = input.checkpointId ?? createUlid(now.getTime());
-  const operationId = input.operationId ?? createUlid(now.getTime());
-  assertUlid(checkpointId, "scope change checkpointId");
-  assertUlid(operationId, "scope change operationId");
-  const opened = await openScopeChangeContext({
-    projectRoot: input.projectRoot,
-    taskRef,
-    sessionId: input.sessionId,
-    expectedTaskRevision: input.expectedTaskRevision,
-    scope,
-    checkpointId,
-    successorClaimIds: input.successorClaimIds,
-    operationId,
-    now
-  });
-  const { context, activeClaims: activeClaims2, successorClaimIds, successorPredecessors } = opened;
-  let journal = null;
-  try {
-    assertScopeChangeEligible(context, scope);
-    assertClaimsFreshForScopeChange(context, activeClaims2);
-    const pendingMetadata = markScopeChangeOperationPending(
-      context.task.metadata,
-      context.operationId,
-      timestamp4
-    );
-    const branch = await readCheckoutBranch(context.projectRoot) ?? "HEAD";
-    const checkpoint = buildScopeChangedCheckpoint(
-      context,
-      pendingMetadata,
-      checkpointId,
-      input.checkpointSummary,
-      input.checkpointNextAction,
-      branch,
-      timestamp4
-    );
-    const metadata = completeScopeChangeMetadata(
-      pendingMetadata,
-      scope,
-      checkpoint,
-      context.operationId,
-      timestamp4
-    );
-    const pendingSuccessorClaims = buildPendingSuccessorClaims2(
-      successorPredecessors,
-      successorClaimIds,
-      metadata,
-      branch,
-      requireCodeHead3(context),
-      context.operationId,
-      timestamp4,
-      capabilitiesFromProjectConfig(context.project.config)
-    );
-    const successorByPredecessor = new Map(
-      successorPredecessors.map((claim, index) => {
-        const successorClaimId = successorClaimIds[index];
-        if (successorClaimId === void 0) {
-          throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_COUNT_INVALID");
-        }
-        return [claim.claimId, successorClaimId];
-      })
-    );
-    const terminatedClaims = activeClaims2.map(
-      (claim) => terminateClaimForScopeChange(
-        claim,
-        successorByPredecessor.get(claim.claimId) ?? null,
-        context.operationId,
-        timestamp4
-      )
-    );
-    const activeSuccessorClaims = pendingSuccessorClaims.map(
-      (claim) => activateSuccessorClaim3(claim, context.operationId, timestamp4)
-    );
-    const aggregate = buildTaskAggregateManifest({
-      metadata,
-      requirements: context.task.requirements,
-      review: context.task.review,
-      verification: context.task.verification,
-      planDigest: context.task.plan?.digest ?? null,
-      latestCheckpoint: checkpoint
-    });
-    const taskHeadFence = nextTaskHeadFence(context, aggregate, timestamp4);
-    if (taskHeadFence === null) {
-      throw new Error("MANCODE_TASK_HEAD_FENCE_MISSING");
-    }
-    journal = await createTaskOperationJournal(context, {
-      type: "scope_change_reclaim",
-      action: "task_complete_scope_change_child_merge",
-      expectedRevisions: scopeChangeExpectedRevisions(
-        context,
-        checkpointId,
-        activeClaims2,
-        successorClaimIds
-      ),
-      conditions: { completionGateSatisfied: true },
-      recovery: {
-        actions: [
-          createTaskAuthorityFileRecoveryAction({
-            stepId: "mark-task-operation-pending",
-            taskRef,
-            fileName: "metadata.json",
-            beforeContent: serializeTaskAuthority(context.task.metadata),
-            targetContent: serializeTaskAuthority(pendingMetadata)
-          }),
-          createCheckpointRecoveryAction({
-            stepId: "write-scope-changed-checkpoint",
-            before: null,
-            checkpoint
-          }),
-          ...pendingSuccessorClaims.map(
-            (claim) => createClaimRecoveryAction({
-              stepId: "create-pending-successor-claims",
-              before: null,
-              claim
-            })
-          ),
-          ...terminatedClaims.map((claim, index) => {
-            const before = activeClaims2[index];
-            if (before === void 0) {
-              throw new Error("MANCODE_CLAIM_SET_CHANGED");
-            }
-            return createClaimRecoveryAction({
-              stepId: "terminate-old-claims",
-              before,
-              claim
-            });
-          }),
-          createTaskAuthorityFileRecoveryAction({
-            stepId: "update-metadata-scope",
-            taskRef,
-            fileName: "metadata.json",
-            beforeContent: serializeTaskAuthority(pendingMetadata),
-            targetContent: serializeTaskAuthority(metadata)
-          }),
-          ...activeSuccessorClaims.map((claim, index) => {
-            const before = pendingSuccessorClaims[index];
-            if (before === void 0) {
-              throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_COUNT_INVALID");
-            }
-            return createClaimRecoveryAction({
-              stepId: "activate-successor-claims",
-              before,
-              claim
-            });
-          }),
-          createTaskHeadFenceRecoveryAction({
-            stepId: "update-task-head-fence",
-            before: context.coordination.taskHeadFence,
-            fence: taskHeadFence
-          })
-        ],
-        noOpStepIds: [
-          ...pendingSuccessorClaims.length === 0 ? ["create-pending-successor-claims"] : [],
-          ...terminatedClaims.length === 0 ? ["terminate-old-claims"] : [],
-          ...activeSuccessorClaims.length === 0 ? ["activate-successor-claims"] : []
-        ]
-      }
-    });
-    journal = await advanceTaskOperation(context, journal, "validate", true);
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "mark-task-operation-pending",
-      false
-    );
-    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-    await writeTaskAuthorityFile(
-      context,
-      "metadata.json",
-      `${JSON.stringify(pendingMetadata, null, 2)}
-`
-    );
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "write-scope-changed-checkpoint",
-      false
-    );
-    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-    await writeTaskCheckpoint(context, checkpoint);
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "create-pending-successor-claims",
-      false
-    );
-    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-    for (const claim of pendingSuccessorClaims) {
-      await createClaim(context.homeStore, claim);
-    }
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "terminate-old-claims",
-      false
-    );
-    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-    for (const [index, claim] of terminatedClaims.entries()) {
-      const previous = activeClaims2[index];
-      if (previous === void 0) {
-        throw new Error("MANCODE_CLAIM_SET_CHANGED");
-      }
-      await updateClaim(context.homeStore, claim, previous.revision);
-    }
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "update-metadata-scope",
-      false
-    );
-    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-    await writeTaskAuthorityFile(
-      context,
-      "metadata.json",
-      `${JSON.stringify(metadata, null, 2)}
-`
-    );
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "activate-successor-claims",
-      false
-    );
-    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-    for (const claim of activeSuccessorClaims) {
-      await updateClaim(context.homeStore, claim, 1);
-    }
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "update-task-head-fence",
-      false
-    );
-    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-    await replaceTaskHeadFence(context.homeStore, taskHeadFence);
-    const operation = await commitTaskOperation(context, journal);
-    return {
-      metadata,
-      checkpoint,
-      terminatedClaims,
-      successorClaims: activeSuccessorClaims,
-      aggregate,
-      taskHeadFence,
-      operation
-    };
-  } catch (error) {
-    if (journal !== null) {
-      try {
-        await handleTaskOperationFailure(context, journal);
-      } catch {
-      }
-    }
-    throw error;
-  } finally {
-    await context.release();
-  }
-}
-async function openScopeChangeContext(input) {
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    const runtime = await readProjectRuntimeContext(input.projectRoot);
-    const store = new V3ContextStore(input.projectRoot);
-    const homeStore = resolveTaskEntityHomeStore(
-      runtime.entityHomeStoreContext,
-      input.taskRef
-    );
-    const preflight = await store.readCoordinationSnapshot(
-      input.taskRef,
-      homeStore
-    );
-    const preflightClaims = activeClaims(preflight.claims);
-    const preflightSuccessors = claimsWithinScope(preflightClaims, input.scope);
-    const preflightSuccessorIds = resolveSuccessorClaimIds2(
-      preflightSuccessors,
-      input.successorClaimIds,
-      input.operationId,
-      input.now.toISOString()
-    );
-    const context = await openV3TaskOperation({
-      projectRoot: input.projectRoot,
-      taskRef: input.taskRef,
-      sessionId: input.sessionId,
-      expectedTaskRevision: input.expectedTaskRevision,
-      operationId: input.operationId,
-      extraEntityLocks: [
-        `checkpoint:${input.checkpointId}`,
-        taskHeadEntityKey(input.taskRef),
-        ...preflightClaims.map((claim) => `claim:${claim.claimId}`),
-        ...preflightSuccessorIds.map((claimId) => `claim:${claimId}`)
-      ],
-      now: input.now
-    });
-    const lockedClaims = activeClaims(context.coordination.claims);
-    if (sameClaimIdSet(preflightClaims, lockedClaims)) {
-      const successors = claimsWithinScope(lockedClaims, input.scope);
-      const successorIds = resolveSuccessorClaimIds2(
-        successors,
-        input.successorClaimIds,
-        input.operationId,
-        input.now.toISOString()
-      );
-      return {
-        context,
-        activeClaims: lockedClaims,
-        successorPredecessors: successors,
-        successorClaimIds: successorIds
-      };
-    }
-    await context.release();
-  }
-  throw new Error("MANCODE_CLAIM_SET_CHANGED");
-}
-function assertScopeChangeEligible(context, scope) {
-  const metadata = context.task.metadata;
-  if (context.project.config.transport.mode !== "local") {
-    throw new Error("MANCODE_GIT_REF_TRANSPORT_NOT_IMPLEMENTED");
-  }
-  if (metadata.workflowMode !== "manteam") {
-    throw new Error("MANCODE_SCOPE_CHANGE_WORKFLOW_MODE_INVALID");
-  }
-  if (metadata.status !== "in_progress") {
-    throw new Error("MANCODE_SCOPE_CHANGE_WORKFLOW_NOT_ACTIVE");
-  }
-  if (metadata.ownerActorId !== context.session.actorId) {
-    throw new Error("MANCODE_TASK_OWNER_REQUIRED");
-  }
-  if (metadata.parent !== null) {
-    throw new Error("MANCODE_PARENT_SCOPE_INHERITANCE_REQUIRED");
-  }
-  if (metadata.implementationScope.digest === scope.digest) {
-    throw new Error("MANCODE_SCOPE_CHANGE_NOOP");
-  }
-}
-function assertClaimsFreshForScopeChange(context, claims) {
-  const codeHead = requireCodeHead3(context);
-  for (const claim of claims) {
-    if (claim.authority.mode !== "local") {
-      throw new Error("MANCODE_OPERATION_REPAIR_REQUIRED");
-    }
-    const validity = deriveClaimValidity(claim, {
-      taskRef: context.taskRef,
-      taskRevision: context.task.metadata.revision,
-      implementationScopeDigest: context.task.metadata.implementationScope.digest,
-      ownershipEpoch: context.task.metadata.ownershipEpoch,
-      codeRefHead: codeHead,
-      now: context.now,
-      transportFreshness: "fresh"
-    });
-    if (validity !== "fresh") {
-      throw new Error("MANCODE_CLAIM_REVALIDATION_REQUIRED");
-    }
-  }
-}
-function normalizeImplementationScope(value) {
-  assertRecord(value, "workflow scope change");
-  assertKnownKeys(
-    value,
-    ["include", "exclude", "modules"],
-    "workflow scope change"
-  );
-  const scope = {
-    source: "explicit",
-    include: normalizeScopeValues(value.include, "include", true),
-    exclude: normalizeScopeValues(value.exclude, "exclude", true),
-    modules: normalizeScopeValues(value.modules, "modules", false)
-  };
-  return { ...scope, digest: digestCanonicalJson(scope) };
-}
-function normalizeScopeValues(value, label, paths) {
-  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.trim())) {
-    throw new Error(`MANCODE_SCOPE_${label.toUpperCase()}_INVALID`);
-  }
-  const values = value.map((item) => item.trim());
-  const normalized = sortUtf8StringSet(values);
-  if (normalized.length !== values.length) {
-    throw new Error(`MANCODE_SCOPE_${label.toUpperCase()}_DUPLICATE`);
-  }
-  for (const item of normalized) {
-    assertSharedTextSafe(item, `workflow scope ${label}`);
-    if (paths) assertScopePath(item);
-  }
-  return normalized;
-}
-function assertScopePath(value) {
-  if (value.startsWith("/") || value.startsWith("~") || /^[A-Za-z]:/.test(value) || value.includes("\\") || value.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
-    throw new Error("MANCODE_SCOPE_PATH_INVALID");
-  }
-}
-function markScopeChangeOperationPending(previous, operationId, updatedAt) {
-  const next = parseWorkflowMetadata({
-    ...previous,
-    revision: previous.revision + 1,
-    transitionState: "operation_pending",
-    lastOperationId: operationId,
-    updatedAt
-  });
-  assertWorkflowMetadataTransition(previous, next, "ordinary");
-  return next;
-}
-function completeScopeChangeMetadata(previous, scope, checkpoint, operationId, updatedAt) {
-  const next = parseWorkflowMetadata({
-    ...previous,
-    revision: previous.revision + 1,
-    transitionState: "stable",
-    implementationScope: scope,
-    latestCheckpointRef: {
-      taskRef: checkpoint.taskRef,
-      kind: "checkpoint",
-      artifactId: checkpoint.checkpointId
-    },
-    lastOperationId: operationId,
-    updatedAt
-  });
-  assertWorkflowMetadataTransition(previous, next, "ordinary");
-  return next;
-}
-function buildScopeChangedCheckpoint(context, pendingMetadata, checkpointId, summary, nextAction, branch, timestamp4) {
-  return parseCheckpoint({
-    schemaVersion: 1,
-    checkpointId,
-    operationId: context.operationId,
-    taskRef: context.taskRef,
-    taskRevision: pendingMetadata.revision,
-    ownershipEpochAtOffer: pendingMetadata.ownershipEpoch,
-    kind: "scope_changed",
-    git: {
-      branch,
-      head: requireCodeHead3(context),
-      base: pendingMetadata.base?.head ?? null
-    },
-    summary: summary ?? "Changed the implementation scope and replaced affected coordination claims.",
-    governance: {
-      requirementsDigest: context.task.requirements.contentDigest,
-      planVersion: pendingMetadata.governance.planVersion,
-      reviewLedgerDigest: context.task.review.contentDigest,
-      verificationLedgerDigest: context.task.verification.contentDigest
-    },
-    nextAction: nextAction ?? "Re-read the updated scope and continue only with the successor claim.",
-    createdBy: {
-      actorId: context.session.actorId,
-      client: context.session.client
-    },
-    createdAt: timestamp4
-  });
-}
-function buildPendingSuccessorClaims2(predecessors, successorClaimIds, metadata, branch, codeHead, operationId, timestamp4, capabilities) {
-  return predecessors.map((previous, index) => {
-    const claimId = successorClaimIds[index];
-    if (claimId === void 0) {
-      throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_COUNT_INVALID");
-    }
-    return parseClaim({
-      ...previous,
-      claimId,
-      authority: { mode: "local", remoteRevision: null },
-      taskRevisionAtAcquire: metadata.revision,
-      lastValidatedTaskRevision: metadata.revision,
-      implementationScopeDigest: metadata.implementationScope.digest,
-      ownershipEpochAtAcquire: metadata.ownershipEpoch,
-      state: "pending",
-      revision: 1,
-      codeRefAtAcquire: { branch, head: codeHead },
-      lastValidatedCodeRef: { branch, head: codeHead },
-      acquisitionEnforcement: capabilities.claimAcquisition,
-      writeGuard: capabilities.writeGuard,
-      predecessorClaimId: previous.claimId,
-      successorClaimId: null,
-      lastOperationId: operationId,
-      createdAt: timestamp4,
-      updatedAt: timestamp4
-    });
-  });
-}
-function terminateClaimForScopeChange(previous, successorClaimId, operationId, timestamp4) {
-  const next = parseClaim({
-    ...previous,
-    state: successorClaimId === null ? "released" : "transferred",
-    revision: previous.revision + 1,
-    successorClaimId,
-    lastOperationId: operationId,
-    updatedAt: timestamp4
-  });
-  assertClaimTransition(previous, next);
-  return next;
-}
-function activateSuccessorClaim3(previous, operationId, timestamp4) {
-  const next = parseClaim({
-    ...previous,
-    state: "active",
-    revision: previous.revision + 1,
-    lastOperationId: operationId,
-    updatedAt: timestamp4
-  });
-  assertClaimTransition(previous, next);
-  return next;
-}
-function scopeChangeExpectedRevisions(context, checkpointId, predecessors, successorClaimIds) {
-  const expected = {
-    [taskEntityKey(context.taskRef)]: context.task.metadata.revision,
-    [`checkpoint:${checkpointId}`]: 0
-  };
-  for (const claim of predecessors) {
-    expected[`claim:${claim.claimId}`] = claim.revision;
-  }
-  for (const claimId of successorClaimIds) {
-    expected[`claim:${claimId}`] = 0;
-  }
-  const fence = context.coordination.taskHeadFence;
-  if (fence === null) throw new Error("MANCODE_TASK_HEAD_FENCE_MISSING");
-  expected[taskHeadEntityKey(context.taskRef)] = fence.fenceRevision;
-  return expected;
-}
-function activeClaims(claims) {
-  return claims.filter((claim) => claim.state === "active").sort((left, right) => compareUtf815(left.claimId, right.claimId));
-}
-function claimsWithinScope(claims, scope) {
-  return claims.filter(
-    (claim) => evaluateClaimScopeSubset(claim.scope, {
-      source: scope.source,
-      include: scope.include,
-      exclude: scope.exclude,
-      modules: scope.modules
-    }).allowed
-  );
-}
-function resolveSuccessorClaimIds2(predecessors, requested, operationId, timestamp4) {
-  const ids = requested ?? predecessors.map(
-    (claim) => scopeSuccessorClaimId(operationId, claim.claimId, timestamp4)
-  );
-  if (ids.length !== predecessors.length) {
-    throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_COUNT_INVALID");
-  }
-  const predecessorIds = new Set(predecessors.map((claim) => claim.claimId));
-  const seen = /* @__PURE__ */ new Set();
-  for (const claimId of ids) {
-    assertUlid(claimId, "scope successor claimId");
-    if (predecessorIds.has(claimId) || seen.has(claimId)) {
-      throw new Error("MANCODE_SCOPE_SUCCESSOR_CLAIM_INVALID");
-    }
-    seen.add(claimId);
-  }
-  return ids;
-}
-function scopeSuccessorClaimId(operationId, predecessorClaimId, timestamp4) {
-  assertUlid(operationId, "scope change operationId");
-  assertUlid(predecessorClaimId, "scope predecessor claimId");
-  const milliseconds = Date.parse(timestamp4);
-  if (Number.isNaN(milliseconds)) {
-    throw new Error("MANCODE_SCOPE_TIMESTAMP_INVALID");
-  }
-  const entropy = createHash11("sha256").update(`scope-change:${operationId}:${predecessorClaimId}`, "utf8").digest().subarray(0, 10);
-  return createUlid(milliseconds, entropy);
-}
-function requireCodeHead3(context) {
-  if (context.codeHead === null) {
-    throw new Error("MANCODE_TASK_HEAD_CODE_REF_UNAVAILABLE");
-  }
-  return context.codeHead;
-}
-function sameClaimIdSet(left, right) {
-  return left.length === right.length && left.every((claim, index) => claim.claimId === right[index]?.claimId);
-}
-function compareUtf815(left, right) {
-  return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
-}
-
 // src/context/solo-handoff.ts
 async function startV3SoloHandoff(input) {
   const taskRef = assertLocalTaskRef(input.taskRef);
@@ -43949,6 +44148,8 @@ function assertSoloStartEligible(context) {
   if (metadata.workflowMode !== "man" || metadata.coordination !== "single" || metadata.status !== "in_progress" || metadata.currentStep !== 4 || metadata.governance.planDecision !== null || metadata.soloExecution !== null || metadata.ownerActorId !== context.session.actorId || plan === null || requirements.status !== "confirmed" || !requirementsAreReady(requirements) || metadata.governance.requirementsStatus !== "ready" || metadata.governance.requirementsDigest !== requirements.contentDigest) {
     throw new Error("MANCODE_SOLO_HANDOFF_NOT_ELIGIBLE");
   }
+  assertRequirementsScopeConsistent(requirements);
+  assertExecutableImplementationScope(metadata.implementationScope);
 }
 function assertSoloCompletionEligible(context) {
   const { metadata } = context.task;
@@ -45237,11 +45438,20 @@ function initialScope(parent, explicitScope) {
     };
     return { ...inherited, digest: digestCanonicalJson(inherited) };
   }
+  if (explicitScope === void 0) {
+    const unspecified = {
+      source: "legacy_unspecified",
+      include: [],
+      exclude: [],
+      modules: []
+    };
+    return { ...unspecified, digest: digestCanonicalJson(unspecified) };
+  }
   const explicit = {
     source: "explicit",
-    include: [...explicitScope?.include ?? []],
-    exclude: [...explicitScope?.exclude ?? []],
-    modules: [...explicitScope?.modules ?? []]
+    include: [...explicitScope.include ?? []],
+    exclude: [...explicitScope.exclude ?? []],
+    modules: [...explicitScope.modules ?? []]
   };
   return { ...explicit, digest: digestCanonicalJson(explicit) };
 }
@@ -45703,10 +45913,22 @@ async function changeGitRefWorkflowScope(input) {
       operationId,
       timestamp4
     );
+    const review = markTaskReviewStale(
+      opened.context.task.review,
+      operationId,
+      timestamp4
+    );
+    const verification = markTaskVerificationStale(
+      opened.context.task.verification,
+      operationId,
+      timestamp4
+    );
     const metadata = scopeChangedMetadata(
       pendingMetadata,
       scope,
       checkpointId,
+      review.contentDigest,
+      verification.contentDigest,
       operationId,
       timestamp4
     );
@@ -45717,6 +45939,9 @@ async function changeGitRefWorkflowScope(input) {
       summary: input.checkpointSummary,
       nextAction: input.checkpointNextAction,
       codeRef: opened.bundle.codeRef,
+      planVersion: pendingMetadata.governance.planVersion + 1,
+      reviewLedgerDigest: review.contentDigest,
+      verificationLedgerDigest: verification.contentDigest,
       timestamp: timestamp4
     });
     const finalMetadata = parseWorkflowMetadata({
@@ -45730,8 +45955,8 @@ async function changeGitRefWorkflowScope(input) {
     const aggregate = buildTaskAggregateManifest({
       metadata: finalMetadata,
       requirements: opened.context.task.requirements,
-      review: opened.context.task.review,
-      verification: opened.context.task.verification,
+      review,
+      verification,
       planDigest: opened.context.task.plan?.digest ?? null,
       latestCheckpoint: checkpoint
     });
@@ -45754,6 +45979,8 @@ async function changeGitRefWorkflowScope(input) {
       task: {
         ...opened.context.task,
         metadata: finalMetadata,
+        review,
+        verification,
         latestCheckpoint: checkpoint,
         aggregate
       },
@@ -46173,12 +46400,20 @@ function assertClaimsFresh(context, bundle, claims) {
     }
   }
 }
-function scopeChangedMetadata(previous, scope, checkpointId, operationId, updatedAt) {
+function scopeChangedMetadata(previous, scope, checkpointId, reviewLedgerDigest2, verificationLedgerDigest2, operationId, updatedAt) {
   const next = parseWorkflowMetadata({
     ...previous,
     revision: previous.revision + 1,
     transitionState: "stable",
     implementationScope: scope,
+    governance: {
+      ...previous.governance,
+      planVersion: previous.governance.planVersion + 1,
+      reviewStatus: "stale",
+      reviewLedgerDigest: reviewLedgerDigest2,
+      verificationStatus: "stale",
+      verificationLedgerDigest: verificationLedgerDigest2
+    },
     latestCheckpointRef: {
       taskRef: previous.taskRef,
       kind: "checkpoint",
@@ -46207,9 +46442,9 @@ function scopeChangedCheckpoint(input) {
     summary: input.summary ?? "Changed the implementation scope and replaced affected coordination claims.",
     governance: {
       requirementsDigest: input.context.task.requirements.contentDigest,
-      planVersion: input.metadata.governance.planVersion,
-      reviewLedgerDigest: input.context.task.review.contentDigest,
-      verificationLedgerDigest: input.context.task.verification.contentDigest
+      planVersion: input.planVersion,
+      reviewLedgerDigest: input.reviewLedgerDigest,
+      verificationLedgerDigest: input.verificationLedgerDigest
     },
     nextAction: input.nextAction ?? "Re-read the updated scope and continue only with the successor claim.",
     createdBy: {
@@ -46541,60 +46776,43 @@ async function workflow(rootDir, subcommand, args = [], options = {}) {
       return EXIT_INVALID_ARG3;
   }
 }
+var WORKFLOW_V3_HANDLERS = {
+  create: workflowCreateV3,
+  list: workflowListV3,
+  show: workflowShowV3,
+  update: workflowUpdateV3,
+  requirements: workflowRequirementsV3,
+  plan: workflowPlanV3,
+  review: workflowReviewV3,
+  verify: workflowVerifyV3,
+  complete: workflowCompleteV3,
+  scope: workflowScopeChangeV3,
+  reframe: workflowReframeV3,
+  archive: (rootDir, args, options) => workflowArtifactShowV3(rootDir, "archive", args, options),
+  checkpoint: (rootDir, args, options) => workflowArtifactShowV3(rootDir, "checkpoint", args, options),
+  child: workflowChildResultMergeV3,
+  promote: workflowPromoteV3,
+  handoff: workflowSoloHandoffV3
+};
+var CONTINUITY_COMPATIBILITY_HANDLERS = {
+  clean: (_rootDir, _args, options) => workflowCleanV3(options)
+};
 async function workflowV3(rootDir, subcommand, args, options) {
-  if (subcommand === "list") {
-    return workflowListV3(rootDir, args, options);
-  }
-  if (subcommand === "show") {
-    return workflowShowV3(rootDir, args, options);
-  }
-  if (subcommand === "clean") {
-    return workflowCleanV3(options);
-  }
-  if (subcommand === "create") {
-    return workflowCreateV3(rootDir, args, options);
-  }
-  if (subcommand === "update") {
-    return workflowUpdateV3(rootDir, args, options);
-  }
-  if (subcommand === "requirements") {
-    return workflowRequirementsV3(rootDir, args, options);
-  }
-  if (subcommand === "plan") {
-    return workflowPlanV3(rootDir, args, options);
-  }
-  if (subcommand === "review") {
-    return workflowReviewV3(rootDir, args, options);
-  }
-  if (subcommand === "verify") {
-    return workflowVerifyV3(rootDir, args, options);
-  }
-  if (subcommand === "complete") {
-    return workflowCompleteV3(rootDir, args, options);
-  }
-  if (subcommand === "scope") {
-    return workflowScopeChangeV3(rootDir, args, options);
-  }
-  if (subcommand === "reframe") {
-    return workflowReframeV3(rootDir, args, options);
-  }
-  if (subcommand === "archive" || subcommand === "checkpoint") {
-    return workflowArtifactShowV3(rootDir, subcommand, args, options);
-  }
-  if (subcommand === "child") {
-    return workflowChildResultMergeV3(rootDir, args, options);
-  }
-  if (subcommand === "promote") {
-    return workflowPromoteV3(rootDir, args, options);
+  if (!WORKFLOW_SUBCOMMAND_SET.has(subcommand) && !CONTINUITY_COMPATIBILITY_SUBCOMMANDS.has(subcommand)) {
+    return printV3Error(
+      options.json,
+      "MANCODE_V3_OPERATION_NOT_IMPLEMENTED",
+      `Unknown workflow subcommand: ${subcommand}. Use one of: ${WORKFLOW_SUBCOMMANDS.join(", ")}.`
+    );
   }
-  if (subcommand === "handoff") {
-    return workflowSoloHandoffV3(rootDir, args, options);
+  if (WORKFLOW_SUBCOMMAND_SET.has(subcommand)) {
+    return WORKFLOW_V3_HANDLERS[subcommand](
+      rootDir,
+      args,
+      options
+    );
   }
-  return printV3Error(
-    options.json,
-    "MANCODE_V3_OPERATION_NOT_IMPLEMENTED",
-    `workflow ${subcommand} is not yet implemented for mancode authority.`
-  );
+  return CONTINUITY_COMPATIBILITY_HANDLERS[subcommand](rootDir, args, options);
 }
 async function workflowListV3(rootDir, args, options) {
   if (args.length !== 0) {
@@ -47400,7 +47618,7 @@ async function workflowPlanV3(rootDir, args, options) {
     return printV3Error(
       options.json,
       "MANCODE_PLAN_ARGUMENT_INVALID",
-      "Use: workflow plan <namespace:ULID> revise --expected-revision <n> --file <path>, or confirm --expected-revision <n> --plan-decision <plan_only|governed_execution>.",
+      "Use: workflow plan <namespace:ULID> revise --expected-revision <n> --file <path> [--scope-file <path>], or confirm --expected-revision <n> --plan-decision <plan_only|governed_execution>.",
       EXIT_INVALID_ARG3
     );
   }
@@ -47429,6 +47647,14 @@ async function workflowPlanV3(rootDir, args, options) {
       EXIT_INVALID_ARG3
     );
   }
+  if (action === "confirm" && options.scopeFile !== void 0) {
+    return printV3Error(
+      options.json,
+      "MANCODE_PLAN_SCOPE_REVISE_REQUIRED",
+      "Bind implementation scope with workflow plan revise before confirmation.",
+      EXIT_INVALID_ARG3
+    );
+  }
   try {
     const project = await readV3CommandProject(rootDir);
     const taskRef = parseTaskRef(task);
@@ -47445,12 +47671,17 @@ async function workflowPlanV3(rootDir, args, options) {
     if (plan === void 0 || plan === null) {
       throw new Error("MANCODE_PLAN_FILE_REQUIRED");
     }
+    const implementationScope = action === "revise" && options.scopeFile !== void 0 ? await readWorkflowJsonInputFile(
+      project.projectRoot,
+      options.scopeFile
+    ) : void 0;
     const result2 = await reviseV3Plan({
       projectRoot: project.projectRoot,
       taskRef,
       sessionId: session.sessionId,
       expectedTaskRevision,
       plan,
+      implementationScope,
       planDecision: parseV3PlanDecision(options.planDecision)
     });
     return printV3Result(options.json, {
@@ -47703,6 +47934,7 @@ async function workflowRequirements(rootDir, args, options) {
     const inputPath = path69.isAbsolute(options.file) ? options.file : path69.resolve(rootDir, options.file);
     const input = await readFile48(inputPath, "utf-8");
     const requirements = parseRequirementsLedger2(input);
+    assertRequirementsScopeConsistent2(requirements);
     [originalJson, originalMarkdown, originalMetadata] = await Promise.all([
       readOptionalText2(jsonPath),
       readOptionalText2(markdownPath),
@@ -48811,442 +49043,528 @@ async function pathExists16(p) {
 }
 
 // src/cli.ts
-program.name("mancode").description(
-  "AI coding agent harness. Modes: solo, man, manba, manteam, manps."
-).version(VERSION);
-program.command("init").description("Initialize mancode in the current project").option("--force", "Reinstall even if already initialized").option("--yes", "Skip all confirmations (CI mode)").option("--team", "Force enable team mode (MVP-2)").option("--no-team", "Force disable team mode (MVP-2)").option("--style <name>", "Specify aesthetic style (MVP-2)").option("--platform <platforms>", "Adapters: comma-separated names or all").option("--empty", "Initialize a safe empty directory as a generic project").addOption(new Option("--v3").hideHelp()).option("--legacy", "Use the legacy state.json initializer").option("--lang <locale>", "Initialization language: zh-CN or en").action(async (options) => {
-  const code = await init(process.cwd(), {
-    ...options,
-    fromCli: true,
-    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
-  });
-  process.exitCode = code;
-});
-program.command("install [platform]").description(
-  "Install platform adapter (claude-code, cursor, codex, copilot, zcode, kimi-code, qoder)"
-).option("--force", "Reinstall even if already installed").option("--minimal", "Minimal install (MVP-2)").option(
-  "--shadow",
-  "Stage a mancode bootstrap candidate without changing live files"
-).option("--confirm", "Confirm a journaled adapter install or repair").option("--operation-id <id>", "Operation ID returned by adapter dry-run").option("--session <id>", "mancode session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").action(async (platform, options) => {
-  const code = await install(
-    process.cwd(),
-    platform ?? "claude-code",
-    options
-  );
-  process.exitCode = code;
-});
-var adapterProgram = program.command("adapter").description("Inspect and explicitly upgrade managed platform adapters");
-adapterProgram.command("status").description("Inspect managed adapter content on disk").option("--platform <platform>", "Inspect one platform adapter").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await adapterStatus(process.cwd(), options);
-});
-adapterProgram.command("upgrade").description("Preview or repair managed adapter content").option("--all", "Upgrade all platform adapters").option("--platform <platform>", "Upgrade one platform adapter").option("--dry-run", "Stage and report changes without writing live targets").option("--confirm", "Confirm the journaled adapter upgrade").option("--operation-id <id>", "Operation ID returned by adapter dry-run").option("--session <id>", "mancode session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await adapterUpgrade(process.cwd(), options);
-});
-program.command("status").description("Show current mancode project status").option("--json", "Output as JSON (for scripts)").option("--brief", "Output compact mancode Continuity runtime status").action(async (options) => {
-  const code = await status(process.cwd(), options);
-  process.exitCode = code;
-});
-var projectProgram = program.command("project").description("Manage project-level mancode policy and compatibility");
-projectProgram.command("upgrade").description("Upgrade project governance policy explicitly").requiredOption("--policy <version>", "Target planning policy version (2)").option("--dry-run", "Preview the upgrade without writing").option("--operation-id <id>", "Operation ID returned by project dry-run").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await projectUpgrade(process.cwd(), options);
-});
-program.command("list-platforms").description("List available and installed mancode platform adapters").action(async () => {
-  const code = await listPlatforms(process.cwd());
-  process.exitCode = code;
-});
-program.command("uninstall [platform]").description("Remove platform adapter or all mancode artifacts").option("--force", "Skip confirmation message").option("--all", "Remove everything including .mancode/ directory").action(async (platform, options) => {
-  const code = await uninstall(process.cwd(), platform, options);
-  process.exitCode = code;
-});
-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("--parent <namespace:id>", "Parent TaskRef for a manba child").option(
-  "--participant <actorId>",
-  "Invite a joined team participant",
-  collectOption,
-  []
-).option("--visibility <visibility>", "Task visibility: local or shared").option("--coordination <coordination>", "Task coordination: single or team").option("--session <id>", "mancode session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--expected-revision <n>", "Expected task revision for mutations").option("--checkpoint-id <id>", "Checkpoint ID for a requirements reframe").option("--child-revision <n>", "Expected child task revision for merge").option("--summary <text>", "Privacy-screened child result summary").option("--next-action <text>", "Next parent action after a child merge").option("--sync", "Publish shared mutations through git-ref transport").option(
-  "--confirm-shared",
-  "Confirm that task metadata may enter shared mancode authority"
-).option("--blocking-reason <reason>", "Explain why a workflow is blocked").option("--outcome <outcome>", "Set manba outcome when completing a task").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(
-  "--file <path>",
-  "Semantic requirements JSON, plan Markdown, or ledger 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,
-    participants: options.participant.length === 0 ? void 0 : options.participant
-  });
-  process.exitCode = code;
-});
-var contextProgram = program.command("context").description("Resolve mancode task context and manage explicit sessions");
-contextProgram.command("show").description("Resolve one mancode Context Pack").option("--task <namespace:id>", "Explicit TaskRef").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--level <level>", "bootstrap, task, or full").option(
-  "--purpose <purpose>",
-  "orient, plan, implement, review, verify, or handoff"
-).option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextShow(process.cwd(), options);
-});
-var contextSessionProgram = contextProgram.command("session").description("Manage mancode session identities");
-contextSessionProgram.command("new").description("Create an explicit bootstrap session").requiredOption("--client <name>", "Client identity").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextSessionNew(process.cwd(), options);
-});
-contextSessionProgram.command("show").description("Show one explicit session without changing it").requiredOption("--session <id>", "Session ID").option("--client <name>", "Expected client identity").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextSessionShow(process.cwd(), options);
-});
-contextSessionProgram.command("spike").description("Record real-host session evidence without persisting host keys").requiredOption(
-  "--platform <platform>",
-  "claude-code, codex, cursor, copilot, zcode, kimi-code, or qoder"
-).requiredOption("--session-mode <mode>", "Evidence path: host or explicit").requiredOption(
-  "--host-session-source <source>",
-  "hook_stdin, environment, api, or none for explicit sessions"
-).requiredOption(
-  "--command-propagation <status>",
-  "Real host child-command result: proven, not_proven, not_tested, or not_applicable"
-).requiredOption(
-  "--subagent-inheritance <status>",
-  "Real host child-agent result: proven, not_proven, not_tested, or not_applicable"
-).option(
-  "--subagent-inheritance-reason <reason>",
-  "Required when child-agent inheritance is not applicable"
-).option(
-  "--hook-approval <status>",
-  "approved, unapproved, unknown, or not_applicable"
-).requiredOption(
-  "--host-version <version>",
-  "Installed host version used for the spike"
-).requiredOption(
-  "--release-candidate <id>",
-  "Immutable mancode release candidate or source commit identifier"
-).option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextSessionSpike(process.cwd(), options);
-});
-contextProgram.command("resume <namespace:id>").description("Validate and bind the current session to a mancode TaskRef").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish shared mutations through git-ref transport").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await contextResume(process.cwd(), task, options);
-});
-contextProgram.command("close").description("Close one explicit session without affecting other sessions").requiredOption("--session <id>", "Session ID").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextClose(process.cwd(), options);
-});
-contextProgram.command("doctor").description("Inspect unfinished mancode operations or repair one explicitly").option(
-  "--repair <operationId>",
-  "Repair this operation with its original session"
-).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextDoctor(process.cwd(), options);
-});
-contextProgram.command("diagnostics [action]").description("Show or configure local aggregate diagnostics").option("--json", "Output as JSON (for scripts)").action(async (action, options) => {
-  process.exitCode = await contextDiagnostics(process.cwd(), action, options);
-});
-contextProgram.command("compact").description("List and remove eligible mancode runtime retention candidates").option("--task <namespace:id>", "Compact checkpoints for one completed task").option("--dry-run", "Show the deletion list without changing files").option("--apply-shared", "Permit deletion for shared completed tasks").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextCompact(process.cwd(), options);
-});
-contextProgram.command("beta", { hidden: true }).description("Evaluate internal release-evidence gates").requiredOption(
-  "--release-candidate <id>",
-  "Release candidate that must match every platform evidence record"
-).option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextBeta(process.cwd(), options);
-});
-contextProgram.command("publish <local:id>").description("Create a privacy-screened shared man successor").requiredOption("--expected-revision <n>", "Current local task revision").requiredOption(
-  "--confirm-shared",
-  "Confirm that the screened task authority may enter shared storage"
-).option("--dry-run", "Validate the publish preflight without writing").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await contextPublish(process.cwd(), task, options);
-});
-contextProgram.command("reconcile-task-head <shared:id>").description(
-  "Adopt a Git-sourced shared aggregate through an explicit fence CAS"
-).requiredOption(
-  "--expected-fence-revision <n>",
-  "Current shared task-head fence revision"
-).requiredOption(
-  "--from-git",
-  "Confirm the checked-out aggregate came from Git"
-).option("--dry-run", "Validate adoption without changing the task-head fence").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await contextReconcileTaskHead(
-    process.cwd(),
-    task,
-    options
-  );
-});
-contextProgram.command("glossary <action>").description("Manage the user-confirmed shared project glossary").option("--term <term>", "Glossary term (add, update, remove)").option("--definition <text>", "Term definition (add, update)").option(
-  "--alias <alias>",
-  "Term alias; repeat for multiple aliases (add, update)",
-  (value, previous) => [...previous, value],
-  []
-).option("--task <namespace:id>", "Source shared TaskRef (add, update)").option(
-  "--expected-revision <n>",
-  "Current glossary revision (0 for an empty glossary)"
-).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (action, options) => {
-  process.exitCode = await contextGlossary(process.cwd(), action, options);
-});
-var contextWorktreeProgram = contextProgram.command("worktree").description("Register and inspect the current mancode checkout binding");
-contextWorktreeProgram.command("register").description(
-  "Register this linked worktree before using mancode coordination"
-).option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await contextWorktreeRegister(process.cwd(), options);
-});
-var operationProgram = program.command("operation").description("Inspect and recover durable mancode operations");
-operationProgram.command("show <operationId>").description("Show one operation journal and its recovery disposition").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
-  process.exitCode = await operationShow(process.cwd(), operationId, options);
-});
-operationProgram.command("repair <operationId>").description("Repair an operation using its original actor and session").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
-  process.exitCode = await operationRepair(
-    process.cwd(),
-    operationId,
-    options
-  );
-});
-operationProgram.command("abort <operationId>").description(
-  "Abort only an operation proven to have no visible business write"
-).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
-  process.exitCode = await operationAbort(
-    process.cwd(),
-    operationId,
-    options
-  );
-});
-var teamProgram = program.command("team").description("Manage mancode local identity and local-team membership");
-teamProgram.command("status").description("Show mancode team policy, transport, and local identity state").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamStatus(process.cwd(), options);
-});
-teamProgram.command("policy <mode>").description("Set the mancode team recommendation policy with a revision CAS").requiredOption("--expected-revision <n>", "Current team policy revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (policy, options) => {
-  process.exitCode = await teamPolicy(process.cwd(), {
-    ...options,
-    policy
+function createCliProgram() {
+  const program = new Command();
+  program.name("mancode").description(
+    "AI coding agent harness. Modes: solo, man, manba, manteam, manps."
+  ).version(VERSION);
+  program.command("init").description("Initialize mancode in the current project").option("--force", "Reinstall even if already initialized").option("--yes", "Skip all confirmations (CI mode)").option("--team", "Force enable team mode").option("--no-team", "Force disable team mode").option(
+    "--style <name>",
+    "Legacy aesthetic style (only supported with mancode init --legacy)"
+  ).option("--platform <platforms>", "Adapters: comma-separated names or all").option("--empty", "Initialize a safe empty directory as a generic project").addOption(new Option("--v3").hideHelp()).option("--legacy", "Use the legacy state.json initializer").option("--lang <locale>", "Initialization language: zh-CN or en").action(async (options) => {
+    const code = await init(process.cwd(), {
+      ...options,
+      fromCli: true,
+      interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+    });
+    process.exitCode = code;
+  });
+  program.command("install [platform]").description(
+    "Install platform adapter (claude-code, cursor, codex, copilot, zcode, kimi-code, qoder)"
+  ).option("--force", "Reinstall even if already installed").option(
+    "--minimal",
+    "Retained for legacy compatibility; Continuity bootstrap is already minimal"
+  ).option(
+    "--shadow",
+    "Stage a mancode bootstrap candidate without changing live files"
+  ).option("--confirm", "Confirm a journaled adapter install or repair").option("--operation-id <id>", "Operation ID returned by adapter dry-run").option(
+    "--session <id>",
+    "mancode session ID (otherwise MANCODE_SESSION_ID)"
+  ).option("--client <name>", "Client identity (default: mancode-cli)").action(async (platform, options) => {
+    const code = await install(
+      process.cwd(),
+      platform ?? "claude-code",
+      options
+    );
+    process.exitCode = code;
+  });
+  const adapterProgram = program.command("adapter").description("Inspect and explicitly upgrade managed platform adapters");
+  adapterProgram.command("status").description("Inspect managed adapter content on disk").option("--platform <platform>", "Inspect one platform adapter").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await adapterStatus(process.cwd(), options);
+  });
+  adapterProgram.command("upgrade").description("Preview or repair managed adapter content").option("--all", "Upgrade all platform adapters").option("--platform <platform>", "Upgrade one platform adapter").option(
+    "--dry-run",
+    "Stage and report changes without writing live targets"
+  ).option("--confirm", "Confirm the journaled adapter upgrade").option("--operation-id <id>", "Operation ID returned by adapter dry-run").option(
+    "--session <id>",
+    "mancode session ID (otherwise MANCODE_SESSION_ID)"
+  ).option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await adapterUpgrade(process.cwd(), options);
+  });
+  program.command("status").description("Show current mancode project status").option("--json", "Output as JSON (for scripts)").option("--brief", "Output compact mancode Continuity runtime status").action(async (options) => {
+    const code = await status(process.cwd(), options);
+    process.exitCode = code;
+  });
+  const projectProgram = program.command("project").description("Manage project-level mancode policy and compatibility");
+  projectProgram.command("upgrade").description("Upgrade project governance policy explicitly").requiredOption("--policy <version>", "Target planning policy version (2)").option("--dry-run", "Preview the upgrade without writing").option("--operation-id <id>", "Operation ID returned by project dry-run").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await projectUpgrade(process.cwd(), options);
+  });
+  program.command("list-platforms").description("List available and installed mancode platform adapters").action(async () => {
+    const code = await listPlatforms(process.cwd());
+    process.exitCode = code;
+  });
+  program.command("uninstall [platform]").description("Remove platform adapter or all mancode artifacts").option("--force", "Skip confirmation message").option("--all", "Remove everything including .mancode/ directory").action(async (platform, options) => {
+    const code = await uninstall(process.cwd(), platform, options);
+    process.exitCode = code;
+  });
+  program.command("workflow <subcommand> [args...]").description("Manage mancode workflows").addHelpText(
+    "after",
+    `
+Public Continuity subcommands:
+  ${WORKFLOW_SUBCOMMANDS.join(", ")}
+`
+  ).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("--parent <namespace:id>", "Parent TaskRef for a manba child").option(
+    "--participant <actorId>",
+    "Invite a joined team participant",
+    collectOption,
+    []
+  ).option("--visibility <visibility>", "Task visibility: local or shared").option(
+    "--coordination <coordination>",
+    "Task coordination: single or team"
+  ).option(
+    "--session <id>",
+    "mancode session ID (otherwise MANCODE_SESSION_ID)"
+  ).option("--client <name>", "Client identity (default: mancode-cli)").option("--expected-revision <n>", "Expected task revision for mutations").option("--checkpoint-id <id>", "Checkpoint ID for a requirements reframe").option("--child-revision <n>", "Expected child task revision for merge").option("--summary <text>", "Privacy-screened child result summary").option("--next-action <text>", "Next parent action after a child merge").option("--sync", "Publish shared mutations through git-ref transport").option(
+    "--confirm-shared",
+    "Confirm that task metadata may enter shared mancode authority"
+  ).option("--blocking-reason <reason>", "Explain why a workflow is blocked").option("--outcome <outcome>", "Set manba outcome when completing a task").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(
+    "--file <path>",
+    "Semantic requirements JSON, plan Markdown, or ledger input file"
+  ).option(
+    "--scope-file <path>",
+    "Plan implementation scope JSON {include,exclude,modules}"
+  ).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,
+      participants: options.participant.length === 0 ? void 0 : options.participant
+    });
+    process.exitCode = code;
+  });
+  const contextProgram = program.command("context").description("Resolve mancode task context and manage explicit sessions");
+  contextProgram.command("show").description("Resolve one mancode Context Pack").option("--task <namespace:id>", "Explicit TaskRef").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--level <level>", "bootstrap, task, or full").option(
+    "--purpose <purpose>",
+    "orient, plan, implement, review, verify, or handoff"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextShow(process.cwd(), options);
+  });
+  const contextSessionProgram = contextProgram.command("session").description("Manage mancode session identities");
+  contextSessionProgram.command("new").description("Create an explicit bootstrap session").requiredOption("--client <name>", "Client identity").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextSessionNew(process.cwd(), options);
+  });
+  contextSessionProgram.command("show").description("Show one explicit session without changing it").requiredOption("--session <id>", "Session ID").option("--client <name>", "Expected client identity").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextSessionShow(process.cwd(), options);
+  });
+  contextSessionProgram.command("spike").description(
+    "Record real-host session evidence without persisting host keys"
+  ).requiredOption(
+    "--platform <platform>",
+    "claude-code, codex, cursor, copilot, zcode, kimi-code, or qoder"
+  ).requiredOption("--session-mode <mode>", "Evidence path: host or explicit").requiredOption(
+    "--host-session-source <source>",
+    "hook_stdin, environment, api, or none for explicit sessions"
+  ).requiredOption(
+    "--command-propagation <status>",
+    "Real host child-command result: proven, not_proven, not_tested, or not_applicable"
+  ).requiredOption(
+    "--subagent-inheritance <status>",
+    "Real host child-agent result: proven, not_proven, not_tested, or not_applicable"
+  ).option(
+    "--subagent-inheritance-reason <reason>",
+    "Required when child-agent inheritance is not applicable"
+  ).option(
+    "--hook-approval <status>",
+    "approved, unapproved, unknown, or not_applicable"
+  ).requiredOption(
+    "--host-version <version>",
+    "Installed host version used for the spike"
+  ).requiredOption(
+    "--release-candidate <id>",
+    "Immutable mancode release candidate or source commit identifier"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextSessionSpike(process.cwd(), options);
+  });
+  contextProgram.command("resume <namespace:id>").description("Validate and bind the current session to a mancode TaskRef").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish shared mutations through git-ref transport").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await contextResume(process.cwd(), task, options);
+  });
+  contextProgram.command("close").description("Close one explicit session without affecting other sessions").requiredOption("--session <id>", "Session ID").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextClose(process.cwd(), options);
+  });
+  contextProgram.command("doctor").description(
+    "Inspect unfinished mancode operations or repair one explicitly"
+  ).option(
+    "--repair <operationId>",
+    "Repair this operation with its original session"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextDoctor(process.cwd(), options);
+  });
+  contextProgram.command("diagnostics [action]").description("Show or configure local aggregate diagnostics").option("--json", "Output as JSON (for scripts)").action(async (action, options) => {
+    process.exitCode = await contextDiagnostics(
+      process.cwd(),
+      action,
+      options
+    );
+  });
+  contextProgram.command("compact").description(
+    "List and remove eligible mancode runtime retention candidates"
+  ).option(
+    "--task <namespace:id>",
+    "Compact checkpoints for one completed task"
+  ).option("--dry-run", "Show the deletion list without changing files").option("--apply-shared", "Permit deletion for shared completed tasks").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextCompact(process.cwd(), options);
+  });
+  contextProgram.command("beta", { hidden: true }).description("Evaluate internal release-evidence gates").requiredOption(
+    "--release-candidate <id>",
+    "Release candidate that must match every platform evidence record"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextBeta(process.cwd(), options);
+  });
+  contextProgram.command("publish <local:id>").description("Create a privacy-screened shared man successor").requiredOption("--expected-revision <n>", "Current local task revision").requiredOption(
+    "--confirm-shared",
+    "Confirm that the screened task authority may enter shared storage"
+  ).option("--dry-run", "Validate the publish preflight without writing").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await contextPublish(process.cwd(), task, options);
+  });
+  contextProgram.command("reconcile-task-head <shared:id>").description(
+    "Adopt a Git-sourced shared aggregate through an explicit fence CAS"
+  ).requiredOption(
+    "--expected-fence-revision <n>",
+    "Current shared task-head fence revision"
+  ).requiredOption(
+    "--from-git",
+    "Confirm the checked-out aggregate came from Git"
+  ).option(
+    "--dry-run",
+    "Validate adoption without changing the task-head fence"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await contextReconcileTaskHead(
+      process.cwd(),
+      task,
+      options
+    );
+  });
+  contextProgram.command("glossary <action>").description("Manage the user-confirmed shared project glossary").option("--term <term>", "Glossary term (add, update, remove)").option("--definition <text>", "Term definition (add, update)").option(
+    "--alias <alias>",
+    "Term alias; repeat for multiple aliases (add, update)",
+    (value, previous) => [...previous, value],
+    []
+  ).option("--task <namespace:id>", "Source shared TaskRef (add, update)").option(
+    "--expected-revision <n>",
+    "Current glossary revision (0 for an empty glossary)"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (action, options) => {
+    process.exitCode = await contextGlossary(process.cwd(), action, options);
+  });
+  const contextWorktreeProgram = contextProgram.command("worktree").description("Register and inspect the current mancode checkout binding");
+  contextWorktreeProgram.command("register").description(
+    "Register this linked worktree before using mancode coordination"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await contextWorktreeRegister(process.cwd(), options);
+  });
+  const operationProgram = program.command("operation").description("Inspect and recover durable mancode operations");
+  operationProgram.command("show <operationId>").description("Show one operation journal and its recovery disposition").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
+    process.exitCode = await operationShow(
+      process.cwd(),
+      operationId,
+      options
+    );
   });
-});
-teamProgram.command("conflicts").description(
-  "Inspect local claim conflicts and handoffs without mutating coordination"
-).option("--task <namespace:id>", "Narrow the report to one shared TaskRef").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamConflicts(process.cwd(), options);
-});
-var teamTransportProgram = teamProgram.command("transport").description("Inspect and migrate the coordination authority");
-teamTransportProgram.command("status").description("Show active coordination transport and freshness").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamTransportStatus(process.cwd(), options);
-});
-teamTransportProgram.command("set <mode>").description(
-  "Switch an empty coordination authority; otherwise use transport migrate"
-).requiredOption(
-  "--expected-config-revision <n>",
-  "Current project config revision"
-).option(
-  "--remote <name>",
-  "Git remote for a git-ref target (default: origin)"
-).option("--dry-run", "Validate the empty-authority switch without writing").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (mode, options) => {
-  process.exitCode = await teamTransportSet(process.cwd(), {
-    ...options,
-    mode
+  operationProgram.command("repair <operationId>").description("Repair an operation using its original actor and session").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
+    process.exitCode = await operationRepair(
+      process.cwd(),
+      operationId,
+      options
+    );
   });
-});
-teamTransportProgram.command("migrate").description("Journal a single-authority local/git-ref transport switch").requiredOption("--to <mode>", "Target authority: local or git-ref").requiredOption(
-  "--expected-config-revision <n>",
-  "Current project config revision"
-).option(
-  "--remote <name>",
-  "Git remote for a git-ref target (default: origin)"
-).option("--dry-run", "Validate and preview without writing authority state").option("--confirm", "Explicitly confirm the authority migration").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamTransportMigrate(process.cwd(), options);
-});
-teamTransportProgram.command("recover <operationId>").description("Repair forward or safely abort a transport migration").requiredOption("--to <mode>", "Original target authority: local or git-ref").option("--remote <name>", "Original Git remote for a git-ref target").option("--abort", "Abort only before the target authority is established").option("--session <id>", "Original migration session ID").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
-  process.exitCode = await teamTransportRecover(
-    process.cwd(),
-    operationId,
-    options
-  );
-});
-var teamSyncProgram = teamProgram.command("sync").description("Explicitly synchronize the git-ref coordination authority");
-teamSyncProgram.command("pull").description("Fetch, validate, and cache refs/mancode/team").option("--task <namespace:id>", "Narrow output to one shared TaskRef").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamSyncPull(process.cwd(), options);
-});
-teamSyncProgram.command("push <namespace:id>").description("Publish one task bundle through a fresh ownership fence CAS").requiredOption(
-  "--expected-task-revision <n>",
-  "Current shared task revision"
-).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await teamSyncPush(process.cwd(), {
-    ...options,
-    task
+  operationProgram.command("abort <operationId>").description(
+    "Abort only an operation proven to have no visible business write"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
+    process.exitCode = await operationAbort(
+      process.cwd(),
+      operationId,
+      options
+    );
   });
-});
-var teamIdentityProgram = teamProgram.command("identity").description("Manage the machine-local actor identity");
-teamIdentityProgram.command("create").description("Create one local actor identity").requiredOption("--name <displayName>", "Display name").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamIdentityCreate(process.cwd(), options);
-});
-teamIdentityProgram.command("show").description("Show local identity and whether it is joined").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamIdentityShow(process.cwd(), options);
-});
-var teamDecisionProgram = teamProgram.command("decision").description("Publish explicitly confirmed, privacy-safe shared decisions");
-teamDecisionProgram.command("publish").description("Publish one immutable confirmed decision").requiredOption("--title <text>", "Short decision title").requiredOption("--statement <text>", "Confirmed decision statement").option("--task <namespace:id>", "Optional shared TaskRef that produced it").requiredOption("--confirm", "Confirm this decision may enter shared memory").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamDecisionPublish(process.cwd(), options);
-});
-teamProgram.command("join").description(
-  "Publish the approved shared actor profile after explicit confirmation"
-).requiredOption("--name <displayName>", "Must match the local actor identity").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Request explicit remote sync when transport supports it").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await teamJoin(process.cwd(), options);
-});
-teamProgram.command("checkpoint <namespace:id>").description("Create a journaled immutable checkpoint for a shared task").requiredOption(
-  "--expected-task-revision <n>",
-  "Current shared task revision"
-).requiredOption("--kind <kind>", "Checkpoint kind").requiredOption("--summary <text>", "Privacy-safe checkpoint summary").option("--next-action <text>", "Next action for the receiving workflow").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await teamCheckpoint(process.cwd(), {
-    ...options,
-    task
+  const teamProgram = program.command("team").description("Manage mancode local identity and local-team membership");
+  teamProgram.command("status").description(
+    "Show mancode team policy, transport, and local identity state"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamStatus(process.cwd(), options);
   });
-});
-teamProgram.command("claim <namespace:id>").description("Acquire a scoped claim for a shared task").requiredOption(
-  "--expected-task-revision <n>",
-  "Current shared task revision"
-).option("--path <glob>", "Repository-relative path glob", collectOption, []).option("--module <name>", "Implementation module", collectOption, []).option("--api <name>", "Public API boundary", collectOption, []).option("--schema <name>", "Shared schema boundary", collectOption, []).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await teamClaim(process.cwd(), {
-    ...options,
-    task,
-    paths: options.path,
-    modules: options.module,
-    apis: options.api,
-    schemas: options.schema
+  teamProgram.command("policy <mode>").description(
+    "Set the mancode team recommendation policy with a revision CAS"
+  ).requiredOption("--expected-revision <n>", "Current team policy revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (policy, options) => {
+    process.exitCode = await teamPolicy(process.cwd(), {
+      ...options,
+      policy
+    });
+  });
+  teamProgram.command("conflicts").description(
+    "Inspect local claim conflicts and handoffs without mutating coordination"
+  ).option("--task <namespace:id>", "Narrow the report to one shared TaskRef").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamConflicts(process.cwd(), options);
+  });
+  const teamTransportProgram = teamProgram.command("transport").description("Inspect and migrate the coordination authority");
+  teamTransportProgram.command("status").description("Show active coordination transport and freshness").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamTransportStatus(process.cwd(), options);
+  });
+  teamTransportProgram.command("set <mode>").description(
+    "Switch an empty coordination authority; otherwise use transport migrate"
+  ).requiredOption(
+    "--expected-config-revision <n>",
+    "Current project config revision"
+  ).option(
+    "--remote <name>",
+    "Git remote for a git-ref target (default: origin)"
+  ).option("--dry-run", "Validate the empty-authority switch without writing").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (mode, options) => {
+    process.exitCode = await teamTransportSet(process.cwd(), {
+      ...options,
+      mode
+    });
   });
-});
-teamProgram.command("renew <claimId>").description("Renew one fresh claim lease").requiredOption("--expected-revision <n>", "Current claim revision").option("--ttl <duration>", "Lease duration: ms, s, m, h, or d").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimRenew(process.cwd(), {
-    ...options,
-    claimId
+  teamTransportProgram.command("migrate").description("Journal a single-authority local/git-ref transport switch").requiredOption("--to <mode>", "Target authority: local or git-ref").requiredOption(
+    "--expected-config-revision <n>",
+    "Current project config revision"
+  ).option(
+    "--remote <name>",
+    "Git remote for a git-ref target (default: origin)"
+  ).option("--dry-run", "Validate and preview without writing authority state").option("--confirm", "Explicitly confirm the authority migration").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamTransportMigrate(process.cwd(), options);
+  });
+  teamTransportProgram.command("recover <operationId>").description("Repair forward or safely abort a transport migration").requiredOption(
+    "--to <mode>",
+    "Original target authority: local or git-ref"
+  ).option("--remote <name>", "Original Git remote for a git-ref target").option("--abort", "Abort only before the target authority is established").option("--session <id>", "Original migration session ID").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (operationId, options) => {
+    process.exitCode = await teamTransportRecover(
+      process.cwd(),
+      operationId,
+      options
+    );
   });
-});
-teamProgram.command("release <claimId>").description("Release one claim").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimRelease(process.cwd(), {
-    ...options,
-    claimId
+  const teamSyncProgram = teamProgram.command("sync").description("Explicitly synchronize the git-ref coordination authority");
+  teamSyncProgram.command("pull").description("Fetch, validate, and cache refs/mancode/team").option("--task <namespace:id>", "Narrow output to one shared TaskRef").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamSyncPull(process.cwd(), options);
   });
-});
-teamProgram.command("transfer <claimId>").description("Transfer a claim through a new successor identity").requiredOption("--to <actorId>", "Receiving joined participant actor ID").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimTransfer(process.cwd(), {
-    ...options,
-    claimId
+  teamSyncProgram.command("push <namespace:id>").description("Publish one task bundle through a fresh ownership fence CAS").requiredOption(
+    "--expected-task-revision <n>",
+    "Current shared task revision"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await teamSyncPush(process.cwd(), {
+      ...options,
+      task
+    });
+  });
+  const teamIdentityProgram = teamProgram.command("identity").description("Manage the machine-local actor identity");
+  teamIdentityProgram.command("create").description("Create one local actor identity").requiredOption("--name <displayName>", "Display name").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamIdentityCreate(process.cwd(), options);
+  });
+  teamIdentityProgram.command("show").description("Show local identity and whether it is joined").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamIdentityShow(process.cwd(), options);
+  });
+  const teamDecisionProgram = teamProgram.command("decision").description("Publish explicitly confirmed, privacy-safe shared decisions");
+  teamDecisionProgram.command("publish").description("Publish one immutable confirmed decision").requiredOption("--title <text>", "Short decision title").requiredOption("--statement <text>", "Confirmed decision statement").option("--task <namespace:id>", "Optional shared TaskRef that produced it").requiredOption(
+    "--confirm",
+    "Confirm this decision may enter shared memory"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamDecisionPublish(process.cwd(), options);
+  });
+  teamProgram.command("join").description(
+    "Publish the approved shared actor profile after explicit confirmation"
+  ).requiredOption(
+    "--name <displayName>",
+    "Must match the local actor identity"
+  ).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Request explicit remote sync when transport supports it").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await teamJoin(process.cwd(), options);
+  });
+  teamProgram.command("checkpoint <namespace:id>").description("Create a journaled immutable checkpoint for a shared task").requiredOption(
+    "--expected-task-revision <n>",
+    "Current shared task revision"
+  ).requiredOption("--kind <kind>", "Checkpoint kind").requiredOption("--summary <text>", "Privacy-safe checkpoint summary").option("--next-action <text>", "Next action for the receiving workflow").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await teamCheckpoint(process.cwd(), {
+      ...options,
+      task
+    });
   });
-});
-teamProgram.command("reclaim <claimId>").description("Explicitly mark an expired claim terminal").requiredOption("--expected-revision <n>", "Current claim revision").requiredOption("--reason <text>", "Privacy-safe expiry reclaim reason").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimReclaim(process.cwd(), {
-    ...options,
-    claimId
+  teamProgram.command("claim <namespace:id>").description("Acquire a scoped claim for a shared task").requiredOption(
+    "--expected-task-revision <n>",
+    "Current shared task revision"
+  ).option("--path <glob>", "Repository-relative path glob", collectOption, []).option("--module <name>", "Implementation module", collectOption, []).option("--api <name>", "Public API boundary", collectOption, []).option("--schema <name>", "Shared schema boundary", collectOption, []).option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await teamClaim(process.cwd(), {
+      ...options,
+      task,
+      paths: options.path,
+      modules: options.module,
+      apis: options.api,
+      schemas: options.schema
+    });
   });
-});
-teamProgram.command("revalidate <claimId>").description("Refresh one claim after task or code snapshot drift").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
-  process.exitCode = await teamClaimRevalidate(process.cwd(), {
-    ...options,
-    claimId
+  teamProgram.command("renew <claimId>").description("Renew one fresh claim lease").requiredOption("--expected-revision <n>", "Current claim revision").option("--ttl <duration>", "Lease duration: ms, s, m, h, or d").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimRenew(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-var teamHandoffProgram = teamProgram.command("handoff").description("Create and transition journaled ownership handoffs");
-teamHandoffProgram.command("draft <namespace:id>").description("Create a checkpoint-backed named handoff draft").requiredOption(
-  "--expected-task-revision <n>",
-  "Current shared task revision"
-).requiredOption("--to <actorId>", "Receiving joined participant actor ID").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
-  process.exitCode = await teamHandoffDraft(process.cwd(), {
-    ...options,
-    task
+  teamProgram.command("release <claimId>").description("Release one claim").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimRelease(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-teamHandoffProgram.command("offer <handoffId>").description("Offer a handoff draft to its receiving actor").requiredOption("--expected-revision <n>", "Current handoff revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
-  process.exitCode = await teamHandoffOffer(process.cwd(), {
-    ...options,
-    handoffId
+  teamProgram.command("transfer <claimId>").description("Transfer a claim through a new successor identity").requiredOption("--to <actorId>", "Receiving joined participant actor ID").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimTransfer(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-teamHandoffProgram.command("accept <handoffId>").description("Accept an offered handoff and transfer ownership atomically").requiredOption("--expected-revision <n>", "Current handoff revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
-  process.exitCode = await teamHandoffAccept(process.cwd(), {
-    ...options,
-    handoffId
+  teamProgram.command("reclaim <claimId>").description("Explicitly mark an expired claim terminal").requiredOption("--expected-revision <n>", "Current claim revision").requiredOption("--reason <text>", "Privacy-safe expiry reclaim reason").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimReclaim(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-teamHandoffProgram.command("reject <handoffId>").description("Reject an offered handoff with a durable reason").requiredOption("--expected-revision <n>", "Current handoff revision").requiredOption("--reason <text>", "Reason for rejecting the handoff").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
-  process.exitCode = await teamHandoffReject(process.cwd(), {
-    ...options,
-    handoffId
+  teamProgram.command("revalidate <claimId>").description("Refresh one claim after task or code snapshot drift").requiredOption("--expected-revision <n>", "Current claim revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (claimId, options) => {
+    process.exitCode = await teamClaimRevalidate(process.cwd(), {
+      ...options,
+      claimId
+    });
   });
-});
-teamHandoffProgram.command("cancel <handoffId>").description("Cancel a draft or offered handoff").requiredOption("--expected-revision <n>", "Current handoff revision").option("--reason <text>", "Optional cancellation reason").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
-  process.exitCode = await teamHandoffCancel(process.cwd(), {
-    ...options,
-    handoffId
+  const teamHandoffProgram = teamProgram.command("handoff").description("Create and transition journaled ownership handoffs");
+  teamHandoffProgram.command("draft <namespace:id>").description("Create a checkpoint-backed named handoff draft").requiredOption(
+    "--expected-task-revision <n>",
+    "Current shared task revision"
+  ).requiredOption("--to <actorId>", "Receiving joined participant actor ID").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (task, options) => {
+    process.exitCode = await teamHandoffDraft(process.cwd(), {
+      ...options,
+      task
+    });
   });
-});
-var migrateProgram = program.command("migrate").description("Inspect and migrate legacy context into mancode staging");
-var migrateContextProgram = migrateProgram.command("context").description("Manage the isolated legacy-to-mancode context migration stage").option("--dry-run", "Inspect legacy authority without writing files").option("--stage", "Create or refresh an isolated local migration stage").option("--status", "Show local migration stages").option("--activate", "Attempt the journaled mancode activation").option(
-  "--rollback <operationId>",
-  "Roll back an untouched mancode activation"
-).option("--stage-id <id>", "Migration stage ID (required if more than one)").option(
-  "--expected-stage-revision <n>",
-  "Expected stage revision for activation"
-).option("--session <id>", "Active session required for activation").option("--confirm", "Explicitly confirm the mancode cutover").option("--confirm-shared", "Confirm promotion of staged shared authority").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  const code = await migrateContext(process.cwd(), options);
-  process.exitCode = code;
-});
-migrateContextProgram.command("resolve <legacyTaskId>").description("Resolve missing owner or implementation scope in one stage").requiredOption(
-  "--expected-stage-revision <n>",
-  "Expected local migration stage revision"
-).option("--stage-id <id>", "Migration stage ID (required if more than one)").option("--owner <actorId>", "Explicit owner actor ID").option(
-  "--scope-file <path>",
-  "JSON implementation scope {include,exclude,modules}"
-).option("--json", "Output as JSON (for scripts)").action(async (legacyTaskId, options) => {
-  const code = await migrateContextResolve(
-    process.cwd(),
-    legacyTaskId,
-    options
-  );
-  process.exitCode = code;
-});
-program.command("manps [area]").description("Run deterministic preseason health scan").option("--json", "Output as JSON (for scripts)").option("--remediate", "Review scan issues with y/n/skip prompts").action(async (area, options) => {
-  const code = await manps(process.cwd(), area ?? "all", options);
-  process.exitCode = code;
-});
-var designProgram = program.command("design").description("Inspect and configure project UI design policy");
-designProgram.command("status").description("Show the configured and effective project design policy").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await designStatus(process.cwd(), options);
-});
-designProgram.command("context").description("Emit bounded UI design context for coding agents").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await designContext(process.cwd(), options);
-});
-designProgram.command("configure").description("CAS-update the optional project design policy").requiredOption(
-  "--expected-revision <n>",
-  "Current policy revision; use 0 when absent"
-).option("--preset <preset>", "preserve, refine, or experimental").option("--icons <policy>", "existing-first or lucide").option(
-  "--emoji <policy>",
-  "forbid-as-interface-icon; legacy allow is normalized"
-).option("--motion <policy>", "minimal or purposeful").option("--browser-validation <mode>", "off, when-available, or required").option("--confirm-experimental", "Explicitly allow the experimental preset").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await designConfigure(process.cwd(), options);
-});
-designProgram.command("disable").description("Disable the project design policy without deleting it").requiredOption("--expected-revision <n>", "Current policy revision").option("--json", "Output as JSON (for scripts)").action(async (options) => {
-  process.exitCode = await designDisable(process.cwd(), options);
-});
-program.command("refresh-style").description("Refresh project profile and rescan applicable design tokens").option("--root <path>", "Repository-relative UI project root").action(async (options) => {
-  const code = await refreshStyle(process.cwd(), options);
-  process.exitCode = code;
-});
-program.command("refresh-project").description(
-  "Refresh detected project facts after adding Git or project files"
-).action(async () => {
-  const code = await refreshProject(process.cwd());
-  process.exitCode = code;
-});
-program.command("version").description("Show version, node version, and platform").action(() => {
-  version();
-});
-program.parse();
+  teamHandoffProgram.command("offer <handoffId>").description("Offer a handoff draft to its receiving actor").requiredOption("--expected-revision <n>", "Current handoff revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
+    process.exitCode = await teamHandoffOffer(process.cwd(), {
+      ...options,
+      handoffId
+    });
+  });
+  teamHandoffProgram.command("accept <handoffId>").description("Accept an offered handoff and transfer ownership atomically").requiredOption("--expected-revision <n>", "Current handoff revision").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
+    process.exitCode = await teamHandoffAccept(process.cwd(), {
+      ...options,
+      handoffId
+    });
+  });
+  teamHandoffProgram.command("reject <handoffId>").description("Reject an offered handoff with a durable reason").requiredOption("--expected-revision <n>", "Current handoff revision").requiredOption("--reason <text>", "Reason for rejecting the handoff").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
+    process.exitCode = await teamHandoffReject(process.cwd(), {
+      ...options,
+      handoffId
+    });
+  });
+  teamHandoffProgram.command("cancel <handoffId>").description("Cancel a draft or offered handoff").requiredOption("--expected-revision <n>", "Current handoff revision").option("--reason <text>", "Optional cancellation reason").option("--session <id>", "Session ID (otherwise MANCODE_SESSION_ID)").option("--client <name>", "Client identity (default: mancode-cli)").option("--sync", "Publish through the active git-ref authority").option("--json", "Output as JSON (for scripts)").action(async (handoffId, options) => {
+    process.exitCode = await teamHandoffCancel(process.cwd(), {
+      ...options,
+      handoffId
+    });
+  });
+  const migrateProgram = program.command("migrate").description("Inspect and migrate legacy context into mancode staging");
+  const migrateContextProgram = migrateProgram.command("context").description(
+    "Manage the isolated legacy-to-mancode context migration stage"
+  ).option("--dry-run", "Inspect legacy authority without writing files").option("--stage", "Create or refresh an isolated local migration stage").option("--status", "Show local migration stages").option("--activate", "Attempt the journaled mancode activation").option(
+    "--rollback <operationId>",
+    "Roll back an untouched mancode activation"
+  ).option("--stage-id <id>", "Migration stage ID (required if more than one)").option(
+    "--expected-stage-revision <n>",
+    "Expected stage revision for activation"
+  ).option("--session <id>", "Active session required for activation").option("--confirm", "Explicitly confirm the mancode cutover").option("--confirm-shared", "Confirm promotion of staged shared authority").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    const code = await migrateContext(process.cwd(), options);
+    process.exitCode = code;
+  });
+  migrateContextProgram.command("resolve <legacyTaskId>").description("Resolve missing owner or implementation scope in one stage").requiredOption(
+    "--expected-stage-revision <n>",
+    "Expected local migration stage revision"
+  ).option("--stage-id <id>", "Migration stage ID (required if more than one)").option("--owner <actorId>", "Explicit owner actor ID").option(
+    "--scope-file <path>",
+    "JSON implementation scope {include,exclude,modules}"
+  ).option("--json", "Output as JSON (for scripts)").action(async (legacyTaskId, options) => {
+    const code = await migrateContextResolve(
+      process.cwd(),
+      legacyTaskId,
+      options
+    );
+    process.exitCode = code;
+  });
+  program.command("manps [area]").description("Run deterministic preseason health scan").option("--json", "Output as JSON (for scripts)").option("--remediate", "Review scan issues with y/n/skip prompts").action(async (area, options) => {
+    const code = await manps(process.cwd(), area ?? "all", options);
+    process.exitCode = code;
+  });
+  const designProgram = program.command("design").description("Inspect and configure project UI design policy");
+  designProgram.command("status").description("Show the configured and effective project design policy").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await designStatus(process.cwd(), options);
+  });
+  designProgram.command("context").description("Emit bounded UI design context for coding agents").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await designContext(process.cwd(), options);
+  });
+  designProgram.command("configure").description("CAS-update the optional project design policy").requiredOption(
+    "--expected-revision <n>",
+    "Current policy revision; use 0 when absent"
+  ).option("--preset <preset>", "preserve, refine, or experimental").option("--icons <policy>", "existing-first or lucide").option(
+    "--emoji <policy>",
+    "forbid-as-interface-icon; legacy allow is normalized"
+  ).option("--motion <policy>", "minimal or purposeful").option("--browser-validation <mode>", "off, when-available, or required").option(
+    "--confirm-experimental",
+    "Explicitly allow the experimental preset"
+  ).option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await designConfigure(process.cwd(), options);
+  });
+  designProgram.command("disable").description("Disable the project design policy without deleting it").requiredOption("--expected-revision <n>", "Current policy revision").option("--json", "Output as JSON (for scripts)").action(async (options) => {
+    process.exitCode = await designDisable(process.cwd(), options);
+  });
+  program.command("refresh-style").description("Refresh project profile and rescan applicable design tokens").option("--root <path>", "Repository-relative UI project root").action(async (options) => {
+    const code = await refreshStyle(process.cwd(), options);
+    process.exitCode = code;
+  });
+  program.command("refresh-project").description(
+    "Refresh detected project facts after adding Git or project files"
+  ).action(async () => {
+    const code = await refreshProject(process.cwd());
+    process.exitCode = code;
+  });
+  program.command("version").description("Show version, node version, and platform").action(() => {
+    version();
+  });
+  return program;
+}
+if (isDirectExecution()) {
+  createCliProgram().parse();
+}
+function isDirectExecution() {
+  const entrypoint = process.argv[1];
+  if (entrypoint === void 0) return false;
+  try {
+    return realpathSync(entrypoint) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
 function collectOption(value, previous) {
   return [...previous, value];
 }
 export {
-  program as cliProgram
+  createCliProgram
 };
 //# sourceMappingURL=cli.js.map