mancode 0.5.4 → 0.5.5

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-YWHFHZ4A.js";
 import {
   DEFAULT_MANCODE_END_MARKER,
   DEFAULT_MANCODE_START_MARKER,
@@ -136,7 +139,7 @@ import {
   stageV3AdapterUpgradeFiles,
   v3AdapterTargetPath,
   v3AdapterVersionsFromStatuses
-} from "./chunk-PQDAFZYS.js";
+} from "./chunk-AWOIP2LC.js";
 
 // src/cli.ts
 import { Option, program } from "commander";
@@ -1154,6 +1157,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 +5702,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 +5716,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;
 }
@@ -9622,7 +9638,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-DREAZNIX.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 +9901,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 +13757,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 +14348,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 +14359,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 +14426,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 +14471,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 +14496,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 +14508,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 +14542,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 +14801,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 +14811,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 +15360,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 +15384,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 +15395,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 +15407,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 +15429,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 +15443,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 +15777,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 +16752,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 +16778,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,",
@@ -41821,311 +41870,41 @@ 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");
-  }
-  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 {
-    assertPlanRevisionEligible(
-      context.task.metadata,
-      context.task.requirements
-    );
-    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(
-      context.task.verification,
-      context.operationId,
-      timestamp4
-    ) : context.task.verification;
-    const metadata = updateMetadata(
-      context.task.metadata,
-      context.task.requirements,
-      review,
-      verification,
-      planChanged,
-      planDecision,
-      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)
-          }),
-          ...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
-            })
-          ]
-        ],
-        noOpStepIds: [
-          ...planChanged ? [] : ["write-plan", "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 (planChanged) {
-      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) {
-  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 || metadata.governance.requirementsStatus !== "ready" || metadata.governance.requirementsDigest !== requirements.contentDigest || requirements.status !== "confirmed" || !requirementsAreReady(requirements)) {
-    throw new Error("MANCODE_PLAN_REQUIREMENTS_OR_DECISION_INVALID");
+  if (taskRef.namespace !== "shared") {
+    throw new Error("MANCODE_SCOPE_CHANGE_REQUIRES_SHARED_TASK");
   }
-}
-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 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(operationId, "reframe operationId");
-  const opened = await openReframeContext({
+  assertUlid(checkpointId, "scope change checkpointId");
+  assertUlid(operationId, "scope change operationId");
+  const opened = await openScopeChangeContext({
     projectRoot: input.projectRoot,
     taskRef,
     sessionId: input.sessionId,
     expectedTaskRevision: input.expectedTaskRevision,
-    checkpointId: input.checkpointId,
+    scope,
+    checkpointId,
+    successorClaimIds: input.successorClaimIds,
     operationId,
     now
   });
-  const { context, activeClaims: activeClaims2, openHandoffs, activeChildren } = opened;
+  const { context, activeClaims: activeClaims2, successorClaimIds, successorPredecessors } = opened;
   let journal = null;
   try {
-    assertReframeEligible(context, activeClaims2, openHandoffs, activeChildren);
-    assertReframeClaimsFresh(context, activeClaims2);
-    const timestamp4 = context.now.toISOString();
-    const archivedRequirementsContent = await readTaskAuthorityFileAtRoot(
-      context.task.location.taskRoot,
-      "requirements.json"
-    );
-    if (archivedRequirementsContent === null) {
-      throw new Error("MANCODE_REFRAME_REQUIREMENTS_MISSING");
-    }
-    const pendingMetadata = markReframeOperationPending(
+    assertScopeChangeEligible(context, scope);
+    assertClaimsFreshForScopeChange(context, activeClaims2);
+    const pendingMetadata = markScopeChangeOperationPending(
       context.task.metadata,
       context.operationId,
       timestamp4
     );
-    const requirements = createReframedRequirements(
-      context.task.requirements,
-      context.operationId,
-      timestamp4
-    );
     const review = markTaskReviewStale(
       context.task.review,
       context.operationId,
@@ -42136,71 +41915,80 @@ async function reframeV3Workflow(input) {
       context.operationId,
       timestamp4
     );
-    const releasedClaims = activeClaims2.map(
-      (claim) => releaseClaimForReframe(claim, context.operationId, timestamp4)
-    );
-    const archiveAction = createTaskArchiveRecoveryAction({
-      stepId: "archive-requirements-plan",
-      taskRef,
-      archiveId: context.operationId,
-      sourceTaskRevision: context.task.metadata.revision,
-      sourcePlanVersion: context.task.metadata.governance.planVersion,
-      createdAt: timestamp4,
-      requirementsContent: archivedRequirementsContent,
-      planContent: context.task.plan?.content ?? null
-    });
-    const branch = await readCheckoutBranch(context.projectRoot);
-    const checkpoint = buildReframeCheckpoint({
+    const branch = await readCheckoutBranch(context.projectRoot) ?? "HEAD";
+    const checkpoint = buildScopeChangedCheckpoint(
       context,
-      checkpointId: input.checkpointId,
-      taskRevision: pendingMetadata.revision + 1,
-      requirements,
-      review,
-      verification,
-      summary: input.summary,
-      nextAction: input.nextAction,
+      pendingMetadata,
+      checkpointId,
+      input.checkpointSummary,
+      input.checkpointNextAction,
       branch,
-      timestamp: timestamp4
-    });
-    const metadata = completeReframeMetadata(
+      pendingMetadata.governance.planVersion + 1,
+      review.contentDigest,
+      verification.contentDigest,
+      timestamp4
+    );
+    const metadata = completeScopeChangeMetadata(
       pendingMetadata,
-      requirements,
-      review,
-      verification,
+      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,
+      requirements: context.task.requirements,
       review,
       verification,
       planDigest: context.task.plan?.digest ?? null,
       latestCheckpoint: checkpoint
     });
     const taskHeadFence = nextTaskHeadFence(context, aggregate, timestamp4);
-    const refreshesSessionPointer = context.session.activeTaskRef !== null && sameTaskRef(context.session.activeTaskRef, taskRef);
-    if (refreshesSessionPointer) {
-      await enqueueSessionPointerProjection(context.projectRoot, {
-        operationId: context.operationId,
-        action: "resume",
-        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: "reframe",
-      action: taskRef.namespace === "shared" ? "shared_metadata_plan_mutation" : "local_workflow_mutation",
-      expectedRevisions: reframeExpectedRevisions(
+      type: "scope_change_reclaim",
+      action: "task_complete_scope_change_child_merge",
+      expectedRevisions: scopeChangeExpectedRevisions(
         context,
-        input.checkpointId,
-        activeClaims2
+        checkpointId,
+        activeClaims2,
+        successorClaimIds
       ),
+      conditions: { completionGateSatisfied: true },
       recovery: {
         actions: [
           createTaskAuthorityFileRecoveryAction({
@@ -42210,20 +41998,28 @@ async function reframeV3Workflow(input) {
             beforeContent: serializeTaskAuthority(context.task.metadata),
             targetContent: serializeTaskAuthority(pendingMetadata)
           }),
-          archiveAction,
-          ...releasedClaims.map(
-            (claim, index) => createClaimRecoveryAction({
-              stepId: "release-active-claims",
-              before: activeClaims2[index] ?? null,
+          createCheckpointRecoveryAction({
+            stepId: "write-scope-changed-checkpoint",
+            before: null,
+            checkpoint
+          }),
+          ...pendingSuccessorClaims.map(
+            (claim) => createClaimRecoveryAction({
+              stepId: "create-pending-successor-claims",
+              before: null,
               claim
             })
           ),
-          createTaskAuthorityFileRecoveryAction({
-            stepId: "write-requirements-draft",
-            taskRef,
-            fileName: "requirements.json",
-            beforeContent: serializeTaskAuthority(context.task.requirements),
-            targetContent: serializeTaskAuthority(requirements)
+          ...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",
@@ -42239,29 +42035,34 @@ async function reframeV3Workflow(input) {
             beforeContent: serializeTaskAuthority(context.task.verification),
             targetContent: serializeTaskAuthority(verification)
           }),
-          createCheckpointRecoveryAction({
-            stepId: "write-reframe-checkpoint",
-            before: null,
-            checkpoint
-          }),
           createTaskAuthorityFileRecoveryAction({
-            stepId: "commit-reframed-metadata",
+            stepId: "update-metadata-scope",
             taskRef,
             fileName: "metadata.json",
             beforeContent: serializeTaskAuthority(pendingMetadata),
             targetContent: serializeTaskAuthority(metadata)
           }),
-          ...taskHeadFence === null ? [] : [
-            createTaskHeadFenceRecoveryAction({
-              stepId: "update-task-head-fence",
-              before: context.coordination.taskHeadFence,
-              fence: taskHeadFence
-            })
-          ]
+          ...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: [
-          ...releasedClaims.length === 0 ? ["release-active-claims"] : [],
-          ...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"] : []
         ]
       }
     });
@@ -42272,65 +42073,1015 @@ async function reframeV3Workflow(input) {
       "mark-task-operation-pending",
       false
     );
-    await assertReframeCodeHeadUnchanged(context);
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
     await writeTaskAuthorityFile(
       context,
       "metadata.json",
-      serializeTaskAuthority(pendingMetadata)
+      `${JSON.stringify(pendingMetadata, null, 2)}
+`
     );
     journal = await advanceTaskOperation(
       context,
       journal,
-      "archive-requirements-plan",
+      "write-scope-changed-checkpoint",
       false
     );
-    await assertReframeCodeHeadUnchanged(context);
-    await writeTaskArchive(context, archiveAction);
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+    await writeTaskCheckpoint(context, checkpoint);
     journal = await advanceTaskOperation(
       context,
       journal,
-      "release-active-claims",
+      "create-pending-successor-claims",
       false
     );
-    await assertReframeCodeHeadUnchanged(context);
-    for (const [index, claim] of releasedClaims.entries()) {
-      const previous = activeClaims2[index];
-      if (previous === void 0) throw new Error("MANCODE_CLAIM_SET_CHANGED");
-      await updateClaim(context.homeStore, claim, previous.revision);
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+    for (const claim of pendingSuccessorClaims) {
+      await createClaim(context.homeStore, claim);
     }
     journal = await advanceTaskOperation(
       context,
       journal,
-      "write-requirements-draft",
+      "terminate-old-claims",
       false
     );
-    await assertReframeCodeHeadUnchanged(context);
-    await writeTaskAuthorityFile(
-      context,
-      "requirements.json",
-      serializeTaskAuthority(requirements)
-    );
+    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
     );
-    await assertReframeCodeHeadUnchanged(context);
+    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
     await writeTaskAuthorityFile(
       context,
       "review-ledger.json",
-      serializeTaskAuthority(review)
+      `${JSON.stringify(review, null, 2)}
+`
     );
     await writeTaskAuthorityFile(
       context,
       "verification-ledger.json",
-      serializeTaskAuthority(verification)
+      `${JSON.stringify(verification, null, 2)}
+`
     );
     journal = await advanceTaskOperation(
       context,
       journal,
-      "write-reframe-checkpoint",
+      "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)
+  };
+  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({
+    projectRoot: input.projectRoot,
+    taskRef,
+    sessionId: input.sessionId,
+    expectedTaskRevision: input.expectedTaskRevision,
+    checkpointId: input.checkpointId,
+    operationId,
+    now
+  });
+  const { context, activeClaims: activeClaims2, openHandoffs, activeChildren } = opened;
+  let journal = null;
+  try {
+    assertReframeEligible(context, activeClaims2, openHandoffs, activeChildren);
+    assertReframeClaimsFresh(context, activeClaims2);
+    const timestamp4 = context.now.toISOString();
+    const archivedRequirementsContent = await readTaskAuthorityFileAtRoot(
+      context.task.location.taskRoot,
+      "requirements.json"
+    );
+    if (archivedRequirementsContent === null) {
+      throw new Error("MANCODE_REFRAME_REQUIREMENTS_MISSING");
+    }
+    const pendingMetadata = markReframeOperationPending(
+      context.task.metadata,
+      context.operationId,
+      timestamp4
+    );
+    const requirements = createReframedRequirements(
+      context.task.requirements,
+      context.operationId,
+      timestamp4
+    );
+    const review = markTaskReviewStale(
+      context.task.review,
+      context.operationId,
+      timestamp4
+    );
+    const verification = markTaskVerificationStale(
+      context.task.verification,
+      context.operationId,
+      timestamp4
+    );
+    const releasedClaims = activeClaims2.map(
+      (claim) => releaseClaimForReframe(claim, context.operationId, timestamp4)
+    );
+    const archiveAction = createTaskArchiveRecoveryAction({
+      stepId: "archive-requirements-plan",
+      taskRef,
+      archiveId: context.operationId,
+      sourceTaskRevision: context.task.metadata.revision,
+      sourcePlanVersion: context.task.metadata.governance.planVersion,
+      createdAt: timestamp4,
+      requirementsContent: archivedRequirementsContent,
+      planContent: context.task.plan?.content ?? null
+    });
+    const branch = await readCheckoutBranch(context.projectRoot);
+    const checkpoint = buildReframeCheckpoint({
+      context,
+      checkpointId: input.checkpointId,
+      taskRevision: pendingMetadata.revision + 1,
+      requirements,
+      review,
+      verification,
+      summary: input.summary,
+      nextAction: input.nextAction,
+      branch,
+      timestamp: timestamp4
+    });
+    const metadata = completeReframeMetadata(
+      pendingMetadata,
+      requirements,
+      review,
+      verification,
+      checkpoint,
+      context.operationId,
+      timestamp4
+    );
+    const aggregate = buildTaskAggregateManifest({
+      metadata,
+      requirements,
+      review,
+      verification,
+      planDigest: context.task.plan?.digest ?? null,
+      latestCheckpoint: checkpoint
+    });
+    const taskHeadFence = nextTaskHeadFence(context, aggregate, timestamp4);
+    const refreshesSessionPointer = context.session.activeTaskRef !== null && sameTaskRef(context.session.activeTaskRef, taskRef);
+    if (refreshesSessionPointer) {
+      await enqueueSessionPointerProjection(context.projectRoot, {
+        operationId: context.operationId,
+        action: "resume",
+        sessionId: context.session.sessionId,
+        expectedPreviousTaskRef: context.session.activeTaskRef,
+        taskRef,
+        workflowMode: metadata.workflowMode,
+        taskRevision: metadata.revision,
+        now: context.now
+      });
+    }
+    journal = await createTaskOperationJournal(context, {
+      type: "reframe",
+      action: taskRef.namespace === "shared" ? "shared_metadata_plan_mutation" : "local_workflow_mutation",
+      expectedRevisions: reframeExpectedRevisions(
+        context,
+        input.checkpointId,
+        activeClaims2
+      ),
+      recovery: {
+        actions: [
+          createTaskAuthorityFileRecoveryAction({
+            stepId: "mark-task-operation-pending",
+            taskRef,
+            fileName: "metadata.json",
+            beforeContent: serializeTaskAuthority(context.task.metadata),
+            targetContent: serializeTaskAuthority(pendingMetadata)
+          }),
+          archiveAction,
+          ...releasedClaims.map(
+            (claim, index) => createClaimRecoveryAction({
+              stepId: "release-active-claims",
+              before: activeClaims2[index] ?? null,
+              claim
+            })
+          ),
+          createTaskAuthorityFileRecoveryAction({
+            stepId: "write-requirements-draft",
+            taskRef,
+            fileName: "requirements.json",
+            beforeContent: serializeTaskAuthority(context.task.requirements),
+            targetContent: serializeTaskAuthority(requirements)
+          }),
+          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)
+          }),
+          createCheckpointRecoveryAction({
+            stepId: "write-reframe-checkpoint",
+            before: null,
+            checkpoint
+          }),
+          createTaskAuthorityFileRecoveryAction({
+            stepId: "commit-reframed-metadata",
+            taskRef,
+            fileName: "metadata.json",
+            beforeContent: serializeTaskAuthority(pendingMetadata),
+            targetContent: serializeTaskAuthority(metadata)
+          }),
+          ...taskHeadFence === null ? [] : [
+            createTaskHeadFenceRecoveryAction({
+              stepId: "update-task-head-fence",
+              before: context.coordination.taskHeadFence,
+              fence: taskHeadFence
+            })
+          ]
+        ],
+        noOpStepIds: [
+          ...releasedClaims.length === 0 ? ["release-active-claims"] : [],
+          ...taskHeadFence === null ? ["update-task-head-fence"] : []
+        ]
+      }
+    });
+    journal = await advanceTaskOperation(context, journal, "validate", true);
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "mark-task-operation-pending",
+      false
+    );
+    await assertReframeCodeHeadUnchanged(context);
+    await writeTaskAuthorityFile(
+      context,
+      "metadata.json",
+      serializeTaskAuthority(pendingMetadata)
+    );
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "archive-requirements-plan",
+      false
+    );
+    await assertReframeCodeHeadUnchanged(context);
+    await writeTaskArchive(context, archiveAction);
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "release-active-claims",
+      false
+    );
+    await assertReframeCodeHeadUnchanged(context);
+    for (const [index, claim] of releasedClaims.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,
+      "write-requirements-draft",
+      false
+    );
+    await assertReframeCodeHeadUnchanged(context);
+    await writeTaskAuthorityFile(
+      context,
+      "requirements.json",
+      serializeTaskAuthority(requirements)
+    );
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "mark-review-verification-stale",
+      false
+    );
+    await assertReframeCodeHeadUnchanged(context);
+    await writeTaskAuthorityFile(
+      context,
+      "review-ledger.json",
+      serializeTaskAuthority(review)
+    );
+    await writeTaskAuthorityFile(
+      context,
+      "verification-ledger.json",
+      serializeTaskAuthority(verification)
+    );
+    journal = await advanceTaskOperation(
+      context,
+      journal,
+      "write-reframe-checkpoint",
       false
     );
     await assertReframeCodeHeadUnchanged(context);
@@ -42658,6 +43409,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");
   }
@@ -42930,454 +43684,95 @@ async function applyV3ReviewLedger(input) {
     journal = await createTaskOperationJournal(context, {
       type: "review_remediation",
       action: authorization.action,
-      evidence: authorization.evidence,
-      conditions: authorization.conditions,
-      expectedRevisions: taskMutationExpectedRevisions(context, [
-        "review",
-        "verification"
-      ]),
-      recovery: {
-        actions: [
-          createTaskAuthorityFileRecoveryAction({
-            stepId: "write-review-ledger",
-            taskRef,
-            fileName: "review-ledger.json",
-            beforeContent: serializeTaskAuthority(context.task.review),
-            targetContent: serializeTaskAuthority(review)
-          }),
-          createTaskAuthorityFileRecoveryAction({
-            stepId: "mark-verification-stale",
-            taskRef,
-            fileName: "verification-ledger.json",
-            beforeContent: serializeTaskAuthority(context.task.verification),
-            targetContent: serializeTaskAuthority(verification)
-          }),
-          createTaskAuthorityFileRecoveryAction({
-            stepId: "update-metadata",
-            taskRef,
-            fileName: "metadata.json",
-            beforeContent: serializeTaskAuthority(context.task.metadata),
-            targetContent: serializeTaskAuthority(metadata)
-          }),
-          ...taskHeadFence === null ? [] : [
-            createTaskHeadFenceRecoveryAction({
-              stepId: "update-task-head-fence",
-              before: context.coordination.taskHeadFence,
-              fence: taskHeadFence
-            })
-          ]
-        ],
-        noOpStepIds: taskHeadFence === null ? ["update-task-head-fence"] : []
-      }
-    });
-    journal = await advanceTaskOperation(context, journal, "validate", true);
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "write-review-ledger",
-      false
-    );
-    await writeTaskAuthorityFile(
-      context,
-      "review-ledger.json",
-      serializeTaskAuthority(review)
-    );
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "mark-verification-stale",
-      false
-    );
-    await writeTaskAuthorityFile(
-      context,
-      "verification-ledger.json",
-      serializeTaskAuthority(verification)
-    );
-    journal = await advanceTaskOperation(
-      context,
-      journal,
-      "update-metadata",
-      false
-    );
-    await writeTaskAuthorityFile(
-      context,
-      "metadata.json",
-      serializeTaskAuthority(metadata)
-    );
-    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);
-    return {
-      metadata,
-      review,
-      verification,
-      aggregate,
-      taskHeadFence,
-      operation
-    };
-  } catch (error) {
-    if (journal !== null) {
-      try {
-        await handleTaskOperationFailure(context, journal);
-      } catch {
-      }
-    }
-    throw error;
-  } finally {
-    await context.release();
-  }
-}
-function assertReviewEligible(metadata, hasPlan) {
-  if (metadata.workflowMode !== "man" && metadata.workflowMode !== "manteam") {
-    throw new Error("MANCODE_REVIEW_WORKFLOW_MODE_INVALID");
-  }
-  if (metadata.status !== "in_progress" && metadata.status !== "blocked") {
-    throw new Error("MANCODE_REVIEW_WORKFLOW_NOT_ACTIVE");
-  }
-  if (metadata.currentStep < 5 || metadata.governance.planDecision !== "governed_execution" || !hasPlan) {
-    throw new Error("MANCODE_REVIEW_PLAN_GATE_REQUIRED");
-  }
-}
-function createCurrentReview(previous, submitted, metadata, operationId, updatedAt) {
-  if (submitted.requirementsDigest !== metadata.governance.requirementsDigest || submitted.planVersion !== metadata.governance.planVersion) {
-    throw new Error("MANCODE_REVIEW_CONTEXT_STALE");
-  }
-  const draft = {
-    ...submitted,
-    taskRef: previous.taskRef,
-    revision: previous.revision + 1,
-    contentDigest: "",
-    lastOperationId: operationId,
-    updatedAt
-  };
-  const next = parseReviewLedger({
-    ...draft,
-    contentDigest: reviewLedgerDigest(draft)
-  });
-  assertReviewLedgerTransition(previous, next);
-  assertReviewLedgerAgainstContext(next, {
-    requirementsDigest: metadata.governance.requirementsDigest,
-    planVersion: metadata.governance.planVersion
-  });
-  return next;
-}
-function updateMetadata3(previous, review, verification, operationId, updatedAt) {
-  const next = parseWorkflowMetadata({
-    ...previous,
-    revision: previous.revision + 1,
-    transitionState: "stable",
-    lastOperationId: operationId,
-    governance: {
-      ...previous.governance,
-      reviewStatus: review.status,
-      reviewLedgerDigest: review.contentDigest,
-      verificationStatus: verification.status,
-      verificationLedgerDigest: verification.contentDigest
-    },
-    updatedAt
-  });
-  assertWorkflowMetadataTransition(previous, next, "ordinary");
-  return next;
-}
-function reviewAuthorization(context, next) {
-  if (context.taskRef.namespace === "local") {
-    return { action: "local_workflow_mutation" };
-  }
-  if (next.skip !== null) {
-    return {
-      action: "review_skip_or_waiver",
-      conditions: { reviewAction: "skip", reason: next.skip.reason }
-    };
-  }
-  const waivers = next.blockers.filter(
-    (blocker) => blocker.status === "waived"
-  );
-  if (waivers.length > 0) {
-    for (const blocker of waivers) {
-      if (blocker.severity === "p0" || blocker.severity === "legacy_unknown" || blocker.waiver === null) {
-        throw new Error("MANCODE_WAIVER_FORBIDDEN");
-      }
-    }
-    const first = waivers[0];
-    if (first?.waiver === null || first === void 0) {
-      throw new Error("MANCODE_WAIVER_FORBIDDEN");
-    }
-    return {
-      action: "review_skip_or_waiver",
-      conditions: {
-        reviewAction: "waiver",
-        reviewSeverity: first.severity,
-        reason: first.waiver.reason
-      }
-    };
-  }
-  return {
-    action: "shared_ledger_evidence",
-    evidence: {
-      assignedToActor: context.task.metadata.ownerActorId === context.session.actorId,
-      restrictsWriteToAssignedItem: true
-    }
-  };
-}
-
-// 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 },
+      evidence: authorization.evidence,
+      conditions: authorization.conditions,
+      expectedRevisions: taskMutationExpectedRevisions(context, [
+        "review",
+        "verification"
+      ]),
       recovery: {
         actions: [
           createTaskAuthorityFileRecoveryAction({
-            stepId: "mark-task-operation-pending",
+            stepId: "write-review-ledger",
             taskRef,
-            fileName: "metadata.json",
-            beforeContent: serializeTaskAuthority(context.task.metadata),
-            targetContent: serializeTaskAuthority(pendingMetadata)
-          }),
-          createCheckpointRecoveryAction({
-            stepId: "write-scope-changed-checkpoint",
-            before: null,
-            checkpoint
+            fileName: "review-ledger.json",
+            beforeContent: serializeTaskAuthority(context.task.review),
+            targetContent: serializeTaskAuthority(review)
           }),
-          ...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-verification-stale",
+            taskRef,
+            fileName: "verification-ledger.json",
+            beforeContent: serializeTaskAuthority(context.task.verification),
+            targetContent: serializeTaskAuthority(verification)
           }),
           createTaskAuthorityFileRecoveryAction({
-            stepId: "update-metadata-scope",
+            stepId: "update-metadata",
             taskRef,
             fileName: "metadata.json",
-            beforeContent: serializeTaskAuthority(pendingMetadata),
+            beforeContent: serializeTaskAuthority(context.task.metadata),
             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
-          })
+          ...taskHeadFence === null ? [] : [
+            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"] : []
-        ]
+        noOpStepIds: taskHeadFence === null ? ["update-task-head-fence"] : []
       }
     });
     journal = await advanceTaskOperation(context, journal, "validate", true);
     journal = await advanceTaskOperation(
       context,
       journal,
-      "mark-task-operation-pending",
+      "write-review-ledger",
       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
+      "review-ledger.json",
+      serializeTaskAuthority(review)
     );
-    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-    await writeTaskCheckpoint(context, checkpoint);
     journal = await advanceTaskOperation(
       context,
       journal,
-      "create-pending-successor-claims",
+      "mark-verification-stale",
       false
     );
-    await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
-    for (const claim of pendingSuccessorClaims) {
-      await createClaim(context.homeStore, claim);
-    }
-    journal = await advanceTaskOperation(
+    await writeTaskAuthorityFile(
       context,
-      journal,
-      "terminate-old-claims",
-      false
+      "verification-ledger.json",
+      serializeTaskAuthority(verification)
     );
-    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",
+      "update-metadata",
       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
+      serializeTaskAuthority(metadata)
     );
-    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);
+    if (taskHeadFence !== null) {
+      await assertTaskCodeHeadUnchanged(context.projectRoot, context.codeHead);
+      await replaceTaskHeadFence(context.homeStore, taskHeadFence);
+    }
     const operation = await commitTaskOperation(context, journal);
     return {
       metadata,
-      checkpoint,
-      terminatedClaims,
-      successorClaims: activeSuccessorClaims,
+      review,
+      verification,
       aggregate,
       taskHeadFence,
       operation
@@ -43394,312 +43789,97 @@ async function changeV3WorkflowScope(input) {
     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`);
+function assertReviewEligible(metadata, hasPlan) {
+  if (metadata.workflowMode !== "man" && metadata.workflowMode !== "manteam") {
+    throw new Error("MANCODE_REVIEW_WORKFLOW_MODE_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`);
+  if (metadata.status !== "in_progress" && metadata.status !== "blocked") {
+    throw new Error("MANCODE_REVIEW_WORKFLOW_NOT_ACTIVE");
   }
-  for (const item of normalized) {
-    assertSharedTextSafe(item, `workflow scope ${label}`);
-    if (paths) assertScopePath(item);
+  if (metadata.currentStep < 5 || metadata.governance.planDecision !== "governed_execution" || !hasPlan) {
+    throw new Error("MANCODE_REVIEW_PLAN_GATE_REQUIRED");
   }
-  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 createCurrentReview(previous, submitted, metadata, operationId, updatedAt) {
+  if (submitted.requirementsDigest !== metadata.governance.requirementsDigest || submitted.planVersion !== metadata.governance.planVersion) {
+    throw new Error("MANCODE_REVIEW_CONTEXT_STALE");
   }
-}
-function markScopeChangeOperationPending(previous, operationId, updatedAt) {
-  const next = parseWorkflowMetadata({
-    ...previous,
+  const draft = {
+    ...submitted,
+    taskRef: previous.taskRef,
     revision: previous.revision + 1,
-    transitionState: "operation_pending",
+    contentDigest: "",
     lastOperationId: operationId,
     updatedAt
+  };
+  const next = parseReviewLedger({
+    ...draft,
+    contentDigest: reviewLedgerDigest(draft)
+  });
+  assertReviewLedgerTransition(previous, next);
+  assertReviewLedgerAgainstContext(next, {
+    requirementsDigest: metadata.governance.requirementsDigest,
+    planVersion: metadata.governance.planVersion
   });
-  assertWorkflowMetadataTransition(previous, next, "ordinary");
   return next;
 }
-function completeScopeChangeMetadata(previous, scope, checkpoint, operationId, updatedAt) {
+function updateMetadata3(previous, review, verification, 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
+      ...previous.governance,
+      reviewStatus: review.status,
+      reviewLedgerDigest: review.contentDigest,
+      verificationStatus: verification.status,
+      verificationLedgerDigest: verification.contentDigest
     },
-    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
+    updatedAt
   });
-  assertClaimTransition(previous, next);
+  assertWorkflowMetadataTransition(previous, next, "ordinary");
   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;
+function reviewAuthorization(context, next) {
+  if (context.taskRef.namespace === "local") {
+    return { action: "local_workflow_mutation" };
   }
-  for (const claimId of successorClaimIds) {
-    expected[`claim:${claimId}`] = 0;
+  if (next.skip !== null) {
+    return {
+      action: "review_skip_or_waiver",
+      conditions: { reviewAction: "skip", reason: next.skip.reason }
+    };
   }
-  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)
+  const waivers = next.blockers.filter(
+    (blocker) => blocker.status === "waived"
   );
-  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");
+  if (waivers.length > 0) {
+    for (const blocker of waivers) {
+      if (blocker.severity === "p0" || blocker.severity === "legacy_unknown" || blocker.waiver === null) {
+        throw new Error("MANCODE_WAIVER_FORBIDDEN");
+      }
     }
-    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");
+    const first = waivers[0];
+    if (first?.waiver === null || first === void 0) {
+      throw new Error("MANCODE_WAIVER_FORBIDDEN");
+    }
+    return {
+      action: "review_skip_or_waiver",
+      conditions: {
+        reviewAction: "waiver",
+        reviewSeverity: first.severity,
+        reason: first.waiver.reason
+      }
+    };
   }
-  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"));
+  return {
+    action: "shared_ledger_evidence",
+    evidence: {
+      assignedToActor: context.task.metadata.ownerActorId === context.session.actorId,
+      restrictsWriteToAssignedItem: true
+    }
+  };
 }
 
 // src/context/solo-handoff.ts
@@ -43949,6 +44129,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 +45419,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 +45894,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 +45920,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 +45936,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 +45960,8 @@ async function changeGitRefWorkflowScope(input) {
       task: {
         ...opened.context.task,
         metadata: finalMetadata,
+        review,
+        verification,
         latestCheckpoint: checkpoint,
         aggregate
       },
@@ -46173,12 +46381,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 +46423,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: {
@@ -47400,7 +47616,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 +47645,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 +47669,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 +47932,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),
@@ -48887,6 +49117,9 @@ program.command("workflow <subcommand> [args...]").description("Manage mancode w
 ).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,