dsh-gate-agent 0.1.5 → 0.1.6

package/README.md

@@ -153,6 +153,36 @@ Host 插件：用 phase/node 门禁组织讨论、规划、实施、评审、验
 
 从 `discuss` 开始，不进入 planning/implement。
 
+初始化会生成：
+
+- `.agents/gate/verify-notes.mjs`
+- `.agents/gate/ci/*.ts`
+- `.agents/gate/artifact-policy.json`
+- `.agents/gate/init-manifest.json`
+
+`init-manifest.json` 记录生成物 hash、artifact-policy hash、AGENTS managed block、verify-notes script 和 notes 目录结构。它被 git 跟踪；同内容重跑 init 时字节稳定。
+
+只读核对：
+
+```text
+gate_init_verify
+```
+
+它会检查：
+
+- 5 个 CI 脚本 + launcher 的 SHA-256；
+- `artifact-policy.json` 的 schema；用户修改后有效则显示 `customized`；
+- AGENTS managed block；
+- `scripts.verify-notes`；
+- workflow 是否存在；
+- notes 四目录结构。
+
+不检查 Note 内容；Note 内容继续用：
+
+```text
+npm run verify-notes
+```
+
 ### Planning
 
 ```text
@@ -315,6 +345,20 @@ gate_status()
 
 root-only；在 discuss 或 `orchestrating/plan` 派 research worker。worker 只能通过 artifact policy 写 research 文档，不获得通用 workspace 写。
 
+### gate_init_verify
+
+root-only 只读校验 `/gate-init` 产物：
+
+- `.agents/gate/init-manifest.json` 是否存在且有效；
+- 5 个 CI 脚本 + `verify-notes.mjs` 的 hash；
+- `artifact-policy.json` schema（custom 有效也通过）；
+- AGENTS managed block；
+- `scripts.verify-notes`；
+- workflow 存在性；
+- notes 四目录。
+
+不修改文件，不运行 `verify-notes`；Note 内容校验仍用 `npm run verify-notes`。
+
 ### Note 工具
 
 - `gate_note_write`：planning worker 写 proposed Note，或原地更新 implemented Note；通用 `write`/`edit`/`apply_patch` 和仓库写被拒绝，只读 shell 可用。
@@ -527,6 +571,27 @@ discuss 和 plan 默认不允许普通文件写。`handoff`、PRD、research 等
 
 `reviewLimit` 是每个 review 节点的最大轮次；默认 5，范围 1–20。达到上限仍有 findings 时进入 blocked。
 
+它**不是项目文件**，而是 DSH profile 的插件 Config。当前 profile 的覆盖文件是：
+
+```text
+%USERPROFILE%\.dsh\profiles\<profile>\cordis.patch.yml
+```
+
+在 profile patch 中按 bundle 的 `id: gate` 覆盖：
+
+```yaml
+- id: gate
+  config:
+    reviewLimit: 8
+```
+
+- 没有 `gate` 条目时使用默认值 5；
+- 修改后重启 DSH 才生效；
+- 不要修改 `packages/gate/cordis.patch.yml` 来配置已有 profile；那是 bundle 默认层，profile patch 会覆盖它；
+- 如果使用自定义 Agent Preset，配置应放在该 preset 中对应的 `dsh-gate-agent` 条目。
+
+`.agents/gate/artifact-policy.json` 是项目级 artifact 白名单，与这里的插件 Config 是两套配置。
+
 
 ## 使用边界
 

package/lib/index.js

@@ -1365,7 +1365,7 @@ function installRestrictions(ctx, deps) {
 }
 
 // src/commands.ts
-import path10 from "node:path";
+import path11 from "node:path";
 
 // src/notes/provision.ts
 import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
@@ -1621,9 +1621,188 @@ function writeArtifact(root, requested, content) {
   return { relative: path9.relative(root, target).replaceAll("\\", "/") };
 }
 
+// src/init-manifest.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import path10 from "node:path";
+var INIT_MANIFEST_PATH = ".agents/gate/init-manifest.json";
+var ARTIFACT_POLICY_PATH2 = ".agents/gate/artifact-policy.json";
+var AGENTS_BLOCK = /<!-- gate-notes:start -->[\s\S]*?<!-- gate-notes:end -->/u;
+function sha256Bytes(value) {
+  return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function sha256File(file) {
+  try {
+    return sha256Bytes(readFileSync4(file));
+  } catch {
+    return null;
+  }
+}
+function packageVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync4(path10.join(PACKAGE_ROOT, "package.json"), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function currentAgentsBlock(root) {
+  try {
+    const text = readFileSync4(path10.join(root, "AGENTS.md"), "utf8");
+    return AGENTS_BLOCK.exec(text)?.[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function readManifest(root) {
+  try {
+    const value = JSON.parse(readFileSync4(path10.join(root, INIT_MANIFEST_PATH), "utf8"));
+    if (value === null || typeof value !== "object" || value.version !== 1) return null;
+    if (typeof value.createdAt !== "string" || typeof value.gateVersion !== "string") return null;
+    if (value.immutable === null || typeof value.immutable !== "object" || Array.isArray(value.immutable)) return null;
+    if (value.managed === null || typeof value.managed !== "object" || Array.isArray(value.managed)) return null;
+    if (value.notes === null || typeof value.notes !== "object" || Array.isArray(value.notes)) return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function immutablePaths() {
+  return [
+    ...NOTES_CI_SCRIPTS.map((name) => `.agents/gate/ci/${name}`),
+    ".agents/gate/verify-notes.mjs"
+  ];
+}
+function provisionInitManifest(root, packageScript) {
+  const previous = readManifest(root);
+  const createdAt = typeof previous?.createdAt === "string" ? previous.createdAt : (/* @__PURE__ */ new Date()).toISOString();
+  const immutable = {};
+  for (const relative of immutablePaths()) {
+    const hash = sha256File(path10.join(root, relative));
+    if (hash !== null) immutable[relative] = hash;
+  }
+  const policyFile = path10.join(root, ARTIFACT_POLICY_PATH2);
+  const policyHash = sha256File(policyFile) ?? sha256Bytes("");
+  const block = currentAgentsBlock(root);
+  let pkgScript = null;
+  try {
+    const pkg = JSON.parse(readFileSync4(path10.join(root, "package.json"), "utf8"));
+    pkgScript = typeof pkg.scripts?.["verify-notes"] === "string" ? pkg.scripts["verify-notes"] : null;
+  } catch {
+  }
+  const manifest = {
+    version: 1,
+    gateVersion: packageVersion(),
+    createdAt,
+    immutable,
+    managed: {
+      artifactPolicy: { path: ARTIFACT_POLICY_PATH2, schemaVersion: 1, sha256: policyHash },
+      agentsBlockHash: block === null ? null : sha256Bytes(block),
+      packageScript: pkgScript ?? packageScript,
+      workflow: ".github/workflows/verify-notes.yml"
+    },
+    notes: { path: ".agents/notes", lifecycles: ["proposed", "implemented", "rejected", "archived"] }
+  };
+  mkdirSync5(path10.dirname(path10.join(root, INIT_MANIFEST_PATH)), { recursive: true });
+  writeFileSync5(path10.join(root, INIT_MANIFEST_PATH), `${JSON.stringify(manifest, null, 2)}
+`);
+  return { path: INIT_MANIFEST_PATH, manifest, status: previous === null ? "created" : "updated" };
+}
+function verifyInit(root) {
+  const manifest = readManifest(root);
+  const issues = [];
+  const immutable = [];
+  for (const relative of immutablePaths()) {
+    const actual = sha256File(path10.join(root, relative));
+    const expected = manifest?.immutable?.[relative];
+    if (actual === null) {
+      immutable.push({ path: relative, status: manifest === null ? "unknown" : "missing" });
+      if (manifest !== null) issues.push({ severity: "error", code: "immutable-missing", message: `${relative} \u7F3A\u5931` });
+    } else if (manifest === null) {
+      immutable.push({ path: relative, status: "unknown" });
+    } else if (expected === void 0) {
+      immutable.push({ path: relative, status: "missing" });
+      issues.push({ severity: "error", code: "immutable-manifest-missing", message: `${relative} \u4E0D\u5728 init-manifest.immutable` });
+    } else if (actual !== expected) {
+      immutable.push({ path: relative, status: "modified" });
+      issues.push({ severity: "error", code: "immutable-modified", message: `${relative} \u4E0E init-manifest \u4E0D\u4E00\u81F4` });
+    } else {
+      immutable.push({ path: relative, status: "ok" });
+    }
+  }
+  const manifestExists = existsSync5(path10.join(root, INIT_MANIFEST_PATH));
+  if (manifest === null) issues.push({ severity: "error", code: manifestExists ? "manifest-invalid" : "manifest-missing", message: manifestExists ? "init-manifest \u65E0\u6548\uFF1B\u91CD\u65B0\u8FD0\u884C /gate-init" : "init-manifest \u7F3A\u5931\uFF1B\u91CD\u65B0\u8FD0\u884C /gate-init" });
+  let artifactPolicy = "missing";
+  const policyFile = path10.join(root, ARTIFACT_POLICY_PATH2);
+  if (existsSync5(policyFile)) {
+    try {
+      const parsed = parseArtifactPolicy(JSON.parse(readFileSync4(policyFile, "utf8")));
+      if (parsed.policy === void 0) artifactPolicy = "invalid";
+      else {
+        const actualHash = sha256File(policyFile);
+        artifactPolicy = manifest?.managed?.artifactPolicy?.sha256 !== void 0 && actualHash !== manifest.managed.artifactPolicy.sha256 ? "customized" : "ok";
+      }
+    } catch {
+      artifactPolicy = "invalid";
+    }
+  }
+  if (artifactPolicy === "missing") issues.push({ severity: "error", code: "artifact-policy-missing", message: "artifact-policy.json \u7F3A\u5931" });
+  if (artifactPolicy === "invalid") issues.push({ severity: "error", code: "artifact-policy-invalid", message: "artifact-policy.json \u65E0\u6548" });
+  const currentBlock = currentAgentsBlock(root);
+  let agentsBlock = manifest === null ? "unknown" : "missing";
+  if (currentBlock !== null && manifest !== null) {
+    agentsBlock = manifest.managed?.agentsBlockHash !== null && manifest.managed?.agentsBlockHash !== void 0 && sha256Bytes(currentBlock) !== manifest.managed.agentsBlockHash ? "modified" : "ok";
+  }
+  if (agentsBlock === "missing") issues.push({ severity: "error", code: "agents-block-missing", message: "AGENTS.md \u7F3A\u5C11 gate managed block" });
+  if (agentsBlock === "modified") issues.push({ severity: "warning", code: "agents-block-modified", message: "AGENTS.md managed block \u5DF2\u4FEE\u6539" });
+  let packageScript = manifest === null ? "unknown" : "missing";
+  let currentScript = null;
+  try {
+    const pkg = JSON.parse(readFileSync4(path10.join(root, "package.json"), "utf8"));
+    currentScript = typeof pkg.scripts?.["verify-notes"] === "string" ? pkg.scripts["verify-notes"] : null;
+  } catch {
+  }
+  if (currentScript === null) {
+    packageScript = "missing";
+    issues.push({ severity: "error", code: "package-script-missing", message: "package.json \u7F3A\u5C11 scripts.verify-notes" });
+  } else if (manifest === null) {
+    packageScript = "unknown";
+  } else if (manifest.managed?.packageScript !== null && manifest.managed?.packageScript !== void 0 && currentScript !== manifest.managed.packageScript) {
+    packageScript = "customized";
+    issues.push({ severity: "warning", code: "package-script-customized", message: "scripts.verify-notes \u4E0E init \u65F6\u4E0D\u540C" });
+  } else packageScript = "ok";
+  const workflowPath = manifest?.managed?.workflow ?? ".github/workflows/verify-notes.yml";
+  const workflow = existsSync5(path10.join(root, workflowPath)) ? "existing" : "missing";
+  if (workflow === "missing") issues.push({ severity: "warning", code: "workflow-missing", message: `${workflowPath} \u7F3A\u5931` });
+  let notes = "ok";
+  for (const lifecycle of ["proposed", "implemented", "rejected", "archived"]) {
+    if (!existsSync5(path10.join(root, ".agents", "notes", lifecycle))) {
+      notes = "missing";
+      issues.push({ severity: "error", code: "notes-missing", message: `.agents/notes/${lifecycle} \u7F3A\u5931` });
+    }
+  }
+  const currentVersion = packageVersion();
+  if (manifest !== null && manifest.gateVersion !== currentVersion) {
+    issues.push({ severity: "warning", code: "stale-init", message: `init gateVersion=${manifest.gateVersion}\uFF0C\u5F53\u524D=${currentVersion}\uFF1B\u5EFA\u8BAE\u91CD\u65B0\u8FD0\u884C /gate-init` });
+  }
+  const ok = !issues.some((issue) => issue.severity === "error");
+  const lines = [
+    `init verify\uFF1A${ok ? "ok" : "FAILED"}`,
+    `manifest\uFF1A${manifest === null ? "missing/invalid" : "ok"}`,
+    `gateVersion\uFF1A${manifest?.gateVersion ?? "unknown"}\uFF08current ${currentVersion}\uFF09`,
+    `artifact-policy\uFF1A${artifactPolicy}`,
+    `agents block\uFF1A${agentsBlock}`,
+    `package script\uFF1A${packageScript}`,
+    `workflow\uFF1A${workflow}`,
+    `notes\uFF1A${notes}`,
+    ...issues.map((issue) => `${issue.severity}: ${issue.message}`)
+  ];
+  return { ok, manifest: manifest === null ? manifestExists ? "invalid" : "missing" : "ok", immutable, artifactPolicy, agentsBlock, packageScript, workflow, notes, issues, text: lines.join("\n") };
+}
+
 // src/commands.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 
 // src/command-catalog.ts
 var GATE_COMMANDS = [
@@ -1691,25 +1870,28 @@ function registerCommands(ctx, deps) {
     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 = path10.resolve(workspace);
+      const root = path11.resolve(workspace);
       let provisioned;
       let projectScripts;
       let projectCi;
       let projectGit;
       let artifactPolicy;
+      let initManifest;
       try {
         provisioned = provisionNotes(root);
         artifactPolicy = provisionArtifactPolicy(root);
         projectCi = provisionCi(root);
         projectScripts = provisionProjectScripts(root);
         projectGit = provisionGit(root);
+        initManifest = provisionInitManifest(root, projectScripts.command);
       } 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}\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");
+      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\uFF0Cinit manifest \u4E3A ${initManifest.path}\uFF08${initManifest.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
+init manifest\uFF1A${initManifest.path}\uFF08${initManifest.status}\uFF09
 AGENTS\uFF1A${provisioned.agents}
 verify-notes\uFF1A${projectScripts.command}
 CI\uFF1A${projectCi.workflow}
@@ -1753,7 +1935,7 @@ ignore\uFF1A${projectGit.ignore}` };
       const topic = String(invocation.rawInput ?? "").trim() || "\u5F53\u524D\u8BA8\u8BBA";
       let skill = "";
       try {
-        skill = readFileSync4(path10.join(SKILLS, "gate-prd", "SKILL.md"), "utf8");
+        skill = readFileSync5(path11.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");
@@ -1920,8 +2102,8 @@ ${JSON.stringify(check.results, null, 2)}` };
       const node = resolveNodeBinary();
       if (node === void 0) return { kind: "error", text: "notes-runtime-unavailable" };
       try {
-        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"] });
+        const script = path11.join(NOTES_SKILL_DIR, "scripts", "archive-agent-note.ts");
+        const output = execFileSync3(node, [script, "--root", path11.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() };
@@ -1932,11 +2114,11 @@ ${JSON.stringify(check.results, null, 2)}` };
       const raw = String(invocation.rawInput ?? "").trim();
       const args = raw === "" ? [] : raw.split(/\s+/u);
       const target = args[0] ?? "board.html";
-      const title = args[1] ?? `${path10.basename(gate.root)} \u51B3\u7B56\u770B\u677F`;
+      const title = args[1] ?? `${path11.basename(gate.root)} \u51B3\u7B56\u770B\u677F`;
       const node = resolveNodeBinary();
       if (node === void 0) return { kind: "error", text: "notes-runtime-unavailable" };
       try {
-        const script = path10.join(NOTES_SKILL_DIR, "scripts", "build-board.ts");
+        const script = path11.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) {
@@ -1948,8 +2130,8 @@ ${JSON.stringify(check.results, null, 2)}` };
       const node = resolveNodeBinary();
       if (node === void 0) return { kind: "error", text: "notes-runtime-unavailable" };
       try {
-        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"] });
+        const script = path11.join(NOTES_SKILL_DIR, "scripts", "verify-archived-agent-notes.ts");
+        const output = execFileSync3(node, [script, "--root", path11.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() };
@@ -2017,8 +2199,8 @@ function registerStartPhase(ctx, deps) {
 }
 
 // src/tools/record.ts
-import { createHash } from "node:crypto";
-import { existsSync as existsSync5, lstatSync as lstatSync5, readFileSync as readFileSync5 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync6, lstatSync as lstatSync5, readFileSync as readFileSync6 } from "node:fs";
 function registerRecord(ctx, deps) {
   const { store, reviewLimit, wake } = deps;
   ctx.tools.register({
@@ -2224,12 +2406,12 @@ function registerRecord(ctx, deps) {
         for (const item of evidence) {
           const target = classifyPath(gate.workspace, item);
           try {
-            if (target.outside || !existsSync5(target.absolute) || !lstatSync5(target.absolute).isFile()) {
+            if (target.outside || !existsSync6(target.absolute) || !lstatSync5(target.absolute).isFile()) {
               invalidEvidence.push(item);
               continue;
             }
-            const bytes = readFileSync5(target.absolute);
-            records.push({ path: target.relative, size: bytes.length, sha256: createHash("sha256").update(bytes).digest("hex") });
+            const bytes = readFileSync6(target.absolute);
+            records.push({ path: target.relative, size: bytes.length, sha256: createHash2("sha256").update(bytes).digest("hex") });
           } catch {
             invalidEvidence.push(item);
           }
@@ -2347,8 +2529,8 @@ function registerStatus(ctx, deps) {
 }
 
 // src/tools/notes.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import path11 from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import path12 from "node:path";
 function registerNoteTools(ctx, deps) {
   const { store, reviewLimit, wake } = deps;
   ctx.tools.register({
@@ -2374,7 +2556,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("..") || path11.isAbsolute(relative) || !relative.endsWith(".md")) {
+      if (relative === "" || relative.includes("..") || path12.isAbsolute(relative) || !relative.endsWith(".md")) {
         return { ok: false, code: "invalid-path" };
       }
       let lifecycle = "proposed";
@@ -2386,16 +2568,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 = path11.join(gate.root, ".agents", "notes", String(lifecycle));
-      const absolute = path11.resolve(base, relative);
+      const base = path12.join(gate.root, ".agents", "notes", String(lifecycle));
+      const absolute = path12.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" && !existsSync6(absolute)) {
+      if (lifecycle === "implemented" && !existsSync7(absolute)) {
         return { ok: false, code: "implemented-must-exist", reason: "implemented Note \u53EA\u80FD\u539F\u5730\u7F16\u8F91\uFF0C\u4E0D\u80FD\u65B0\u5EFA\u3002" };
       }
-      mkdirSync5(path11.dirname(absolute), { recursive: true });
-      writeFileSync5(absolute, String(args.content ?? ""));
-      return { ok: true, path: path11.relative(gate.root, absolute).replaceAll("\\", "/"), lifecycle };
+      mkdirSync6(path12.dirname(absolute), { recursive: true });
+      writeFileSync6(absolute, String(args.content ?? ""));
+      return { ok: true, path: path12.relative(gate.root, absolute).replaceAll("\\", "/"), lifecycle };
     }
   });
   ctx.tools.register({
@@ -2418,7 +2600,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" && existsSync6(path11.join(gate.root, entry.path)));
+        const implemented = state.notePaths.length > 0 && state.notePaths.every((entry) => entry.lifecycle === "implemented" && existsSync7(path12.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);
@@ -2466,9 +2648,9 @@ function registerNoteTools(ctx, deps) {
       const recovered = recoverFinalize(gate.root, sessionId);
       for (const entry of state.notePaths) {
         if (entry.lifecycle !== "proposed") continue;
-        const source = path11.join(gate.root, entry.path);
+        const source = path12.join(gate.root, entry.path);
         const targetRelative = entry.path.replaceAll("\\", "/").replace(".agents/notes/proposed/", ".agents/notes/implemented/");
-        if (!existsSync6(source) && existsSync6(path11.join(gate.root, targetRelative))) {
+        if (!existsSync7(source) && existsSync7(path12.join(gate.root, targetRelative))) {
           entry.path = targetRelative;
           entry.lifecycle = "implemented";
           recovered.push("adopted-target");
@@ -2511,7 +2693,8 @@ var GATE_TOOLS = [
   { 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" }
+  { name: "gate_research_dispatch", summary: "root-only \u5728 discuss/plan \u6D3E research worker\uFF1Bworker \u53EA\u5199 research artifact\u3002" },
+  { name: "gate_init_verify", summary: "root-only \u53EA\u8BFB\u6821\u9A8C init-manifest\u3001\u751F\u6210\u7269 hash\u3001policy \u4E0E init \u7ED3\u6784\u3002" }
 ];
 
 // src/tools/help.ts
@@ -2679,6 +2862,27 @@ function registerResearchDispatch(ctx, deps) {
   });
 }
 
+// src/tools/init-verify.ts
+function registerInitVerify(ctx, _deps) {
+  ctx.tools.register({
+    name: "gate_init_verify",
+    description: "root-only \u53EA\u8BFB\u6821\u9A8C /gate-init \u4EA7\u7269\uFF1Ainit-manifest\u3001immutable hash\u3001artifact policy\u3001AGENTS managed block\u3001verify-notes script\u3001workflow\u3001notes \u76EE\u5F55\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) {
+      if (rootAgentOf(ctx, exec.agent)?.id !== exec.agent?.id) {
+        return { ok: false, code: "root-only", reason: "gate_init_verify \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" };
+      return verifyInit(gate.root);
+    }
+  });
+}
+
 // src/tools/index.ts
 function registerTools(ctx, deps) {
   registerStartPhase(ctx, deps);
@@ -2688,6 +2892,7 @@ function registerTools(ctx, deps) {
   registerHelp(ctx, deps);
   registerArtifactTools(ctx, deps);
   registerResearchDispatch(ctx, deps);
+  registerInitVerify(ctx, deps);
 }
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-gate-agent",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "description": "Phase/node workflow gate with built-in commands, tools, and skills.",
   "exports": {

package/skills/gate-write-agent-notes/SKILL.md

@@ -158,7 +158,9 @@ Status: <状态>
 "verify-notes": "node .agents/gate/verify-notes.mjs"
 ```
 
-这个启动器只调用插件内置脚本，不复制技能。
+这个启动器只调用插件内置脚本，不复制技能。
+
+`/gate-init` 还会生成 `.agents/gate/init-manifest.json`，记录 CI 脚本/启动器的 hash 和 init 结构。需要核对初始化是否被改坏时，用 root-only 只读工具 `gate_init_verify`；它不检查 Note 内容，也不要在每次 Note 操作后运行。`init-manifest.json` 由 git 跟踪，同内容重跑 init 时字节稳定。
 
 - 计划完成前或提交前，运行 `npm run verify-notes`，检查 tree、format、lifecycle、archived。
 - `/gate-init` 同时生成 `.github/workflows/verify-notes.yml` 和 `.agents/gate/ci/` 校验脚本副本；CI 使用项目内副本，不依赖插件安装路径。

package/skills/gate-write-agent-notes/references/verification.md

@@ -33,7 +33,9 @@ Notes 读取/写入命令均接受 `--root <path>` 或 `--root=<path>`，每次
 ## 接入建议
 
 - 轻量（个人/无 git）：前两个脚本即可，归档封印在第一次归档后自然生效。
-- 完整：运行 `npm run verify-notes` 跑 tree/format/lifecycle/archived 四检；该脚本由 `/gate-init` 生成，只调用插件内置脚本。gate 会话内也可用 `/gate-note-verify`。
+- 完整：运行 `npm run verify-notes` 跑 tree/format/lifecycle/archived 四检；该脚本由 `/gate-init` 生成，只调用插件内置脚本。gate 会话内也可用 `/gate-note-verify`。
+
+初始化结构核对用 root-only 的 `gate_init_verify`；它检查 `init-manifest.json`、生成物 hash、artifact-policy schema、AGENTS block、package script、workflow 和 notes 四目录，不检查 Note 内容，也不应随每次 Note 操作运行。
 
 
 ## 脚本路径