dsh-gate-agent 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,2199 @@
+// src/config.ts
+var DEFAULT_REVIEW_LIMIT = 5;
+var SCHEMASTERY = /* @__PURE__ */ Symbol.for("schemastery");
+var Config = {
+  [SCHEMASTERY]: true,
+  type: "object",
+  meta: { default: {} },
+  dict: {
+    reviewLimit: {
+      [SCHEMASTERY]: true,
+      type: "number",
+      meta: { default: DEFAULT_REVIEW_LIMIT, min: 1, max: 20, step: 1 }
+    }
+  },
+  "~standard": {
+    version: 1,
+    vendor: "dsh-gate-agent",
+    validate(value) {
+      if (value === void 0 || value === null) return { value: {} };
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return { issues: [{ message: "gate config must be an object" }] };
+      }
+      const unknown = Object.keys(value).filter((key) => key !== "reviewLimit");
+      if (unknown.length > 0) {
+        return { issues: [{ message: `unknown gate config keys: ${unknown.join(", ")}` }] };
+      }
+      const out = {};
+      if (value.reviewLimit !== void 0) {
+        if (!Number.isInteger(value.reviewLimit) || value.reviewLimit < 1 || value.reviewLimit > 20) {
+          return { issues: [{ message: "reviewLimit must be an integer from 1 to 20" }] };
+        }
+        out.reviewLimit = value.reviewLimit;
+      }
+      return { value: out };
+    }
+  }
+};
+
+// src/protocol.ts
+var DISCUSS_ORCHESTRATION = `## Discuss
+
+discuss \u662F\u9ED8\u8BA4\u9636\u6BB5\uFF0C\u4E0D\u9700\u8981\u547D\u4EE4\u8FDB\u5165\u3002
+
+1. \u5148\u8BFB\u76F8\u5173\u4EE3\u7801\u3001\u6587\u6863\u3001\u5386\u53F2 Note \u4E0E\u9879\u76EE\u7EA6\u675F\u3002
+2. \u660E\u786E\u5B9E\u9645\u95EE\u9898\u3001\u7EA6\u675F\u3001\u5DF2\u6709\u51B3\u5B9A\u4E0E\u51B2\u7A81\u3002
+3. \u7ED9\u51FA\u6709\u5B9E\u8D28\u5DEE\u5F02\u7684\u53EF\u884C\u65B9\u6848\u3001\u63A8\u8350\u4E0E\u5173\u952E\u6743\u8861\u3002
+4. \u53EA\u5BF9\u672A\u51B3\u7684\u4EA7\u54C1\u3001\u8303\u56F4\u3001\u517C\u5BB9\u6027\u3001\u6210\u672C\u3001\u98CE\u9669\u7B49\u4EF7\u503C\u5224\u65AD\u63D0\u95EE\u3002
+5. \u4E0D\u521B\u5EFA\u63D0\u6848\u3001Note \u6216\u89C4\u683C\u6587\u4EF6\u3002
+6. \u6C47\u62A5\uFF1A\u5DF2\u89E3\u51B3\u4E8B\u9879\u3001\u5269\u4F59\u672A\u51B3\u4E8B\u9879\u3001\u5EFA\u8BAE\u7684\u4E0B\u4E00\u9636\u6BB5\u3002
+7. \u4E0D\u81EA\u884C\u79BB\u5F00 discuss\uFF1B\u79BB\u5F00\u5FC5\u987B\u7531\u7528\u6237\u660E\u786E\u6388\u6743\u3002\u6388\u6743\u53EF\u4EE5\u5728\u5BF9\u8BDD\u6216 ask_user_question \u4E2D\u7ED9\u51FA\uFF1B\u83B7\u5F97\u6388\u6743\u540E\u8FDB\u5165 plan/implement\uFF0C\u4E0D\u8981\u8981\u6C42\u7528\u6237\u518D\u8F93\u5165 slash command\u3002`;
+var PLAN_ORCHESTRATION = `## /gate-enter-plan \u7F16\u6392
+\u4E3B\u4EE3\u7406\u6D3E worker\uFF1Bgate \u4E0D\u6D3E\u3002
+
+## Step 1 \u2014 Planning
+\u4E3B agent \u52A0\u8F7D\u6280\u80FD gate-planning \u548C gate-write-agent-notes\uFF1B\u8BFB\u53D6 gate-planning \u7684 SKILL.md\u3001proposal.md \u548C assets/worker-briefs/gate-enter-plan.md \u5199 planning \u4EFB\u52A1\u3002
+\u82E5\u5DE5\u4F5C\u9879\u8981\u5199\u8BBE\u8BA1\u8282\uFF08Note \u7684 \u201C## Design\u201D / \u201C### \u8BBE\u8BA1\u201D / \u81EA\u7531\u8BBE\u8BA1\u8282\uFF09\uFF0C\u5FC5\u987B\u5148\u8BFB\u53D6 rfc.md\uFF0C\u6309\u5176\u68C0\u67E5\u9879\u6536\u655B\uFF0C\u5E76\u628A\u9002\u7528\u68C0\u67E5\u70B9\u5199\u8FDB worker prompt\uFF1Bmechanical \u6216\u4E0D\u5199\u8BBE\u8BA1\u8282\u7684\u5DE5\u4F5C\u9879\u4E0D\u5F3A\u5236\u8BFB rfc\u3002
+\u5148\u6309 write-agent-notes \xA73 \u68C0\u7D22\u5386\u53F2\uFF0C\u518D\u6309 \xA74 \u5224\u5B9A\u5F52\u5C5E\u4E0E class\uFF1B\u7528 gate_note_write \u5199 Note\uFF0C\u8DEF\u5F84\u4E0E class \u5FC5\u987B\u4E00\u81F4\u3002\u53D1\u73B0\u65E7 implemented Note \u88AB\u65B0\u51B3\u5B9A\u5B8C\u5168\u53D6\u4EE3\u65F6\uFF0C\u8BB0\u4E0B\u5F52\u6863\u5019\u9009\uFF1B\u65B0 Note \u5C1A\u672A\u843D\u5730\u524D\u4E0D\u8981\u5F52\u6863\u3002
+\u628A\u5DE5\u4F5C\u9879\u3001\u7EA6\u675F\u548C\u63D0\u70BC\u540E\u7684\u89C4\u5212\u65B9\u6CD5\u5199\u8FDB subagent prompt\uFF1Bplanning worker \u4E0D\u52A0\u8F7D gate \u6280\u80FD\u3002
+\u5B8C\u6210\u540E\u8C03 gate_record({node:'plan', task, notePaths, noteDecision, noteSearch, workerSessionIds})\u3002
+notePaths \u662F [{path,class,lifecycle}] \u6570\u7EC4\uFF1Bpath \u63A5\u53D7 .agents/notes/<lifecycle>/<class>/...\u3001<lifecycle>/<class>/... \u6216 <class>/...\uFF0Cgate_record \u5F52\u4E00\u4E3A\u5B8C\u6574\u8DEF\u5F84\uFF1Bmechanical:<\u8BF4\u660E> \u7528 noteDecision:'mechanical' \u4E14 notePaths \u4E3A\u7A7A\u3002
+
+## Step 2 \u2014 Plan Review
+\u4E3B agent \u52A0\u8F7D\u6280\u80FD gate-plan-review\uFF1B\u8BFB\u53D6\u8BE5\u6280\u80FD\u7684 assets/worker-briefs/plan-review.md \u5199 review \u4EFB\u52A1\uFF0C\u6309\u4EFB\u52A1\u89C4\u6A21\u548C\u98CE\u9669\u81EA\u884C\u51B3\u5B9A\u6D3E\u4E00\u4E2A\u6216\u591A\u4E2A\u53EA\u8BFB review worker\uFF0C\u8986\u76D6 Standards\u3001Spec\u3001Architecture \u4E09\u8F74\u3002
+\u7ED9 worker \u5DE5\u4F5C\u9879\u3001Note\u3001\u56FA\u5B9A\u70B9\u548C\u8BC4\u5BA1\u65B9\u6CD5\uFF1B\u4E0D\u8981\u5728 review worker prompt \u4E2D\u9644\u5E26\u9879\u76EE\u73AF\u5883\u9A8C\u8BC1\uFF08package.json\u3001Node \u7248\u672C\u3001git \u72B6\u6001\u3001\u6587\u4EF6\u5B58\u5728\u6027\u3001\u521D\u59CB\u5316 smoke \u7ED3\u679C\uFF09\u3002
+\u5B8C\u6210\u540E\u8C03 gate_record({node:'plan-review',findings,reviewAxes,workerSessionIds,requiresDiscussion})\u3002
+reviewAxes \u5FC5\u987B\u5305\u542B standards\u3001spec\u3001architecture \u4E09\u8F74\u3002
+\u9700\u8981\u7528\u6237\u51B3\u5B9A\uFF1A\u8FDB\u5165 blocked\uFF0C\u7B49\u5F85 /gate-resume\uFF1B\u4ECD\u6709 findings\uFF1A\u5148 gate_record \u672C\u8F6E plan-review\uFF0C\u786E\u8BA4 node \u5DF2\u53D8\u4E3A plan-revise\uFF0C\u518D\u91CD\u65B0\u52A0\u8F7D gate-planning\uFF0C\u53EA\u5E26 findings \u548C Note \u8DEF\u5F84\u6D3E revise\uFF0C\u518D review\u3002
+
+## Step 3 \u2014 \u56DE\u5230 Discuss
+review \u4E3A\u7A7A\u65F6\u56DE\u5230 discuss\uFF0CplanReady=true\u3002
+\u5B9E\u65BD\u9700\u8981\u7528\u6237\u53E6\u884C\u6267\u884C /gate-enter-implement\uFF1B\u4E0D\u8981\u5728 planning \u91CC\u5F00\u59CB\u5B9E\u73B0\u3002`;
+var IMPLEMENT_ORCHESTRATION = `## /gate-enter-implement \u7F16\u6392
+\u4E3B\u4EE3\u7406\u6D3E worker\uFF1Bgate \u4E0D\u6D3E\u3002
+
+## Step 1 \u2014 Implement
+\u4E3B agent \u52A0\u8F7D\u6280\u80FD gate-implement\uFF1B\u8BFB\u53D6\u8BE5\u6280\u80FD\u7684 assets/worker-briefs/gate-enter-implement.md \u5199 implement \u4EFB\u52A1\u3002\u91C7\u7528\u6D4B\u8BD5\u4F18\u5148\u65F6\u540C\u65F6\u52A0\u8F7D gate-tdd\uFF0C\u5E76\u628A\u76F8\u5173\u89C4\u5219\u4EA4\u7ED9 implement worker\u3002
+worker \u4E0D\u52A0\u8F7D gate \u6280\u80FD\u3002
+\u5B8C\u6210\u540E\u8C03 gate_record({node:'implement', workerSessionIds})\u3002
+
+## Step 2 \u2014 Implementation Review
+\u4E3B agent \u52A0\u8F7D\u6280\u80FD gate-code-review\uFF1B\u8BFB\u53D6\u8BE5\u6280\u80FD\u7684 assets/worker-briefs/gate-implement-review.md \u5199 review \u4EFB\u52A1\uFF0C\u6309\u6539\u52A8\u89C4\u6A21\u81EA\u884C\u51B3\u5B9A\u6D3E\u4E00\u4E2A\u6216\u591A\u4E2A\u53EA\u8BFB review worker\uFF0C\u8986\u76D6 Standards \u4E0E Spec \u4E24\u8F74\u3002
+\u5B8C\u6210\u540E\u8C03 gate_record({node:'code-review', findings, reviewAxes, workerSessionIds})\uFF1B\u6709 findings \u65F6\u5148\u8BB0\u5F55\uFF0C\u786E\u8BA4 node \u5DF2\u53D8\u4E3A implement-revise\uFF0C\u518D\u6D3E revise worker\u3002
+\u5BA1\u67E5\u8981\u6C42\u6EE1\u8DB3\u540E\u7EE7\u7EED Step 3\uFF0C\u65E0\u9700\u518D\u6B21\u6388\u6743\u3002
+\u5B9E\u73B0\u4E2D\u53D1\u73B0\u8303\u56F4\u5916\u95EE\u9898\u3001\u5408\u540C\u53D8\u5316\u6216\u9700\u8981\u91CD\u65B0\u8BA8\u8BBA\u65F6\uFF0Cworker \u505C\u6B62\u5E76\u8FD4\u56DE receipt\uFF1B\u4E3B agent \u5411\u7528\u6237\u8BF4\u660E\uFF0C\u4F7F\u7528 gate_record \u7684 requiresDiscussion \u6216\u63D0\u793A\u7528\u6237\u6267\u884C /gate-return-discuss\u3002\u4E0D\u8981\u505C\u5728 implement \u91CC\u7EE7\u7EED\u6269\u5927\u8303\u56F4\u3002
+
+## Step 3 \u2014 Verify
+\u4E3B agent \u52A0\u8F7D\u6280\u80FD gate-verify\uFF0C\u8BFB\u53D6\u8BE5\u6280\u80FD\u7684 assets/worker-briefs/gate-verify.md \u5199 verify \u4EFB\u52A1\uFF0C\u6D3E verify worker \u5B8C\u6210\u6700\u7EC8\u9A8C\u6536\u3002
+\u5B8C\u6210\u540E\u8C03 gate_record({node:'verify', verification, workerSessionIds})\uFF1Bverification.toolResults \u5FC5\u987B\u662F verify worker session log \u4E2D\u771F\u5B9E tool/result \u7684 call_... id\uFF0Cevidence \u662F workspace \u5185\u7684\u666E\u901A\u6587\u4EF6\u3002
+\u53EA\u6709\u6700\u7EC8 PASS \u624D\u5B8C\u6210\u4EA4\u4ED8\uFF1BFAIL \u56DE\u5230 implement-revise\u3002
+\u72B6\u6001\u66F4\u65B0\u9075\u5FAA\u9879\u76EE\u767B\u8BB0\u7684\u5DE5\u4F5C\u9879\u4E0E\u51B3\u7B56\u8BB0\u5F55\u751F\u547D\u5468\u671F\u3002
+
+## Step 4 \u2014 Note lifecycle
+Verify PASS \u540E\u8FDB\u5165 note-lifecycle\uFF0C\u4E0D\u5F97\u76F4\u63A5 complete\u3002
+\u4E3B agent \u8C03 gate_note_finalize\uFF0C\u518D\u8C03 gate_note_verify\uFF1B\u901A\u8FC7\u540E gate_record({node:'note-lifecycle'})\u3002
+mechanical \u5DE5\u4F5C\u9879\u81EA\u52A8\u8DF3\u8FC7\uFF1B\u8DE8\u4F1A\u8BDD journal \u53EA\u62A5\u544A\u4E0D\u6062\u590D\uFF1Barchived manifest \u53EA\u7531\u7528\u6237\u6267\u884C /gate-note-seal\u3002note-lifecycle \u5B8C\u6210\u540E\u5EFA\u8BAE\u63D0\u4EA4\u672C\u6B21\u5B9E\u73B0\u4E0E Note\uFF1Bgate \u4E0D\u81EA\u52A8\u6267\u884C git add/commit\u3002`;
+var FIX_BUG_ORCHESTRATION = `## /gate-fix-bug \u7F16\u6392
+\u4E3B agent \u8BFB\u53D6 gate-fix-bug\uFF1B\u4E3B agent \u53EA\u6C47\u603B\uFF0C\u4E0D\u81EA\u884C\u4FEE\u590D\u3002
+
+## Step 1 \u2014 Fix
+\u4E3B agent \u8BFB\u53D6 gate-fix-bug \u6280\u80FD\u7684 assets/worker-briefs/gate-fix-bug.md\uFF0C\u6D3E fix worker\u3002fix worker \u4F7F\u7528 gate-fix-bug \u6267\u884C Process 1-9\uFF1A\u590D\u73B0\u3001\u56DE\u5F52\u8986\u76D6\u3001\u6839\u56E0\u3001\u6700\u5C0F\u4FEE\u590D\u3001\u539F\u590D\u73B0\u4E0E\u76F8\u5173\u6D4B\u8BD5\u3002\u5B8C\u6210\u540E\u8FD4\u56DE\u4FEE\u590D receipt\uFF1B\u4E0D\u8981\u81EA\u884C\u5B8C\u6210 Step 10-12\uFF0C\u4E5F\u4E0D\u8981\u63D0\u4EA4\u3002
+
+## Step 2 \u2014 Independent review
+\u4E3B agent \u52A0\u8F7D gate-code-review\uFF0C\u63D0\u70BC\u4E24\u8F74\u8BC4\u5BA1\u8981\u6C42\uFF0C\u518D\u8BFB\u53D6 gate-fix-bug \u6280\u80FD\u7684 assets/worker-briefs/fix-bug-review.md\uFF0C\u6D3E\u4E00\u4E2A\u72EC\u7ACB review worker\uFF1B\u4FEE\u590D\u57FA\u7EBF\u3001\u9009\u5B9A\u5931\u8D25\u3001\u5408\u540C\u5F15\u7528\u548C\u5B8C\u6574 diff \u5199\u8FDB\u7B80\u62A5\u3002review \u53EA\u62A5 findings\u3002
+
+## Step 3 \u2014 Resolve
+\u628A material in-scope findings \u4EA4\u56DE fix worker\uFF08send_message \u6216\u65B0 worker\uFF09\uFF0C\u5B8C\u6210 gate-fix-bug Step 11-12\uFF0C\u91CD\u8DD1\u539F\u590D\u73B0\u548C\u76F8\u5173\u6D4B\u8BD5\uFF1B\u91CD\u590D Step 2-3 \u76F4\u5230\u6CA1\u6709 material findings\u3002
+
+## Step 4 \u2014 Record
+\u5B8C\u6210\u540E\u8C03 gate_record({node:'fix-bug', workerSessionIds})\uFF0CworkerSessionIds \u5305\u542B fix \u4E0E review worker\uFF1Bgate \u4E0D\u518D\u81EA\u52A8\u63D0\u4EA4\u3002`;
+var DOCS_ORCHESTRATION = `## /gate-docs \u7F16\u6392
+\u4E0D\u52A0\u8F7D gate \u6280\u80FD\uFF1B\u8303\u56F4\u7531\u6A21\u578B\u6309\u9879\u76EE\u5B9E\u9645\u6587\u6863\u9700\u8981\u5224\u65AD\u3002
+\u5B8C\u6210\u540E\u8C03 gate_record({node:'docs'}) \u56DE\u5230 discuss\u3002`;
+var NOTE_LIFECYCLE_ORCHESTRATION = `## Note lifecycle
+Verify \u5DF2 PASS\uFF1B\u5F53\u524D\u4E0D\u6D3E worker\uFF0C\u4E5F\u4E0D\u5199\u4E1A\u52A1\u4EE3\u7801\u3002
+\u6309\u987A\u5E8F\u6267\u884C\uFF1Agate_note_finalize \u2192 gate_note_verify \u2192 gate_record({node:'note-lifecycle'})\u3002
+finalize/verify \u5931\u8D25\u7559\u5728\u672C\u8282\u70B9\u4FEE\u590D\uFF1Barchived manifest \u7F3A\u5931\u65F6\u63D0\u793A\u7528\u6237\u6267\u884C /gate-note-seal\u3002
+\u53EA\u6709 noteVerified=true \u624D\u80FD gate_record \u5B8C\u6210\uFF1Bmechanical \u5DE5\u4F5C\u9879\u53EF\u8DF3\u8FC7 finalize\u3002\u5B8C\u6210\u540E\u5EFA\u8BAE\u63D0\u4EA4\u672C\u6B21\u5B9E\u73B0\u4E0E Note\uFF1Bgate \u4E0D\u81EA\u52A8 git add/commit\u3002\u5B8C\u6210\u540E\u68C0\u67E5\u672C\u6B21\u65B0 Note \u662F\u5426\u5B8C\u5168\u53D6\u4EE3\u4E86\u67D0\u7BC7 implemented Note\uFF1A\u6709\u72EC\u7ACB\u53C2\u8003\u4EF7\u503C\u5C31\u5728\u6700\u7EC8\u6C47\u62A5\u4E2D\u7ED9\u51FA\u5F52\u6863\u5019\u9009\u548C\u76EE\u6807\u547D\u4EE4\uFF0C\u6CA1\u6709\u72EC\u7ACB\u4EF7\u503C\u5219\u5EFA\u8BAE\u5220\u9664\uFF1B\u4E0D\u8981\u81EA\u52A8\u5F52\u6863\u3002`;
+var GATE_RECORD_NODES = ["plan", "plan-review", "proposal-review", "plan-revise", "implement", "code-review", "implement-revise", "verify", "verify-standalone", "note-lifecycle", "docs", "code-review-standalone", "fix-bug"];
+var NODE_INFO = {
+  plan: { variant: "plan", method: "`gate-planning` + `gate-write-agent-notes`" },
+  "plan-review": { variant: "plan", method: "`gate-plan-review`" },
+  "plan-revise": { variant: "plan", method: "`gate-planning` + `gate-write-agent-notes`" },
+  "proposal-review": { variant: "reviewing-proposal", method: "`gate-plan-review`\uFF08\u4E09\u8F74\uFF09" },
+  implement: { variant: "implement", method: "`gate-implement`" },
+  "implement-revise": { variant: "implement", method: "`gate-implement`" },
+  "code-review": { variant: "implement", method: "`gate-code-review` (one skill, both axes)" },
+  "code-review-standalone": { variant: "reviewing-code", method: "`gate-code-review` (one skill, both axes)" },
+  verify: { variant: "implement", method: "`gate-verify`" },
+  "verify-standalone": { variant: "reviewing-verify", method: "\u65E0" },
+  "note-lifecycle": { variant: "note-lifecycle", method: "`gate-write-agent-notes`\uFF08lifecycle \u5DE5\u5177\uFF0C\u4E0D\u662F worker\uFF09" },
+  docs: { variant: "docs", method: "\u65E0" },
+  "fix-bug": { variant: "fix-bug", method: "`gate-fix-bug`" }
+};
+var NODE_METHODS = Object.fromEntries(Object.entries(NODE_INFO).map(([node, info]) => [node, info.method]));
+var WORKER_NODES = new Set(GATE_RECORD_NODES.filter((node) => node !== "docs" && node !== "note-lifecycle"));
+var DISPATCH_RULE = `## \u6D3E\u53D1\u89C4\u5219
+\u6BCF\u6B21\u6D3E subagent \u524D\uFF0C\u6309\u5F53\u524D procedure \u7684 method \u91CD\u65B0\u52A0\u8F7D\u6280\u80FD\uFF1B\u4E0D\u8981\u4F7F\u7528\u8BB0\u5FC6\u4E2D\u7684\u8282\u70B9\u6216\u6280\u80FD\uFF1B\u591A\u8F6E/\u538B\u7F29\u540E\u91CD\u65B0\u786E\u8BA4\u3002`;
+var REVIEWING_CODE_PROCEDURE = `## /gate-implement-review \u7F16\u6392
+\u4E3B agent \u52A0\u8F7D gate-code-review\uFF1B\u6D3E\u53EA\u8BFB review worker \u8986\u76D6 Standards \u4E0E Spec \u4E24\u8F74\uFF1B\u5B8C\u6210\u540E gate_record({node:'code-review-standalone', findings, reviewAxes, workerSessionIds}) \u56DE discuss\u3002`;
+var REVIEWING_PROPOSAL_PROCEDURE = `## /gate-propose-review \u7F16\u6392
+\u4E3B agent \u52A0\u8F7D gate-plan-review\uFF1B\u6D3E\u53EA\u8BFB review worker \u8986\u76D6 Standards/Spec/Architecture \u4E09\u8F74\uFF1B\u5B8C\u6210\u540E gate_record({node:'proposal-review', findings, reviewAxes, workerSessionIds}) \u56DE discuss\u3002`;
+var REVIEWING_VERIFY_PROCEDURE = `## /gate-code-verify \u7F16\u6392
+\u6D3E\u5B50\u4EE3\u7406\u52A0\u8F7D\u4F7F\u7528 gate-user-verify \u6309 Step 6 \u6C47\u62A5\uFF1Bverification.toolResults \u5FC5\u987B\u662F verify worker session log \u4E2D\u771F\u5B9E tool/result \u7684 call_... id\uFF0Cevidence \u662F workspace \u5185\u7684\u666E\u901A\u6587\u4EF6\uFF1B\u5B8C\u6210\u540E gate_record({node:'verify-standalone', verification, workerSessionIds}) \u56DE discuss\u3002`;
+function stepSection(text, from, to) {
+  const start = text.indexOf(from);
+  if (start < 0) return "";
+  const end = to === void 0 ? text.length : text.indexOf(to, start);
+  return text.slice(start, end < 0 ? text.length : end).trim();
+}
+var PLAN_STEP_1 = stepSection(PLAN_ORCHESTRATION, "## Step 1", "## Step 2");
+var PLAN_STEP_2 = stepSection(PLAN_ORCHESTRATION, "## Step 2", "## Step 3");
+var IMPLEMENT_STEP_1 = stepSection(IMPLEMENT_ORCHESTRATION, "## Step 1", "## Step 2");
+var IMPLEMENT_STEP_2 = stepSection(IMPLEMENT_ORCHESTRATION, "## Step 2", "## Step 3");
+var IMPLEMENT_STEP_3 = stepSection(IMPLEMENT_ORCHESTRATION, "## Step 3", "## Step 4");
+var NODE_PROCEDURES = {
+  plan: PLAN_STEP_1,
+  "plan-review": PLAN_STEP_2,
+  "plan-revise": `## Plan revise
+\u6839\u636E findings \u7528 gate_note_write \u66F4\u65B0 Note\uFF1B\u5B8C\u6210\u540E gate_record({node:'plan-revise'}) \u56DE\u5230 plan-review\uFF0C\u518D\u6309 plan-review procedure review\u3002`,
+  implement: IMPLEMENT_STEP_1,
+  "code-review": IMPLEMENT_STEP_2,
+  "implement-revise": `## Implement revise
+\u4FEE\u590D findings\uFF1B\u91CD\u8DD1\u6D4B\u8BD5\uFF1B\u5B8C\u6210\u540E gate_record({node:'implement-revise'}) \u56DE\u5230 code-review\uFF0C\u518D\u6309 code-review procedure review\u3002`,
+  verify: IMPLEMENT_STEP_3,
+  "note-lifecycle": NOTE_LIFECYCLE_ORCHESTRATION,
+  "fix-bug": FIX_BUG_ORCHESTRATION,
+  "code-review-standalone": REVIEWING_CODE_PROCEDURE,
+  "proposal-review": REVIEWING_PROPOSAL_PROCEDURE,
+  "verify-standalone": REVIEWING_VERIFY_PROCEDURE
+};
+var GATE_METHODOLOGY = `## Gate \u65B9\u6CD5\u8BBA
+\u672C\u6BB5\u53EA\u5B9A\u4E49\u5404\u9636\u6BB5\u7684\u5DE5\u4F5C\u65B9\u6CD5\u4E0E\u8D28\u91CF\u6807\u51C6\u3002\u5F53\u524D phase/node\u3001procedure \u548C\u8981\u52A0\u8F7D\u7684\u6280\u80FD\u6765\u81EA\u6700\u8FD1\u4E00\u6B21 gate_status\u3001gate_record \u6216\u547D\u4EE4\u7ED3\u679C\uFF1B\u53EA\u6267\u884C\u5F53\u524D phase \u7684 procedure\uFF0C\u5176\u4ED6\u9636\u6BB5\u7684\u65B9\u6CD5\u8BBA\u4EC5\u4F5C\u80CC\u666F\u53C2\u8003\uFF1Bcompaction \u540E\u5FC5\u987B\u91CD\u65B0\u83B7\u53D6\u3002
+
+## discuss
+discuss \u662F\u9ED8\u8BA4\u9636\u6BB5\u3002\u5148\u8BFB\u76F8\u5173\u4EE3\u7801\u3001\u6587\u6863\u3001\u5386\u53F2 Note \u4E0E\u9879\u76EE\u7EA6\u675F\uFF1B\u660E\u786E\u5B9E\u9645\u95EE\u9898\u3001\u7EA6\u675F\u3001\u5DF2\u6709\u51B3\u5B9A\u4E0E\u51B2\u7A81\uFF1B\u7ED9\u51FA\u6709\u5B9E\u8D28\u5DEE\u5F02\u7684\u53EF\u884C\u65B9\u6848\u3001\u63A8\u8350\u4E0E\u5173\u952E\u6743\u8861\uFF1B\u53EA\u5BF9\u672A\u51B3\u7684\u4EA7\u54C1\u3001\u8303\u56F4\u3001\u517C\u5BB9\u6027\u3001\u6210\u672C\u3001\u98CE\u9669\u7B49\u4EF7\u503C\u5224\u65AD\u63D0\u95EE\uFF1B\u6C47\u62A5\u5DF2\u89E3\u51B3\u3001\u672A\u51B3\u4E8B\u9879\u548C\u5EFA\u8BAE\u4E0B\u4E00\u9636\u6BB5\u3002\u4E0D\u8FDB\u5165\u5B9E\u65BD\uFF0C\u53EA\u6709\u7528\u6237\u660E\u786E\u6388\u6743\u624D\u79BB\u5F00\u3002
+
+## plan
+\u628A\u7528\u6237\u7B80\u8FF0\u6536\u655B\u6210\u53EF\u5B9E\u65BD\u8BA1\u5212\u4E0E proposed Note\uFF1B\u8BA1\u5212\u5FC5\u987B\u5199\u6E05\u8303\u56F4\u3001\u9A8C\u6536\u3001\u5907\u9009\u4E0E\u98CE\u9669\u3002Plan Review \u72EC\u7ACB\u5224\u65AD\uFF1Bfindings \u5148\u8BB0\u5F55\u518D revise\uFF1Breview \u901A\u8FC7\u540E\u56DE discuss\u3002\u4E0D\u8981\u5728\u89C4\u5212\u91CC\u5F00\u59CB\u5B9E\u73B0\u3002
+
+## implement
+\u6309\u5DF2\u786E\u8BA4\u7684\u8BA1\u5212\u5B9E\u65BD\u5E76\u5B8C\u6210\u6D4B\u8BD5\uFF1B\u5B9E\u73B0\u540E\u505A\u72EC\u7ACB review\uFF0C\u518D\u7528\u53EF\u6267\u884C\u8BC1\u636E verify\uFF1B\u6700\u540E\u5B8C\u6210 Note lifecycle\u3002\u4E0D\u6269\u5927\u8303\u56F4\uFF0C\u4E0D\u5728\u5B9E\u73B0\u4E2D\u91CD\u65B0\u89C4\u5212\u3002
+
+## code-review
+\u72EC\u7ACB\u5224\u65AD\u6539\u52A8\u662F\u5426\u6EE1\u8DB3\u5408\u540C\u4E0E\u6807\u51C6\uFF1B\u53EA\u62A5 findings\uFF0C\u4E0D\u4FEE\u4EE3\u7801\u3001\u4E0D\u66FF\u4EE3 verify\uFF1Bfindings \u8BB0\u5F55\u540E\u518D\u8FDB\u5165 revise\u3002
+
+## verify
+\u7528\u53EF\u6267\u884C\u8BC1\u636E\u5224\u5B9A PASS/FAIL\uFF1B\u4E0D\u4FEE\u6539\u4EA7\u54C1/\u6D4B\u8BD5\u8BA9\u7ED3\u679C\u53D8\u7EFF\uFF1BFAIL \u56DE implement-revise\u3002
+
+## note-lifecycle
+\u5B8C\u6210 Note \u7684 finalize \u4E0E\u6821\u9A8C\uFF1B\u4E0D\u5199\u4E1A\u52A1\u4EE3\u7801\uFF1B\u68C0\u67E5\u662F\u5426\u4EA7\u751F\u5F52\u6863\u5019\u9009\uFF1B\u5B8C\u6210\u540E\u56DE discuss\u3002
+
+## fix-bug
+\u5BF9\u5DF2\u6388\u6743\u7684\u5B9E\u73B0\u7F3A\u9677\uFF1A\u590D\u73B0\u3001\u56DE\u5F52\u8986\u76D6\u3001\u6839\u56E0\u3001\u6700\u5C0F\u4FEE\u590D\u3001\u72EC\u7ACB review\uFF1B\u4E0D\u505A\u65B0\u529F\u80FD\u3001\u4E0D\u6269\u5927\u8303\u56F4\uFF1B\u5B8C\u6210\u540E\u56DE discuss\u3002
+
+## docs
+\u6587\u6863\u6CBB\u7406\uFF1B\u4E0D\u6539\u53D8\u529F\u80FD\u884C\u4E3A\uFF1B\u8303\u56F4\u7531\u6A21\u578B\u6309\u9879\u76EE\u5B9E\u9645\u6587\u6863\u9700\u8981\u5224\u65AD\uFF1B\u5B8C\u6210\u540E\u56DE discuss\u3002
+
+## reviewing-code
+\u53EA\u8BFB code review\uFF1A\u72EC\u7ACB\u5224\u65AD Standards \u4E0E Spec \u4E24\u8F74\uFF0C\u53EA\u8F93\u51FA findings\uFF0C\u4E0D\u4FEE\u4EE3\u7801\u3001\u4E0D\u66FF\u4EE3 verify\u3002
+
+## reviewing-proposal
+\u53EA\u8BFB\u63D0\u6848\u8BC4\u5BA1\uFF1A\u8986\u76D6 Standards\u3001Spec\u3001Architecture \u4E09\u8F74\uFF0C\u53EA\u8F93\u51FA\u5224\u65AD\uFF0C\u4E0D\u4FEE\u6539\u89C4\u5212\u3001\u4E0D\u81EA\u52A8 revise\u3002
+
+## reviewing-verify
+\u53EA\u8BFB\u72EC\u7ACB\u9A8C\u6536\uFF1A\u4E0D\u6539\u4EE3\u7801\u3001\u4E0D\u66FF\u4EE3 implement\uFF0C\u53EA\u8F93\u51FA PASS/FAIL \u4E0E\u8BC1\u636E\u5224\u65AD\u3002
+
+## blocked / complete
+blocked \u8868\u793A\u51BB\u7ED3\uFF1A\u7B49\u5F85 /gate-resume \u6216 /gate-return-discuss\u3002complete \u8868\u793A\u5F53\u524D\u4EFB\u52A1\u5B8C\u6210\uFF0C\u65B0\u4EFB\u52A1\u9700\u8981\u91CD\u65B0\u6388\u6743\u3002`;
+function protocolVariant(state) {
+  if (state.phase === "orchestrating") return NODE_INFO[state.node ?? ""]?.variant ?? state.phase;
+  if (state.phase === "reviewing") return NODE_INFO[state.node ?? ""]?.variant ?? "reviewing-code";
+  return state.phase;
+}
+function procedureFor(state, { reviewLimit = DEFAULT_REVIEW_LIMIT } = {}) {
+  const variant = protocolVariant(state);
+  const method = NODE_METHODS[state.node ?? ""] ?? "\u65E0";
+  let text;
+  if (variant === "discuss") {
+    text = "discuss \u4E0D\u6D3E worker\uFF1B\u4E3B\u4EE3\u7406\u53EF\u81EA\u884C\u8BFB/\u5199\uFF1B\u7528\u6237\u6388\u6743\u540E\u8C03\u7528 gate_start_phase \u8FDB\u5165 plan/implement\u3002";
+  } else if (variant === "blocked") {
+    text = `Gate \u5DF2\u51BB\u7ED3\uFF1A${state.blockReason ?? "unknown"}\uFF1B\u89E3\u51BB\u540E\u56DE ${state.blockedFrom?.phase ?? "discuss"} / ${state.blockedFrom?.node ?? "\u65E0"}\uFF1B\u7528 /gate-resume \u6216 /gate-return-discuss\u3002`;
+  } else if (variant === "complete") {
+    text = "Gate \u5DF2\u5B8C\u6210\uFF1B\u65B0\u4EFB\u52A1\u9700\u8981\u91CD\u65B0\u6388\u6743\u3002";
+  } else if (variant === "docs") {
+    text = DOCS_ORCHESTRATION;
+  } else {
+    text = NODE_PROCEDURES[state.node ?? ""] ?? "";
+  }
+  if (text === "") {
+    text = "\u5F53\u524D phase/node \u6CA1\u6709\u5339\u914D\u7684 procedure\uFF1B\u8C03\u7528 gate_status \u91CD\u65B0\u8BFB\u53D6\uFF1B\u82E5\u4ECD\u4E0D\u4E00\u81F4\uFF0C\u56DE discuss \u4FEE\u590D Gate \u72B6\u6001\u3002";
+  }
+  if (["plan", "implement", "fix-bug", "reviewing-code", "reviewing-proposal", "reviewing-verify"].includes(variant)) {
+    text = [text, DISPATCH_RULE].filter(Boolean).join("\n\n");
+  }
+  if (variant === "plan" || variant === "implement") {
+    text = [text, `## \u5F53\u524D\u8F6E\u6B21
+${roundsText(state, reviewLimit)}`].filter(Boolean).join("\n\n");
+  }
+  return { phase: state.phase, node: state.node, method, text, hasRounds: variant === "plan" || variant === "implement" };
+}
+function procedureFailure(state, reviewLimit, fields) {
+  const procedure = procedureFor(state, { reviewLimit });
+  return { ok: false, ...fields, procedure, method: procedure.method };
+}
+function roundNumbers(state) {
+  const inPlan = state.node === "plan-review";
+  const inCode = state.node === "code-review";
+  return {
+    inPlan,
+    inCode,
+    planRound: (state.rounds?.planReview ?? 0) + (inPlan ? 1 : 0),
+    codeRound: (state.rounds?.codeReview ?? 0) + (inCode ? 1 : 0)
+  };
+}
+function roundsText(state, reviewLimit) {
+  const { inPlan, inCode, planRound, codeRound } = roundNumbers(state);
+  return `plan ${planRound}/${reviewLimit}${inPlan ? "\uFF08\u5F53\u524D\uFF09" : ""}, code ${codeRound}/${reviewLimit}${inCode ? "\uFF08\u5F53\u524D\uFF09" : ""}`;
+}
+function statusText(state, reviewLimit = DEFAULT_REVIEW_LIMIT, { includeRounds = true } = {}) {
+  const { inPlan, inCode } = roundNumbers(state);
+  const lines = [
+    `\u72B6\u6001\uFF1A${state.phase}`,
+    `\u8282\u70B9\uFF1A${state.node ?? "\u65E0"}`,
+    `\u4E8B\u9879\uFF1A${state.task ?? "\u65E0"}`,
+    ...state.phase === "blocked" ? [`\u89E3\u51BB\u540E\uFF1A${state.blockedFrom?.phase ?? "discuss"}${state.blockedFrom?.node === null || state.blockedFrom?.node === void 0 ? "" : ` / ${state.blockedFrom.node}`}`] : [],
+    `work\uFF1A${state.work}`,
+    `blockReason\uFF1A${state.blockReason ?? "\u65E0"}`,
+    `planReady\uFF1A${state.planReady ? "\u662F" : "\u5426"}`,
+    ...includeRounds ? [`rounds\uFF1A${roundsText(state, reviewLimit)}`] : []
+  ];
+  if (state.notePaths?.length > 0 || state.noteDecision === "mechanical") {
+    lines.push(`notes\uFF1A${state.noteDecision ?? "\u65E0"} ${state.notePaths?.length ?? 0} \u7BC7\uFF0Cverified=${state.noteVerified === true ? "\u662F" : "\u5426"}`);
+  }
+  if (state.exhausted?.plan === true || state.exhausted?.code === true) {
+    lines.push(`exhausted\uFF1Aplan ${state.exhausted.plan ? "\u662F" : "\u5426"}, code ${state.exhausted.code ? "\u662F" : "\u5426"}`);
+  }
+  if (state.verification !== null) {
+    lines.push(`verify\uFF1A${state.verification.passed === true ? "PASS" : "FAIL"}\uFF08${state.verification.selfReported === true ? "self-reported" : "verified"}\uFF09`);
+  }
+  return lines.join("\n");
+}
+function procedureBlock(procedure) {
+  return `\u5F53\u524D phase/node\uFF1A${procedure.phase} / ${procedure.node ?? "\u65E0"}
+\u65B9\u6CD5\uFF1A${procedure.method}
+
+${procedure.text}`;
+}
+function procedureResultText(procedure, trailing) {
+  return [procedureBlock(procedure), trailing].filter(Boolean).join("\n\n---\n\n");
+}
+function renderProcedureResult(value) {
+  const { procedure, ...rest } = value ?? {};
+  const trailing = JSON.stringify(rest);
+  return [{ type: "text", text: procedure !== null && procedure !== void 0 ? procedureResultText(procedure, trailing) : trailing }];
+}
+
+// src/state.ts
+var PHASES = ["discuss", "orchestrating", "reviewing", "docs", "blocked", "complete"];
+var states = /* @__PURE__ */ new WeakMap();
+var idStates = /* @__PURE__ */ new Map();
+function idKey(root, agent) {
+  return `${root}\0${String(agent?.id ?? "anonymous")}`;
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function defaultState() {
+  return {
+    phase: "discuss",
+    node: null,
+    task: null,
+    work: "active",
+    blockReason: null,
+    rounds: { planReview: 0, codeReview: 0 },
+    exhausted: { plan: false, code: false },
+    planReady: false,
+    verification: null,
+    blockedFrom: null,
+    notePaths: [],
+    noteDecision: null,
+    noteSearch: null,
+    noteVerified: false,
+    noteFinalized: false,
+    noteFinalizeRecovery: [],
+    pending: {},
+    updatedAt: null
+  };
+}
+function textOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function normalizeState(value) {
+  const base = defaultState();
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return base;
+  const source = value;
+  const phase = PHASES.includes(source.phase) ? source.phase : "discuss";
+  const blockedFrom = source.blockedFrom !== null && typeof source.blockedFrom === "object" && !Array.isArray(source.blockedFrom) ? { phase: textOrNull(source.blockedFrom.phase), node: textOrNull(source.blockedFrom.node) } : null;
+  return {
+    phase,
+    node: textOrNull(source.node),
+    task: textOrNull(source.task),
+    work: textOrNull(source.work) ?? "active",
+    blockReason: textOrNull(source.blockReason),
+    rounds: {
+      planReview: Number(source.rounds?.planReview) || 0,
+      codeReview: Number(source.rounds?.codeReview) || 0
+    },
+    exhausted: {
+      plan: source.exhausted?.plan === true,
+      code: source.exhausted?.code === true
+    },
+    planReady: source.planReady === true,
+    verification: source.verification !== null && typeof source.verification === "object" && !Array.isArray(source.verification) ? clone(source.verification) : null,
+    blockedFrom,
+    notePaths: Array.isArray(source.notePaths) ? source.notePaths.map((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry) ? { ...entry } : entry) : [],
+    noteDecision: textOrNull(source.noteDecision),
+    noteSearch: textOrNull(source.noteSearch),
+    noteVerified: source.noteVerified === true,
+    noteFinalized: source.noteFinalized === true,
+    noteFinalizeRecovery: Array.isArray(source.noteFinalizeRecovery) ? source.noteFinalizeRecovery : [],
+    pending: source.pending !== null && typeof source.pending === "object" && !Array.isArray(source.pending) ? source.pending : {},
+    updatedAt: textOrNull(source.updatedAt)
+  };
+}
+function loadState(root, agent) {
+  const session = agent?.session;
+  if (session !== null && typeof session === "object" && states.has(session)) {
+    return clone(states.get(session));
+  }
+  return clone(idStates.get(idKey(root, agent)) ?? defaultState());
+}
+function saveState(root, agent, state) {
+  const next = normalizeState({ ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  const session = agent?.session;
+  if (session !== null && typeof session === "object") states.set(session, clone(next));
+  idStates.set(idKey(root, agent), clone(next));
+  return clone(next);
+}
+
+// src/notes/note-files.ts
+import { existsSync as existsSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path4 from "node:path";
+
+// src/notes/fs.ts
+import { existsSync, lstatSync } from "node:fs";
+import path2 from "node:path";
+
+// src/paths.ts
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_ROOT = fileURLToPath(new URL("..", import.meta.url));
+var SKILLS = path.join(PACKAGE_ROOT, "skills");
+var NOTES_SKILL_DIR = path.join(SKILLS, "gate-write-agent-notes");
+var NOTES_LAUNCHER_TEMPLATE = path.join(PACKAGE_ROOT, "launchers", "verify-notes.mjs");
+var NOTES_CI_TEMPLATE = path.join(PACKAGE_ROOT, "launchers", "verify-notes.yml");
+var NOTES_CI_SCRIPTS = [
+  "agent-note-tree.ts",
+  "verify-agent-note-tree.ts",
+  "verify-agent-note-format.ts",
+  "verify-agent-note-lifecycle.ts",
+  "verify-archived-agent-notes.ts"
+];
+
+// src/notes/fs.ts
+function isInside(root, target) {
+  const relative = path2.relative(root, target);
+  return relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== ".." && !path2.isAbsolute(relative);
+}
+function resolveNotesSkill() {
+  const skill = path2.join(NOTES_SKILL_DIR, "SKILL.md");
+  if (!existsSync(skill)) return void 0;
+  const template = path2.join(NOTES_SKILL_DIR, "templates", "proposed.md");
+  return { skill, template: existsSync(template) ? template : void 0 };
+}
+function resolveNodeBinary() {
+  if (!process.versions?.electron) return process.execPath;
+  const configured = process.env.DSH_DESKTOP_NODE_EXECUTABLE;
+  if (typeof configured === "string" && configured !== "" && existsSync(configured)) return configured;
+  if (typeof process.resourcesPath === "string" && process.resourcesPath !== "") {
+    const bin = path2.join(process.resourcesPath, "runtime", "primary-runtime", "dependencies", "node", "bin", process.platform === "win32" ? "node.exe" : "node");
+    if (existsSync(bin)) return bin;
+  }
+  return void 0;
+}
+function pathHasSymlink(base, absolute) {
+  const relative = path2.relative(base, absolute);
+  if (relative === "" || relative.startsWith("..")) return true;
+  let current = base;
+  if (existsSync(current) && lstatSync(current).isSymbolicLink()) return true;
+  for (const part of relative.split(path2.sep)) {
+    if (part === "") continue;
+    current = path2.join(current, part);
+    if (existsSync(current) && lstatSync(current).isSymbolicLink()) return true;
+  }
+  return false;
+}
+
+// src/notes/scripts.ts
+import { execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import path3 from "node:path";
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+function runNotesScripts(root) {
+  const node = resolveNodeBinary();
+  if (node === void 0) return { ok: false, code: "notes-runtime-unavailable", results: [] };
+  const notes = path3.join(root, ".agents", "notes");
+  const scripts = [
+    "verify-agent-note-tree.ts",
+    "verify-agent-note-format.ts",
+    "verify-agent-note-lifecycle.ts",
+    "verify-archived-agent-notes.ts"
+  ];
+  const results = [];
+  for (const name of scripts) {
+    const script = path3.join(NOTES_SKILL_DIR, "scripts", name);
+    try {
+      const output = execFileSync(node, [script, "--root", notes], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+      results.push({ name, ok: true, output: String(output).trim() });
+    } catch (error) {
+      return {
+        ok: false,
+        code: "note-verification-failed",
+        results: [...results, { name, ok: false, output: String(error?.stdout ?? "").trim(), error: String(error?.stderr ?? error?.message ?? error).trim() }]
+      };
+    }
+  }
+  return { ok: true, results };
+}
+function runFormatOnNote(root, entry, content) {
+  const node = resolveNodeBinary();
+  if (node === void 0) return { code: "notes-runtime-unavailable", reason: "\u65E0\u6CD5\u5B9A\u4F4D Node \u53EF\u6267\u884C\u6587\u4EF6\u3002" };
+  const temp = path3.join(root, ".agents", "notes", `.gate-validate-${randomUUID()}`);
+  const relative = path3.join(String(entry.lifecycle ?? "proposed"), String(entry.class ?? "feature"), path3.basename(String(entry.path)));
+  try {
+    mkdirSync(path3.dirname(path3.join(temp, relative)), { recursive: true });
+    writeFileSync(path3.join(temp, relative), content);
+    execFileSync(node, [path3.join(NOTES_SKILL_DIR, "scripts", "verify-agent-note-format.ts"), "--root", temp], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    return void 0;
+  } catch (error) {
+    return { code: "note-format-invalid", path: entry.path, reason: String(error?.stderr ?? error?.message ?? error).trim() };
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+// src/notes/note-files.ts
+function splitNoteSections(content) {
+  const lines = content.replace(/\r\n?/gu, "\n").split("\n");
+  const preamble = [];
+  const sections = [];
+  let current = null;
+  let fenced = false;
+  for (const line of lines) {
+    if (/^\s*```/u.test(line)) fenced = !fenced;
+    if (!fenced && /^## /u.test(line)) {
+      current = { heading: line, body: [] };
+      sections.push(current);
+    } else if (current === null) {
+      preamble.push(line);
+    } else {
+      current.body.push(line);
+    }
+  }
+  return { preamble, sections };
+}
+function transformImplemented(content) {
+  const { preamble, sections } = splitNoteSections(content);
+  const statusIndex = preamble.findIndex((line) => /^Status:/u.test(line));
+  if (statusIndex >= 0) preamble[statusIndex] = "Status: implemented";
+  const kept = [];
+  const extras = [];
+  let hasDecision = false;
+  let consequences = null;
+  for (const section of sections) {
+    if (/^## Proposal\s*$/u.test(section.heading)) {
+      section.heading = "## Decision";
+      hasDecision = true;
+    }
+    if (/^## Plan\s*$/u.test(section.heading)) continue;
+    if (/^## Acceptance criteria\s*$/u.test(section.heading)) {
+      extras.push({ heading: "### Acceptance criteria", body: section.body.join("\n").trim() });
+      continue;
+    }
+    if (/^## Risks\s*$/u.test(section.heading)) {
+      extras.push({ heading: "### Risks", body: section.body.join("\n").trim() });
+      continue;
+    }
+    if (/^## Consequences\s*$/u.test(section.heading)) consequences = section;
+    kept.push(section);
+  }
+  if (!hasDecision) throw new Error("Note \u7F3A\u5C11 ## Proposal\uFF0C\u65E0\u6CD5\u8F6C\u6210 ## Decision");
+  const extraText = extras.filter((item) => item.body !== "").map((item) => `${item.heading}
+
+${item.body}`).join("\n\n");
+  if (extraText !== "") {
+    if (consequences === null) {
+      consequences = { heading: "## Consequences", body: [] };
+      kept.push(consequences);
+    }
+    consequences.body.push("", extraText);
+  }
+  const out = [...preamble, ...kept.flatMap((section) => [section.heading, ...section.body])];
+  return `${out.join("\n").replace(/\s+$/u, "")}
+`;
+}
+function replaceSectionBody(content, heading, body) {
+  const { preamble, sections } = splitNoteSections(content);
+  const target = sections.find((section) => section.heading === heading);
+  if (target === void 0) throw new Error(`\u7F3A\u5C11 ${heading}`);
+  target.body = ["", body];
+  return `${[...preamble, ...sections.flatMap((section) => [section.heading, ...section.body])].join("\n").replace(/\s+$/u, "")}
+`;
+}
+function recoverFinalize(root, sessionId) {
+  const journal = path4.join(root, ".agents", "notes", `.gate-finalize-${sessionId}.json`);
+  if (!existsSync2(journal)) return [];
+  let data;
+  try {
+    data = JSON.parse(readFileSync(journal, "utf8"));
+  } catch {
+    return [];
+  }
+  if (data?.owner !== sessionId) return [];
+  const recovered = [];
+  const source = path4.join(root, data.source);
+  const backup = path4.join(root, data.backup);
+  const target = path4.join(root, data.target);
+  try {
+    if (existsSync2(backup)) {
+      if (!existsSync2(source) && !existsSync2(target)) {
+        renameSync(backup, source);
+        recovered.push("restored-source");
+      } else if (!existsSync2(source) && existsSync2(target)) {
+        const check = runNotesScripts(root);
+        if (!check.ok) {
+          rmSync2(target, { force: true });
+          renameSync(backup, source);
+          recovered.push("restored-source-after-bad-target");
+        } else {
+          rmSync2(backup, { force: true });
+          recovered.push("kept-target");
+        }
+      } else if (existsSync2(source) && !existsSync2(target)) {
+        rmSync2(backup, { force: true });
+        recovered.push("removed-backup");
+      }
+    }
+    const temp = typeof data.temp === "string" ? path4.join(root, data.temp) : void 0;
+    if (!existsSync2(backup) && (temp === void 0 || !existsSync2(temp))) recovered.push("journal-orphan");
+    rmSync2(journal, { force: true });
+  } catch {
+  }
+  return recovered;
+}
+function finalizeNote(root, entry, sessionId, decisionBody) {
+  const sourceRelative = entry.path.replaceAll("\\", "/");
+  const source = path4.join(root, sourceRelative);
+  const targetRelative = sourceRelative.replace(".agents/notes/proposed/", ".agents/notes/implemented/");
+  const target = path4.join(root, targetRelative);
+  if (existsSync2(target)) throw new Error(`\u76EE\u6807\u5DF2\u5B58\u5728\uFF1A${targetRelative}`);
+  if (pathHasSymlink(root, source) || pathHasSymlink(root, target)) throw new Error("finalize \u8DEF\u5F84\u542B symlink");
+  const content = readFileSync(source, "utf8");
+  let next = transformImplemented(content);
+  if (typeof decisionBody === "string" && decisionBody !== "") next = replaceSectionBody(next, "## Decision", decisionBody);
+  const sourceFromNotes = sourceRelative.replace(/^\.agents\/notes\//u, "");
+  const targetFromNotes = targetRelative.replace(/^\.agents\/notes\//u, "");
+  next = next.replaceAll(sourceRelative, targetRelative).replaceAll(sourceFromNotes, targetFromNotes);
+  const dir = path4.dirname(target);
+  mkdirSync2(dir, { recursive: true });
+  const journalRelative = path4.join(".agents", "notes", `.gate-finalize-${sessionId}.json`).replaceAll("\\", "/");
+  const journal = path4.join(root, journalRelative);
+  const backup = `${source}.gate-backup`;
+  const temp = path4.join(dir, `.gate-finalize-${path4.basename(target)}.tmp`);
+  writeFileSync2(journal, JSON.stringify({ owner: sessionId, source: sourceRelative, target: targetRelative, backup: path4.relative(root, backup).replaceAll("\\", "/"), temp: path4.relative(root, temp).replaceAll("\\", "/") }, null, 2));
+  try {
+    writeFileSync2(temp, next);
+    renameSync(source, backup);
+    renameSync(temp, target);
+    const check = runNotesScripts(root);
+    if (!check.ok) throw new Error(`finalize \u540E\u7684 notes \u6821\u9A8C\u5931\u8D25\uFF1A${JSON.stringify(check.results)}`);
+    rmSync2(backup, { force: true });
+    rmSync2(journal, { force: true });
+    return targetRelative.replaceAll("\\", "/");
+  } catch (error) {
+    rmSync2(target, { force: true });
+    rmSync2(temp, { force: true });
+    if (existsSync2(backup) && !existsSync2(source)) renameSync(backup, source);
+    rmSync2(journal, { force: true });
+    throw error;
+  }
+}
+var NOTE_CLASSES = /* @__PURE__ */ new Set(["feature", "bug-fix", "simplification", "architecture", "process", "testing"]);
+function noteTopic(file) {
+  return path4.basename(file).replace(/^\d{4}-\d{2}-\d{2}-/u, "").replace(/\.md$/u, "").replace(/-implemented$/u, "").toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-|-$/gu, "");
+}
+function normalizeNotePaths(value) {
+  if (!Array.isArray(value)) return value;
+  return value.map((entry) => {
+    if (entry === null || typeof entry !== "object" || typeof entry.path !== "string") return entry;
+    const normalized = entry.path.replaceAll("\\", "/").replace(/^\.\//u, "");
+    if (normalized.startsWith(".agents/notes/")) return { ...entry, path: normalized };
+    const parts = normalized.split("/");
+    if (parts[0] === "proposed" || parts[0] === "implemented") return { ...entry, path: `.agents/notes/${normalized}` };
+    if (typeof entry.class === "string" && parts[0] === entry.class && typeof entry.lifecycle === "string") {
+      return { ...entry, path: `.agents/notes/${entry.lifecycle}/${normalized}` };
+    }
+    return { ...entry, path: normalized };
+  });
+}
+function notePathsForDecision(value, decision) {
+  return decision === "mechanical" ? value : normalizeNotePaths(value);
+}
+function validateNotePaths(root, value, decision) {
+  if (decision === "mechanical") {
+    if (!Array.isArray(value) || value.length !== 0) return { code: "note-paths-required", reason: "mechanical \u7684 notePaths \u5FC5\u987B\u4E3A\u7A7A\u3002" };
+    return void 0;
+  }
+  if (!Array.isArray(value) || value.length === 0) return { code: "note-paths-required", reason: "\u975E mechanical \u5DE5\u4F5C\u9879\u81F3\u5C11\u9700\u8981\u4E00\u4E2A notePath\u3002" };
+  const seenTopics = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || typeof entry.path !== "string" || typeof entry.class !== "string" || typeof entry.lifecycle !== "string") {
+      return { code: "invalid-note-path", reason: "notePaths[] \u9700\u8981 {path,class,lifecycle}\u3002" };
+    }
+    if (!NOTE_CLASSES.has(entry.class)) return { code: "invalid-note-class", class: entry.class };
+    if (!["proposed", "implemented"].includes(entry.lifecycle)) return { code: "invalid-note-lifecycle", lifecycle: entry.lifecycle };
+    if (decision === "new" && entry.lifecycle !== "proposed") return { code: "note-decision-mismatch", reason: "new \u53EA\u80FD proposed\u3002" };
+    if (decision === "update" && entry.lifecycle !== "proposed") return { code: "note-decision-mismatch", reason: "update \u53EA\u80FD proposed\u3002" };
+    if (decision === "in-place" && entry.lifecycle !== "implemented") return { code: "note-decision-mismatch", reason: "in-place \u53EA\u80FD implemented\u3002" };
+    const normalized = entry.path.replaceAll("\\", "/");
+    if (normalized.startsWith("/") || normalized.includes("..")) return { code: "invalid-note-path", path: entry.path };
+    const parts = normalized.split("/");
+    if (parts.length !== 5 || parts[0] !== ".agents" || parts[1] !== "notes" || parts[2] !== entry.lifecycle || parts[3] !== entry.class) {
+      return { code: "invalid-note-path", path: entry.path, reason: "\u9700\u8981 .agents/notes/<lifecycle>/<class>/yyyy-mm-dd-topic.md\u3002" };
+    }
+    const filePart = parts[4];
+    if (!/^\d{4}-\d{2}-\d{2}-.+\.md$/u.test(String(filePart))) return { code: "invalid-note-path", path: entry.path, reason: "\u6587\u4EF6\u540D\u9700\u8981 yyyy-mm-dd-topic.md\u3002" };
+    const absolute = path4.join(root, ...parts);
+    if (!isInside(root, absolute) || pathHasSymlink(root, absolute)) return { code: "invalid-note-path", path: entry.path, reason: "\u8DEF\u5F84\u8D8A\u754C\u6216\u542B symlink\u3002" };
+    if (!existsSync2(absolute) || !lstatSync2(absolute).isFile()) return { code: "note-missing", path: entry.path };
+    const content = readFileSync(absolute, "utf8");
+    const status = content.match(/^Status:\s*(proposed|implemented)\s*$/mu)?.[1];
+    if (status !== entry.lifecycle) return { code: "note-status-mismatch", path: entry.path, expected: entry.lifecycle, got: status ?? "missing" };
+    const format = runFormatOnNote(root, entry, content);
+    if (format !== void 0) return format;
+    const topic = noteTopic(String(filePart));
+    if (seenTopics.has(topic)) return { code: "note-topic-duplicate", topic, reason: "\u540C\u4E00 topic \u53EA\u80FD\u6709\u4E00\u7BC7\u3002" };
+    seenTopics.add(topic);
+    for (const other of ["proposed", "implemented", "rejected"]) {
+      const dir = path4.join(root, ".agents", "notes", other, entry.class);
+      if (!existsSync2(dir)) continue;
+      for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".md") || name === path4.basename(String(filePart))) continue;
+        if (noteTopic(name) === topic) return { code: "note-topic-duplicate", topic, other: path4.join(dir, name) };
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/runtime/store.ts
+function applyCommandEvent(state, name, args) {
+  const text = String(args ?? "").trim();
+  switch (name) {
+    case "gate-enter-plan":
+      return {
+        ...state,
+        phase: "orchestrating",
+        node: "plan",
+        task: null,
+        work: "active",
+        blockReason: null,
+        blockedFrom: null,
+        rounds: { planReview: 0, codeReview: 0 },
+        exhausted: { plan: false, code: false },
+        planReady: false,
+        verification: null,
+        notePaths: [],
+        noteDecision: null,
+        noteSearch: null,
+        noteVerified: false,
+        noteFinalizeRecovery: []
+      };
+    case "gate-enter-implement":
+      return {
+        ...state,
+        phase: "orchestrating",
+        node: "implement",
+        work: "active",
+        task: state.planReady !== true && text !== "" ? text : state.task,
+        blockReason: null,
+        blockedFrom: null,
+        verification: null,
+        noteVerified: false,
+        noteFinalizeRecovery: []
+      };
+    case "gate-fix-bug":
+      return { ...state, phase: "orchestrating", task: text === "" ? state.task ?? "\u5F53\u524D\u4E0A\u4E0B\u6587\u4E2D\u7684\u7F3A\u9677" : text, node: "fix-bug", work: "active", blockReason: null, blockedFrom: null };
+    case "gate-docs":
+      return { ...state, phase: "docs", task: text, node: null, work: "active", blockReason: null, blockedFrom: null };
+    case "gate-implement-review":
+      return { ...state, phase: "reviewing", task: text, node: "code-review-standalone", work: "active", blockReason: null, blockedFrom: null };
+    case "gate-code-verify":
+      return { ...state, phase: "reviewing", task: text, node: "verify-standalone", work: "active", blockReason: null, blockedFrom: null };
+    case "gate-propose-review":
+      return { ...state, phase: "reviewing", task: text, node: "proposal-review", work: "active", blockReason: null, blockedFrom: null };
+    case "gate-block":
+      return {
+        ...state,
+        blockedFrom: { phase: state.phase, node: state.node },
+        phase: "blocked",
+        work: "blocked",
+        node: null,
+        blockReason: text === "" ? "user-blocked" : text
+      };
+    case "gate-resume":
+      return {
+        ...state,
+        phase: state.blockedFrom?.phase ?? "discuss",
+        node: state.blockedFrom?.node ?? null,
+        work: "active",
+        blockReason: null,
+        blockedFrom: null
+      };
+    case "gate-return-discuss":
+      return { ...state, phase: "discuss", node: null, work: "active", blockReason: null, blockedFrom: null };
+    default:
+      return state;
+  }
+}
+function applyProjectionEvent(state, event) {
+  if (event.type === "command/run" && typeof event.data?.name === "string" && event.data.name.startsWith("gate-")) {
+    return {
+      ...state,
+      pending: { ...state.pending ?? {}, [event.data.commandId]: { name: event.data.name, args: event.data.args ?? "" } }
+    };
+  }
+  if (event.type === "command/done") {
+    const pending = state.pending?.[event.data?.commandId];
+    if (pending === void 0) return state;
+    const next = { ...state, pending: { ...state.pending } };
+    delete next.pending[event.data.commandId];
+    if (event.data.kind !== "success") return next;
+    return applyCommandEvent(next, pending.name, pending.args);
+  }
+  if (event.type === "tool/result") {
+    const snapshot = event.data?.meta?.gate?.state;
+    if (snapshot !== void 0) return normalizeState(snapshot);
+  }
+  return state;
+}
+function createStateRuntime(ctx) {
+  let handle;
+  ctx.inject(["sessionProjections"], async (scope) => {
+    try {
+      handle = await scope.sessionProjections.register({
+        key: "gate",
+        stateSchema: { parse: normalizeState },
+        init: () => defaultState(),
+        apply: applyProjectionEvent,
+        stateVersion: 1
+      });
+    } catch {
+      handle = void 0;
+    }
+  });
+  return {
+    read(root, agent) {
+      if (handle !== void 0 && agent?.session !== void 0) {
+        try {
+          return normalizeState(handle.stateOf(agent.session));
+        } catch {
+        }
+      }
+      return loadState(root, agent);
+    },
+    write(root, agent, state) {
+      if (handle !== void 0) return state;
+      return saveState(root, agent, state);
+    },
+    get source() {
+      return handle === void 0 ? "memory" : "projection";
+    },
+    get projection() {
+      return handle;
+    }
+  };
+}
+
+// src/runtime/gate.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/runtime/session.ts
+import path5 from "node:path";
+function workspaceBoundary(ctx, agent) {
+  try {
+    const policy = ctx.get("sandboxPolicy");
+    const resolved = policy?.resolve?.({ session: agent?.session });
+    if (resolved?.workspaceRoot !== void 0) return resolved.workspaceRoot;
+  } catch {
+  }
+  return agent?.session?.header?.cwd;
+}
+function resolveGate(ctx, agent) {
+  const workspace = workspaceBoundary(ctx, agent);
+  const root = workspace === void 0 ? void 0 : path5.resolve(workspace);
+  if (root === void 0) return { workspace, root: void 0 };
+  return { workspace: root, root };
+}
+function sessionCwd(ctx, agent, fallback) {
+  try {
+    const cwd = ctx.get("workingDirectory")?.get?.(agent?.session);
+    if (typeof cwd === "string" && cwd !== "") return cwd;
+  } catch {
+  }
+  return fallback;
+}
+function rootAgentOf(ctx, agent) {
+  const header = agent?.session?.header;
+  const delegated = header?.origin === "subagent" && typeof header.parentSession === "string";
+  try {
+    const root = ctx.get("subagents")?.rootOf?.(agent);
+    if (root !== void 0 && root.id !== agent?.id) return root;
+  } catch {
+  }
+  if (delegated) {
+    try {
+      const live = ctx.get("agents")?.get?.(header.parentSession);
+      if (live !== void 0) return live;
+    } catch {
+    }
+    return { id: header.parentSession };
+  }
+  return agent;
+}
+function effectiveState(ctx, agent, gate, store) {
+  const root = rootAgentOf(ctx, agent);
+  return { root, state: store.read(gate.root, root), worker: root?.id !== agent?.id };
+}
+
+// src/runtime/gate.ts
+function isMechanical(task) {
+  return /^mechanical:/iu.test(String(task ?? "").trim());
+}
+function enterPhase(ctx, agent, node, reviewLimit, store, current) {
+  const gate = resolveGate(ctx, agent);
+  const state = current ?? store.read(gate.root, agent);
+  if (state.phase !== "discuss" && state.phase !== "complete") return { kind: "error", text: `\u5F53\u524D phase \u662F ${state.phase}` };
+  if (state.work === "blocked" || state.blockReason !== null) {
+    return { kind: "error", text: `\u5F53\u524D\u88AB blocked\uFF1A${state.blockReason ?? "unknown"}\uFF1B\u5148 /gate-resume` };
+  }
+  if (node === "plan") {
+    const notes = resolveNotesSkill();
+    if (notes === void 0) return { kind: "error", code: "notes-builtin-missing", text: "\u5185\u7F6E write-agent-notes \u7F3A\u5931\uFF1B\u91CD\u88C5\u63D2\u4EF6\u3002" };
+  }
+  if (node === "implement") {
+    if (typeof state.task !== "string" || state.task === "") return { kind: "error", text: "\u6CA1\u6709\u53EF\u5B9E\u65BD\u7684\u5185\u5BB9\uFF1A\u5148\u7528\u4E00\u53E5\u8BDD\u8BF4\u660E\u8981\u6539\u4EC0\u4E48" };
+    if (state.exhausted?.plan === true || state.exhausted?.code === true) {
+      return { kind: "error", text: "review \u8F6E\u6B21\u5DF2\u8017\u5C3D\uFF1B\u9700\u8981\u7528\u6237\u51B3\u5B9A\u540E\u91CD\u65B0 /gate-enter-plan" };
+    }
+  }
+  state.phase = "orchestrating";
+  state.node = node;
+  state.work = "active";
+  state.blockReason = null;
+  state.blockedFrom = null;
+  if (node === "plan") {
+    state.rounds = { planReview: 0, codeReview: 0 };
+    state.exhausted = { plan: false, code: false };
+    state.task = null;
+    state.planReady = false;
+    state.verification = null;
+    state.notePaths = [];
+    state.noteDecision = null;
+    state.noteSearch = null;
+    state.noteVerified = false;
+    state.noteFinalized = false;
+    state.noteFinalizeRecovery = [];
+  }
+  if (node === "implement") {
+    state.verification = null;
+    state.noteVerified = false;
+    state.noteFinalized = false;
+    state.noteFinalizeRecovery = [];
+  }
+  store.write(gate.root, agent, state);
+  return { gate, state, reviewLimit };
+}
+function wakeGateAgent(invocation, text, command) {
+  const followup = invocation?.agent?.followup;
+  if (typeof followup !== "function") return;
+  try {
+    followup.call(invocation.agent, {
+      id: randomUUID2(),
+      role: "user",
+      content: [{ type: "text", text }],
+      source: { kind: "gate-command", command }
+    });
+  } catch {
+  }
+}
+function makeWake(reviewLimit) {
+  return (invocation, state, text, command) => {
+    const procedure = procedureFor(state, { reviewLimit });
+    wakeGateAgent(invocation, `${procedureBlock(procedure)}
+
+${text}`, command);
+  };
+}
+
+// src/runtime/workers.ts
+function workerProtocol(node) {
+  return [
+    "## Gate worker",
+    "\u4F60\u662F gate \u4E3A\u8BE5\u8282\u70B9\u6D3E\u53D1\u7684 worker\u3002\u53EA\u6267\u884C\u8BE5\u8282\u70B9\uFF1B\u4E0D\u8981\u8C03\u7528 gate_record\uFF0C\u4E0D\u8981\u63A8\u8FDB gate\u3002",
+    node === "verify-standalone" ? "\u52A0\u8F7D\u4F7F\u7528 gate-user-verify \u5B8C\u6210\u9A8C\u6536\uFF0C\u5E76\u6309\u8BE5\u6280\u80FD Step 6 \u6C47\u62A5\u3002\u4EFB\u52A1\u4E0E\u6C47\u62A5\u6A21\u677F\u89C1\u8BE5\u6280\u80FD assets/worker-briefs/gate-code-verify.md\u3002\u4E0D\u4FEE\u6539\u4EA7\u54C1\u4EE3\u7801\u3001\u6D4B\u8BD5\u3001\u9700\u6C42\u6216\u8BBE\u8BA1\uFF1B\u53EF\u4EE5\u8FD0\u884C\u6D4B\u8BD5/\u547D\u4EE4\u4F5C\u4E3A\u8BC1\u636E\uFF0C\u4F46\u4E0D\u5F97\u4FEE\u6539\u3001\u653E\u5BBD\u6216\u91CD\u5199\u6D4B\u8BD5\uFF1B\u4E0D\u8981\u81EA\u884C\u63D0\u4EA4\u3002" : node === "fix-bug" ? "\u4E3B\u4EE3\u7406\u5DF2\u8BFB\u53D6 gate-fix-bug\uFF1B\u4F60\u6267\u884C gate-fix-bug \u7684 Process 1-9\uFF08\u590D\u73B0\u3001\u56DE\u5F52\u8986\u76D6\u3001\u6839\u56E0\u3001\u6700\u5C0F\u4FEE\u590D\u3001\u6D4B\u8BD5\uFF09\uFF0C\u8FD4\u56DE\u4FEE\u590D receipt\uFF1B\u4E0D\u8981\u81EA\u884C\u5B8C\u6210 Step 10-12\uFF0C\u4E0D\u8981\u63D0\u4EA4\u3002\u4E0D\u6539\u4EA7\u54C1\u5408\u540C\u3001\u4E0D\u6269\u5927\u8303\u56F4\u3002" : "\u4E3B\u4EE3\u7406\u5DF2\u7ECF\u52A0\u8F7D\u6240\u9700 gate \u6280\u80FD\uFF0C\u5E76\u628A\u5177\u4F53\u4EFB\u52A1\u4E0E\u76F8\u5173\u65B9\u6CD5\u8981\u6C42\u4EA4\u7ED9\u4F60\u3002\u4E0D\u8981\u81EA\u5DF1\u52A0\u8F7D gate \u6280\u80FD\u3002",
+    node === "plan" || node === "plan-revise" ? "\u7528 gate_note_write \u5728 .agents/notes/proposed \u4E0B\u521B\u5EFA\u6216\u66F4\u65B0 proposed Agent Note\uFF1B\u539F\u5730\u540C\u6B65\u65E2\u6709 implemented Note \u65F6\u8DEF\u5F84\u5199 implemented/<class>/...\uFF1Bplanning \u4E2D\u901A\u7528 write/edit/shell \u88AB\u9650\u5236\u3002" : ""
+  ].filter(Boolean).join("\n\n");
+}
+var REVIEW_NODES = /* @__PURE__ */ new Set(["plan-review", "proposal-review", "code-review", "code-review-standalone"]);
+function reviewAxesError(args) {
+  if (!REVIEW_NODES.has(args.node)) return void 0;
+  const axes = args.reviewAxes;
+  const required = args.node === "plan-review" || args.node === "proposal-review" ? ["standards", "spec", "architecture"] : ["standards", "spec"];
+  if (axes === null || typeof axes !== "object" || Array.isArray(axes)) return { code: "review-axes-required", reason: `review \u8282\u70B9\u9700\u8981 ${required.join("\u3001")} \u8F74\u7ED3\u679C\u3002` };
+  for (const axis of required) {
+    const value = axes[axis];
+    if (value === null || typeof value !== "object" || Array.isArray(value) || !Array.isArray(value.findings)) {
+      return { code: "review-axes-required", reason: `${axis} \u8F74\u9700\u8981 findings \u6570\u7EC4\u3002` };
+    }
+  }
+  return void 0;
+}
+async function workerEvidenceError(ctx, root, args) {
+  if (!WORKER_NODES.has(args.node)) return void 0;
+  const ids = Array.isArray(args.workerSessionIds) ? [...new Set(args.workerSessionIds.filter((value) => typeof value === "string" && value !== ""))] : [];
+  if (ids.length === 0) return { code: "worker-required", reason: "gate_record \u9700\u8981 workerSessionIds\uFF1B\u6CA1\u6709 worker \u4E0D\u80FD\u63A8\u8FDB\u3002" };
+  const service = ctx.get("subagents");
+  if (service === void 0 || typeof service.listDescendants !== "function") {
+    return { code: "worker-evidence-unavailable", reason: "subagents.listDescendants \u4E0D\u53EF\u7528\uFF0C\u65E0\u6CD5\u9A8C\u8BC1 worker\u3002" };
+  }
+  let entries;
+  try {
+    entries = await service.listDescendants(root.id);
+  } catch {
+    return { code: "worker-evidence-unavailable", reason: "\u8BFB\u53D6 subagent tree \u5931\u8D25\uFF0C\u65E0\u6CD5\u9A8C\u8BC1 worker\u3002" };
+  }
+  const children = Array.isArray(entries) ? entries.filter((entry) => entry?.kind === "child") : [];
+  for (const id of ids) {
+    const row = children.find((entry) => String(entry.id) === String(id));
+    if (row === void 0) return { code: "worker-not-descendant", workerSessionId: id, reason: "workerSessionId \u4E0D\u5728\u5F53\u524D root \u7684 subagent tree \u4E2D\u3002" };
+  }
+  return void 0;
+}
+async function bindToolResults(ctx, workerSessionIds, toolResults) {
+  const query = ctx.get("sessionQuery");
+  if (query === void 0 || typeof query.readSession !== "function") {
+    return { code: "verification-required", reason: "sessionQuery \u4E0D\u53EF\u7528\uFF0C\u65E0\u6CD5\u7ED1\u5B9A toolResults\u3002" };
+  }
+  const found = /* @__PURE__ */ new Set();
+  for (const sessionId of workerSessionIds) {
+    try {
+      const snapshot = await query.readSession(sessionId);
+      for (const event of snapshot?.events ?? []) {
+        if (event?.type !== "tool/result") continue;
+        const callId = event.data?.message?.toolCallId ?? event.data?.callId;
+        if (callId !== void 0) found.add(String(callId));
+      }
+    } catch {
+    }
+  }
+  const missing = toolResults.filter((id) => !found.has(String(id)));
+  if (missing.length > 0) {
+    return { code: "verification-required", unboundToolResults: missing, reason: "toolResults \u672A\u5728 worker session log \u4E2D\u627E\u5230\u3002" };
+  }
+  return void 0;
+}
+
+// src/runtime/prompt.ts
+function installSystemPrompt(ctx, deps) {
+  ctx.inject(["systemPrompt"], (scope) => {
+    scope.systemPrompt.section({
+      name: "gate:protocol",
+      order: scope.systemPrompt.getSectionOrder("PLAN_POLICY") + 1,
+      text: (context) => {
+        const gate = resolveGate(ctx, context.agent);
+        const effective = effectiveState(ctx, context.agent, gate, deps.store);
+        if (effective.worker) return ["## Gate", "Gate worker\uFF1A\u53EA\u6267\u884C\u5F53\u524D node\uFF0C\u4E0D\u63A8\u8FDB phase\u3002", workerProtocol(effective.state.node ?? "")].filter(Boolean).join("\n\n");
+        return GATE_METHODOLOGY;
+      }
+    });
+  });
+}
+
+// src/classify.ts
+import path6 from "node:path";
+function classifyPath(root, value, cwd = root) {
+  const absolute = path6.resolve(cwd, String(value ?? ""));
+  const relative = path6.relative(root, absolute).replaceAll("\\", "/");
+  const outside = relative === ".." || relative.startsWith("../") || path6.isAbsolute(relative);
+  return { absolute, relative, outside };
+}
+var WRITE_VERB = /(?:^|[\s;(])(Set-Content|Add-Content|Out-File|New-Item|Remove-Item|Move-Item|Copy-Item|Rename-Item|Clear-Content|Set-Item|mkdir|md|touch|tee|rm|mv|cp|sed\s+-i)\b/iu;
+function pathArgs(text) {
+  const beforePipe = String(text).split("|")[0] ?? "";
+  return [...beforePipe.matchAll(/(?:'([^']+)'|"([^"]+)"|(\S+))/gu)].map((match) => match[1] ?? match[2] ?? match[3]).filter((value) => value !== void 0 && !value.startsWith("-"));
+}
+function assignments(text) {
+  const map = /* @__PURE__ */ new Map();
+  for (const match of String(text).matchAll(/(?:^|[;\n])\s*\$?([A-Za-z_]\w*)\s*=\s*(?:'([^']*)'|"([^"]*)"|(\S+))/gu)) {
+    const key = match[1];
+    if (key !== void 0) map.set(key, match[2] ?? match[3] ?? match[4] ?? "");
+  }
+  return map;
+}
+function resolveToken(token, map) {
+  const variable = /^\$([A-Za-z_]\w*)$/u.exec(token);
+  if (variable === null) return token;
+  const key = variable[1];
+  return (key === void 0 ? token : map.get(key)) ?? token;
+}
+function redirectionTargets(text) {
+  return [...String(text).matchAll(/(?:^|\s)>{1,2}\s*(?:'([^']+)'|"([^"]+)"|([^\s;&|]+))/gu)].map((match) => match[1] ?? match[2] ?? match[3]).filter((value) => value !== void 0);
+}
+function pipeTargets(text) {
+  const targets = [];
+  for (const part of String(text).split("|").slice(1)) {
+    const body = part.replace(/^\s*(?:tee|Set-Content|Out-File|Add-Content)\b/iu, "");
+    if (body === part) continue;
+    for (const token of pathArgs(body)) targets.push(token);
+  }
+  return targets;
+}
+function addTarget(targets, token, map) {
+  if (token === void 0 || token === "") return;
+  if (token.startsWith("$")) {
+    const resolved = resolveToken(token, map);
+    if (resolved !== token) targets.push(resolved);
+    return;
+  }
+  targets.push(token);
+}
+function segmentAccess(text, root, cwd, map) {
+  if (/\bgit\s+(?:status|add|commit|push)\b/iu.test(text)) {
+    return { write: false, outsideTargets: [] };
+  }
+  if (/\bgit\s+(?:checkout|reset|clean)\b/iu.test(text)) {
+    return { write: true, outsideTargets: [] };
+  }
+  const raw = [];
+  const verb = WRITE_VERB.exec(text);
+  if (verb !== null) {
+    const tail = text.slice(verb.index + verb[0].length);
+    for (const token of pathArgs(tail)) addTarget(raw, token, map);
+  }
+  for (const token of redirectionTargets(text)) addTarget(raw, token, map);
+  for (const token of pipeTargets(text)) addTarget(raw, token, map);
+  const outsideTargets = [];
+  for (const value of raw) {
+    const target = classifyPath(root, path6.resolve(cwd, value));
+    if (target.outside) outsideTargets.push(target.absolute);
+  }
+  return { write: raw.length > 0 || WRITE_VERB.test(text), outsideTargets };
+}
+function segments(text) {
+  return String(text).split(/&&|\|\||;|\r?\n/u).map((part) => part.trim()).filter(Boolean);
+}
+function shellAccess(command, root, cwd = root) {
+  const map = assignments(command);
+  const parts = segments(command).map((part) => segmentAccess(part, root, cwd, map)).filter((item) => item.write);
+  return {
+    write: parts.length > 0,
+    outsideTargets: parts.flatMap((item) => item.outsideTargets ?? [])
+  };
+}
+
+// src/runtime/guards.ts
+import path7 from "node:path";
+function restrictionFilter(state, worker) {
+  const writeTools = ["write", "edit", "apply_patch", "pwsh", "bash"];
+  if (worker) {
+    if (state.node === "implement" || state.node === "implement-revise" || state.node === "fix-bug") return void 0;
+    return { deny: writeTools };
+  }
+  return state.phase === "blocked" ? { deny: ["write", "edit", "apply_patch"] } : void 0;
+}
+var restrictionState = /* @__PURE__ */ new WeakMap();
+function applyRestrictions(ctx, agent, store) {
+  const tools = agent?.ctx?.tools;
+  if (typeof tools?.restrict !== "function") return;
+  try {
+    const gate = resolveGate(ctx, agent);
+    const previous = restrictionState.get(agent);
+    const effective = effectiveState(ctx, agent, gate, store);
+    const filter = restrictionFilter(effective.state, effective.worker);
+    const key = `${effective.state.phase}/${effective.state.node ?? ""}/${effective.worker ? "worker" : "root"}/${JSON.stringify(filter ?? null)}`;
+    if (previous?.key === key) return;
+    previous?.disposer?.();
+    restrictionState.delete(agent);
+    if (filter !== void 0) {
+      const names = filter.deny.filter((name) => {
+        try {
+          return typeof tools.get !== "function" || tools.get(name) !== void 0;
+        } catch {
+          return false;
+        }
+      });
+      if (names.length > 0) {
+        let disposer;
+        try {
+          disposer = tools.restrict({ deny: names });
+        } catch {
+          const disposers = [];
+          for (const name of names) {
+            try {
+              disposers.push(tools.restrict({ deny: [name] }));
+            } catch {
+            }
+          }
+          if (disposers.length > 0) disposer = () => {
+            for (const release of disposers) release();
+          };
+        }
+        if (disposer !== void 0) restrictionState.set(agent, { key, disposer });
+      }
+    }
+  } catch {
+  }
+}
+function workerWriteAllowed(state, target) {
+  if (state.phase !== "orchestrating") return false;
+  if (state.node === "plan" || state.node === "plan-revise") return false;
+  if (state.node === "implement" || state.node === "implement-revise" || state.node === "fix-bug") return true;
+  return false;
+}
+function workerShellAllowed(state, access) {
+  if (state.phase !== "orchestrating") return false;
+  return state.node === "implement" || state.node === "implement-revise" || state.node === "fix-bug";
+}
+function targetList(name, args) {
+  if (name !== "apply_patch") return [args?.file_path];
+  return [...String(args?.input ?? "").matchAll(/^\*\*\* (?:Add File|Update File|Delete File|Move to):\s*(.+)$/gmu)].map((match) => String(match[1] ?? "").trim());
+}
+var GATE_FROZEN_REASON = "Gate \u5DF2\u51BB\u7ED3\uFF1A\u5148 /gate-resume \u6216 /gate-return-discuss";
+function gateDenyReason(ctx, exec, store) {
+  if (exec.name === "gate_record") {
+    const root = rootAgentOf(ctx, exec.agent);
+    return root?.id === exec.agent?.id ? void 0 : "gate_record \u53EA\u80FD\u7531 root agent \u8C03\u7528";
+  }
+  if (["subagent", "subagent_fork", "workflow"].includes(exec.name)) {
+    const gate = resolveGate(ctx, exec.agent);
+    const state = store.read(gate.root, exec.agent);
+    if (state.phase === "blocked") return GATE_FROZEN_REASON;
+    if (state.phase === "discuss") return "discuss \u4E0D\u6D3E worker";
+    if (state.node === "note-lifecycle") return "note-lifecycle \u53EA\u505A Note \u6536\u5C3E\uFF0C\u4E0D\u6D3E worker";
+    return void 0;
+  }
+  if (exec.name === "write" || exec.name === "edit" || exec.name === "apply_patch") {
+    const gate = resolveGate(ctx, exec.agent);
+    const effective = effectiveState(ctx, exec.agent, gate, store);
+    const state = effective.state;
+    const cwd = sessionCwd(ctx, exec.agent, gate.workspace);
+    const targets = targetList(exec.name, exec.arguments).filter((value) => typeof value === "string" && value !== "");
+    if (targets.length === 0) return void 0;
+    for (const value of targets) {
+      const target = classifyPath(gate.workspace, value, cwd);
+      if (target.outside) return "\u5DE5\u4F5C\u533A\u5916\u5199\u5165\u88AB\u62D2\u7EDD";
+      if (effective.worker) {
+        if (!workerWriteAllowed(state, target)) return `worker ${state.node ?? "unknown"} \u4E0D\u5141\u8BB8\u5199\u8BE5\u76EE\u6807`;
+        continue;
+      }
+      if (state.phase === "blocked") return GATE_FROZEN_REASON;
+    }
+    return void 0;
+  }
+  if (exec.name === "pwsh" || exec.name === "bash") {
+    const gate = resolveGate(ctx, exec.agent);
+    const effective = effectiveState(ctx, exec.agent, gate, store);
+    const state = effective.state;
+    const base = sessionCwd(ctx, exec.agent, gate.workspace);
+    const requested = exec.arguments?.workdir;
+    const cwd = typeof requested === "string" && requested !== "" ? path7.resolve(base, requested) : base;
+    const access = shellAccess(exec.arguments?.command ?? "", gate.workspace, cwd);
+    if (/\bgit(?:\.exe)?\b[^\n;&|]*\scommit\b/iu.test(String(exec.arguments?.command ?? "")) && effective.worker && !["implement", "implement-revise", "fix-bug"].includes(state.node ?? "")) {
+      return `worker ${state.node ?? "unknown"} \u4E0D\u5141\u8BB8 git commit`;
+    }
+    if (!access.write) return void 0;
+    if (access.outsideTargets.length > 0) return "\u5DE5\u4F5C\u533A\u5916\u5199\u5165\u88AB\u62D2\u7EDD";
+    if (effective.worker) return workerShellAllowed(state, access) ? void 0 : `worker ${state.node ?? "unknown"} \u4E0D\u5141\u8BB8\u5199\u8BE5\u76EE\u6807`;
+    if (state.phase === "blocked") return GATE_FROZEN_REASON;
+    return void 0;
+  }
+  return void 0;
+}
+function installGuard(ctx, deps) {
+  ctx.tools.guard((exec) => gateDenyReason(ctx, exec, deps.store));
+}
+function installRestrictions(ctx, deps) {
+  ctx.on("agent/pre-step", async (payload, next) => {
+    applyRestrictions(ctx, payload.agent, deps.store);
+    return next();
+  });
+}
+
+// src/commands.ts
+import path9 from "node:path";
+
+// src/notes/provision.ts
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import path8 from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { lstatSync as lstatSync3 } from "node:fs";
+var NOTES_BLOCK_START = "<!-- gate-notes:start -->";
+var NOTES_BLOCK_END = "<!-- gate-notes:end -->";
+var NOTES_AGENTS_TEXT = `${NOTES_BLOCK_START}
+## \u91CD\u8981\u6539\u52A8\u5FC5\u987B\u7559\u7B14\u8BB0
+
+1. \u975E\u5E73\u51E1\u6539\u52A8\uFF08\u884C\u4E3A\u3001\u67B6\u6784\u3001\u8DE8\u6587\u4EF6\u5951\u7EA6\u3001\u6D41\u7A0B/\u5DE5\u5177\u94FE\u3001\u6D4B\u8BD5\u7B56\u7565\u3001\u843D\u76D8/\u7F51\u7EDC/\u914D\u7F6E\u683C\u5F0F\uFF09\u5728\u52A8\u624B\u524D\u4F7F\u7528\u5185\u7F6E\u6280\u80FD \`gate-write-agent-notes\`\uFF0C\u6309 \xA73 \u68C0\u7D22\u3001\xA74 \u5224\u5B9A\u5F52\u5C5E\u4E0E class\uFF1B\u673A\u68B0\u6027\u5C0F\u6539\u76F4\u63A5\u63D0\u4EA4\u3002
+2. \u65E2\u6709\u51B3\u5B9A\u672A\u53D8\u65F6\u539F\u5730\u540C\u6B65 \`implemented/\` Note\uFF1B\u65B0\u60F3\u6CD5\u5148\u653E \`proposed/\`\uFF1B\u843D\u5730\u968F\u540C\u4EE3\u7801\u8F6C \`implemented/\`\u3002
+3. \u88AB\u653E\u5F03\u7684\u65B9\u6848\u5148\u5199\u6700\u5F3A\u7406\u7531\u518D\u5426\u51B3\u3002
+4. \u63D0\u4EA4\u524D\u8FD0\u884C \`npm run verify-notes\` \u68C0\u67E5\uFF1Bgate \u4F1A\u8BDD\u5185\u4E5F\u53EF\u7528 \`/gate-note-verify\`\u3002gate \u7684 lifecycle \u7531 \`gate_note_finalize\` \u2192 \`gate_note_verify\` \u2192 \`gate_record({node:'note-lifecycle'})\` \u5B8C\u6210\u3002
+${NOTES_BLOCK_END}`;
+function provisionNotes(root) {
+  const notes = path8.join(root, ".agents", "notes");
+  if (pathHasSymlink(root, notes)) throw new Error("notes \u8DEF\u5F84\u5305\u542B symlink");
+  for (const lifecycle of ["proposed", "implemented", "rejected", "archived"]) {
+    const dir = path8.join(notes, lifecycle);
+    if (pathHasSymlink(root, dir)) throw new Error(`${lifecycle} \u8DEF\u5F84\u5305\u542B symlink`);
+    mkdirSync3(dir, { recursive: true });
+    const keep = path8.join(dir, ".gitkeep");
+    if (!existsSync3(keep)) writeFileSync3(keep, "");
+  }
+  const agents = path8.join(root, "AGENTS.md");
+  if (existsSync3(agents) && lstatSync3(agents).isSymbolicLink()) throw new Error("AGENTS.md \u662F symlink");
+  const existing = existsSync3(agents) ? readFileSync2(agents, "utf8") : "";
+  const block = /<!-- gate-notes:start -->[\s\S]*?<!-- gate-notes:end -->/u;
+  const next = block.test(existing) ? existing.replace(block, NOTES_AGENTS_TEXT) : `${existing}${existing === "" || existing.endsWith("\n") ? "" : "\n"}
+${NOTES_AGENTS_TEXT}
+`;
+  writeFileSync3(agents, next);
+  return { notes: path8.relative(root, notes).replaceAll("\\", "/"), agents: path8.relative(root, agents).replaceAll("\\", "/") };
+}
+function provisionProjectScripts(root) {
+  const dir = path8.join(root, ".agents", "gate");
+  const launcher = path8.join(dir, "verify-notes.mjs");
+  mkdirSync3(dir, { recursive: true });
+  copyFileSync(NOTES_LAUNCHER_TEMPLATE, launcher);
+  const packagePath = path8.join(root, "package.json");
+  let pkg = { private: true };
+  if (existsSync3(packagePath)) {
+    try {
+      pkg = JSON.parse(readFileSync2(packagePath, "utf8"));
+    } catch {
+      throw new Error("package.json \u4E0D\u662F\u6709\u6548 JSON");
+    }
+    if (pkg === null || typeof pkg !== "object" || Array.isArray(pkg)) throw new Error("package.json \u5FC5\u987B\u662F\u5BF9\u8C61");
+  }
+  pkg.scripts = pkg.scripts !== null && typeof pkg.scripts === "object" && !Array.isArray(pkg.scripts) ? pkg.scripts : {};
+  const command = "node .agents/gate/verify-notes.mjs";
+  const existing = pkg.scripts["verify-notes"];
+  if (existing === void 0) pkg.scripts["verify-notes"] = command;
+  writeFileSync3(packagePath, `${JSON.stringify(pkg, null, 2)}
+`);
+  return {
+    launcher: path8.relative(root, launcher).replaceAll("\\", "/"),
+    package: path8.relative(root, packagePath).replaceAll("\\", "/"),
+    command: existing === void 0 ? command : String(existing),
+    changed: existing === void 0
+  };
+}
+var BASE_GITIGNORE = `node_modules/
+.env
+.env.*
+!.env.example
+*.log
+.DS_Store
+Thumbs.db
+coverage/
+dist/
+.agents/notes/.gate-finalize-*
+.agents/notes/.gate-validate-*
+.agents/notes/*.gate-backup
+`;
+function provisionGit(root) {
+  const ignore = path8.join(root, ".gitignore");
+  let ignoreStatus = "existing";
+  if (!existsSync3(ignore)) {
+    writeFileSync3(ignore, BASE_GITIGNORE);
+    ignoreStatus = "created";
+  }
+  const git = (args, options = {}) => execFileSync2("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], ...options });
+  let gitError = null;
+  const init = () => {
+    try {
+      git(["init", "-b", "main"]);
+    } catch (first) {
+      try {
+        git(["init"]);
+      } catch (second) {
+        gitError = String(second?.stderr ?? second?.message ?? first?.stderr ?? first?.message ?? second).trim();
+        return "init-failed";
+      }
+    }
+    return "initialized";
+  };
+  let gitStatus;
+  try {
+    gitStatus = git(["rev-parse", "--is-inside-work-tree"]).trim() === "true" ? "existing" : init();
+  } catch (error) {
+    gitStatus = error?.code === "ENOENT" ? "unavailable" : init();
+  }
+  return { git: gitStatus, ignore: ignoreStatus, gitError };
+}
+function provisionCi(root) {
+  const ciDir = path8.join(root, ".agents", "gate", "ci");
+  mkdirSync3(ciDir, { recursive: true });
+  for (const name of NOTES_CI_SCRIPTS) {
+    copyFileSync(path8.join(NOTES_SKILL_DIR, "scripts", name), path8.join(ciDir, name));
+  }
+  const workflow = path8.join(root, ".github", "workflows", "verify-notes.yml");
+  mkdirSync3(path8.dirname(workflow), { recursive: true });
+  const existing = existsSync3(workflow);
+  if (!existing) copyFileSync(NOTES_CI_TEMPLATE, workflow);
+  return { workflow: path8.relative(root, workflow).replaceAll("\\", "/"), scripts: path8.relative(root, ciDir).replaceAll("\\", "/"), changed: !existing };
+}
+
+// src/commands.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+function registerCommands(ctx, deps) {
+  const { store, reviewLimit, wake } = deps;
+  ctx.inject(["commands"], (scope) => {
+    const register = (name, description, handler, input = { hint: "<\u5DE5\u4F5C\u9879>" }) => scope.commands.register({
+      name,
+      description,
+      ...input === null ? {} : { input },
+      handler
+    });
+    register("gate-init", "\u521D\u59CB\u5316 notes\u3001AGENTS.md\u3001verify-notes \u4E0E GitHub Actions CI", async (invocation) => {
+      const workspace = workspaceBoundary(ctx, invocation.agent);
+      if (workspace === void 0) return { kind: "error", text: "\u65E0\u6CD5\u786E\u5B9A\u5F53\u524D\u4F1A\u8BDD\u5DE5\u4F5C\u533A" };
+      const root = path9.resolve(workspace);
+      let provisioned;
+      let projectScripts;
+      let projectCi;
+      let projectGit;
+      try {
+        provisioned = provisionNotes(root);
+        projectCi = provisionCi(root);
+        projectScripts = provisionProjectScripts(root);
+        projectGit = provisionGit(root);
+      } catch (error) {
+        return { kind: "error", text: `notes \u521D\u59CB\u5316\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}` };
+      }
+      wake(invocation, store.read(root, invocation.agent), `Gate \u5DF2\u521D\u59CB\u5316\uFF1A${root}\uFF08phase=discuss\uFF09\uFF0Cnotes \u5DF2\u521D\u59CB\u5316\u4E3A ${provisioned.notes}\uFF0CAGENTS.md \u5DF2\u66F4\u65B0\uFF0Cverify-notes \u5DF2\u914D\u7F6E\u4E3A ${projectScripts.command}\uFF0CCI \u5DF2\u914D\u7F6E\u4E3A ${projectCi.workflow}\uFF0Cgit\uFF1A${projectGit.git}${projectGit.gitError === null ? "" : `\uFF08${projectGit.gitError}\uFF09`}\uFF0Cignore\uFF1A${projectGit.ignore}\u3002`, "gate-init");
+      return { kind: "success", text: `Gate \u5DF2\u521D\u59CB\u5316\uFF1A${root}\uFF08phase=discuss\uFF09
+notes\uFF1A${provisioned.notes}
+AGENTS\uFF1A${provisioned.agents}
+verify-notes\uFF1A${projectScripts.command}
+CI\uFF1A${projectCi.workflow}
+git\uFF1A${projectGit.git}${projectGit.gitError === null ? "" : `\uFF08${projectGit.gitError}\uFF09`}
+ignore\uFF1A${projectGit.ignore}` };
+    }, null);
+    register("gate-enter-plan", "\u6309\u7528\u6237\u7B80\u8FF0\u8FDB\u5165 planning", async (invocation) => {
+      const result = enterPhase(ctx, invocation.agent, "plan", reviewLimit, store, void 0);
+      if (result.kind === "error") return result;
+      const brief = String(invocation.rawInput ?? "").trim();
+      wake(invocation, result.state, `Gate \u5DF2\u8FDB\u5165 plan\u3002\u7528\u6237\u89C4\u5212\u8F93\u5165\uFF1A${brief === "" ? "\uFF08\u672A\u63D0\u4F9B\u989D\u5916\u8F93\u5165\uFF09" : brief}\u3002`, "gate-enter-plan");
+      return { kind: "success", text: "\u8FDB\u5165 planning\u3002" };
+    }, { hint: "[\u7B80\u5355\u9700\u6C42]" });
+    register("gate-enter-implement", "\u4ECE\u5DF2\u786E\u8BA4\u89C4\u5212\u6216\u7528\u6237\u7B80\u8FF0\u8FDB\u5165 implementation", async (invocation) => {
+      const brief = String(invocation.rawInput ?? "").trim();
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      const direct = state.planReady !== true;
+      if (direct) {
+        if (brief === "") return { kind: "error", text: "\u8BF7\u7528\u4E00\u53E5\u8BDD\u8BF4\u660E\u8981\u5B9E\u65BD\u7684\u5185\u5BB9\uFF1B\u4E0D\u8981\u6C42\u5DE5\u4F5C\u9879\u683C\u5F0F\u3002" };
+        state.task = brief;
+        state.planReady = false;
+        state.noteDecision = null;
+        state.notePaths = [];
+        state.noteSearch = null;
+        state.noteVerified = false;
+        state.noteFinalized = false;
+        state.noteFinalizeRecovery = [];
+        store.write(gate.root, invocation.agent, state);
+      }
+      const result = enterPhase(ctx, invocation.agent, "implement", reviewLimit, store, direct ? state : void 0);
+      if (result.kind === "error") return result;
+      const constraints = direct ? "\uFF08\u672C\u53E5\u5373\u5DE5\u4F5C\u9879\u7B80\u8FF0\uFF09" : brief === "" ? "\uFF08\u65E0\u989D\u5916\u7EA6\u675F\uFF09" : brief;
+      wake(invocation, result.state, `Gate \u5DF2\u8FDB\u5165 implement\uFF1A${result.state.task ?? ""}${direct ? "\uFF08\u76F4\u63A5\u5B9E\u65BD\uFF0C\u672A\u8D70 planning\uFF09" : ""}\u3002\u7528\u6237\u8BF4\u660E\uFF1A${constraints}\u3002`, "gate-enter-implement");
+      return { kind: "success", text: `\u8FDB\u5165 implement\uFF1A${result.state.task}${direct ? "\uFF08\u76F4\u63A5\u5B9E\u65BD\uFF09" : ""}` };
+    }, { hint: "[\u7B80\u5355\u8BF4\u660E]" });
+    register("gate-fix-bug", "\u4E3A\u5DF2\u6388\u6743\u7684\u5B9E\u73B0\u7F3A\u9677\u6D3E\u53D1 fix worker", async (invocation) => {
+      const brief = String(invocation.rawInput ?? "").trim();
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      if (state.phase !== "discuss" && state.phase !== "complete") return { kind: "error", text: `\u5F53\u524D phase \u662F ${state.phase}` };
+      if (state.work === "blocked" || state.blockReason !== null) return { kind: "error", text: `\u5F53\u524D\u88AB blocked\uFF1A${state.blockReason ?? "unknown"}\uFF1B\u5148 /gate-resume` };
+      const scope2 = brief === "" ? state.task ?? "\u5F53\u524D\u4E0A\u4E0B\u6587\u4E2D\u7684\u7F3A\u9677" : brief;
+      state.phase = "orchestrating";
+      state.node = "fix-bug";
+      state.task = scope2;
+      state.work = "active";
+      state.blockReason = null;
+      state.blockedFrom = null;
+      store.write(gate.root, invocation.agent, state);
+      wake(invocation, state, `Gate \u5DF2\u8FDB\u5165 fix-bug\uFF1A${scope2}\u3002`, "gate-fix-bug");
+      return { kind: "success", text: `\u8FDB\u5165 fix-bug\uFF1A${scope2}` };
+    }, { hint: "[\u7F3A\u9677\u7B80\u8FF0]" });
+    register("gate-docs", "\u5F00\u59CB\u6587\u6863\u6CBB\u7406", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      if (state.phase !== "discuss" && state.phase !== "complete") return { kind: "error", text: `\u5F53\u524D phase \u662F ${state.phase}` };
+      if (state.work === "blocked" || state.blockReason !== null) return { kind: "error", text: `\u5F53\u524D\u88AB blocked\uFF1A${state.blockReason ?? "unknown"}\uFF1B\u5148 /gate-resume` };
+      state.phase = "docs";
+      state.task = "\u6587\u6863\u6CBB\u7406";
+      state.work = "active";
+      state.blockReason = null;
+      state.blockedFrom = null;
+      state.node = null;
+      store.write(gate.root, invocation.agent, state);
+      wake(invocation, state, "Gate \u5DF2\u8FDB\u5165 docs\u3002", "gate-docs");
+      return { kind: "success", text: "\u8FDB\u5165 docs\uFF1A\u6587\u6863\u6CBB\u7406" };
+    }, null);
+    register("gate-implement-review", "\u5F00\u59CB\u72EC\u7ACB\u53EA\u8BFB code review", async (invocation) => {
+      const brief = String(invocation.rawInput ?? "").trim();
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      if (state.phase !== "discuss" && state.phase !== "complete") return { kind: "error", text: `\u5F53\u524D phase \u662F ${state.phase}` };
+      if (state.work === "blocked" || state.blockReason !== null) return { kind: "error", text: `\u5F53\u524D\u88AB blocked\uFF1A${state.blockReason ?? "unknown"}\uFF1B\u5148 /gate-resume` };
+      const scope2 = brief === "" ? state.task ?? "\u5F53\u524D\u4E0A\u4E0B\u6587\u4E2D\u7684\u6539\u52A8" : brief;
+      state.phase = "reviewing";
+      state.task = scope2;
+      state.node = "code-review-standalone";
+      state.work = "active";
+      state.blockReason = null;
+      state.blockedFrom = null;
+      store.write(gate.root, invocation.agent, state);
+      wake(invocation, state, `Gate \u5DF2\u8FDB\u5165\u53EA\u8BFB code review\uFF1A${scope2}\u3002`, "gate-implement-review");
+      return { kind: "success", text: `\u8FDB\u5165\u53EA\u8BFB code review\uFF1A${scope2}` };
+    });
+    register("gate-code-verify", "\u5F00\u59CB\u72EC\u7ACB\u53EA\u8BFB\u9A8C\u6536", async (invocation) => {
+      const brief = String(invocation.rawInput ?? "").trim();
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      if (state.phase !== "discuss" && state.phase !== "complete") return { kind: "error", text: `\u5F53\u524D phase \u662F ${state.phase}` };
+      if (state.work === "blocked" || state.blockReason !== null) return { kind: "error", text: `\u5F53\u524D\u88AB blocked\uFF1A${state.blockReason ?? "unknown"}\uFF1B\u5148 /gate-resume` };
+      const scope2 = brief === "" ? state.task ?? "\u5F53\u524D\u4E0A\u4E0B\u6587\u4E2D\u7684\u6539\u52A8" : brief;
+      state.phase = "reviewing";
+      state.task = scope2;
+      state.node = "verify-standalone";
+      state.work = "active";
+      state.blockReason = null;
+      state.blockedFrom = null;
+      store.write(gate.root, invocation.agent, state);
+      wake(invocation, state, `Gate \u5DF2\u8FDB\u5165\u72EC\u7ACB\u9A8C\u6536\uFF1A${scope2}\u3002`, "gate-code-verify");
+      return { kind: "success", text: `\u8FDB\u5165\u72EC\u7ACB\u9A8C\u6536\uFF1A${scope2}` };
+    });
+    register("gate-propose-review", "\u5F00\u59CB\u72EC\u7ACB\u63D0\u6848\u8BC4\u5BA1", async (invocation) => {
+      const brief = String(invocation.rawInput ?? "").trim();
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      if (state.phase !== "discuss" && state.phase !== "complete") return { kind: "error", text: `\u5F53\u524D phase \u662F ${state.phase}` };
+      if (state.work === "blocked" || state.blockReason !== null) return { kind: "error", text: `\u5F53\u524D\u88AB blocked\uFF1A${state.blockReason ?? "unknown"}\uFF1B\u5148 /gate-resume` };
+      const scope2 = brief === "" ? state.task ?? "\u5F53\u524D\u63D0\u6848/Note" : brief;
+      state.phase = "reviewing";
+      state.task = scope2;
+      state.node = "proposal-review";
+      state.work = "active";
+      state.blockReason = null;
+      state.blockedFrom = null;
+      store.write(gate.root, invocation.agent, state);
+      wake(invocation, state, `Gate \u5DF2\u8FDB\u5165\u63D0\u6848\u8BC4\u5BA1\uFF1A${scope2}\u3002`, "gate-propose-review");
+      return { kind: "success", text: `\u8FDB\u5165\u63D0\u6848\u8BC4\u5BA1\uFF1A${scope2}` };
+    });
+    register("gate-block", "\u624B\u52A8\u6682\u505C\uFF1A\u4FDD\u7559\u5F53\u524D\u8282\u70B9\u5E76\u505C\u6B62\u5199\u5165/\u6D3E worker\uFF1B\u5BF9\u8BDD\u4ECD\u53EF\u7EE7\u7EED", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      if (state.phase === "blocked") return { kind: "success", text: "\u5DF2\u7ECF\u662F blocked" };
+      state.blockedFrom = { phase: state.phase, node: state.node };
+      state.phase = "blocked";
+      state.work = "blocked";
+      state.node = null;
+      state.blockReason = String(invocation.rawInput ?? "").trim() || "user-blocked";
+      store.write(gate.root, invocation.agent, state);
+      return { kind: "success", text: `\u5DF2\u6682\u505C\uFF1A${state.blockReason}
+\u89E3\u51BB\u540E\uFF1A${state.blockedFrom?.phase ?? "discuss"}${state.blockedFrom?.node === null || state.blockedFrom?.node === void 0 ? "" : ` / ${state.blockedFrom.node}`}
+\u540C\u4E00\u4E8B\u9879\uFF1A/gate-resume \u56DE\u5230\u8BE5\u8282\u70B9\uFF1B\u6539\u53D8\u65B9\u6848\uFF1A/gate-return-discuss\u3002` };
+    }, { hint: "[\u539F\u56E0]" });
+    register("gate-resume", "\u89E3\u51BB blocked\uFF1A\u56DE\u5230 block \u524D\u7684\u8282\u70B9\uFF1B\u8F6E\u6B21\u8017\u5C3D\u56DE discuss", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      if (state.phase !== "blocked") return { kind: "error", text: "\u5F53\u524D\u4E0D\u662F blocked" };
+      const from = state.blockedFrom;
+      const reason = state.blockReason;
+      state.phase = from?.phase ?? "discuss";
+      state.node = from?.node ?? null;
+      state.work = "active";
+      state.blockReason = null;
+      state.blockedFrom = null;
+      store.write(gate.root, invocation.agent, state);
+      if (state.phase === "orchestrating" || state.phase === "reviewing" || state.phase === "docs") {
+        wake(invocation, state, `Gate \u5DF2\u6062\u590D\u5230 ${state.phase}${state.node === null ? "" : ` / ${state.node}`}\u3002`, "gate-resume");
+      }
+      const exhausted = reason === "plan-review-rounds-exhausted" || reason === "code-review-rounds-exhausted";
+      return { kind: "success", text: `\u5DF2\u89E3\u9664 blocked\uFF1A${state.phase}${state.node === null ? "" : ` / ${state.node}`}${exhausted ? "\nreview \u8F6E\u6B21\u5DF2\u8017\u5C3D\uFF0C\u4E0D\u80FD\u7EE7\u7EED\u539F\u8282\u70B9\uFF1B\u7528 /gate-enter-plan \u91CD\u65B0\u89C4\u5212\u3002" : "\n\u5DF2\u56DE\u5230\u6682\u505C\u524D\u8282\u70B9\uFF0C\u6309\u5F53\u524D procedure \u7EE7\u7EED\u3002"}` };
+    }, null);
+    register("gate-return-discuss", "\u56DE\u5230 discuss", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      if (state.phase === "blocked") return { kind: "error", text: `\u5F53\u524D blocked\uFF1A${state.blockReason ?? "unknown"}\uFF1B\u5148 /gate-resume` };
+      state.phase = "discuss";
+      state.node = null;
+      state.work = "active";
+      state.blockReason = null;
+      state.blockedFrom = null;
+      state.task = null;
+      state.planReady = false;
+      state.rounds = { planReview: 0, codeReview: 0 };
+      state.verification = null;
+      state.notePaths = [];
+      state.noteDecision = null;
+      state.noteSearch = null;
+      state.noteVerified = false;
+      state.noteFinalized = false;
+      state.noteFinalizeRecovery = [];
+      state.pending = {};
+      store.write(gate.root, invocation.agent, state);
+      return { kind: "success", text: "\u5DF2\u56DE\u5230 discuss" };
+    }, null);
+    register("gate-status", "\u67E5\u770B\u5F53\u524D gate \u72B6\u6001", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const root = rootAgentOf(ctx, invocation.agent);
+      return { kind: "success", text: statusText(store.read(gate.root, root), reviewLimit) };
+    }, null);
+    register("gate-note-verify", "\u53EA\u8BFB\u68C0\u67E5 notes tree/format/lifecycle/archived", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const check = runNotesScripts(gate.root);
+      return check.ok ? { kind: "success", text: check.results.map((item) => `${item.name}: ok`).join("\n") } : { kind: "error", text: `notes \u6821\u9A8C\u5931\u8D25\uFF1A
+${JSON.stringify(check.results, null, 2)}` };
+    }, null);
+    register("gate-note-archive", "\u5C06 implemented Note \u5F52\u6863\u5230 archived/\uFF1A\u52A0 Archived\u3001\u79FB\u52A8\u3001\u5C01\u5370\u5E76\u62A5\u544A\u5165\u7AD9\u94FE\u63A5", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const raw = String(invocation.rawInput ?? "").trim();
+      const args = raw === "" ? [] : raw.split(/\s+/u);
+      if (args.length === 0) return { kind: "error", text: "\u7528\u6CD5\uFF1A/gate-note-archive implemented/<class>/<note>.md [--superseded-by implemented/<class>/<new>.md]" };
+      const node = resolveNodeBinary();
+      if (node === void 0) return { kind: "error", text: "notes-runtime-unavailable" };
+      try {
+        const script = path9.join(NOTES_SKILL_DIR, "scripts", "archive-agent-note.ts");
+        const output = execFileSync3(node, [script, "--root", path9.join(gate.root, ".agents", "notes"), ...args], { cwd: gate.root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+        return { kind: "success", text: String(output).trim() || "Note \u5DF2\u5F52\u6863" };
+      } catch (error) {
+        return { kind: "error", text: String(error?.stderr ?? error?.message ?? error).trim() };
+      }
+    }, { hint: "<implemented-note> [--superseded-by <new-note>]" });
+    register("gate-note-board", "\u751F\u6210\u51B3\u7B56\u770B\u677F board.html\uFF08\u8F7B\u91CF\u6A21\u5F0F\uFF0C\u8FDE\u63A5\u672C\u5730 notes \u76EE\u5F55\uFF09", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const raw = String(invocation.rawInput ?? "").trim();
+      const args = raw === "" ? [] : raw.split(/\s+/u);
+      const target = args[0] ?? "board.html";
+      const title = args[1] ?? `${path9.basename(gate.root)} \u51B3\u7B56\u770B\u677F`;
+      const node = resolveNodeBinary();
+      if (node === void 0) return { kind: "error", text: "notes-runtime-unavailable" };
+      try {
+        const script = path9.join(NOTES_SKILL_DIR, "scripts", "build-board.ts");
+        const output = execFileSync3(node, [script, "--init", target, title], { cwd: gate.root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+        return { kind: "success", text: String(output).trim() || `\u51B3\u7B56\u770B\u677F\u5DF2\u751F\u6210\uFF1A${target}` };
+      } catch (error) {
+        return { kind: "error", text: String(error?.stderr ?? error?.message ?? error).trim() };
+      }
+    }, { hint: "[\u8F93\u51FA\u8DEF\u5F84] [\u6807\u9898]" });
+    register("gate-note-seal", "\u53EA\u7ED9 archived/ \u4E2D\u5DF2\u6709 Note \u8865\u5199 manifest.json \u7684 SHA-256 \u5C01\u5370\uFF1B\u4E0D\u5F52\u6863\u3001\u4E0D\u6539 Note \u5185\u5BB9", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const node = resolveNodeBinary();
+      if (node === void 0) return { kind: "error", text: "notes-runtime-unavailable" };
+      try {
+        const script = path9.join(NOTES_SKILL_DIR, "scripts", "verify-archived-agent-notes.ts");
+        const output = execFileSync3(node, [script, "--root", path9.join(gate.root, ".agents", "notes"), "--write"], { cwd: gate.root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+        return { kind: "success", text: String(output).trim() || "archived manifest \u5DF2\u5199\u5165" };
+      } catch (error) {
+        return { kind: "error", text: String(error?.stderr ?? error?.message ?? error).trim() };
+      }
+    }, null);
+  });
+}
+
+// src/tools/start-phase.ts
+function registerStartPhase(ctx, deps) {
+  const { store, reviewLimit, wake } = deps;
+  ctx.tools.register({
+    name: "gate_start_phase",
+    description: "\u5728\u7528\u6237\u660E\u786E\u6388\u6743\u540E\u4ECE discuss/complete \u8FDB\u5165 plan \u6216 implement\u3002\u4EC5 root agent \u53EF\u8C03\u7528\uFF1B\u6388\u6743\u53EF\u6765\u81EA\u5BF9\u8BDD\u6216 ask_user_question\uFF0C\u4E0D\u8981\u6C42\u7528\u6237\u8F93\u5165 slash command\u3002",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        node: { type: "string", enum: ["plan", "implement"] },
+        brief: { type: "string" }
+      },
+      required: ["node"]
+    },
+    output: {
+      schema: { type: "object", additionalProperties: true },
+      render: (_args, value) => renderProcedureResult(value),
+      presentationMeta: (_args, value) => value?.state === void 0 ? { gate: {} } : { gate: { state: value.state } }
+    },
+    async execute(args, exec) {
+      const root = rootAgentOf(ctx, exec.agent);
+      if (root?.id !== exec.agent?.id) return { ok: false, code: "root-only", reason: "gate_start_phase \u53EA\u80FD\u7531 root agent \u8C03\u7528\u3002" };
+      const gate = resolveGate(ctx, exec.agent);
+      const state = store.read(gate.root, exec.agent);
+      const fail = (fields) => procedureFailure(state, reviewLimit, fields);
+      if (args.node !== "plan" && args.node !== "implement") return fail({ code: "invalid-node", reason: "node \u5FC5\u987B\u662F plan \u6216 implement\u3002" });
+      const direct = args.node === "implement" && state.planReady !== true;
+      if (direct) {
+        const brief = String(args.brief ?? "").trim();
+        if (brief === "") return fail({ code: "brief-required", reason: "\u76F4\u63A5 implement \u9700\u8981\u4E00\u53E5\u8BF4\u660E\u3002" });
+        state.task = brief;
+        state.planReady = false;
+        state.noteDecision = null;
+        state.notePaths = [];
+        state.noteSearch = null;
+        state.noteVerified = false;
+        state.noteFinalized = false;
+        state.noteFinalizeRecovery = [];
+        store.write(gate.root, exec.agent, state);
+      }
+      const result = enterPhase(ctx, exec.agent, args.node, reviewLimit, store, direct ? state : void 0);
+      if (result.kind === "error") return fail({ code: "phase-enter-failed", reason: result.text });
+      const procedure = procedureFor(result.state, { reviewLimit });
+      return {
+        ok: true,
+        phase: result.state.phase,
+        node: result.state.node,
+        task: result.state.task,
+        procedure,
+        method: procedure.method,
+        state: normalizeState(result.state)
+      };
+    }
+  });
+}
+
+// src/tools/record.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync4, lstatSync as lstatSync4, readFileSync as readFileSync3 } from "node:fs";
+function registerRecord(ctx, deps) {
+  const { store, reviewLimit, wake } = deps;
+  ctx.tools.register({
+    name: "gate_record",
+    description: "\u8BB0\u5F55 root agent \u6D3E\u53D1\u7684\u8282\u70B9 worker \u7ED3\u679C\u5E76\u63A8\u8FDB gate \u72B6\u6001\u3002worker \u8282\u70B9\u8981\u6C42 workerSessionIds\uFF1Breview \u8282\u70B9\u8981\u6C42\u4E24\u8F74\u7ED3\u679C\uFF1Bverify \u8981\u6C42 toolResults\u3002\u4EC5 root agent \u53EF\u8C03\u7528\u3002",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        node: { type: "string", enum: GATE_RECORD_NODES },
+        workerSessionIds: { type: "array", items: { type: "string" } },
+        reviewAxes: { type: "object", additionalProperties: true },
+        task: { type: "string" },
+        findings: { type: "array", items: { type: "object", additionalProperties: true } },
+        requiresDiscussion: { type: "boolean" },
+        discussionReason: { type: "string" },
+        notePaths: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              path: { type: "string", description: "\u63A5\u53D7 .agents/notes/<lifecycle>/<class>/...\u3001<lifecycle>/<class>/... \u6216 <class>/...\uFF1Bstate \u5F52\u4E00\u4E3A\u5B8C\u6574\u8DEF\u5F84\u3002" },
+              class: { type: "string", enum: ["feature", "bug-fix", "simplification", "architecture", "process", "testing"] },
+              lifecycle: { type: "string", enum: ["proposed", "implemented"] }
+            },
+            required: ["path", "class", "lifecycle"]
+          }
+        },
+        noteDecision: { type: "string", enum: ["new", "update", "in-place", "mechanical"] },
+        noteSearch: { type: "string" },
+        verification: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            commands: { type: "array", items: { type: "string" } },
+            evidence: { type: "array", items: { type: "string", description: "gate workspace \u5185\u666E\u901A\u6587\u4EF6\u8DEF\u5F84\u3002" } },
+            toolResults: { type: "array", items: { type: "string", description: "verify worker session log \u4E2D\u771F\u5B9E tool/result \u7684 call_... id\u3002" } },
+            passed: { type: "boolean" }
+          },
+          required: ["commands", "evidence", "toolResults", "passed"]
+        }
+      },
+      required: ["node"]
+    },
+    output: {
+      schema: { type: "object", additionalProperties: true },
+      render: (_args, value) => renderProcedureResult(value),
+      presentationMeta: (_args, value) => value?.state === void 0 ? { gate: {} } : { gate: { state: value.state } }
+    },
+    async execute(args, exec) {
+      const root = rootAgentOf(ctx, exec.agent);
+      if (root?.id !== exec.agent?.id) return { ok: false, code: "root-only", reason: "gate_record \u53EA\u80FD\u7531 root agent \u8C03\u7528\uFF1Bworker \u5B8C\u6210\u5F53\u524D node \u540E\u8FD4\u56DE receipt\u3002" };
+      const gate = resolveGate(ctx, exec.agent);
+      const state = store.read(gate.root, exec.agent);
+      const fail = (fields) => procedureFailure(state, reviewLimit, fields);
+      if (state.phase === "docs") {
+        if (args.node !== "docs") return fail({ code: "wrong-node", expected: "docs", got: args.node ?? null, reason: 'docs \u9636\u6BB5\u53EA\u80FD\u901A\u8FC7 gate_record({node:"docs"}) \u7ED3\u675F\u3002' });
+        state.phase = "discuss";
+        state.node = null;
+        state.work = "active";
+        state.blockReason = null;
+        state.blockedFrom = null;
+        store.write(gate.root, exec.agent, state);
+        const procedure2 = procedureFor(state, { reviewLimit });
+        return { ok: true, phase: state.phase, node: state.node, procedure: procedure2, method: procedure2.method, state: normalizeState(state) };
+      }
+      if (state.phase !== "orchestrating" && state.phase !== "reviewing") {
+        return fail({ code: "not-orchestrating", phase: state.phase, stateSource: store.source, reason: `\u5F53\u524D phase \u662F ${state.phase}\uFF1B\u5148\u8FDB\u5165\u5BF9\u5E94\u9636\u6BB5\u3002` });
+      }
+      if (state.node !== args.node) return fail({ code: "wrong-node", expected: state.node ?? null, got: args.node ?? null, reason: `\u5F53\u524D\u8282\u70B9\u662F ${state.node ?? "\u65E0"}\uFF0C\u8BF7\u6C42\u7684 node \u662F ${args.node ?? "\u672A\u63D0\u4F9B"}\u3002` });
+      const axesError = reviewAxesError(args);
+      if (axesError !== void 0) return fail(axesError);
+      const workerError = await workerEvidenceError(ctx, root, args);
+      if (workerError !== void 0) return fail(workerError);
+      const topFindings = Array.isArray(args.findings) ? args.findings : [];
+      const axesFindings = REVIEW_NODES.has(args.node) ? [
+        ...args.reviewAxes.standards.findings,
+        ...args.reviewAxes.spec.findings,
+        ...args.node === "plan-review" || args.node === "proposal-review" ? args.reviewAxes.architecture.findings : []
+      ] : [];
+      const findings = [...axesFindings, ...topFindings];
+      let commitHint = null;
+      if (args.requiresDiscussion === true) {
+        if (args.node === "plan-review") state.planReady = false;
+        state.blockedFrom = { phase: state.phase, node: state.node };
+        state.phase = "blocked";
+        state.node = null;
+        state.work = "blocked";
+        state.blockReason = "needs-user-decision";
+        store.write(gate.root, exec.agent, state);
+        const procedure2 = procedureFor(state, { reviewLimit });
+        return { ok: true, phase: state.phase, blockReason: state.blockReason, reason: args.discussionReason ?? null, procedure: procedure2, method: procedure2.method, state: normalizeState(state) };
+      }
+      if (args.node === "proposal-review") {
+        state.phase = "discuss";
+        state.node = null;
+        state.work = "active";
+        state.blockReason = null;
+        state.blockedFrom = null;
+      } else if (args.node === "code-review-standalone") {
+        state.phase = "discuss";
+        state.node = null;
+        state.work = "active";
+        state.blockReason = null;
+      } else if (args.node === "plan") {
+        if (typeof args.task !== "string" || args.task.trim() === "") {
+          return fail({ code: "task-required", reason: "node=plan \u5FC5\u987B\u643A\u5E26 task\uFF08planning \u4EA7\u51FA\u7684\u5DE5\u4F5C\u9879\u6216 mechanical:<\u8BF4\u660E>\uFF09\u3002" });
+        }
+        const decision = args.noteDecision;
+        if (!["new", "update", "in-place", "mechanical"].includes(decision)) {
+          return fail({ code: "note-decision-required", reason: "node=plan \u9700\u8981 noteDecision\uFF08new/update/in-place/mechanical\uFF09\u3002" });
+        }
+        if (decision === "mechanical" && !isMechanical(args.task)) {
+          return fail({ code: "mechanical-required", reason: "mechanical \u53EA\u5141\u8BB8 task \u4EE5 mechanical: \u5F00\u5934\u3002" });
+        }
+        const optionNotePaths = notePathsForDecision(args.notePaths, decision);
+        const noteError = validateNotePaths(gate.root, optionNotePaths, decision);
+        if (noteError !== void 0) return fail(noteError);
+        state.task = args.task.trim();
+        state.notePaths = decision === "mechanical" ? [] : optionNotePaths;
+        state.noteDecision = decision;
+        state.noteSearch = typeof args.noteSearch === "string" ? args.noteSearch : null;
+        state.noteVerified = decision === "mechanical";
+        state.node = "plan-review";
+      } else if (args.node === "plan-revise") {
+        if (args.noteDecision !== void 0 || args.notePaths !== void 0) {
+          const decision = args.noteDecision ?? state.noteDecision;
+          if (!["new", "update", "in-place", "mechanical"].includes(decision)) {
+            return fail({ code: "note-decision-required", reason: "plan-revise \u9700\u8981\u5408\u6CD5 noteDecision\u3002" });
+          }
+          if (decision === "mechanical" && !isMechanical(state.task)) {
+            return fail({ code: "mechanical-required", reason: "mechanical \u53EA\u5141\u8BB8 task \u4EE5 mechanical: \u5F00\u5934\u3002" });
+          }
+          const requestedNotePaths = args.notePaths ?? state.notePaths;
+          const optionNotePaths = notePathsForDecision(requestedNotePaths, decision);
+          const noteError = validateNotePaths(gate.root, optionNotePaths, decision);
+          if (noteError !== void 0) return fail(noteError);
+          state.notePaths = decision === "mechanical" ? [] : optionNotePaths;
+          state.noteDecision = decision;
+          if (typeof args.noteSearch === "string") state.noteSearch = args.noteSearch;
+          state.noteVerified = decision === "mechanical";
+        }
+        state.node = "plan-review";
+      } else if (args.node === "plan-review") {
+        state.rounds.planReview += 1;
+        if (findings.length === 0) {
+          state.phase = "discuss";
+          state.node = null;
+          state.planReady = true;
+          state.work = "active";
+          state.blockReason = null;
+          commitHint = "\u5EFA\u8BAE\u63D0\u4EA4 planning baseline\uFF08Note + \u8BA1\u5212\uFF09";
+        } else if (state.rounds.planReview >= reviewLimit) {
+          state.exhausted.plan = true;
+          state.blockedFrom = { phase: "discuss", node: null };
+          state.phase = "blocked";
+          state.node = null;
+          state.work = "blocked";
+          state.blockReason = "plan-review-rounds-exhausted";
+        } else state.node = "plan-revise";
+      } else if (args.node === "implement") {
+        if (args.noteDecision === "mechanical") {
+          state.noteDecision = "mechanical";
+          state.notePaths = [];
+          state.noteVerified = true;
+        } else {
+          if (Array.isArray(args.notePaths)) {
+            const nextNotePaths = normalizeNotePaths(args.notePaths);
+            const noteError = validateNotePaths(gate.root, nextNotePaths, args.noteDecision ?? state.noteDecision);
+            if (noteError !== void 0) return fail(noteError);
+            state.notePaths = nextNotePaths;
+          }
+          if (["new", "update", "in-place"].includes(args.noteDecision)) state.noteDecision = args.noteDecision;
+        }
+        state.node = "code-review";
+      } else if (args.node === "implement-revise") state.node = "code-review";
+      else if (args.node === "code-review") {
+        state.rounds.codeReview += 1;
+        if (findings.length === 0) state.node = "verify";
+        else if (state.rounds.codeReview >= reviewLimit) {
+          state.exhausted.code = true;
+          state.blockedFrom = { phase: "discuss", node: null };
+          state.phase = "blocked";
+          state.node = null;
+          state.work = "blocked";
+          state.blockReason = "code-review-rounds-exhausted";
+        } else state.node = "implement-revise";
+      } else if (args.node === "verify" || args.node === "verify-standalone") {
+        const verification = args.verification;
+        const commands = Array.isArray(verification?.commands) ? verification.commands.filter((item) => typeof item === "string" && item.trim() !== "") : [];
+        const evidence = Array.isArray(verification?.evidence) ? verification.evidence.filter((item) => typeof item === "string" && item.trim() !== "") : [];
+        const toolResults = Array.isArray(verification?.toolResults) ? verification.toolResults.filter((item) => typeof item === "string" && item.trim() !== "") : [];
+        const unbound = await bindToolResults(ctx, Array.isArray(args.workerSessionIds) ? args.workerSessionIds : [], toolResults);
+        if (unbound !== void 0) return fail(unbound);
+        const records = [];
+        const invalidEvidence = [];
+        for (const item of evidence) {
+          const target = classifyPath(gate.workspace, item);
+          try {
+            if (target.outside || !existsSync4(target.absolute) || !lstatSync4(target.absolute).isFile()) {
+              invalidEvidence.push(item);
+              continue;
+            }
+            const bytes = readFileSync3(target.absolute);
+            records.push({ path: target.relative, size: bytes.length, sha256: createHash("sha256").update(bytes).digest("hex") });
+          } catch {
+            invalidEvidence.push(item);
+          }
+        }
+        if (commands.length === 0 || evidence.length === 0 || toolResults.length === 0 || invalidEvidence.length > 0 || records.length !== evidence.length || typeof verification?.passed !== "boolean") {
+          return fail({ code: "verification-required", invalidEvidence, commands, evidence, toolResults, reason: "verify \u9700\u8981\u975E\u7A7A commands\u3001workspace \u5185\u7684\u666E\u901A evidence \u6587\u4EF6\u3001toolResults\uFF0C\u4EE5\u53CA\u660E\u786E\u7684 passed\u3002" });
+        }
+        state.verification = {
+          commands,
+          evidence: records,
+          toolResults,
+          passed: verification.passed,
+          selfReported: false,
+          executionBound: true,
+          verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (args.node === "verify-standalone") {
+          state.phase = "discuss";
+          state.node = null;
+          state.work = "active";
+          state.blockReason = null;
+          state.blockedFrom = null;
+        } else if (verification.passed !== true) {
+          state.node = "implement-revise";
+          state.noteVerified = false;
+        } else if (state.noteDecision === "mechanical") {
+          state.noteVerified = true;
+          state.noteFinalized = true;
+          commitHint = "\u5EFA\u8BAE\u63D0\u4EA4\u5B9E\u73B0";
+          state.phase = "discuss";
+          state.node = null;
+          state.work = "active";
+          state.blockReason = null;
+          state.blockedFrom = null;
+          state.task = null;
+          state.planReady = false;
+        } else {
+          state.phase = "orchestrating";
+          state.node = "note-lifecycle";
+          state.work = "active";
+          state.noteVerified = false;
+          state.noteFinalized = false;
+          state.noteFinalizeRecovery = [];
+        }
+      } else if (args.node === "fix-bug") {
+        state.phase = "discuss";
+        state.node = null;
+        state.work = "active";
+        state.blockReason = null;
+        state.blockedFrom = null;
+        state.task = null;
+        state.planReady = false;
+      } else if (args.node === "note-lifecycle") {
+        if (state.noteVerified !== true) {
+          return fail({ code: "note-lifecycle-incomplete", reason: "note-lifecycle \u9700\u8981\u5148 gate_note_finalize + gate_note_verify\u3002" });
+        }
+        commitHint = "\u5EFA\u8BAE\u63D0\u4EA4\u672C\u6B21\u5B9E\u73B0\u4E0E Note";
+        state.phase = "discuss";
+        state.node = null;
+        state.work = "active";
+        state.blockReason = null;
+        state.blockedFrom = null;
+        state.task = null;
+        state.planReady = false;
+      }
+      store.write(gate.root, exec.agent, state);
+      const next = normalizeState(state);
+      const procedure = procedureFor(next, { reviewLimit });
+      return { ok: true, phase: state.phase, node: state.node, rounds: state.rounds, blockReason: state.blockReason, verification: state.verification, procedure, method: procedure.method, state: next, ...commitHint === null ? {} : { commitHint } };
+    }
+  });
+}
+
+// src/tools/status.ts
+function registerStatus(ctx, deps) {
+  const { store, reviewLimit, wake } = deps;
+  ctx.tools.register({
+    name: "gate_status",
+    description: "\u8BFB\u53D6 Gate \u5F53\u524D\u72B6\u6001\u4E0E\u5F53\u524D procedure\uFF08root\uFF09\u3002\u53EA\u8BFB\uFF1B\u6D3E\u53D1 worker \u524D\u3001\u63A8\u8FDB\u8282\u70B9\u524D\u3001compaction \u540E\u3001\u5931\u8D25\u540E\u6062\u590D\u65F6\u4F7F\u7528\u3002worker \u8C03\u7528\u8FD4\u56DE root \u72B6\u6001\u4F46\u4E0D\u8FD4\u56DE root procedure\u3002",
+    parameters: { type: "object", additionalProperties: false, properties: {} },
+    output: {
+      schema: { type: "object", additionalProperties: true },
+      render: (_args, value) => [{ type: "text", text: typeof value?.text === "string" ? value.text : JSON.stringify(value) }]
+    },
+    async execute(_args, exec) {
+      const root = rootAgentOf(ctx, exec.agent);
+      if (exec.agent?.session?.header?.origin === "subagent" && root?.id === exec.agent?.id) {
+        return { ok: false, code: "root-unresolved", reason: "\u65E0\u6CD5\u89E3\u6790 worker \u7684 root session\uFF1B\u4E0D\u8FD4\u56DE worker \u81EA\u8EAB\u7684\u72B6\u6001\u3002" };
+      }
+      if (root?.session === void 0) {
+        return { ok: false, code: "root-unresolved", reason: "root session \u4E0D\u5B8C\u6574\uFF1B\u65E0\u6CD5\u8BFB\u53D6 Gate \u72B6\u6001\u3002" };
+      }
+      const gate = resolveGate(ctx, exec.agent);
+      if (gate.root === void 0) return { ok: false, code: "state-unavailable", reason: "\u65E0\u6CD5\u786E\u5B9A\u5DE5\u4F5C\u533A\u3002" };
+      const state = store.read(gate.root, root);
+      if (root?.id !== exec.agent?.id) {
+        return { ok: true, procedure: null, method: null, text: statusText(state, reviewLimit) };
+      }
+      const procedure = procedureFor(state, { reviewLimit });
+      const includeRounds = !procedure.hasRounds;
+      return {
+        ok: true,
+        procedure,
+        method: procedure.method,
+        text: procedureResultText(procedure, statusText(state, reviewLimit, { includeRounds }))
+      };
+    }
+  });
+}
+
+// src/tools/notes.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import path10 from "node:path";
+function registerNoteTools(ctx, deps) {
+  const { store, reviewLimit, wake } = deps;
+  ctx.tools.register({
+    name: "gate_note_write",
+    description: "\u5199 proposed Agent Note\uFF0C\u6216\u5728 planning \u539F\u5730\u66F4\u65B0\u5DF2\u5B58\u5728\u7684 implemented Note\u3002\u4EC5 planning worker\uFF1B\u901A\u7528 write/edit/shell \u88AB\u9650\u5236\u3002",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        path: { type: "string", description: "\u76F8\u5BF9 .agents/notes \u7684\u8DEF\u5F84\uFF1Bproposed/ \u53EF\u65B0\u5EFA\uFF0Cimplemented/ \u53EA\u80FD\u7F16\u8F91\u5DF2\u5B58\u5728\u6587\u4EF6\u3002" },
+        content: { type: "string" }
+      },
+      required: ["path", "content"]
+    },
+    output: {
+      schema: { type: "object", additionalProperties: true },
+      render: (_args, value) => [{ type: "text", text: JSON.stringify(value) }]
+    },
+    async execute(args, exec) {
+      const gate = resolveGate(ctx, exec.agent);
+      const effective = effectiveState(ctx, exec.agent, gate, store);
+      if (!effective.worker || !["plan", "plan-revise"].includes(effective.state.node ?? "")) {
+        return { ok: false, code: "planning-only", reason: "gate_note_write \u53EA\u5141\u8BB8 planning worker \u5728 plan/plan-revise \u8282\u70B9\u4F7F\u7528\u3002" };
+      }
+      let relative = String(args.path ?? "").replaceAll("\\", "/").replace(/^\.?\//u, "");
+      if (relative === "" || relative.includes("..") || path10.isAbsolute(relative) || !relative.endsWith(".md")) {
+        return { ok: false, code: "invalid-path" };
+      }
+      let lifecycle = "proposed";
+      if (relative.startsWith("proposed/")) relative = relative.slice("proposed/".length);
+      else if (relative.startsWith("implemented/")) {
+        lifecycle = "implemented";
+        relative = relative.slice("implemented/".length);
+      }
+      if (!/^(?:feature|bug-fix|simplification|architecture|process|testing)\/\d{4}-\d{2}-\d{2}-.+\.md$/u.test(relative)) {
+        return { ok: false, code: "invalid-path", reason: "\u9700\u8981 <class>/yyyy-mm-dd-topic.md\uFF0C\u6216 proposed|implemented/<class>/...\u3002" };
+      }
+      const base = path10.join(gate.root, ".agents", "notes", String(lifecycle));
+      const absolute = path10.resolve(base, relative);
+      if (!isInside(base, absolute)) return { ok: false, code: "invalid-path" };
+      if (pathHasSymlink(base, absolute)) return { ok: false, code: "invalid-path" };
+      if (lifecycle === "implemented" && !existsSync5(absolute)) {
+        return { ok: false, code: "implemented-must-exist", reason: "implemented Note \u53EA\u80FD\u539F\u5730\u7F16\u8F91\uFF0C\u4E0D\u80FD\u65B0\u5EFA\u3002" };
+      }
+      mkdirSync4(path10.dirname(absolute), { recursive: true });
+      writeFileSync4(absolute, String(args.content ?? ""));
+      return { ok: true, path: path10.relative(gate.root, absolute).replaceAll("\\", "/"), lifecycle };
+    }
+  });
+  ctx.tools.register({
+    name: "gate_note_verify",
+    description: "\u8FD0\u884C\u5185\u7F6E notes \u6821\u9A8C\uFF1Bnote-lifecycle \u4E2D\u901A\u8FC7\u540E\u8BBE\u7F6E noteVerified\u3002root-only\u3002",
+    parameters: { type: "object", additionalProperties: false, properties: {} },
+    output: {
+      schema: { type: "object", additionalProperties: true },
+      render: (_args, value) => [{ type: "text", text: JSON.stringify(value) }],
+      presentationMeta: (_args, value) => value?.state === void 0 ? { gate: {} } : { gate: { state: value.state } }
+    },
+    async execute(_args, exec) {
+      const root = rootAgentOf(ctx, exec.agent);
+      if (root?.id !== exec.agent?.id) return { ok: false, code: "root-only", reason: "gate_note_verify \u53EA\u80FD\u7531 root agent \u8C03\u7528\u3002" };
+      const gate = resolveGate(ctx, exec.agent);
+      const state = store.read(gate.root, exec.agent);
+      const recovered = recoverFinalize(gate.root, String(exec.agent?.session?.id ?? exec.agent?.id ?? "unknown"));
+      if (recovered.length > 0) state.noteFinalizeRecovery = [...state.noteFinalizeRecovery, ...recovered];
+      const check = runNotesScripts(gate.root);
+      if (!check.ok) return { ...check, state: normalizeState(state) };
+      if (state.node === "note-lifecycle") {
+        if (state.noteFinalized !== true) return { ok: false, code: "note-lifecycle-incomplete", reason: "\u5148\u8C03\u7528 gate_note_finalize\u3002", state: normalizeState(state) };
+        const implemented = state.notePaths.length > 0 && state.notePaths.every((entry) => entry.lifecycle === "implemented" && existsSync5(path10.join(gate.root, entry.path)));
+        if (!implemented) return { ok: false, code: "note-lifecycle-incomplete", reason: "notePaths \u5C1A\u672A\u5168\u90E8\u8FDB\u5165 implemented\u3002", results: check.results, state: normalizeState(state) };
+        state.noteVerified = true;
+        store.write(gate.root, exec.agent, state);
+        return { ok: true, noteVerified: true, results: check.results, state: normalizeState(state) };
+      }
+      return { ok: true, noteVerified: false, results: check.results, state: normalizeState(state) };
+    }
+  });
+  ctx.tools.register({
+    name: "gate_note_finalize",
+    description: "\u628A note-lifecycle \u4E2D\u7684 proposed Note \u79FB\u5230 implemented \u5E76\u66F4\u65B0\u5934\u5757\uFF1Broot-only\u3002",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        decisionBodies: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: { path: { type: "string" }, body: { type: "string" } },
+            required: ["path", "body"]
+          }
+        }
+      }
+    },
+    output: {
+      schema: { type: "object", additionalProperties: true },
+      render: (_args, value) => [{ type: "text", text: JSON.stringify(value) }],
+      presentationMeta: (_args, value) => value?.state === void 0 ? { gate: {} } : { gate: { state: value.state } }
+    },
+    async execute(args, exec) {
+      const root = rootAgentOf(ctx, exec.agent);
+      if (root?.id !== exec.agent?.id) return { ok: false, code: "root-only", reason: "gate_note_finalize \u53EA\u80FD\u7531 root agent \u8C03\u7528\u3002" };
+      const gate = resolveGate(ctx, exec.agent);
+      const state = store.read(gate.root, exec.agent);
+      if (state.node !== "note-lifecycle") return { ok: false, code: "not-note-lifecycle", reason: "\u53EA\u5728 note-lifecycle \u8282\u70B9\u53EF\u7528\u3002" };
+      if (state.noteDecision === "mechanical") {
+        state.noteVerified = true;
+        state.noteFinalized = true;
+        store.write(gate.root, exec.agent, state);
+        return { ok: true, skipped: true, state: normalizeState(state) };
+      }
+      const sessionId = String(exec.agent?.session?.id ?? exec.agent?.id ?? "unknown");
+      const recovered = recoverFinalize(gate.root, sessionId);
+      for (const entry of state.notePaths) {
+        if (entry.lifecycle !== "proposed") continue;
+        const source = path10.join(gate.root, entry.path);
+        const targetRelative = entry.path.replaceAll("\\", "/").replace(".agents/notes/proposed/", ".agents/notes/implemented/");
+        if (!existsSync5(source) && existsSync5(path10.join(gate.root, targetRelative))) {
+          entry.path = targetRelative;
+          entry.lifecycle = "implemented";
+          recovered.push("adopted-target");
+        }
+      }
+      const moved = [];
+      const decisionBodies = new Map((Array.isArray(args.decisionBodies) ? args.decisionBodies : []).map((item) => [String(item.path).replaceAll("\\", "/"), String(item.body ?? "")]));
+      try {
+        for (const entry of state.notePaths) {
+          if (entry.lifecycle !== "proposed") continue;
+          const original = entry.path.replaceAll("\\", "/");
+          const relative = finalizeNote(gate.root, entry, sessionId, decisionBodies.get(original));
+          moved.push({ from: original, to: relative });
+          entry.path = relative;
+          entry.lifecycle = "implemented";
+        }
+        const finalCheck = runNotesScripts(gate.root);
+        if (!finalCheck.ok) throw new Error(`finalize/decisionBodies \u540E\u7684 notes \u6821\u9A8C\u5931\u8D25\uFF1A${JSON.stringify(finalCheck.results)}`);
+        state.noteFinalizeRecovery = recovered;
+        state.noteVerified = false;
+        state.noteFinalized = true;
+        store.write(gate.root, exec.agent, state);
+        return { ok: true, moved, recovered, state: normalizeState(state) };
+      } catch (error) {
+        state.noteFinalizeRecovery = recovered;
+        store.write(gate.root, exec.agent, state);
+        return { ok: false, code: "note-finalize-failed", reason: error instanceof Error ? error.message : String(error), moved, recovered, state: normalizeState(state) };
+      }
+    }
+  });
+}
+
+// src/tools/index.ts
+function registerTools(ctx, deps) {
+  registerStartPhase(ctx, deps);
+  registerRecord(ctx, deps);
+  registerStatus(ctx, deps);
+  registerNoteTools(ctx, deps);
+}
+
+// src/index.ts
+var inject = ["tools"];
+function apply(ctx, config = {}) {
+  const reviewLimit = Number.isInteger(config?.reviewLimit) ? config.reviewLimit : DEFAULT_REVIEW_LIMIT;
+  const store = createStateRuntime(ctx);
+  const wake = makeWake(reviewLimit);
+  const deps = { ctx, store, reviewLimit, wake };
+  installSystemPrompt(ctx, deps);
+  installGuard(ctx, deps);
+  installRestrictions(ctx, deps);
+  registerCommands(ctx, deps);
+  registerTools(ctx, deps);
+}
+export {
+  Config,
+  DISCUSS_ORCHESTRATION,
+  DOCS_ORCHESTRATION,
+  FIX_BUG_ORCHESTRATION,
+  GATE_RECORD_NODES,
+  IMPLEMENT_ORCHESTRATION,
+  NODE_METHODS,
+  NOTE_LIFECYCLE_ORCHESTRATION,
+  PHASES,
+  PLAN_ORCHESTRATION,
+  WORKER_NODES,
+  apply,
+  defaultState,
+  inject,
+  loadState,
+  normalizeState,
+  saveState,
+  transformImplemented
+};