dsh-gate-agent 0.1.3 → 0.1.5

package/lib/index.js

@@ -126,7 +126,7 @@ var FIX_BUG_ORCHESTRATION = `## /gate-fix-bug \u7F16\u6392
 ## 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
+\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
@@ -189,43 +189,80 @@ var NODE_PROCEDURES = {
   "proposal-review": REVIEWING_PROPOSAL_PROCEDURE,
   "verify-standalone": REVIEWING_VERIFY_PROCEDURE
 };
+var METHODOLOGY_KEYS = [
+  "discuss",
+  "orchestrating/plan",
+  "orchestrating/plan-review",
+  "orchestrating/plan-revise",
+  "orchestrating/implement",
+  "orchestrating/code-review",
+  "orchestrating/implement-revise",
+  "orchestrating/verify",
+  "orchestrating/note-lifecycle",
+  "orchestrating/fix-bug",
+  "docs",
+  "reviewing/code-review-standalone",
+  "reviewing/proposal-review",
+  "reviewing/verify-standalone",
+  "blocked",
+  "complete",
+  "orchestrating",
+  "reviewing"
+];
+var METHODOLOGY_KEY_SET = new Set(METHODOLOGY_KEYS);
+function methodologyKeyFor(state) {
+  if (state.phase === "orchestrating" || state.phase === "reviewing") {
+    const key = state.node === null ? state.phase : `${state.phase}/${state.node}`;
+    return METHODOLOGY_KEY_SET.has(key) ? key : state.phase;
+  }
+  return state.phase;
+}
 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 procedure\uFF0C\u5E76\u786E\u8BA4\u6280\u80FD\u5185\u5BB9\u662F\u5426\u4ECD\u5728\u4E0A\u4E0B\u6587\uFF1A\u9996\u6B21\u9700\u8981\u65F6\u52A0\u8F7D\uFF0C\u5DF2\u5728\u4E0A\u6587\u5219\u590D\u7528\uFF0C\u4E0D\u8981\u56E0 procedure \u66F4\u65B0\u91CD\u590D\u52A0\u8F7D\u3002
+\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 procedure\uFF0C\u5E76\u786E\u8BA4\u6280\u80FD\u5185\u5BB9\u662F\u5426\u4ECD\u5728\u4E0A\u4E0B\u6587\uFF1A\u9996\u6B21\u9700\u8981\u65F6\u52A0\u8F7D\uFF0C\u5DF2\u5728\u4E0A\u6587\u5219\u590D\u7528\uFF0C\u4E0D\u8981\u56E0 procedure \u66F4\u65B0\u91CD\u590D\u52A0\u8F7D\u3002\u4E0D\u786E\u5B9A\u6709\u54EA\u4E9B /gate-* \u547D\u4EE4\u6216\u5DE5\u5177\u7528\u9014\u65F6\uFF0C\u8C03\u7528\u53EA\u8BFB gate_help\u3002
 
 ${DISCUSS_ORCHESTRATION}
 
-## 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
+## orchestrating/plan \xB7 orchestrating/plan-review \xB7 orchestrating/plan-revise
+\u628A\u8BA8\u8BBA\u5171\u8BC6\u3001\u65E2\u6709\u51B3\u7B56\u4E0E\u7528\u6237\u9700\u6C42\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
+## orchestrating/implement \xB7 orchestrating/implement-revise
+\u6309\u5DF2\u786E\u8BA4\u7684\u8BA1\u5212\u6216\u8BA8\u8BBA\u540E\u7684\u5B9E\u65BD\u8BF4\u660E\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
+## orchestrating/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
+## orchestrating/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
+## orchestrating/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
+## orchestrating/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
+## reviewing/code-review-standalone
 \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
+## reviewing/proposal-review
 \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
+## reviewing/verify-standalone
 \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`;
+## blocked
+blocked \u8868\u793A\u51BB\u7ED3\uFF1A\u7B49\u5F85 /gate-resume\u3002
+
+## complete
+complete \u8868\u793A\u5F53\u524D\u4EFB\u52A1\u5B8C\u6210\uFF0C\u65B0\u4EFB\u52A1\u9700\u8981\u91CD\u65B0\u6388\u6743\u3002
+
+## orchestrating
+\u5F53\u524D\u5904\u4E8E orchestrating \u4F46\u6CA1\u6709\u5339\u914D node\uFF1B\u8C03\u7528 gate_status \u91CD\u65B0\u8BFB\u53D6\uFF1B\u82E5\u4ECD\u4E0D\u4E00\u81F4\uFF0C\u56DE discuss \u4FEE\u590D Gate \u72B6\u6001\u3002
+
+## reviewing
+\u5F53\u524D\u5904\u4E8E reviewing \u4F46\u6CA1\u6709\u5339\u914D node\uFF1B\u8C03\u7528 gate_status \u91CD\u65B0\u8BFB\u53D6\uFF1B\u82E5\u4ECD\u4E0D\u4E00\u81F4\uFF0C\u56DE discuss \u4FEE\u590D Gate \u72B6\u6001\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";
@@ -238,7 +275,7 @@ function procedureFor(state, { reviewLimit = DEFAULT_REVIEW_LIMIT } = {}) {
   if (variant === "discuss") {
     text = "discuss \u4E0D\u6D3E worker\uFF1B\u6587\u4EF6\u9ED8\u8BA4\u53EA\u8BFB\uFF0C\u63D0\u4EA4\u5DF2\u6709\u6539\u52A8\u4E0D\u53D7\u5F71\u54CD\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`;
+    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\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") {
@@ -256,7 +293,7 @@ function procedureFor(state, { reviewLimit = DEFAULT_REVIEW_LIMIT } = {}) {
     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" };
+  return { phase: state.phase, node: state.node, methodologyKey: methodologyKeyFor(state), method, text, hasRounds: variant === "plan" || variant === "implement" };
 }
 function procedureFailure(state, reviewLimit, fields) {
   const procedure = procedureFor(state, { reviewLimit });
@@ -301,6 +338,7 @@ function statusText(state, reviewLimit = DEFAULT_REVIEW_LIMIT, { includeRounds =
 }
 function procedureBlock(procedure) {
   return `\u5F53\u524D phase/node\uFF1A${procedure.phase} / ${procedure.node ?? "\u65E0"}
+\u65B9\u6CD5\u8BBA\uFF1A${procedure.methodologyKey}
 \u65B9\u6CD5\uFF1A${procedure.method}
 
 ${procedure.text}`;
@@ -910,9 +948,9 @@ function classifyPath(root, value, cwd = root) {
 var GIT_VALUE_OPTIONS = /* @__PURE__ */ new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--config-env"]);
 var GIT_FILE_WRITE = /* @__PURE__ */ new Set(["checkout", "switch", "reset", "clean", "restore", "stash", "merge", "rebase", "cherry-pick", "apply", "pull"]);
 var GIT_NON_WRITE = /* @__PURE__ */ new Set(["status", "add", "commit", "push"]);
-function gitSubcommands(command) {
+function gitSubcommands(command2) {
   const subcommands = /* @__PURE__ */ new Set();
-  for (const segment of String(command).split(/&&|\|\||;|\r?\n|\|/u)) {
+  for (const segment of String(command2).split(/&&|\|\||;|\r?\n|\|/u)) {
     const tokens = [...segment.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/gu)].map((match) => match[1] ?? match[2] ?? match[3] ?? "");
     const gitIndex = tokens.findIndex((token) => /^git(?:\.exe)?$/iu.test(token));
     if (gitIndex < 0) continue;
@@ -975,8 +1013,8 @@ function addTarget(targets, token, map) {
 }
 function segmentAccess(text, root, cwd, map) {
   const git = gitSubcommands(text);
-  if ([...git].some((command) => GIT_FILE_WRITE.has(command))) return { write: true, outsideTargets: [] };
-  if ([...git].some((command) => GIT_NON_WRITE.has(command))) return { write: false, outsideTargets: [] };
+  if ([...git].some((command2) => GIT_FILE_WRITE.has(command2))) return { write: true, outsideTargets: [] };
+  if ([...git].some((command2) => GIT_NON_WRITE.has(command2))) return { write: false, outsideTargets: [] };
   const raw = [];
   const verb = WRITE_VERB.exec(text);
   if (verb !== null) {
@@ -995,9 +1033,9 @@ function segmentAccess(text, root, cwd, map) {
 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);
+function shellAccess(command2, root, cwd = root) {
+  const map = assignments(command2);
+  const parts = segments(command2).map((part) => segmentAccess(part, root, cwd, map)).filter((item) => item.write);
   return {
     write: parts.length > 0,
     outsideTargets: parts.flatMap((item) => item.outsideTargets ?? [])
@@ -1032,9 +1070,9 @@ function accessFor(state, worker) {
 function accessText(access) {
   return `\u6743\u9650\uFF1Aread=${access.read ? "yes" : "no"} write=${access.write} noteWrite=${access.noteWrite ? "yes" : "no"} shell=${access.shell} repoWrite=${access.repoWrite}`;
 }
-function repoCommands(command) {
+function repoCommands(command2) {
   const commands = /* @__PURE__ */ new Set();
-  for (const subcommand of gitSubcommands(command)) {
+  for (const subcommand of gitSubcommands(command2)) {
     if (subcommand === "add" || subcommand === "commit" || subcommand === "push") commands.add(subcommand);
   }
   return commands;
@@ -1085,7 +1123,7 @@ function enterPhase(ctx, agent, node, reviewLimit, store, current) {
   store.write(gate.root, agent, state);
   return { gate, state, reviewLimit };
 }
-function wakeGateAgent(invocation, text, command) {
+function wakeGateAgent(invocation, text, command2) {
   const followup = invocation?.agent?.followup;
   if (typeof followup !== "function") return;
   try {
@@ -1093,19 +1131,19 @@ function wakeGateAgent(invocation, text, command) {
       id: randomUUID2(),
       role: "user",
       content: [{ type: "text", text }],
-      source: { kind: "gate-command", command }
+      source: { kind: "gate-command", command: command2 }
     });
   } catch {
   }
 }
 function makeWake(reviewLimit) {
-  return (invocation, state, text, command) => {
+  return (invocation, state, text, command2) => {
     const procedure = procedureFor(state, { reviewLimit });
     wakeGateAgent(invocation, `${procedureBlock(procedure)}
 
 ${accessText(accessFor(state, false))}
 
-${text}`, command);
+${text}`, command2);
   };
 }
 
@@ -1249,7 +1287,7 @@ 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";
+var GATE_FROZEN_REASON = "Gate \u5DF2\u51BB\u7ED3\uFF1A\u5148 /gate-resume";
 function fileWriteDenied(state, effective) {
   if (state.phase === "blocked") return GATE_FROZEN_REASON;
   if (!effective.worker && state.phase === "discuss") return DISCUSS_READ_ONLY;
@@ -1303,10 +1341,10 @@ function gateDenyReason(ctx, exec, store) {
     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 command = String(exec.arguments?.command ?? "");
-    const repos = repoCommands(command);
+    const command2 = String(exec.arguments?.command ?? "");
+    const repos = repoCommands(command2);
     if (repos.size > 0 && access.repoWrite === "none") return repoDenied(state, effective, [...repos].join("/"));
-    const shell = shellAccess(command, gate.workspace, cwd);
+    const shell = shellAccess(command2, gate.workspace, cwd);
     if (!shell.write) return void 0;
     if (shell.outsideTargets.length > 0) return "\u5DE5\u4F5C\u533A\u5916\u5199\u5165\u88AB\u62D2\u7EDD";
     if (access.write === "none") return shellWriteDenied(state, effective);
@@ -1327,7 +1365,7 @@ function installRestrictions(ctx, deps) {
 }
 
 // src/commands.ts
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/notes/provision.ts
 import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
@@ -1380,15 +1418,15 @@ function provisionProjectScripts(root) {
     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 command2 = "node .agents/gate/verify-notes.mjs";
   const existing = pkg.scripts["verify-notes"];
-  if (existing === void 0) pkg.scripts["verify-notes"] = command;
+  if (existing === void 0) pkg.scripts["verify-notes"] = command2;
   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),
+    command: existing === void 0 ? command2 : String(existing),
     changed: existing === void 0
   };
 }
@@ -1401,6 +1439,7 @@ var BASE_GITIGNORE = `node_modules/
 Thumbs.db
 coverage/
 dist/
+.scratch/
 .agents/notes/.gate-finalize-*
 .agents/notes/.gate-validate-*
 .agents/notes/*.gate-backup
@@ -1448,50 +1487,243 @@ function provisionCi(root) {
   return { workflow: path8.relative(root, workflow).replaceAll("\\", "/"), scripts: path8.relative(root, ciDir).replaceAll("\\", "/"), changed: !existing };
 }
 
+// src/artifacts/policy.ts
+import { existsSync as existsSync4, lstatSync as lstatSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import path9 from "node:path";
+var ARTIFACT_POLICY_PATH = ".agents/gate/artifact-policy.json";
+var BASE_ARTIFACT_POLICY = {
+  version: 1,
+  artifacts: {
+    handoff: { phases: ["*"], roles: ["root"], paths: [".scratch/handoff/**"] },
+    prd: { phases: ["discuss"], roles: ["root"], paths: ["docs/prd/**", ".scratch/prd/**"] },
+    research: {
+      phases: ["discuss", "orchestrating/plan"],
+      roles: ["root", "worker"],
+      paths: ["docs/research/**", ".scratch/research/**"]
+    }
+  }
+};
+var PHASES2 = new Set(METHODOLOGY_KEYS);
+var RESERVED = [".agents/gate/artifact-policy.json", ".agents/notes/"];
+function normalizeArtifactPath(value) {
+  return path9.posix.normalize(String(value).replaceAll("\\", "/").replace(/^\.\//u, ""));
+}
+function isReservedPath(value) {
+  const normalized = value.toLowerCase();
+  return RESERVED.some((prefix) => normalized === prefix || normalized.startsWith(prefix.endsWith("/") ? prefix : `${prefix}/`));
+}
+function artifactPolicyText(policy = BASE_ARTIFACT_POLICY) {
+  return `${JSON.stringify(policy, null, 2)}
+`;
+}
+function provisionArtifactPolicy(root) {
+  const file = path9.join(root, ARTIFACT_POLICY_PATH);
+  if (pathHasSymlink(root, file)) throw new Error("artifact policy \u8DEF\u5F84\u5305\u542B symlink");
+  mkdirSync4(path9.dirname(file), { recursive: true });
+  if (existsSync4(file)) return { path: ARTIFACT_POLICY_PATH, status: "existing" };
+  writeFileSync4(file, artifactPolicyText());
+  return { path: ARTIFACT_POLICY_PATH, status: "created" };
+}
+function parseArtifactPolicy(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return { error: "artifact policy \u5FC5\u987B\u662F\u5BF9\u8C61" };
+  const source = value;
+  if (source.version !== 1) return { error: "artifact policy version \u5FC5\u987B\u4E3A 1" };
+  if (source.artifacts === null || typeof source.artifacts !== "object" || Array.isArray(source.artifacts)) {
+    return { error: "artifact policy artifacts \u5FC5\u987B\u662F\u5BF9\u8C61" };
+  }
+  for (const key of Object.keys(source)) {
+    if (key !== "version" && key !== "artifacts") return { error: `artifact policy \u672A\u77E5\u5B57\u6BB5\uFF1A${key}` };
+  }
+  const artifacts = {};
+  for (const [kind, raw] of Object.entries(source.artifacts)) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return { error: `artifact ${kind} \u5FC5\u987B\u662F\u5BF9\u8C61` };
+    const rule = raw;
+    for (const key of Object.keys(rule)) {
+      if (key !== "phases" && key !== "roles" && key !== "paths") return { error: `artifact ${kind} \u672A\u77E5\u5B57\u6BB5\uFF1A${key}` };
+    }
+    if (!Array.isArray(rule.phases) || rule.phases.length === 0 || !rule.phases.every((phase) => phase === "*" || typeof phase === "string" && PHASES2.has(phase))) {
+      return { error: `artifact ${kind} phases \u975E\u6CD5` };
+    }
+    if (!Array.isArray(rule.roles) || rule.roles.length === 0 || !rule.roles.every((role) => role === "root" || role === "worker")) {
+      return { error: `artifact ${kind} roles \u975E\u6CD5` };
+    }
+    if (!Array.isArray(rule.paths) || rule.paths.length === 0) return { error: `artifact ${kind} paths \u975E\u6CD5` };
+    const paths = [];
+    for (const item of rule.paths) {
+      if (typeof item !== "string" || item.trim() === "") return { error: `artifact ${kind} path \u975E\u6CD5` };
+      const normalized = normalizeArtifactPath(item);
+      if (path9.isAbsolute(normalized) || normalized.split("/").includes("..")) return { error: `artifact ${kind} path \u8D8A\u754C\uFF1A${item}` };
+      if (isReservedPath(normalized)) return { error: `artifact ${kind} path \u662F\u4FDD\u7559\u8DEF\u5F84\uFF1A${item}` };
+      paths.push(normalized);
+    }
+    artifacts[kind] = { phases: [...rule.phases], roles: [...rule.roles], paths };
+  }
+  return { policy: { version: 1, artifacts } };
+}
+function loadArtifactPolicy(root) {
+  const file = path9.join(root, ARTIFACT_POLICY_PATH);
+  if (!existsSync4(file)) return { error: "artifact policy \u4E0D\u5B58\u5728\uFF1B\u5148\u8FD0\u884C /gate-init \u5E76\u586B\u5199 .agents/gate/artifact-policy.json" };
+  if (lstatSync4(file).isSymbolicLink()) return { error: "artifact policy \u4E0D\u80FD\u662F symlink" };
+  try {
+    return parseArtifactPolicy(JSON.parse(readFileSync3(file, "utf8")));
+  } catch {
+    return { error: "artifact policy \u4E0D\u662F\u6709\u6548 JSON" };
+  }
+}
+function segmentMatches(pattern, value) {
+  const regex = new RegExp(`^${pattern.split("").map((char) => {
+    if (char === "*") return "[^/]*";
+    if (char === "?") return "[^/]";
+    return char.replace(/[\\^$.*+?()[\]{}|]/gu, "\\$&");
+  }).join("")}$`, "u");
+  return regex.test(value);
+}
+function pathMatches(pattern, relative) {
+  const patternParts = pattern.split("/").filter(Boolean);
+  const valueParts = relative.split("/").filter(Boolean);
+  const walk = (p, v) => {
+    if (p === patternParts.length) return v === valueParts.length;
+    const part = patternParts[p] ?? "";
+    if (part === "**") return walk(p + 1, v) || v < valueParts.length && walk(p, v + 1);
+    if (v >= valueParts.length) return false;
+    if (!segmentMatches(part, valueParts[v] ?? "")) return false;
+    return walk(p + 1, v + 1);
+  };
+  return walk(0, 0);
+}
+function artifactRuleAllows(policy, state, worker, kind) {
+  if (state.phase === "blocked") return { error: "blocked \u4E0D\u5141\u8BB8 artifact \u5199\u5165" };
+  const rule = policy.artifacts[kind];
+  if (rule === void 0) return { error: `artifact kind \u672A\u6388\u6743\uFF1A${kind}` };
+  const phaseKey = methodologyKeyFor(state);
+  if (!rule.phases.includes("*") && !rule.phases.includes(phaseKey)) return { error: `\u5F53\u524D\u9636\u6BB5 ${phaseKey} \u4E0D\u5141\u8BB8 artifact ${kind}` };
+  if (!rule.roles.includes(worker ? "worker" : "root")) return { error: `\u5F53\u524D\u89D2\u8272\u4E0D\u5141\u8BB8 artifact ${kind}` };
+  return { rule };
+}
+function checkArtifactPath(root, rule, requested, kind) {
+  const normalized = normalizeArtifactPath(requested);
+  if (path9.isAbsolute(normalized) || normalized.split("/").includes("..")) return { error: "artifact path \u8D8A\u754C" };
+  if (isReservedPath(normalized)) return { error: "artifact path \u662F\u4FDD\u7559\u8DEF\u5F84" };
+  if (!rule.paths.some((pattern) => pathMatches(pattern, normalized))) return { error: `artifact ${kind} path \u4E0D\u5728\u767D\u540D\u5355\uFF1A${requested}` };
+  const absolute = path9.resolve(root, normalized);
+  if (!isInside(root, absolute)) return { error: "artifact path \u8D8A\u754C" };
+  if (pathHasSymlink(root, absolute)) return { error: "artifact path \u5305\u542B symlink" };
+  return { absolute, relative: path9.relative(root, absolute).replaceAll("\\", "/") };
+}
+function writeArtifact(root, requested, content) {
+  const normalized = normalizeArtifactPath(requested);
+  if (path9.isAbsolute(normalized) || normalized.split("/").includes("..") || isReservedPath(normalized)) return { error: "artifact path \u88AB\u62D2\u7EDD" };
+  const target = path9.resolve(root, normalized);
+  if (!isInside(root, target)) return { error: "artifact path \u8D8A\u754C" };
+  if (pathHasSymlink(root, target)) return { error: "artifact path \u5305\u542B symlink" };
+  mkdirSync4(path9.dirname(target), { recursive: true });
+  writeFileSync4(target, content);
+  return { relative: path9.relative(root, target).replaceAll("\\", "/") };
+}
+
 // src/commands.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
+import { readFileSync as readFileSync4 } from "node:fs";
+
+// src/command-catalog.ts
+var GATE_COMMANDS = [
+  { name: "gate-init", description: "\u521D\u59CB\u5316 notes\u3001AGENTS.md\u3001verify-notes\u3001CI\u3001git \u4E0E\u57FA\u7840 .gitignore", hint: null, when: "any" },
+  { name: "gate-enter-plan", description: "\u57FA\u4E8E\u8BA8\u8BBA\u5171\u8BC6\u3001\u65E2\u6709\u51B3\u7B56\u4E0E\u7528\u6237\u9700\u6C42\u8FDB\u5165 planning", hint: "<\u5177\u4F53\u5DE5\u4F5C\u4E8B\u9879\u6216\u4E0A\u4E0B\u6587\u8BED\u4E49>", when: "discuss/complete" },
+  { name: "gate-enter-implement", description: "\u57FA\u4E8E\u5DF2\u786E\u8BA4\u8BA1\u5212\u6216\u8BA8\u8BBA\u540E\u7684\u5B9E\u65BD\u8BF4\u660E\u8FDB\u5165 implementation", hint: "<\u5177\u4F53\u5DE5\u4F5C\u4E8B\u9879\u6216\u4E0A\u4E0B\u6587\u8BED\u4E49>", when: "discuss/complete" },
+  { name: "gate-prd", description: "\u5728 discuss \u4E2D\u6309\u7528\u6237\u8981\u6C42\u521B\u5EFA\u6216\u66F4\u65B0 PRD", hint: "[\u4E3B\u9898\u6216\u4E0A\u4E0B\u6587\u8BED\u4E49]", when: "discuss" },
+  { name: "gate-fix-bug", description: "\u4E3A\u5DF2\u6388\u6743\u7F3A\u9677\u6D3E\u53D1 fix worker\uFF0C\u57FA\u4E8E\u63CF\u8FF0\u6216\u5F53\u524D\u4E0A\u4E0B\u6587\u4FEE\u590D", hint: "<\u5177\u4F53\u5DE5\u4F5C\u4E8B\u9879\u6216\u4E0A\u4E0B\u6587\u8BED\u4E49>", when: "discuss/complete" },
+  { name: "gate-docs", description: "\u8FDB\u5165\u6587\u6863\u6CBB\u7406\uFF0C\u6309\u9879\u76EE\u6587\u6863\u89C4\u8303\u5904\u7406", hint: "[\u6587\u6863\u8303\u56F4\u6216\u4E0A\u4E0B\u6587\u8BED\u4E49]", when: "discuss/complete" },
+  { name: "gate-implement-review", description: "\u5BF9\u5F53\u524D\u6539\u52A8\u505A\u72EC\u7ACB\u53EA\u8BFB code review", hint: "<\u5177\u4F53\u5DE5\u4F5C\u4E8B\u9879\u6216\u4E0A\u4E0B\u6587\u8BED\u4E49>", when: "discuss/complete" },
+  { name: "gate-code-verify", description: "\u5BF9\u5F53\u524D\u6539\u52A8\u505A\u72EC\u7ACB\u53EA\u8BFB\u9A8C\u6536\uFF08gate-user-verify\uFF09", hint: "<\u5177\u4F53\u5DE5\u4F5C\u4E8B\u9879\u6216\u4E0A\u4E0B\u6587\u8BED\u4E49>", when: "discuss/complete" },
+  { name: "gate-propose-review", description: "\u5BF9\u63D0\u6848\u505A\u72EC\u7ACB\u53EA\u8BFB\u4E09\u8F74\u8BC4\u5BA1", hint: "<\u5177\u4F53\u5DE5\u4F5C\u4E8B\u9879\u6216\u4E0A\u4E0B\u6587\u8BED\u4E49>", when: "discuss/complete" },
+  { name: "gate-block", description: "\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", hint: "[\u539F\u56E0]", when: "any" },
+  { name: "gate-resume", description: "\u89E3\u51BB blocked\uFF1A\u56DE\u5230 block \u524D\u7684\u8282\u70B9\uFF1B\u8F6E\u6B21\u8017\u5C3D\u56DE discuss", hint: null, when: "blocked" },
+  { name: "gate-return-discuss", description: "\u653E\u5F03\u5F53\u524D\u8282\u70B9\uFF0C\u56DE\u5230 discuss", hint: null, when: "non-blocked" },
+  { name: "gate-status", description: "\u67E5\u770B\u5F53\u524D phase/node\u3001procedure\u3001access \u4E0E\u4E0B\u4E00\u6B65\u547D\u4EE4", hint: null, when: "any" },
+  { name: "gate-note-verify", description: "\u53EA\u8BFB\u68C0\u67E5 notes tree/format/lifecycle/archived", hint: null, when: "any" },
+  { name: "gate-note-archive", description: "\u5C06 implemented Note \u5F52\u6863\u5230 archived/\uFF1A\u52A0 Archived\u3001\u79FB\u52A8\u3001\u5C01\u5370\u5E76\u62A5\u544A\u5165\u7AD9\u94FE\u63A5", hint: "<implemented-note> [--superseded-by <new-note>]", when: "any" },
+  { name: "gate-note-board", description: "\u751F\u6210\u51B3\u7B56\u770B\u677F board.html\uFF08\u8F7B\u91CF\u6A21\u5F0F\uFF0C\u8FDE\u63A5\u672C\u5730 notes \u76EE\u5F55\uFF09", hint: "[\u8F93\u51FA\u8DEF\u5F84] [\u6807\u9898]", when: "any" },
+  { name: "gate-note-seal", description: "\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", hint: null, when: "any" }
+];
+function commandSpec(name) {
+  return GATE_COMMANDS.find((command2) => command2.name === name);
+}
+function commandLabel(spec) {
+  return `/${spec.name}`;
+}
+
+// src/command-next.ts
+function command(name, reason) {
+  const spec = commandSpec(name);
+  return { command: spec === void 0 ? `/${name}` : commandLabel(spec), reason };
+}
+function nextCommandsFor(state) {
+  if (state.phase === "blocked") {
+    return [command("gate-resume", "\u89E3\u51BB\u540E\u56DE\u5230\u6682\u505C\u524D\u8282\u70B9\uFF1B\u8F6E\u6B21\u8017\u5C3D\u65F6\u56DE discuss\u3002")];
+  }
+  if (state.phase === "discuss" || state.phase === "complete") {
+    return [
+      command("gate-enter-plan", "\u9700\u8981\u7528\u6237\u6388\u6743\u540E\u8FDB\u5165 planning\u3002"),
+      command("gate-enter-implement", "\u9700\u8981\u7528\u6237\u6388\u6743\u540E\u8FDB\u5165\u5B9E\u65BD\uFF1B\u590D\u7528\u5DF2\u901A\u8FC7\u7684 plan task\uFF0C\u6216\u76F4\u63A5\u4ECE\u7528\u6237\u7B80\u8FF0\u5B9E\u65BD\u3002")
+    ];
+  }
+  return [];
+}
+function nextCommandsText(commands) {
+  if (commands.length === 0) return "";
+  return `\u4E0B\u4E00\u6B65\u547D\u4EE4\uFF1A${commands.map((item) => `${item.command}\uFF08${item.reason}\uFF09`).join("\uFF1B")}`;
+}
+
+// src/commands.ts
 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 command2 = (name, handler) => {
+      const spec = commandSpec(name);
+      if (spec === void 0) throw new Error(`unknown gate command: ${name}`);
+      scope.commands.register({
+        name: spec.name,
+        description: spec.description,
+        ...spec.hint === null ? {} : { input: { hint: spec.hint } },
+        handler
+      });
+    };
+    command2("gate-init", 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);
+      const root = path10.resolve(workspace);
       let provisioned;
       let projectScripts;
       let projectCi;
       let projectGit;
+      let artifactPolicy;
       try {
         provisioned = provisionNotes(root);
+        artifactPolicy = provisionArtifactPolicy(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");
+      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}\uFF0Cartifact policy \u4E3A ${artifactPolicy.path}\uFF08${artifactPolicy.status}\uFF09\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}
+artifact policy\uFF1A${artifactPolicy.path}\uFF08${artifactPolicy.status}\uFF09
 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) => {
+    });
+    command2("gate-enter-plan", 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) => {
+    });
+    command2("gate-enter-implement", async (invocation) => {
       const brief = String(invocation.rawInput ?? "").trim();
       const gate = resolveGate(ctx, invocation.agent);
       const state = store.read(gate.root, invocation.agent);
@@ -1513,8 +1745,21 @@ ignore\uFF1A${projectGit.ignore}` };
       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) => {
+    });
+    command2("gate-prd", async (invocation) => {
+      const gate = resolveGate(ctx, invocation.agent);
+      const state = store.read(gate.root, invocation.agent);
+      if (state.phase !== "discuss") return { kind: "error", text: "gate-prd \u53EA\u5728 discuss \u9636\u6BB5\u53EF\u7528" };
+      const topic = String(invocation.rawInput ?? "").trim() || "\u5F53\u524D\u8BA8\u8BBA";
+      let skill = "";
+      try {
+        skill = readFileSync4(path10.join(SKILLS, "gate-prd", "SKILL.md"), "utf8");
+      } catch {
+      }
+      wake(invocation, state, ["\u8BF7\u6309 gate-prd \u6280\u80FD\u521B\u5EFA\u6216\u66F4\u65B0 PRD\u3002", "\u4E3B\u9898/\u4E0A\u4E0B\u6587\uFF1A" + topic, skill].filter(Boolean).join("\n\n"), "gate-prd");
+      return { kind: "success", text: "\u5DF2\u8BF7\u6C42 PRD\uFF1A" + topic };
+    });
+    command2("gate-fix-bug", async (invocation) => {
       const brief = String(invocation.rawInput ?? "").trim();
       const gate = resolveGate(ctx, invocation.agent);
       const state = store.read(gate.root, invocation.agent);
@@ -1530,23 +1775,24 @@ ignore\uFF1A${projectGit.ignore}` };
       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) => {
+    });
+    command2("gate-docs", async (invocation) => {
+      const scope2 = String(invocation.rawInput ?? "").trim() || "\u6587\u6863\u6CBB\u7406";
       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.task = scope2;
       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) => {
+      wake(invocation, state, `Gate \u5DF2\u8FDB\u5165 docs\uFF1A${scope2}\u3002`, "gate-docs");
+      return { kind: "success", text: `\u8FDB\u5165 docs\uFF1A${scope2}` };
+    });
+    command2("gate-implement-review", async (invocation) => {
       const brief = String(invocation.rawInput ?? "").trim();
       const gate = resolveGate(ctx, invocation.agent);
       const state = store.read(gate.root, invocation.agent);
@@ -1563,7 +1809,7 @@ ignore\uFF1A${projectGit.ignore}` };
       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) => {
+    command2("gate-code-verify", async (invocation) => {
       const brief = String(invocation.rawInput ?? "").trim();
       const gate = resolveGate(ctx, invocation.agent);
       const state = store.read(gate.root, invocation.agent);
@@ -1580,7 +1826,7 @@ ignore\uFF1A${projectGit.ignore}` };
       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) => {
+    command2("gate-propose-review", async (invocation) => {
       const brief = String(invocation.rawInput ?? "").trim();
       const gate = resolveGate(ctx, invocation.agent);
       const state = store.read(gate.root, invocation.agent);
@@ -1597,7 +1843,7 @@ ignore\uFF1A${projectGit.ignore}` };
       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) => {
+    command2("gate-block", 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" };
@@ -1609,9 +1855,9 @@ ignore\uFF1A${projectGit.ignore}` };
       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) => {
+\u540C\u4E00\u4E8B\u9879\uFF1A/gate-resume \u56DE\u5230\u8BE5\u8282\u70B9\uFF1B\u6539\u53D8\u65B9\u6848\uFF1A\u5148 /gate-resume\uFF0C\u518D /gate-return-discuss\u3002` };
+    });
+    command2("gate-resume", 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" };
@@ -1628,8 +1874,8 @@ ignore\uFF1A${projectGit.ignore}` };
       }
       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) => {
+    });
+    command2("gate-return-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` };
@@ -1651,21 +1897,22 @@ ignore\uFF1A${projectGit.ignore}` };
       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) => {
+    });
+    command2("gate-status", async (invocation) => {
       const gate = resolveGate(ctx, invocation.agent);
       const root = rootAgentOf(ctx, invocation.agent);
       const state = store.read(gate.root, root);
       const worker = root?.id !== invocation.agent?.id;
-      return { kind: "success", text: [accessText(accessFor(state, worker)), statusText(state, reviewLimit)].join("\n\n") };
-    }, null);
-    register("gate-note-verify", "\u53EA\u8BFB\u68C0\u67E5 notes tree/format/lifecycle/archived", async (invocation) => {
+      const next = worker ? "" : nextCommandsText(nextCommandsFor(state));
+      return { kind: "success", text: [accessText(accessFor(state, worker)), statusText(state, reviewLimit), next].filter(Boolean).join("\n\n") };
+    });
+    command2("gate-note-verify", 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) => {
+    });
+    command2("gate-note-archive", async (invocation) => {
       const gate = resolveGate(ctx, invocation.agent);
       const raw = String(invocation.rawInput ?? "").trim();
       const args = raw === "" ? [] : raw.split(/\s+/u);
@@ -1673,41 +1920,41 @@ ${JSON.stringify(check.results, null, 2)}` };
       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"] });
+        const script = path10.join(NOTES_SKILL_DIR, "scripts", "archive-agent-note.ts");
+        const output = execFileSync3(node, [script, "--root", path10.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) => {
+    });
+    command2("gate-note-board", 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 title = args[1] ?? `${path10.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 script = path10.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) => {
+    });
+    command2("gate-note-seal", 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"] });
+        const script = path10.join(NOTES_SKILL_DIR, "scripts", "verify-archived-agent-notes.ts");
+        const output = execFileSync3(node, [script, "--root", path10.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);
+    });
   });
 }
 
@@ -1771,7 +2018,7 @@ function registerStartPhase(ctx, deps) {
 
 // src/tools/record.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync4, lstatSync as lstatSync4, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync5, lstatSync as lstatSync5, readFileSync as readFileSync5 } from "node:fs";
 function registerRecord(ctx, deps) {
   const { store, reviewLimit, wake } = deps;
   ctx.tools.register({
@@ -1977,11 +2224,11 @@ function registerRecord(ctx, deps) {
         for (const item of evidence) {
           const target = classifyPath(gate.workspace, item);
           try {
-            if (target.outside || !existsSync4(target.absolute) || !lstatSync4(target.absolute).isFile()) {
+            if (target.outside || !existsSync5(target.absolute) || !lstatSync5(target.absolute).isFile()) {
               invalidEvidence.push(item);
               continue;
             }
-            const bytes = readFileSync3(target.absolute);
+            const bytes = readFileSync5(target.absolute);
             records.push({ path: target.relative, size: bytes.length, sha256: createHash("sha256").update(bytes).digest("hex") });
           } catch {
             invalidEvidence.push(item);
@@ -2081,8 +2328,10 @@ function registerStatus(ctx, deps) {
       const worker = root?.id !== exec.agent?.id;
       const access = accessFor(state, worker);
       if (worker) {
-        return { ok: true, procedure: null, method: null, access, text: [accessText(access), statusText(state, reviewLimit)].join("\n\n") };
+        return { ok: true, procedure: null, method: null, access, nextCommands: [], text: [accessText(access), statusText(state, reviewLimit)].join("\n\n") };
       }
+      const nextCommands = nextCommandsFor(state);
+      const nextText = nextCommandsText(nextCommands);
       const procedure = procedureFor(state, { reviewLimit });
       const includeRounds = !procedure.hasRounds;
       return {
@@ -2090,15 +2339,16 @@ function registerStatus(ctx, deps) {
         procedure,
         method: procedure.method,
         access,
-        text: procedureResultText(procedure, [statusText(state, reviewLimit, { includeRounds }), accessText(access)].join("\n\n"))
+        nextCommands,
+        text: procedureResultText(procedure, [statusText(state, reviewLimit, { includeRounds }), nextText, accessText(access)].filter(Boolean).join("\n\n"))
       };
     }
   });
 }
 
 // src/tools/notes.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import path10 from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import path11 from "node:path";
 function registerNoteTools(ctx, deps) {
   const { store, reviewLimit, wake } = deps;
   ctx.tools.register({
@@ -2124,7 +2374,7 @@ function registerNoteTools(ctx, deps) {
         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")) {
+      if (relative === "" || relative.includes("..") || path11.isAbsolute(relative) || !relative.endsWith(".md")) {
         return { ok: false, code: "invalid-path" };
       }
       let lifecycle = "proposed";
@@ -2136,16 +2386,16 @@ function registerNoteTools(ctx, deps) {
       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);
+      const base = path11.join(gate.root, ".agents", "notes", String(lifecycle));
+      const absolute = path11.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)) {
+      if (lifecycle === "implemented" && !existsSync6(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 };
+      mkdirSync5(path11.dirname(absolute), { recursive: true });
+      writeFileSync5(absolute, String(args.content ?? ""));
+      return { ok: true, path: path11.relative(gate.root, absolute).replaceAll("\\", "/"), lifecycle };
     }
   });
   ctx.tools.register({
@@ -2168,7 +2418,7 @@ function registerNoteTools(ctx, deps) {
       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)));
+        const implemented = state.notePaths.length > 0 && state.notePaths.every((entry) => entry.lifecycle === "implemented" && existsSync6(path11.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);
@@ -2216,9 +2466,9 @@ function registerNoteTools(ctx, deps) {
       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 source = path11.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))) {
+        if (!existsSync6(source) && existsSync6(path11.join(gate.root, targetRelative))) {
           entry.path = targetRelative;
           entry.lifecycle = "implemented";
           recovered.push("adopted-target");
@@ -2251,12 +2501,193 @@ function registerNoteTools(ctx, deps) {
   });
 }
 
+// src/tools/catalog.ts
+var GATE_TOOLS = [
+  { name: "gate_status", summary: "\u8BFB\u53D6\u5F53\u524D phase/node\u3001procedure\u3001access \u548C nextCommands\uFF1Broot/worker \u5747\u53EF\u8C03\u7528\u3002" },
+  { name: "gate_record", summary: "\u8BB0\u5F55 worker \u7ED3\u679C\u5E76\u63A8\u8FDB gate\uFF1B\u4EC5 root \u53EF\u8C03\u7528\u3002" },
+  { name: "gate_start_phase", summary: "\u5728\u7528\u6237\u6388\u6743\u540E\u8FDB\u5165 plan/implement\uFF1Bplan \u57FA\u4E8E\u8BA8\u8BBA\u5171\u8BC6\uFF0Cimplement \u57FA\u4E8E\u5DF2\u786E\u8BA4\u8BA1\u5212\u6216\u5B9E\u65BD\u8BF4\u660E\uFF1B\u4EC5 root \u53EF\u8C03\u7528\u3002" },
+  { name: "gate_note_write", summary: "planning worker \u5199 proposed Note \u6216\u539F\u5730\u66F4\u65B0 implemented Note\u3002" },
+  { name: "gate_note_verify", summary: "\u5728 note-lifecycle \u4E2D\u8FD0\u884C notes \u6821\u9A8C\uFF1Broot-only\u3002" },
+  { name: "gate_note_finalize", summary: "\u628A proposed Note \u79FB\u5230 implemented \u5E76\u66F4\u65B0\u5934\u5757\uFF1Broot-only\u3002" },
+  { name: "gate_help", summary: "\u5217\u51FA gate \u547D\u4EE4\u3001\u5DE5\u5177\u548C\u5F53\u524D phase/node\uFF1B\u53EA\u8BFB\uFF0Croot-only\u3002" },
+  { name: "gate_artifact_write", summary: "\u6309 artifact policy \u5199\u767D\u540D\u5355\u6587\u4EF6\uFF1B\u4E0D\u8D70\u666E\u901A workspace write\u3002" },
+  { name: "gate_research_dispatch", summary: "root-only \u5728 discuss/plan \u6D3E research worker\uFF1Bworker \u53EA\u5199 research artifact\u3002" }
+];
+
+// src/tools/help.ts
+function commandLine(spec) {
+  const hint = spec.hint === null ? "" : ` ${spec.hint}`;
+  return `- ${commandLabel(spec)}${hint} \u2014 ${spec.description}\uFF08${spec.when}\uFF09`;
+}
+function helpText(phase, node) {
+  return [
+    "## Gate help",
+    `\u5F53\u524D phase/node\uFF1A${phase} / ${node ?? "\u65E0"}`,
+    "",
+    "\u547D\u4EE4\uFF08\u7531\u7528\u6237\u6267\u884C\uFF09\uFF1A",
+    ...GATE_COMMANDS.map(commandLine),
+    "",
+    "\u5DE5\u5177\uFF08\u7531\u6A21\u578B\u8C03\u7528\uFF09\uFF1A",
+    ...GATE_TOOLS.map((tool) => `- ${tool.name} \u2014 ${tool.summary}`),
+    "",
+    "\u547D\u4EE4\u7531\u7528\u6237\u6267\u884C\uFF1B\u5DE5\u5177\u7531\u6A21\u578B\u8C03\u7528\u3002\u547D\u4EE4\u4E0D\u4F1A\u4F5C\u4E3A tool \u51FA\u73B0\u5728\u5DE5\u5177\u76EE\u5F55\u3002"
+  ].join("\n");
+}
+function registerHelp(ctx, deps) {
+  const { store } = deps;
+  ctx.tools.register({
+    name: "gate_help",
+    description: "\u53EA\u8BFB\u5217\u51FA gate \u547D\u4EE4\u3001\u5DE5\u5177\u7528\u9014\u548C\u5F53\u524D phase/node\u3002\u4EC5 root agent\uFF1B\u53EA\u5728\u4E0D\u786E\u5B9A\u547D\u4EE4\u540D/\u5DE5\u5177\u7528\u9014\u65F6\u4F7F\u7528\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 (root?.id !== exec.agent?.id) return { ok: false, code: "root-only", reason: "gate_help \u53EA\u80FD\u7531 root agent \u8C03\u7528\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);
+      return {
+        ok: true,
+        phase: state.phase,
+        node: state.node,
+        current: { phase: state.phase, node: state.node },
+        note: "\u547D\u4EE4\u7531\u7528\u6237\u6267\u884C\uFF1B\u5DE5\u5177\u7531\u6A21\u578B\u8C03\u7528\u3002",
+        commands: GATE_COMMANDS.map((spec) => ({ ...spec, command: commandLabel(spec) })),
+        tools: GATE_TOOLS,
+        text: helpText(state.phase, state.node)
+      };
+    }
+  });
+}
+
+// src/tools/artifact.ts
+function registerArtifactTools(ctx, deps) {
+  const { store } = deps;
+  ctx.tools.register({
+    name: "gate_artifact_write",
+    description: "\u6309 .agents/gate/artifact-policy.json \u5199\u767D\u540D\u5355 artifact\uFF08handoff/prd/research \u7B49\uFF09\u3002\u53EA\u5199\u6587\u4EF6\uFF0C\u4E0D\u8D70\u666E\u901A workspace write \u6743\u9650\u3002",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", description: "policy \u4E2D\u7684 artifact kind\u3002" },
+        path: { type: "string", description: "workspace \u5185\u76F8\u5BF9\u8DEF\u5F84\u3002" },
+        content: { type: "string" }
+      },
+      required: ["kind", "path", "content"]
+    },
+    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 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 effective = effectiveState(ctx, exec.agent, gate, store);
+      const loaded = loadArtifactPolicy(gate.root);
+      if (loaded.policy === void 0) return { ok: false, code: "artifact-policy-invalid", reason: loaded.error };
+      const allowed = artifactRuleAllows(loaded.policy, effective.state, effective.worker, String(args?.kind ?? ""));
+      if (allowed.rule === void 0) return { ok: false, code: "artifact-denied", reason: allowed.error };
+      const checked = checkArtifactPath(gate.root, allowed.rule, String(args?.path ?? ""), String(args?.kind ?? ""));
+      if (checked.absolute === void 0) return { ok: false, code: "artifact-denied", reason: checked.error };
+      const written = writeArtifact(gate.root, checked.relative ?? String(args?.path ?? ""), String(args?.content ?? ""));
+      if (written.relative === void 0) return { ok: false, code: "artifact-write-failed", reason: written.error };
+      return { ok: true, kind: String(args.kind), path: written.relative, bytes: Buffer.byteLength(String(args.content ?? "")) };
+    }
+  });
+}
+
+// src/tools/research.ts
+function registerResearchDispatch(ctx, deps) {
+  const { store } = deps;
+  ctx.tools.register({
+    name: "gate_research_dispatch",
+    description: "root-only\uFF1A\u5728 discuss \u6216 orchestrating/plan \u6D3E research worker\uFF0C\u7B49\u5F85\u7ED3\u679C\uFF1Bworker \u53EA\u80FD\u901A\u8FC7 artifact policy \u5199 research \u6587\u6863\u3002",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        question: { type: "string" },
+        purpose: { type: "string" }
+      },
+      required: ["question"]
+    },
+    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 (root?.id !== exec.agent?.id) return { ok: false, code: "root-only", reason: "gate_research_dispatch \u53EA\u80FD\u7531 root agent \u8C03\u7528\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 (!(state.phase === "discuss" || state.phase === "orchestrating" && state.node === "plan")) {
+        return { ok: false, code: "wrong-phase", reason: "research dispatch \u53EA\u5141\u8BB8 discuss \u6216 orchestrating/plan\u3002" };
+      }
+      const loaded = loadArtifactPolicy(gate.root);
+      if (loaded.policy === void 0) return { ok: false, code: "artifact-policy-invalid", reason: loaded.error };
+      const allowed = artifactRuleAllows(loaded.policy, state, true, "research");
+      if (allowed.rule === void 0) return { ok: false, code: "artifact-denied", reason: allowed.error };
+      const subagents = typeof ctx.get === "function" ? ctx.get("subagents") : void 0;
+      if (subagents?.startActivation === void 0 || subagents?.getProvider === void 0) {
+        return { ok: false, code: "subagents-unavailable", reason: "ctx.subagents \u4E0D\u53EF\u7528\uFF0C\u65E0\u6CD5\u6D3E research worker\u3002" };
+      }
+      const provider = subagents.getProvider("spawn");
+      if (provider === void 0) return { ok: false, code: "provider-unavailable", reason: "ctx.subagents \u6CA1\u6709 spawn provider\u3002" };
+      const question = String(args?.question ?? "").trim();
+      if (question === "") return { ok: false, code: "question-required", reason: "research \u9700\u8981 question\u3002" };
+      const purpose = String(args?.purpose ?? "").trim();
+      const prompt = [{
+        type: "text",
+        text: [
+          "Research worker task. Investigate primary sources and write a Markdown report.",
+          `Question: ${question}`,
+          purpose === "" ? "" : `Purpose: ${purpose}`,
+          "Use gate_artifact_write({ kind: 'research', path, content }) to save the report.",
+          "Prefer project docs research location; otherwise .scratch/research/. Cite sources. Do not modify product code."
+        ].filter(Boolean).join("\n")
+      }];
+      let activation;
+      try {
+        activation = await subagents.startActivation({
+          provider: "spawn",
+          label: "gate-research",
+          prompt,
+          parent: exec.agent,
+          signal: exec.signal,
+          delivery: "caller"
+        });
+        const result = await activation.result;
+        const output = result?.output;
+        const text = typeof output === "string" ? output : JSON.stringify(output ?? result);
+        return { ok: true, name: activation.name, text };
+      } catch (error) {
+        return { ok: false, code: "research-dispatch-failed", reason: error instanceof Error ? error.message : String(error) };
+      } finally {
+        if (activation?.dispose !== void 0) {
+          try {
+            await activation.dispose();
+          } catch {
+          }
+        }
+      }
+    }
+  });
+}
+
 // src/tools/index.ts
 function registerTools(ctx, deps) {
   registerStartPhase(ctx, deps);
   registerRecord(ctx, deps);
   registerStatus(ctx, deps);
   registerNoteTools(ctx, deps);
+  registerHelp(ctx, deps);
+  registerArtifactTools(ctx, deps);
+  registerResearchDispatch(ctx, deps);
 }
 
 // src/index.ts