npm - cleargate - Versions diffs - 0.6.1 → 0.7.0 - Mend

cleargate 0.6.1 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/MANIFEST.json +2 -2
package/dist/cli.cjs +526 -460
package/dist/cli.cjs.map +1 -1
package/dist/cli.js +535 -470
package/dist/cli.js.map +1 -1
package/dist/templates/cleargate-planning/MANIFEST.json +2 -2
package/package.json +1 -1
package/templates/cleargate-planning/MANIFEST.json +2 -2

package/dist/cli.js CHANGED Viewed

@@ -14,7 +14,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "cleargate",
-  version: "0.6.1",
+  version: "0.7.0",
   private: false,
   type: "module",
   description: "Planning framework for Claude Code agents \u2014 sprint/epic/story protocol, four-agent loop (architect/developer/qa/reporter), Karpathy-style awareness wiki.",
@@ -1272,8 +1272,8 @@ async function stampHandler(file, opts, cli) {
 }
 // src/commands/init.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs14 from "fs";
+import * as path14 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawnSync as spawnSync3 } from "child_process";
@@ -1285,6 +1285,7 @@ var HOOK_FILES_WITH_PIN = /* @__PURE__ */ new Set([
   ".claude/hooks/stamp-and-gate.sh",
   ".claude/hooks/session-start.sh"
 ]);
+var SKIP_FILES = /* @__PURE__ */ new Set(["CLAUDE.md"]);
 function listFilesRecursive(dir) {
   const results = [];
   function walk(current, rel) {
@@ -1307,7 +1308,7 @@ function copyPayload(payloadDir, targetCwd, opts) {
   if (!fs5.existsSync(payloadDir)) {
     throw new Error(`copyPayload: payloadDir does not exist: ${payloadDir}`);
   }
-  const files = listFilesRecursive(payloadDir);
+  const files = listFilesRecursive(payloadDir).filter((r) => !SKIP_FILES.has(r));
   for (const relPath of files) {
     const srcPath = path4.join(payloadDir, relPath);
     const dstPath = path4.join(targetCwd, relPath);
@@ -1318,9 +1319,14 @@ function copyPayload(payloadDir, targetCwd, opts) {
       srcContent = text;
     }
     const srcBuffer = typeof srcContent === "string" ? Buffer.from(srcContent, "utf8") : srcContent;
+    const srcMode = fs5.statSync(srcPath).mode;
+    const needsExec = (srcMode & 73) !== 0 || relPath.endsWith(".sh");
     if (fs5.existsSync(dstPath)) {
       const dstContent = fs5.readFileSync(dstPath);
       if (srcBuffer.equals(dstContent)) {
+        if (needsExec && process.platform !== "win32") {
+          fs5.chmodSync(dstPath, 493);
+        }
         report.skipped++;
         report.actions.push({ action: "skipped", relPath });
         continue;
@@ -1331,10 +1337,16 @@ function copyPayload(payloadDir, targetCwd, opts) {
         continue;
       }
       fs5.writeFileSync(dstPath, srcBuffer);
+      if (needsExec && process.platform !== "win32") {
+        fs5.chmodSync(dstPath, 493);
+      }
       report.overwritten++;
       report.actions.push({ action: "overwritten", relPath });
     } else {
       fs5.writeFileSync(dstPath, srcBuffer);
+      if (needsExec && process.platform !== "win32") {
+        fs5.chmodSync(dstPath, 493);
+      }
       report.created++;
       report.actions.push({ action: "created", relPath });
     }
@@ -1401,13 +1413,46 @@ function injectClaudeMd(existing, block) {
   return existing.trimEnd() + "\n\n" + block + "\n";
 }
+// src/init/inject-mcp-json.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+function mergeMcpJson(existing, entry) {
+  const next = existing ? { ...existing } : {};
+  const servers = { ...next.mcpServers ?? {} };
+  servers.cleargate = entry;
+  next.mcpServers = servers;
+  return JSON.stringify(next, null, 2) + "\n";
+}
+function injectMcpJson(cwd, url) {
+  const dst = path5.join(cwd, ".mcp.json");
+  const entry = { type: "http", url };
+  let existing = null;
+  let existingRaw = null;
+  if (fs6.existsSync(dst)) {
+    existingRaw = fs6.readFileSync(dst, "utf8");
+    try {
+      existing = JSON.parse(existingRaw);
+    } catch {
+      throw new Error(
+        `inject-mcp-json: ${dst} is not valid JSON; refusing to overwrite. Fix or remove the file and re-run init.`
+      );
+    }
+  }
+  const next = mergeMcpJson(existing, entry);
+  if (existingRaw !== null && existingRaw === next) {
+    return "unchanged";
+  }
+  fs6.writeFileSync(dst, next);
+  return existingRaw === null ? "created" : "updated";
+}
 // src/commands/wiki-build.ts
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs12 from "fs";
+import * as path11 from "path";
 // src/wiki/scan.ts
-import * as fs6 from "fs";
-import * as path5 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 // src/wiki/derive-bucket.ts
 var PREFIX_MAP = [
@@ -1450,19 +1495,19 @@ var EXCLUDED_SUFFIXES = [
 function scanRawItems(deliveryRoot, repoRoot) {
   const results = [];
   for (const subdir of ["pending-sync", "archive"]) {
-    const dir = path5.join(deliveryRoot, subdir);
-    if (!fs6.existsSync(dir)) continue;
-    const entries = fs6.readdirSync(dir, { recursive: true, encoding: "utf8" });
+    const dir = path6.join(deliveryRoot, subdir);
+    if (!fs7.existsSync(dir)) continue;
+    const entries = fs7.readdirSync(dir, { recursive: true, encoding: "utf8" });
     for (const rel of entries) {
       if (!rel.endsWith(".md")) continue;
       if (rel.includes("~") || rel.startsWith(".")) continue;
-      const absPath = path5.join(dir, rel);
-      const stat = fs6.statSync(absPath);
+      const absPath = path6.join(dir, rel);
+      const stat = fs7.statSync(absPath);
       if (!stat.isFile()) continue;
-      const rawPath = path5.relative(repoRoot, absPath).replace(/\\/g, "/");
+      const rawPath = path6.relative(repoRoot, absPath).replace(/\\/g, "/");
       const isExcluded = EXCLUDED_SUFFIXES.some((excl) => rawPath.startsWith(excl));
       if (isExcluded) continue;
-      const filename = path5.basename(absPath);
+      const filename = path6.basename(absPath);
       let bucketInfo;
       try {
         bucketInfo = deriveBucket(filename);
@@ -1475,7 +1520,7 @@ function scanRawItems(deliveryRoot, repoRoot) {
       } catch {
         continue;
       }
-      const raw = fs6.readFileSync(absPath, "utf8");
+      const raw = fs7.readFileSync(absPath, "utf8");
       let fm;
       let body;
       try {
@@ -1587,8 +1632,8 @@ function parseFmRaw(raw) {
 }
 // src/wiki/synthesis/active-sprint.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 import { fileURLToPath } from "url";
 // src/wiki/synthesis/render.ts
@@ -1627,7 +1672,7 @@ function renderSection(template, ctx) {
 // src/wiki/synthesis/active-sprint.ts
 function compile(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir();
-  const tpl = fs7.readFileSync(path6.join(tplDir, "active-sprint.md"), "utf8");
+  const tpl = fs8.readFileSync(path7.join(tplDir, "active-sprint.md"), "utf8");
   const sprints = state2.filter((i) => i.bucket === "sprints");
   const active = sprints.filter((s) => isSet(s.fm["activated_at"]) && !isSet(s.fm["completed_at"]));
   const completed = sprints.filter((s) => isSet(s.fm["completed_at"]));
@@ -1651,17 +1696,17 @@ function isSet(val) {
   return s !== "" && s !== "null";
 }
 function resolveDefaultTemplateDir() {
-  const __dirname2 = path6.dirname(fileURLToPath(import.meta.url));
-  return path6.resolve(__dirname2, "..", "templates", "synthesis");
+  const __dirname2 = path7.dirname(fileURLToPath(import.meta.url));
+  return path7.resolve(__dirname2, "..", "templates", "synthesis");
 }
 // src/wiki/synthesis/open-gates.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs9 from "fs";
+import * as path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function compile2(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir2();
-  const tpl = fs8.readFileSync(path7.join(tplDir, "open-gates.md"), "utf8");
+  const tpl = fs9.readFileSync(path8.join(tplDir, "open-gates.md"), "utf8");
   const gate1 = state2.filter((i) => {
     if (i.bucket !== "proposals") return false;
     const status = String(i.fm["status"] ?? "");
@@ -1690,17 +1735,17 @@ function compile2(state2, templateDir) {
   return renderTemplate(tpl, data);
 }
 function resolveDefaultTemplateDir2() {
-  const __dirname2 = path7.dirname(fileURLToPath2(import.meta.url));
-  return path7.resolve(__dirname2, "..", "templates", "synthesis");
+  const __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
+  return path8.resolve(__dirname2, "..", "templates", "synthesis");
 }
 // src/wiki/synthesis/product-state.ts
-import * as fs9 from "fs";
-import * as path8 from "path";
+import * as fs10 from "fs";
+import * as path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function compile3(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir3();
-  const tpl = fs9.readFileSync(path8.join(tplDir, "product-state.md"), "utf8");
+  const tpl = fs10.readFileSync(path9.join(tplDir, "product-state.md"), "utf8");
   function countBucket(bucket) {
     return state2.filter((i) => i.bucket === bucket);
   }
@@ -1747,17 +1792,17 @@ function compile3(state2, templateDir) {
   return renderTemplate(tpl, data);
 }
 function resolveDefaultTemplateDir3() {
-  const __dirname2 = path8.dirname(fileURLToPath3(import.meta.url));
-  return path8.resolve(__dirname2, "..", "templates", "synthesis");
+  const __dirname2 = path9.dirname(fileURLToPath3(import.meta.url));
+  return path9.resolve(__dirname2, "..", "templates", "synthesis");
 }
 // src/wiki/synthesis/roadmap.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path10 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function compile4(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir4();
-  const tpl = fs10.readFileSync(path9.join(tplDir, "roadmap.md"), "utf8");
+  const tpl = fs11.readFileSync(path10.join(tplDir, "roadmap.md"), "utf8");
   const sprints = state2.filter((i) => i.bucket === "sprints");
   const epics = state2.filter((i) => i.bucket === "epics");
   const inFlightSprints = sprints.filter(
@@ -1810,8 +1855,8 @@ function isShippedStatus(status) {
   return status === "Completed" || status === "Approved";
 }
 function resolveDefaultTemplateDir4() {
-  const __dirname2 = path9.dirname(fileURLToPath4(import.meta.url));
-  return path9.resolve(__dirname2, "..", "templates", "synthesis");
+  const __dirname2 = path10.dirname(fileURLToPath4(import.meta.url));
+  return path10.resolve(__dirname2, "..", "templates", "synthesis");
 }
 // src/commands/wiki-build.ts
@@ -1836,16 +1881,16 @@ async function wikiBuildHandler(opts = {}) {
   const exit = opts.exit ?? ((c) => process.exit(c));
   const gitRunner = opts.gitRunner;
   const templateDir = opts.templateDir;
-  const deliveryRoot = path10.join(cwd, ".cleargate", "delivery");
-  const wikiRoot = path10.join(cwd, ".cleargate", "wiki");
-  if (!fs11.existsSync(deliveryRoot)) {
+  const deliveryRoot = path11.join(cwd, ".cleargate", "delivery");
+  const wikiRoot = path11.join(cwd, ".cleargate", "wiki");
+  if (!fs12.existsSync(deliveryRoot)) {
     stderr(`wiki build: .cleargate/delivery/ not found at ${deliveryRoot}
 `);
     exit(1);
     return;
   }
   for (const bucket of BUCKET_ORDER) {
-    fs11.mkdirSync(path10.join(wikiRoot, bucket), { recursive: true });
+    fs12.mkdirSync(path11.join(wikiRoot, bucket), { recursive: true });
   }
   const items = scanRawItems(deliveryRoot, cwd);
   const timestamp = now();
@@ -1868,19 +1913,19 @@ async function wikiBuildHandler(opts = {}) {
     };
     const body = buildPageBody(item, wikiPage);
     const content = serializePage(wikiPage, body);
-    const pageDir = path10.join(wikiRoot, item.bucket);
-    fs11.mkdirSync(pageDir, { recursive: true });
-    fs11.writeFileSync(path10.join(pageDir, `${item.id}.md`), content, "utf8");
+    const pageDir = path11.join(wikiRoot, item.bucket);
+    fs12.mkdirSync(pageDir, { recursive: true });
+    fs12.writeFileSync(path11.join(pageDir, `${item.id}.md`), content, "utf8");
     pagesWritten++;
   }
   const indexContent = buildIndex(items);
-  fs11.writeFileSync(path10.join(wikiRoot, "index.md"), indexContent, "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "index.md"), indexContent, "utf8");
   const logContent = buildLog(items, timestamp);
-  fs11.writeFileSync(path10.join(wikiRoot, "log.md"), logContent, "utf8");
-  fs11.writeFileSync(path10.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
-  fs11.writeFileSync(path10.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
-  fs11.writeFileSync(path10.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
-  fs11.writeFileSync(path10.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "log.md"), logContent, "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
   stdout(`wiki build: OK (${pagesWritten} pages written)
 `);
 }
@@ -2045,8 +2090,8 @@ function buildLog(items, timestamp) {
 // src/lib/manifest.ts
 import { readFile as readFile3, writeFile as writeFile2, rename, mkdir } from "fs/promises";
-import { existsSync as existsSync7, readFileSync as readFileSync10 } from "fs";
-import * as path11 from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync11 } from "fs";
+import * as path12 from "path";
 // src/lib/sha256.ts
 import { createHash } from "crypto";
@@ -2069,31 +2114,31 @@ function shortHash(full) {
 // src/lib/manifest.ts
 function resolveDefaultPackageRoot() {
   const here = new URL(".", import.meta.url).pathname;
-  const distCandidate = path11.join(here, "MANIFEST.json");
-  if (existsSync7(distCandidate)) {
+  const distCandidate = path12.join(here, "MANIFEST.json");
+  if (existsSync8(distCandidate)) {
     return here;
   }
-  const oneLevelUp = path11.join(here, "..", "MANIFEST.json");
-  if (existsSync7(oneLevelUp)) {
-    return path11.join(here, "..");
+  const oneLevelUp = path12.join(here, "..", "MANIFEST.json");
+  if (existsSync8(oneLevelUp)) {
+    return path12.join(here, "..");
   }
-  const devCandidate = path11.join(here, "..", "..", "..", "cleargate-planning", "MANIFEST.json");
-  if (existsSync7(devCandidate)) {
-    return path11.join(here, "..", "..", "..", "cleargate-planning");
+  const devCandidate = path12.join(here, "..", "..", "..", "cleargate-planning", "MANIFEST.json");
+  if (existsSync8(devCandidate)) {
+    return path12.join(here, "..", "..", "..", "cleargate-planning");
   }
   return here;
 }
 function loadPackageManifest(opts) {
   const packageRoot = opts?.packageRoot ?? resolveDefaultPackageRoot();
-  const manifestPath = path11.join(packageRoot, "MANIFEST.json");
-  if (!existsSync7(manifestPath)) {
+  const manifestPath = path12.join(packageRoot, "MANIFEST.json");
+  if (!existsSync8(manifestPath)) {
     throw new Error(
       `MANIFEST.json not found at ${manifestPath}; run 'npm run build' to generate it.`
     );
   }
   let raw;
   try {
-    raw = readFileSync10(manifestPath, "utf-8");
+    raw = readFileSync11(manifestPath, "utf-8");
   } catch {
     throw new Error(
       `MANIFEST.json not found at ${manifestPath}; run 'npm run build' to generate it.`
@@ -2102,7 +2147,7 @@ function loadPackageManifest(opts) {
   return JSON.parse(raw);
 }
 async function loadInstallSnapshot(projectRoot) {
-  const snapshotPath = path11.join(projectRoot, ".cleargate", ".install-manifest.json");
+  const snapshotPath = path12.join(projectRoot, ".cleargate", ".install-manifest.json");
   try {
     const raw = await readFile3(snapshotPath, "utf-8");
     return JSON.parse(raw);
@@ -2111,7 +2156,7 @@ async function loadInstallSnapshot(projectRoot) {
   }
 }
 async function computeCurrentSha(file, projectRoot) {
-  const filePath = path11.join(projectRoot, file.path);
+  const filePath = path12.join(projectRoot, file.path);
   try {
     const raw = await readFile3(filePath);
     return hashNormalized(raw);
@@ -2140,8 +2185,8 @@ function classify(pkgSha, installSha, currentSha, tier) {
   return "both-changed";
 }
 async function writeDriftState(projectRoot, state2, opts) {
-  const cleargatDir = path11.join(projectRoot, ".cleargate");
-  const finalPath = path11.join(cleargatDir, ".drift-state.json");
+  const cleargatDir = path12.join(projectRoot, ".cleargate");
+  const finalPath = path12.join(cleargatDir, ".drift-state.json");
   const tmpPath = `${finalPath}.tmp`;
   const lastRefreshed = opts?.lastRefreshed ?? (/* @__PURE__ */ new Date()).toISOString();
   const fileContent = { last_refreshed: lastRefreshed, drift: state2 };
@@ -2150,7 +2195,7 @@ async function writeDriftState(projectRoot, state2, opts) {
   await rename(tmpPath, finalPath);
 }
 async function readDriftState(projectRoot) {
-  const driftPath = path11.join(projectRoot, ".cleargate", ".drift-state.json");
+  const driftPath = path12.join(projectRoot, ".cleargate", ".drift-state.json");
   try {
     const raw = await readFile3(driftPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -2223,24 +2268,24 @@ async function promptEmail(question, defaultValue, opts) {
 }
 // src/lib/identity.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 import * as fsPromises from "fs/promises";
 import * as os3 from "os";
 import { spawnSync as spawnSync2 } from "child_process";
 function readParticipant(projectRoot) {
-  const filePath = path12.join(projectRoot, ".cleargate", ".participant.json");
+  const filePath = path13.join(projectRoot, ".cleargate", ".participant.json");
   try {
-    const raw = fs12.readFileSync(filePath, "utf8");
+    const raw = fs13.readFileSync(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function writeParticipant(projectRoot, email, source, now = () => (/* @__PURE__ */ new Date()).toISOString()) {
-  const cleargateDir = path12.join(projectRoot, ".cleargate");
+  const cleargateDir = path13.join(projectRoot, ".cleargate");
   await fsPromises.mkdir(cleargateDir, { recursive: true });
-  const filePath = path12.join(cleargateDir, ".participant.json");
+  const filePath = path13.join(cleargateDir, ".participant.json");
   const tmpPath = filePath + ".tmp." + Date.now();
   const content = {
     email,
@@ -2316,16 +2361,16 @@ var HOOK_ADDITION = {
 };
 function resolveDefaultPayloadDir() {
   const thisFile = fileURLToPath5(import.meta.url);
-  const pkgRoot = path13.resolve(path13.dirname(thisFile), "..");
-  return path13.join(pkgRoot, "templates", "cleargate-planning");
+  const pkgRoot = path14.resolve(path14.dirname(thisFile), "..");
+  return path14.join(pkgRoot, "templates", "cleargate-planning");
 }
 function countDeliveryItems(cwd) {
-  const pendingSync = path13.join(cwd, ".cleargate", "delivery", "pending-sync");
-  const archive = path13.join(cwd, ".cleargate", "delivery", "archive");
+  const pendingSync = path14.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const archive = path14.join(cwd, ".cleargate", "delivery", "archive");
   let count = 0;
   for (const dir of [pendingSync, archive]) {
-    if (!fs13.existsSync(dir)) continue;
-    const entries = fs13.readdirSync(dir);
+    if (!fs14.existsSync(dir)) continue;
+    const entries = fs14.readdirSync(dir);
     for (const f of entries) {
       if (f.endsWith(".md") && f !== ".gitkeep") count++;
     }
@@ -2334,12 +2379,12 @@ function countDeliveryItems(cwd) {
 }
 function writeAtomic(filePath, content) {
   const tmpPath = filePath + ".tmp." + Date.now();
-  fs13.writeFileSync(tmpPath, content, "utf8");
-  fs13.renameSync(tmpPath, filePath);
+  fs14.writeFileSync(tmpPath, content, "utf8");
+  fs14.renameSync(tmpPath, filePath);
 }
 function readPackageVersion(packageJsonPath) {
   try {
-    const raw = fs13.readFileSync(packageJsonPath, "utf8");
+    const raw = fs14.readFileSync(packageJsonPath, "utf8");
     const pkg = JSON.parse(raw);
     if (typeof pkg.version === "string" && pkg.version.length > 0) {
       return pkg.version;
@@ -2359,16 +2404,16 @@ async function initHandler(opts = {}) {
   const promptYesNoFn = opts.promptYesNo ?? promptYesNo;
   const promptEmailFn = opts.promptEmail ?? promptEmail;
   const spawnSyncFn = opts.spawnSyncFn ?? spawnSync3;
-  if (!fs13.existsSync(cwd)) {
+  if (!fs14.existsSync(cwd)) {
     stderr(`[cleargate init] ERROR: target directory does not exist: ${cwd}
 `);
     exit(1);
     return;
   }
-  const testWritePath = path13.join(cwd, `.cleargate-init-write-test-${Date.now()}`);
+  const testWritePath = path14.join(cwd, `.cleargate-init-write-test-${Date.now()}`);
   try {
-    fs13.writeFileSync(testWritePath, "");
-    fs13.unlinkSync(testWritePath);
+    fs14.writeFileSync(testWritePath, "");
+    fs14.unlinkSync(testWritePath);
   } catch {
     stderr(`[cleargate init] ERROR: target directory is not writable: ${cwd}
 `);
@@ -2378,7 +2423,7 @@ async function initHandler(opts = {}) {
   stdout(`[cleargate init] Target: ${cwd}
 `);
   const payloadDir = opts.payloadDir ?? resolveDefaultPayloadDir();
-  if (!fs13.existsSync(payloadDir)) {
+  if (!fs14.existsSync(payloadDir)) {
     stderr(`[cleargate init] ERROR: payload directory not found: ${payloadDir}
 `);
     stderr(`[cleargate init] Run \`npm run prebuild\` to copy the payload first.
@@ -2386,12 +2431,12 @@ async function initHandler(opts = {}) {
     exit(1);
     return;
   }
-  const uninstalledMarkerPath = path13.join(cwd, ".cleargate", ".uninstalled");
+  const uninstalledMarkerPath = path14.join(cwd, ".cleargate", ".uninstalled");
   let uninstalledMarker = null;
   let userChoseRestore = false;
-  if (fs13.existsSync(uninstalledMarkerPath)) {
+  if (fs14.existsSync(uninstalledMarkerPath)) {
     try {
-      const raw = fs13.readFileSync(uninstalledMarkerPath, "utf8");
+      const raw = fs14.readFileSync(uninstalledMarkerPath, "utf8");
       uninstalledMarker = JSON.parse(raw);
     } catch {
       stderr(`[cleargate init] WARNING: .uninstalled marker is malformed; ignoring it.
@@ -2403,8 +2448,8 @@ async function initHandler(opts = {}) {
       userChoseRestore = await promptYesNoFn(question, true);
       if (userChoseRestore) {
         for (const preservedPath of preserved) {
-          const absPreserved = path13.isAbsolute(preservedPath) ? preservedPath : path13.join(cwd, preservedPath);
-          if (fs13.existsSync(absPreserved)) {
+          const absPreserved = path14.isAbsolute(preservedPath) ? preservedPath : path14.join(cwd, preservedPath);
+          if (fs14.existsSync(absPreserved)) {
             stdout(`[cleargate init] [preserved] ${preservedPath}
 `);
           } else {
@@ -2424,8 +2469,8 @@ async function initHandler(opts = {}) {
   if (opts.pin) {
     pinVersion = opts.pin;
   } else {
-    const payloadParent = path13.resolve(payloadDir, "..", "..");
-    pinVersion = readPackageVersion(path13.join(payloadParent, "package.json")) ?? readPackageVersion(path13.join(path13.dirname(fileURLToPath5(import.meta.url)), "..", "package.json")) ?? "latest";
+    const payloadParent = path14.resolve(payloadDir, "..", "..");
+    pinVersion = readPackageVersion(path14.join(payloadParent, "package.json")) ?? readPackageVersion(path14.join(path14.dirname(fileURLToPath5(import.meta.url)), "..", "package.json")) ?? "latest";
   }
   const copyReport = copyPayload(payloadDir, cwd, { force, pinVersion });
   for (const action of copyReport.actions) {
@@ -2433,33 +2478,33 @@ async function initHandler(opts = {}) {
     stdout(`[cleargate init] ${verb} ${action.relPath}
 `);
   }
-  const settingsPath = path13.join(cwd, ".claude", "settings.json");
+  const settingsPath = path14.join(cwd, ".claude", "settings.json");
   let existingSettings = null;
-  if (fs13.existsSync(settingsPath)) {
+  if (fs14.existsSync(settingsPath)) {
     try {
-      existingSettings = JSON.parse(fs13.readFileSync(settingsPath, "utf8"));
+      existingSettings = JSON.parse(fs14.readFileSync(settingsPath, "utf8"));
     } catch {
       stderr(`[cleargate init] WARNING: could not parse ${settingsPath}; treating as empty.
 `);
     }
   }
   const mergedSettings = mergeSettings(existingSettings, HOOK_ADDITION);
-  fs13.mkdirSync(path13.dirname(settingsPath), { recursive: true });
+  fs14.mkdirSync(path14.dirname(settingsPath), { recursive: true });
   writeAtomic(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n");
   stdout(`[cleargate init] Updated .claude/settings.json: merged PostToolUse hook
 `);
-  const claudeMdPath = path13.join(cwd, "CLAUDE.md");
-  const claudeMdSrcPath = path13.join(payloadDir, "CLAUDE.md");
+  const claudeMdPath = path14.join(cwd, "CLAUDE.md");
+  const claudeMdSrcPath = path14.join(payloadDir, "CLAUDE.md");
   let claudeMdBlock;
   try {
-    const claudeMdSrc = fs13.readFileSync(claudeMdSrcPath, "utf8");
+    const claudeMdSrc = fs14.readFileSync(claudeMdSrcPath, "utf8");
     claudeMdBlock = extractBlock(claudeMdSrc);
   } catch (e) {
     stderr(`[cleargate init] WARNING: could not read CLAUDE.md block from payload: ${String(e)}
 `);
     claudeMdBlock = "<!-- CLEARGATE:START -->\n<!-- CLEARGATE:END -->";
   }
-  const existingClaudeMd = fs13.existsSync(claudeMdPath) ? fs13.readFileSync(claudeMdPath, "utf8") : null;
+  const existingClaudeMd = fs14.existsSync(claudeMdPath) ? fs14.readFileSync(claudeMdPath, "utf8") : null;
   const newClaudeMd = injectClaudeMd(existingClaudeMd, claudeMdBlock);
   writeAtomic(claudeMdPath, newClaudeMd);
   if (existingClaudeMd === null) {
@@ -2470,6 +2515,26 @@ async function initHandler(opts = {}) {
 `);
   } else {
     stdout(`[cleargate init] CLAUDE.md unchanged (block already up to date)
+`);
+  }
+  try {
+    const action = injectMcpJson(cwd, "https://cleargate-mcp.soula.ge/mcp");
+    if (action === "created") {
+      stdout(
+        `[cleargate init] Created .mcp.json (cleargate MCP server registered) \u2014 restart Claude Code to load it.
+`
+      );
+    } else if (action === "updated") {
+      stdout(
+        `[cleargate init] Updated .mcp.json (cleargate MCP server entry merged) \u2014 restart Claude Code to pick up changes.
+`
+      );
+    } else {
+      stdout(`[cleargate init] .mcp.json unchanged (cleargate entry already present)
+`);
+    }
+  } catch (e) {
+    stderr(`[cleargate init] WARNING: ${String(e instanceof Error ? e.message : e)}
 `);
   }
   const itemCount = countDeliveryItems(cwd);
@@ -2483,9 +2548,9 @@ async function initHandler(opts = {}) {
     stdout(`[cleargate init] Bootstrap: no items to ingest, skipping build
 `);
   }
-  const cleargateDir = path13.join(cwd, ".cleargate");
-  fs13.mkdirSync(cleargateDir, { recursive: true });
-  const snapshotPath = path13.join(cleargateDir, ".install-manifest.json");
+  const cleargateDir = path14.join(cwd, ".cleargate");
+  fs14.mkdirSync(cleargateDir, { recursive: true });
+  const snapshotPath = path14.join(cleargateDir, ".install-manifest.json");
   try {
     const readManifest = opts.readInstallManifest ?? (() => loadPackageManifest({ packageRoot: payloadDir }));
     const pkgManifest = readManifest();
@@ -2500,19 +2565,19 @@ async function initHandler(opts = {}) {
     stderr(`[cleargate init] WARNING: could not write install snapshot: ${String(e)}
 `);
   }
-  if (uninstalledMarker !== null && fs13.existsSync(uninstalledMarkerPath)) {
+  if (uninstalledMarker !== null && fs14.existsSync(uninstalledMarkerPath)) {
     try {
-      fs13.unlinkSync(uninstalledMarkerPath);
+      fs14.unlinkSync(uninstalledMarkerPath);
     } catch (e) {
       stderr(`[cleargate init] WARNING: could not remove .uninstalled marker: ${String(e)}
 `);
     }
   }
   {
-    const distCliPath = path13.join(cwd, "cleargate-cli", "dist", "cli.js");
+    const distCliPath = path14.join(cwd, "cleargate-cli", "dist", "cli.js");
     let branch = null;
     let branchLabel = "";
-    if (fs13.existsSync(distCliPath)) {
+    if (fs14.existsSync(distCliPath)) {
       branch = { cmd: "node", args: [distCliPath, "--version"] };
       branchLabel = `local dist (${distCliPath})`;
     } else {
@@ -2583,8 +2648,8 @@ async function initHandler(opts = {}) {
 }
 // src/commands/wiki-ingest.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 import { spawnSync as spawnSync4 } from "child_process";
 var EXCLUDED_SUFFIXES2 = [
   ".cleargate/knowledge/",
@@ -2610,16 +2675,16 @@ async function wikiIngestHandler(opts) {
   const stderr = opts.stderr ?? ((s) => process.stderr.write(s));
   const exit = opts.exit ?? ((c) => process.exit(c));
   const gitRunner = opts.gitRunner;
-  const rename11 = opts.rename ?? fs14.renameSync;
+  const rename11 = opts.rename ?? fs15.renameSync;
   const templateDir = opts.templateDir;
   const rawPath = opts.rawPath;
-  const absRawPath = path14.isAbsolute(rawPath) ? rawPath : path14.resolve(cwd, rawPath);
-  const relRawPath = path14.relative(cwd, absRawPath).replace(/\\/g, "/");
-  const deliveryRoot = path14.join(cwd, ".cleargate", "delivery");
+  const absRawPath = path15.isAbsolute(rawPath) ? rawPath : path15.resolve(cwd, rawPath);
+  const relRawPath = path15.relative(cwd, absRawPath).replace(/\\/g, "/");
+  const deliveryRoot = path15.join(cwd, ".cleargate", "delivery");
   const deliveryRootNorm = deliveryRoot.replace(/\\/g, "/");
   const absDeliveryRoot = deliveryRoot;
-  const relToDelivery = path14.relative(absDeliveryRoot, absRawPath);
-  if (relToDelivery.startsWith("..") || path14.isAbsolute(relToDelivery)) {
+  const relToDelivery = path15.relative(absDeliveryRoot, absRawPath);
+  if (relToDelivery.startsWith("..") || path15.isAbsolute(relToDelivery)) {
     stderr(`wiki ingest: ${rawPath} not under .cleargate/delivery/
 `);
     exit(2);
@@ -2633,7 +2698,7 @@ async function wikiIngestHandler(opts) {
     exit(0);
     return;
   }
-  const filename = path14.basename(absRawPath);
+  const filename = path15.basename(absRawPath);
   let bucketInfo;
   try {
     bucketInfo = deriveBucket(filename);
@@ -2653,12 +2718,12 @@ async function wikiIngestHandler(opts) {
     return;
   }
   const { type, id, bucket } = bucketInfo;
-  const wikiRoot = path14.join(cwd, ".cleargate", "wiki");
-  const pageDir = path14.join(wikiRoot, bucket);
-  const pagePath = path14.join(pageDir, `${id}.md`);
+  const wikiRoot = path15.join(cwd, ".cleargate", "wiki");
+  const pageDir = path15.join(wikiRoot, bucket);
+  const pagePath = path15.join(pageDir, `${id}.md`);
   let rawContent;
   try {
-    rawContent = fs14.readFileSync(absRawPath, "utf8");
+    rawContent = fs15.readFileSync(absRawPath, "utf8");
   } catch (e) {
     stderr(`wiki ingest: cannot read ${rawPath}: ${e.message}
 `);
@@ -2678,11 +2743,11 @@ async function wikiIngestHandler(opts) {
     return;
   }
   const currentSha = getGitSha(absRawPath, gitRunner) ?? "";
-  const pageExists = fs14.existsSync(pagePath);
+  const pageExists = fs15.existsSync(pagePath);
   if (pageExists && currentSha !== "") {
     let isNoOp = false;
     try {
-      const existingPageContent = fs14.readFileSync(pagePath, "utf8");
+      const existingPageContent = fs15.readFileSync(pagePath, "utf8");
       const existingPage = parsePage(existingPageContent);
       if (existingPage.last_ingest_commit === currentSha) {
         const contentUnchanged = checkContentUnchanged(absRawPath, currentSha, relRawPath, gitRunner);
@@ -2717,8 +2782,8 @@ async function wikiIngestHandler(opts) {
   };
   const pageBody = buildPageBody2({ id, fm, body });
   const pageContent = serializePage(wikiPage, pageBody);
-  fs14.mkdirSync(pageDir, { recursive: true });
-  fs14.writeFileSync(pagePath, pageContent, "utf8");
+  fs15.mkdirSync(pageDir, { recursive: true });
+  fs15.writeFileSync(pagePath, pageContent, "utf8");
   appendLogEntry(wikiRoot, { timestamp, action, id, relRawPath });
   updateIndex(wikiRoot, { id, type, status: wikiPage.status, relRawPath, rename: rename11 });
   recompileSynthesis(wikiRoot, cwd, templateDir);
@@ -2730,7 +2795,7 @@ function checkContentUnchanged(absRawPath, sha, relRawPath, gitRunner) {
     const run = gitRunner ?? defaultGitRunner;
     const gitContent = run("git", ["show", `${sha}:${relRawPath}`]);
     if (!gitContent && gitContent !== "") return false;
-    const currentContent = fs14.readFileSync(absRawPath, "utf8");
+    const currentContent = fs15.readFileSync(absRawPath, "utf8");
     return gitContent === currentContent;
   } catch {
     return false;
@@ -2783,7 +2848,7 @@ function buildPageBody2(item) {
   ].join("\n");
 }
 function appendLogEntry(wikiRoot, entry) {
-  const logPath = path14.join(wikiRoot, "log.md");
+  const logPath = path15.join(wikiRoot, "log.md");
   const logEntry = [
     `- timestamp: "${entry.timestamp}"`,
     `  actor: "cleargate wiki ingest"`,
@@ -2791,25 +2856,25 @@ function appendLogEntry(wikiRoot, entry) {
     `  target: "${entry.id}"`,
     `  path: "${entry.relRawPath}"`
   ].join("\n");
-  if (fs14.existsSync(logPath)) {
-    const existing = fs14.readFileSync(logPath, "utf8");
+  if (fs15.existsSync(logPath)) {
+    const existing = fs15.readFileSync(logPath, "utf8");
     const newContent = existing.trimEnd() + "\n" + logEntry + "\n";
-    fs14.writeFileSync(logPath, newContent, "utf8");
+    fs15.writeFileSync(logPath, newContent, "utf8");
   } else {
-    fs14.mkdirSync(wikiRoot, { recursive: true });
-    fs14.writeFileSync(logPath, `# Wiki Event Log
+    fs15.mkdirSync(wikiRoot, { recursive: true });
+    fs15.writeFileSync(logPath, `# Wiki Event Log
 ${logEntry}
 `, "utf8");
   }
 }
 function updateIndex(wikiRoot, opts) {
-  const indexPath = path14.join(wikiRoot, "index.md");
+  const indexPath = path15.join(wikiRoot, "index.md");
   const tmpPath = `${indexPath}.tmp`;
   const newRow = `| [[${opts.id}]] | ${opts.type} | ${opts.status} | ${opts.relRawPath} |`;
   let content;
-  if (fs14.existsSync(indexPath)) {
-    content = fs14.readFileSync(indexPath, "utf8");
+  if (fs15.existsSync(indexPath)) {
+    content = fs15.readFileSync(indexPath, "utf8");
     const idPattern = `[[${opts.id}]]`;
     const lines = content.split("\n");
     let replaced = false;
@@ -2828,7 +2893,7 @@ function updateIndex(wikiRoot, opts) {
   } else {
     content = buildMinimalIndex(opts.id, opts.type, opts.status, opts.relRawPath);
   }
-  fs14.writeFileSync(tmpPath, content, "utf8");
+  fs15.writeFileSync(tmpPath, content, "utf8");
   opts.rename(tmpPath, indexPath);
 }
 function insertIntoSection(content, id, newRow) {
@@ -2923,39 +2988,39 @@ function buildMinimalIndex(id, type, status, relRawPath) {
   return lines.join("\n");
 }
 function recompileSynthesis(wikiRoot, cwd, templateDir) {
-  const deliveryRoot = path14.join(cwd, ".cleargate", "delivery");
+  const deliveryRoot = path15.join(cwd, ".cleargate", "delivery");
   let items = [];
-  if (fs14.existsSync(deliveryRoot)) {
+  if (fs15.existsSync(deliveryRoot)) {
     try {
       items = scanRawItems(deliveryRoot, cwd);
     } catch {
     }
   }
-  fs14.writeFileSync(path14.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
-  fs14.writeFileSync(path14.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
-  fs14.writeFileSync(path14.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
-  fs14.writeFileSync(path14.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
+  fs15.writeFileSync(path15.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
+  fs15.writeFileSync(path15.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
+  fs15.writeFileSync(path15.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
+  fs15.writeFileSync(path15.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
 }
 // src/commands/wiki-lint.ts
-import * as path18 from "path";
+import * as path19 from "path";
 // src/wiki/load-wiki.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
+import * as fs16 from "fs";
+import * as path16 from "path";
 var BUCKET_DIRS = ["epics", "stories", "sprints", "proposals", "crs", "bugs", "topics"];
 function loadWikiPages(wikiRoot) {
   const results = [];
   for (const bucket of BUCKET_DIRS) {
-    const dir = path15.join(wikiRoot, bucket);
-    if (!fs15.existsSync(dir)) continue;
-    const entries = fs15.readdirSync(dir, { encoding: "utf8" });
+    const dir = path16.join(wikiRoot, bucket);
+    if (!fs16.existsSync(dir)) continue;
+    const entries = fs16.readdirSync(dir, { encoding: "utf8" });
     for (const filename of entries) {
       if (!filename.endsWith(".md")) continue;
-      const absPath = path15.join(dir, filename);
-      const stat = fs15.statSync(absPath);
+      const absPath = path16.join(dir, filename);
+      const stat = fs16.statSync(absPath);
       if (!stat.isFile()) continue;
-      const raw = fs15.readFileSync(absPath, "utf8");
+      const raw = fs16.readFileSync(absPath, "utf8");
       let fm;
       let body;
       try {
@@ -2984,8 +3049,8 @@ function loadWikiPages(wikiRoot) {
 }
 // src/wiki/lint-checks.ts
-import * as fs16 from "fs";
-import * as path16 from "path";
+import * as fs17 from "fs";
+import * as path17 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import yaml3 from "js-yaml";
@@ -3044,9 +3109,9 @@ function checkOrphan(page, repoRoot) {
   if (!rawPath) return null;
   const isExcluded = EXCLUDED_DIRS.some((excl) => rawPath.startsWith(excl));
   if (isExcluded) return null;
-  const absRaw = path16.join(repoRoot, rawPath);
-  if (!fs16.existsSync(absRaw)) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+  const absRaw = path17.join(repoRoot, rawPath);
+  if (!fs17.existsSync(absRaw)) {
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "orphan",
       line: `orphan: ${relPage} -> missing ${rawPath} (raw missing)`
@@ -3064,7 +3129,7 @@ function checkRepoMismatch(page, repoRoot) {
     return null;
   }
   if (page.page.repo !== derivedRepo) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "repo-mismatch",
       line: `repo-mismatch: ${relPage} declares repo:${page.page.repo} but raw_path implies repo:${derivedRepo}`
@@ -3089,7 +3154,7 @@ function checkStaleCommit(page, repoRoot, gitRunner) {
   }
   if (!currentSha) return null;
   if (storedSha !== currentSha) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "stale-commit",
       line: `stale-commit: ${relPage} at ${storedSha}, current ${currentSha}`
@@ -3100,14 +3165,14 @@ function checkStaleCommit(page, repoRoot, gitRunner) {
 function checkMissingIngest(page, repoRoot) {
   const rawPath = page.page.raw_path;
   if (!rawPath) return null;
-  const absRaw = path16.join(repoRoot, rawPath);
-  if (!fs16.existsSync(absRaw)) return null;
-  const rawStat = fs16.statSync(absRaw);
-  const pageStat = fs16.statSync(page.absPath);
+  const absRaw = path17.join(repoRoot, rawPath);
+  if (!fs17.existsSync(absRaw)) return null;
+  const rawStat = fs17.statSync(absRaw);
+  const pageStat = fs17.statSync(page.absPath);
   const rawMtimeMs = rawStat.mtimeMs;
   const pageMtimeMs = pageStat.mtimeMs;
   if (rawMtimeMs - pageMtimeMs > 2e3) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     const rawMtime = rawStat.mtime.toISOString();
     const pageMtime = pageStat.mtime.toISOString();
     return {
@@ -3118,7 +3183,7 @@ function checkMissingIngest(page, repoRoot) {
   return null;
 }
 function checkBrokenBacklinks(pages, repoRoot) {
-  const wikiRoot = path16.join(repoRoot, ".cleargate", "wiki");
+  const wikiRoot = path17.join(repoRoot, ".cleargate", "wiki");
   const byId = /* @__PURE__ */ new Map();
   for (const p of pages) {
     if (p.page.id) byId.set(p.page.id, p);
@@ -3132,7 +3197,7 @@ function checkBrokenBacklinks(pages, repoRoot) {
     const parentId = match[1];
     const parentPage = byId.get(parentId);
     if (!parentPage) {
-      const relChild = path16.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
+      const relChild = path17.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
       findings.push({
         category: "broken-backlink",
         line: `broken-backlink: ${relChild} -> ${parentId} (parent missing child entry)`
@@ -3145,7 +3210,7 @@ function checkBrokenBacklinks(pages, repoRoot) {
       (c) => c === childRef || c === childId
     );
     if (!parentHasChild) {
-      const relChild = path16.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
+      const relChild = path17.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
       findings.push({
         category: "broken-backlink",
         line: `broken-backlink: ${relChild} -> ${parentId} (parent missing child entry)`
@@ -3155,7 +3220,7 @@ function checkBrokenBacklinks(pages, repoRoot) {
   return findings;
 }
 function checkInvalidatedCitations(pages, repoRoot) {
-  const wikiRoot = path16.join(repoRoot, ".cleargate", "wiki");
+  const wikiRoot = path17.join(repoRoot, ".cleargate", "wiki");
   const byId = /* @__PURE__ */ new Map();
   for (const p of pages) {
     if (p.page.id) byId.set(p.page.id, p);
@@ -3163,10 +3228,10 @@ function checkInvalidatedCitations(pages, repoRoot) {
   const findings = [];
   const topicPages = pages.filter((p) => p.page.type === "topic");
   for (const topicPage of topicPages) {
-    const relTopic = path16.relative(wikiRoot, topicPage.absPath).replace(/\\/g, "/");
+    const relTopic = path17.relative(wikiRoot, topicPage.absPath).replace(/\\/g, "/");
     let citesList = [];
     try {
-      const raw = fs16.readFileSync(topicPage.absPath, "utf8");
+      const raw = fs17.readFileSync(topicPage.absPath, "utf8");
       const { fm } = parseFrontmatter(raw);
       const rawCites = fm["cites"];
       if (Array.isArray(rawCites)) {
@@ -3202,7 +3267,7 @@ function checkExcludedPathIngested(page, repoRoot) {
   if (!rawPath) return null;
   const isExcluded = EXCLUDED_DIRS.some((excl) => rawPath.startsWith(excl));
   if (isExcluded) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "excluded-path-ingested",
       line: `excluded-path-ingested: ${relPage} (raw_path ${rawPath} is under an excluded directory)`
@@ -3213,7 +3278,7 @@ function checkExcludedPathIngested(page, repoRoot) {
 function checkPaginationNeeded(pages) {
   const bucketCounts = /* @__PURE__ */ new Map();
   for (const p of pages) {
-    const bucket = path16.basename(path16.dirname(p.absPath));
+    const bucket = path17.basename(path17.dirname(p.absPath));
     bucketCounts.set(bucket, (bucketCounts.get(bucket) ?? 0) + 1);
   }
   const findings = [];
@@ -3251,11 +3316,11 @@ function parseCachedGateResult(raw) {
 function checkGateFailure(page, repoRoot) {
   const rawPath = page.page.raw_path;
   if (!rawPath) return null;
-  const absRaw = path16.join(repoRoot, rawPath);
-  if (!fs16.existsSync(absRaw)) return null;
+  const absRaw = path17.join(repoRoot, rawPath);
+  if (!fs17.existsSync(absRaw)) return null;
   let rawFm;
   try {
-    const raw = fs16.readFileSync(absRaw, "utf8");
+    const raw = fs17.readFileSync(absRaw, "utf8");
     const { fm } = parseFrontmatter(raw);
     rawFm = fm;
   } catch {
@@ -3289,11 +3354,11 @@ function checkGateFailure(page, repoRoot) {
 function checkGateStaleness(page, repoRoot) {
   const rawPath = page.page.raw_path;
   if (!rawPath) return null;
-  const absRaw = path16.join(repoRoot, rawPath);
-  if (!fs16.existsSync(absRaw)) return null;
+  const absRaw = path17.join(repoRoot, rawPath);
+  if (!fs17.existsSync(absRaw)) return null;
   let rawFm;
   try {
-    const raw = fs16.readFileSync(absRaw, "utf8");
+    const raw = fs17.readFileSync(absRaw, "utf8");
     const { fm } = parseFrontmatter(raw);
     rawFm = fm;
   } catch {
@@ -3316,7 +3381,7 @@ function checkGateStaleness(page, repoRoot) {
   return null;
 }
 function discoverPlainTextMentions(pages, repoRoot) {
-  const wikiRoot = path16.join(repoRoot, ".cleargate", "wiki");
+  const wikiRoot = path17.join(repoRoot, ".cleargate", "wiki");
   const byId = /* @__PURE__ */ new Map();
   for (const p of pages) {
     if (p.page.id) byId.set(p.page.id, true);
@@ -3325,7 +3390,7 @@ function discoverPlainTextMentions(pages, repoRoot) {
   const ID_PATTERN = /\b((?:EPIC|STORY|SPRINT|PROPOSAL|CR|BUG)-[\w-]+)\b/g;
   const LINK_PATTERN = /\[\[[\w-]+\]\]/g;
   for (const page of pages) {
-    const relPage = path16.relative(wikiRoot, page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(wikiRoot, page.absPath).replace(/\\/g, "/");
     const wrappedRefs = /* @__PURE__ */ new Set();
     for (const m of page.body.matchAll(LINK_PATTERN)) {
       const inner = m[0].slice(2, -2);
@@ -3342,11 +3407,11 @@ function discoverPlainTextMentions(pages, repoRoot) {
   return suggestions;
 }
 function checkIndexBudget(repoRoot, indexTokenCeiling) {
-  const indexPath = path16.join(repoRoot, ".cleargate", "wiki", "index.md");
-  if (!fs16.existsSync(indexPath)) {
+  const indexPath = path17.join(repoRoot, ".cleargate", "wiki", "index.md");
+  if (!fs17.existsSync(indexPath)) {
     return { finding: null };
   }
-  const bytes = fs16.statSync(indexPath).size;
+  const bytes = fs17.statSync(indexPath).size;
   const tokens = Math.round(bytes / 4);
   const ceiling = indexTokenCeiling;
   if (tokens > ceiling) {
@@ -3363,18 +3428,18 @@ function checkIndexBudget(repoRoot, indexTokenCeiling) {
 }
 // src/lib/wiki-config.ts
-import * as fs17 from "fs";
-import * as path17 from "path";
+import * as fs18 from "fs";
+import * as path18 from "path";
 import yaml4 from "js-yaml";
 var DEFAULT_INDEX_TOKEN_CEILING = 8e3;
 function loadWikiConfig(repoRoot) {
-  const configPath = path17.join(repoRoot, ".cleargate", "config.yml");
-  if (!fs17.existsSync(configPath)) {
+  const configPath = path18.join(repoRoot, ".cleargate", "config.yml");
+  if (!fs18.existsSync(configPath)) {
     return { wiki: { index_token_ceiling: DEFAULT_INDEX_TOKEN_CEILING }, gates: {} };
   }
   let raw;
   try {
-    raw = fs17.readFileSync(configPath, "utf8");
+    raw = fs18.readFileSync(configPath, "utf8");
   } catch (err) {
     throw new Error(`Failed to read ${configPath}: ${String(err)}`);
   }
@@ -3435,7 +3500,7 @@ async function wikiLintHandler(opts = {}) {
   const exit = opts.exit ?? ((c) => process.exit(c));
   const gitRunner = opts.gitRunner;
   const mode = opts.mode ?? "enforce";
-  const wikiRoot = path18.join(cwd, ".cleargate", "wiki");
+  const wikiRoot = path19.join(cwd, ".cleargate", "wiki");
   const repoRoot = cwd;
   let pages = loadWikiPages(wikiRoot);
   const findings = [];
@@ -3506,8 +3571,8 @@ async function wikiLintHandler(opts = {}) {
 }
 // src/commands/wiki-query.ts
-import * as fs18 from "fs";
-import * as path19 from "path";
+import * as fs19 from "fs";
+import * as path20 from "path";
 function computeSlug(query) {
   return query.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 40).replace(/-+$/, "");
 }
@@ -3537,9 +3602,9 @@ async function wikiQueryHandler(opts) {
   const query = opts.query;
   const persist = opts.persist ?? false;
   void stderr;
-  const wikiRoot = path19.join(cwd, ".cleargate", "wiki");
-  const indexPath = path19.join(wikiRoot, "index.md");
-  if (!fs18.existsSync(indexPath)) {
+  const wikiRoot = path20.join(cwd, ".cleargate", "wiki");
+  const indexPath = path20.join(wikiRoot, "index.md");
+  if (!fs19.existsSync(indexPath)) {
     stdout(`wiki query: no index.md found at ${indexPath}
 `);
     stdout(`Run \`cleargate wiki build\` first.
@@ -3547,7 +3612,7 @@ async function wikiQueryHandler(opts) {
     exit(1);
     return;
   }
-  const indexContent = fs18.readFileSync(indexPath, "utf8");
+  const indexContent = fs19.readFileSync(indexPath, "utf8");
   const matches = searchIndex(indexContent, query);
   if (matches.length === 0) {
     stdout(`wiki query: no matches for "${query}"
@@ -3572,8 +3637,8 @@ async function wikiQueryHandler(opts) {
     return;
   }
   const slug = computeSlug(query);
-  const topicsDir = path19.join(wikiRoot, "topics");
-  fs18.mkdirSync(topicsDir, { recursive: true });
+  const topicsDir = path20.join(wikiRoot, "topics");
+  fs19.mkdirSync(topicsDir, { recursive: true });
   const citesArray = matches.map(({ id }) => `"[[${id}]]"`);
   const createdAt = now();
   const frontmatter = [
@@ -3588,13 +3653,13 @@ async function wikiQueryHandler(opts) {
   const topicContent = `${frontmatter}
 ${body}`;
-  const topicPath = path19.join(topicsDir, `${slug}.md`);
-  fs18.writeFileSync(topicPath, topicContent, "utf8");
+  const topicPath = path20.join(topicsDir, `${slug}.md`);
+  fs19.writeFileSync(topicPath, topicContent, "utf8");
   updateIndexTopicsSection(indexPath, slug, query, createdAt);
   exit(0);
 }
 function updateIndexTopicsSection(indexPath, slug, query, createdAt) {
-  let content = fs18.readFileSync(indexPath, "utf8");
+  let content = fs19.readFileSync(indexPath, "utf8");
   const row = `| ${slug} | ${query} | ${createdAt} |`;
   if (content.includes("## Topics")) {
     const topicsIdx = content.indexOf("## Topics");
@@ -3617,12 +3682,12 @@ ${row}
 ${row}
 `;
   }
-  fs18.writeFileSync(indexPath, content, "utf8");
+  fs19.writeFileSync(indexPath, content, "utf8");
 }
 // src/commands/wiki-audit-status.ts
-import * as fs19 from "fs";
-import * as path20 from "path";
+import * as fs20 from "fs";
+import * as path21 from "path";
 import * as readline4 from "readline";
 var TERMINAL = /* @__PURE__ */ new Set(["Completed", "Done", "Abandoned", "Closed", "Resolved"]);
 async function wikiAuditStatusHandler(opts = {}) {
@@ -3635,8 +3700,8 @@ async function wikiAuditStatusHandler(opts = {}) {
   });
   const exit = opts.exit ?? ((c) => process.exit(c));
   const isTTY = opts.isTTY ?? Boolean(process.stdout.isTTY);
-  const deliveryRoot = path20.join(cwd, ".cleargate", "delivery");
-  if (!fs19.existsSync(deliveryRoot)) {
+  const deliveryRoot = path21.join(cwd, ".cleargate", "delivery");
+  if (!fs20.existsSync(deliveryRoot)) {
     stderr(`audit-status: .cleargate/delivery/ not found at ${deliveryRoot}
 `);
     exit(1);
@@ -3776,7 +3841,7 @@ async function wikiAuditStatusHandler(opts = {}) {
     }
   }
   for (const d of fixable) {
-    const rawText = fs19.readFileSync(d.absPath, "utf8");
+    const rawText = fs20.readFileSync(d.absPath, "utf8");
     const updated = applyStatusFix(rawText, d.suggestedStatus);
     if (!opts.quiet) {
       stdout(`--- ${d.rawPath}
@@ -3792,7 +3857,7 @@ async function wikiAuditStatusHandler(opts = {}) {
       stdout(`+${newLine}
 `);
     }
-    fs19.writeFileSync(d.absPath, updated, "utf8");
+    fs20.writeFileSync(d.absPath, updated, "utf8");
   }
   stdout(`audit-status: applied ${fixable.length} fix(es)
 `);
@@ -3820,8 +3885,8 @@ function applyStatusFix(rawText, newStatus) {
 }
 // src/commands/doctor.ts
-import * as fs20 from "fs";
-import * as path21 from "path";
+import * as fs21 from "fs";
+import * as path22 from "path";
 import { spawnSync as spawnSync6 } from "child_process";
 // src/lib/pricing.ts
@@ -3897,24 +3962,24 @@ function parseHookLogLine(line) {
   };
 }
 function runHookHealth(stdout, cwd, now, outcome) {
-  const cleargateDir = path21.join(cwd, ".cleargate");
-  if (!fs20.existsSync(cleargateDir)) {
+  const cleargateDir = path22.join(cwd, ".cleargate");
+  if (!fs21.existsSync(cleargateDir)) {
     stdout("cleargate misconfigured: no .cleargate/ found. Run: cleargate init");
     if (outcome) outcome.configError = true;
     return;
   }
-  const manifestPath = path21.join(cwd, "cleargate-planning", "MANIFEST.json");
-  if (!fs20.existsSync(manifestPath)) {
+  const manifestPath = path22.join(cwd, "cleargate-planning", "MANIFEST.json");
+  if (!fs21.existsSync(manifestPath)) {
     stdout(`cleargate misconfigured: cleargate-planning/MANIFEST.json not found. Run: cleargate init`);
     if (outcome) outcome.configError = true;
   }
-  const settingsPath = path21.join(cwd, ".claude", "settings.json");
-  if (!fs20.existsSync(settingsPath)) {
+  const settingsPath = path22.join(cwd, ".claude", "settings.json");
+  if (!fs21.existsSync(settingsPath)) {
     stdout("[doctor] No .claude/settings.json found \u2014 hook config unavailable.");
     return;
   }
   try {
-    const raw = fs20.readFileSync(settingsPath, "utf-8");
+    const raw = fs21.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(raw);
     const hasHooks = typeof settings === "object" && settings !== null && "hooks" in settings;
     if (hasHooks) {
@@ -3925,13 +3990,13 @@ function runHookHealth(stdout, cwd, now, outcome) {
   } catch {
     stdout("[doctor] .claude/settings.json is not valid JSON \u2014 cannot verify hook config.");
   }
-  const logPath = path21.join(cwd, ".cleargate", "hook-log", "gate-check.log");
-  if (!fs20.existsSync(logPath)) {
+  const logPath = path22.join(cwd, ".cleargate", "hook-log", "gate-check.log");
+  if (!fs21.existsSync(logPath)) {
     return;
   }
   let logContent;
   try {
-    logContent = fs20.readFileSync(logPath, "utf-8");
+    logContent = fs21.readFileSync(logPath, "utf-8");
   } catch {
     return;
   }
@@ -4045,8 +4110,8 @@ function parseCachedGateResult2(raw) {
   };
 }
 function emitResolverStatusLine(cwd, stdout) {
-  const distCliPath = path21.join(cwd, "cleargate-cli", "dist", "cli.js");
-  if (fs20.existsSync(distCliPath)) {
+  const distCliPath = path22.join(cwd, "cleargate-cli", "dist", "cli.js");
+  if (fs21.existsSync(distCliPath)) {
     stdout(`cleargate CLI: local dist \u2014 ${distCliPath}`);
     return;
   }
@@ -4060,10 +4125,10 @@ function emitResolverStatusLine(cwd, stdout) {
     return;
   }
   let pinVersion = "unknown";
-  const hookPath = path21.join(cwd, ".claude", "hooks", "stamp-and-gate.sh");
-  if (fs20.existsSync(hookPath)) {
+  const hookPath = path22.join(cwd, ".claude", "hooks", "stamp-and-gate.sh");
+  if (fs21.existsSync(hookPath)) {
     try {
-      const hookContent = fs20.readFileSync(hookPath, "utf-8");
+      const hookContent = fs21.readFileSync(hookPath, "utf-8");
       const pinMatch = hookContent.match(/^#\s*cleargate-pin:\s*(\S+)\s*$/m);
       if (pinMatch?.[1]) {
         pinVersion = pinMatch[1];
@@ -4095,10 +4160,10 @@ async function runSessionStart(cwd, stdout, outcome) {
   if (outcome && resolverLines.some((l) => l.includes("\u{1F534}"))) {
     outcome.configError = true;
   }
-  const pendingSyncDir = path21.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const pendingSyncDir = path22.join(cwd, ".cleargate", "delivery", "pending-sync");
   let files;
   try {
-    files = fs20.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path21.join(pendingSyncDir, f));
+    files = fs21.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path22.join(pendingSyncDir, f));
   } catch {
     return;
   }
@@ -4107,7 +4172,7 @@ async function runSessionStart(cwd, stdout, outcome) {
   for (const filePath of files) {
     let raw;
     try {
-      raw = fs20.readFileSync(filePath, "utf-8");
+      raw = fs21.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -4133,13 +4198,13 @@ async function runSessionStart(cwd, stdout, outcome) {
       }
     }
     if (!itemId) {
-      itemId = path21.basename(filePath, ".md");
+      itemId = path22.basename(filePath, ".md");
     }
     const firstCriterionId = gate2.failing_criteria.length > 0 ? gate2.failing_criteria[0]?.id ?? "" : "";
     blocked.push({ id: itemId, firstCriterionId });
   }
-  const activesentinel = path21.join(cwd, ".cleargate", "sprint-runs", ".active");
-  const sprintActive = fs20.existsSync(activesentinel);
+  const activesentinel = path22.join(cwd, ".cleargate", "sprint-runs", ".active");
+  const sprintActive = fs21.existsSync(activesentinel);
   const shouldRemind = !hasApprovedStory && !sprintActive;
   if (shouldRemind) {
     stdout(PLANNING_FIRST_REMINDER);
@@ -4174,10 +4239,10 @@ async function runPricing(filePath, cwd, stdout, stderr, exit, outcome) {
     exit(2);
     return;
   }
-  const absPath = path21.isAbsolute(filePath) ? filePath : path21.resolve(cwd, filePath);
+  const absPath = path22.isAbsolute(filePath) ? filePath : path22.resolve(cwd, filePath);
   let raw;
   try {
-    raw = fs20.readFileSync(absPath, "utf-8");
+    raw = fs21.readFileSync(absPath, "utf-8");
   } catch {
     stderr(`cleargate doctor --pricing: cannot read file: ${absPath}`);
     if (outcome) outcome.configError = true;
@@ -4239,7 +4304,7 @@ async function runPricing(filePath, cwd, stdout, stderr, exit, outcome) {
   const output = draftTokens.output ?? 0;
   const cacheRead = draftTokens.cache_read ?? 0;
   const cacheCreation = draftTokens.cache_creation ?? 0;
-  const fileName = path21.basename(absPath);
+  const fileName = path22.basename(absPath);
   stdout(
     `${fileName}: ${model} \u2014 input:${input} output:${output} cache_read:${cacheRead} cache_creation:${cacheCreation} \u2248 $${usd.toFixed(4)}`
   );
@@ -4252,15 +4317,15 @@ function globMatch(pattern, filePath) {
   return re.test(normalFile);
 }
 async function runCanEdit(filePath, cwd, stdout, exit, outcome) {
-  const activeSentinel = path21.join(cwd, ".cleargate", "sprint-runs", ".active");
-  if (fs20.existsSync(activeSentinel)) {
+  const activeSentinel = path22.join(cwd, ".cleargate", "sprint-runs", ".active");
+  if (fs21.existsSync(activeSentinel)) {
     stdout("allowed: sprint active");
     return;
   }
-  const pendingSyncDir = path21.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const pendingSyncDir = path22.join(cwd, ".cleargate", "delivery", "pending-sync");
   let files;
   try {
-    files = fs20.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path21.join(pendingSyncDir, f));
+    files = fs21.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path22.join(pendingSyncDir, f));
   } catch {
     stdout("blocked: no_approved_stories");
     if (outcome) outcome.blocker = true;
@@ -4272,7 +4337,7 @@ async function runCanEdit(filePath, cwd, stdout, exit, outcome) {
   for (const storyPath of files) {
     let raw;
     try {
-      raw = fs20.readFileSync(storyPath, "utf-8");
+      raw = fs21.readFileSync(storyPath, "utf-8");
     } catch {
       continue;
     }
@@ -4369,13 +4434,13 @@ async function doctorHandler(flags, cli) {
 }
 // src/commands/gate.ts
-import * as fs24 from "fs";
-import * as path24 from "path";
+import * as fs25 from "fs";
+import * as path25 from "path";
 import { spawnSync as spawnSync7 } from "child_process";
 // src/commands/execution-mode.ts
-import * as fs21 from "fs";
-import * as path22 from "path";
+import * as fs22 from "fs";
+import * as path23 from "path";
 var V1_INERT_MESSAGE = "v1 mode active \u2014 command inert. Set execution_mode: v2 in sprint frontmatter to enable.";
 function parseFrontmatterSimple(raw) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
@@ -4393,24 +4458,24 @@ function parseFrontmatterSimple(raw) {
 }
 function discoverSprintFile(sprintId, cwd) {
   const searchDirs = [
-    path22.join(cwd, ".cleargate", "delivery", "pending-sync"),
-    path22.join(cwd, ".cleargate", "delivery", "archive")
+    path23.join(cwd, ".cleargate", "delivery", "pending-sync"),
+    path23.join(cwd, ".cleargate", "delivery", "archive")
   ];
   for (const dir of searchDirs) {
-    if (!fs21.existsSync(dir)) continue;
+    if (!fs22.existsSync(dir)) continue;
     let entries;
     try {
-      entries = fs21.readdirSync(dir);
+      entries = fs22.readdirSync(dir);
     } catch {
       continue;
     }
     const prefix = `${sprintId}_`;
     for (const entry of entries) {
       if (entry.startsWith(prefix) && entry.endsWith(".md")) {
-        return path22.join(dir, entry);
+        return path23.join(dir, entry);
       }
       if (entry === `${sprintId}.md`) {
-        return path22.join(dir, entry);
+        return path23.join(dir, entry);
       }
     }
   }
@@ -4418,9 +4483,9 @@ function discoverSprintFile(sprintId, cwd) {
 }
 function resolveSprintIdFromSentinel(cwd) {
   const resolvedCwd = cwd ?? process.cwd();
-  const sentinelPath = path22.join(resolvedCwd, ".cleargate", "sprint-runs", ".active");
+  const sentinelPath = path23.join(resolvedCwd, ".cleargate", "sprint-runs", ".active");
   try {
-    const content = fs21.readFileSync(sentinelPath, "utf8").trim();
+    const content = fs22.readFileSync(sentinelPath, "utf8").trim();
     return content.length > 0 ? content : null;
   } catch {
     return null;
@@ -4439,12 +4504,12 @@ function readSprintExecutionMode(sprintId, opts = {}) {
   if (!filePath) {
     filePath = discoverSprintFile(resolvedSprintId, cwd);
   }
-  if (!filePath || !fs21.existsSync(filePath)) {
+  if (!filePath || !fs22.existsSync(filePath)) {
     return "v1";
   }
   let raw;
   try {
-    raw = fs21.readFileSync(filePath, "utf8");
+    raw = fs22.readFileSync(filePath, "utf8");
   } catch {
     return "v1";
   }
@@ -4462,8 +4527,8 @@ function printInertAndExit(stdoutFn, exitFn) {
 import yaml6 from "js-yaml";
 // src/lib/readiness-predicates.ts
-import * as fs22 from "fs";
-import * as path23 from "path";
+import * as fs23 from "fs";
+import * as path24 from "path";
 function parsePredicate(src) {
   const s = src.trim();
   const fmMatch = s.match(
@@ -4627,18 +4692,18 @@ function compareValues(actual, op, expected) {
 }
 function resolveLinkedPath(ref, docAbsPath, projectRoot) {
   const candidates = [
-    path23.resolve(path23.dirname(docAbsPath), ref),
-    path23.resolve(projectRoot, ref)
+    path24.resolve(path24.dirname(docAbsPath), ref),
+    path24.resolve(projectRoot, ref)
   ];
   for (const candidate of candidates) {
     if (!candidate.startsWith(projectRoot)) continue;
-    if (fs22.existsSync(candidate)) return candidate;
+    if (fs23.existsSync(candidate)) return candidate;
   }
   return null;
 }
 function readFrontmatterFromFile(absPath) {
   try {
-    const raw = fs22.readFileSync(absPath, "utf8");
+    const raw = fs23.readFileSync(absPath, "utf8");
     const lines = raw.split("\n");
     if (lines[0] !== "---") return {};
     let closeIdx = -1;
@@ -4782,14 +4847,14 @@ function applyCountOp(actual, op, n) {
   }
 }
 function evalFileExists(parsed, projectRoot) {
-  const resolved = path23.resolve(projectRoot, parsed.path);
-  if (!resolved.startsWith(projectRoot + path23.sep) && resolved !== projectRoot) {
+  const resolved = path24.resolve(projectRoot, parsed.path);
+  if (!resolved.startsWith(projectRoot + path24.sep) && resolved !== projectRoot) {
     return {
       pass: false,
       detail: `path '${parsed.path}' resolves outside project root (sandbox violation)`
     };
   }
-  const exists = fs22.existsSync(resolved);
+  const exists = fs23.existsSync(resolved);
   return {
     pass: exists,
     detail: exists ? `${parsed.path} exists` : `${parsed.path} not found`
@@ -4797,13 +4862,13 @@ function evalFileExists(parsed, projectRoot) {
 }
 function evalLinkTargetExists(parsed, opts) {
   const projectRoot = opts?.projectRoot ?? process.cwd();
-  const wikiIndexPath = opts?.wikiIndexPath ?? path23.join(projectRoot, ".cleargate", "wiki", "index.md");
+  const wikiIndexPath = opts?.wikiIndexPath ?? path24.join(projectRoot, ".cleargate", "wiki", "index.md");
   if (!wikiIndexPath.startsWith(projectRoot)) {
     return { pass: false, detail: "wikiIndexPath resolves outside project root" };
   }
   let indexContent;
   try {
-    indexContent = fs22.readFileSync(wikiIndexPath, "utf8");
+    indexContent = fs23.readFileSync(wikiIndexPath, "utf8");
   } catch {
     return { pass: false, detail: `wiki index not found at ${wikiIndexPath}` };
   }
@@ -4814,13 +4879,13 @@ function evalLinkTargetExists(parsed, opts) {
   };
 }
 function evalStatusOf(parsed, opts, projectRoot) {
-  const wikiIndexPath = opts?.wikiIndexPath ?? path23.join(projectRoot, ".cleargate", "wiki", "index.md");
+  const wikiIndexPath = opts?.wikiIndexPath ?? path24.join(projectRoot, ".cleargate", "wiki", "index.md");
   if (!wikiIndexPath.startsWith(projectRoot)) {
     return { pass: false, detail: "wikiIndexPath resolves outside project root" };
   }
   let indexContent;
   try {
-    indexContent = fs22.readFileSync(wikiIndexPath, "utf8");
+    indexContent = fs23.readFileSync(wikiIndexPath, "utf8");
   } catch {
     return { pass: false, detail: `wiki index not found at ${wikiIndexPath}` };
   }
@@ -4831,7 +4896,7 @@ function evalStatusOf(parsed, opts, projectRoot) {
     return { pass: false, detail: `[[${parsed.id}]] not found in wiki index` };
   }
   const rawPath = rowMatch[1].trim();
-  const fullPath = path23.resolve(projectRoot, rawPath);
+  const fullPath = path24.resolve(projectRoot, rawPath);
   if (!fullPath.startsWith(projectRoot)) {
     return { pass: false, detail: `wiki path for ${parsed.id} resolves outside project root` };
   }
@@ -4848,12 +4913,12 @@ function evalStatusOf(parsed, opts, projectRoot) {
 }
 // src/lib/frontmatter-cache.ts
-import * as fs23 from "fs/promises";
+import * as fs24 from "fs/promises";
 import yaml5 from "js-yaml";
 async function readCachedGate(absPath) {
   let raw;
   try {
-    raw = await fs23.readFile(absPath, "utf8");
+    raw = await fs24.readFile(absPath, "utf8");
   } catch {
     return null;
   }
@@ -4873,7 +4938,7 @@ async function writeCachedGate(absPath, result, opts) {
     failing_criteria: result.failing_criteria,
     last_gate_check: lastGateCheck
   };
-  const raw = await fs23.readFile(absPath, "utf8");
+  const raw = await fs24.readFile(absPath, "utf8");
   let fm;
   let body;
   try {
@@ -4903,7 +4968,7 @@ async function writeCachedGate(absPath, result, opts) {
 ${body}` : `${fmBlock}
 `;
-  await fs23.writeFile(absPath, newContent, "utf8");
+  await fs24.writeFile(absPath, newContent, "utf8");
 }
 function coerceCachedGate(val) {
   if (val === void 0 || val === null) return null;
@@ -4934,7 +4999,7 @@ function coerceCachedGate(val) {
 // src/commands/gate.ts
 function loadGateBlocks(gatesDocPath) {
-  const raw = fs24.readFileSync(gatesDocPath, "utf8");
+  const raw = fs25.readFileSync(gatesDocPath, "utf8");
   const blocks = [];
   const fenceRe = /^```yaml\n([\s\S]*?)^```/gm;
   let match;
@@ -4969,14 +5034,14 @@ async function gateCheckHandler(file, opts, cli) {
   const exitFn = cli?.exit ?? ((code) => process.exit(code));
   const cwd = cli?.cwd ?? process.cwd();
   const nowFn = cli?.now ?? (() => /* @__PURE__ */ new Date());
-  const absPath = path24.isAbsolute(file) ? file : path24.resolve(cwd, file);
-  if (!fs24.existsSync(absPath)) {
+  const absPath = path25.isAbsolute(file) ? file : path25.resolve(cwd, file);
+  if (!fs25.existsSync(absPath)) {
     stderrFn(`[cleargate gate] error: file not found: ${absPath}`);
     return exitFn(1);
   }
   let raw;
   try {
-    raw = fs24.readFileSync(absPath, "utf8");
+    raw = fs25.readFileSync(absPath, "utf8");
   } catch (err) {
     stderrFn(`[cleargate gate] error: cannot read file: ${absPath}`);
     return exitFn(1);
@@ -4995,8 +5060,8 @@ async function gateCheckHandler(file, opts, cli) {
     return exitFn(1);
   }
   const projectRoot = cwd;
-  const gatesDocPath = cli?.gatesDocPath ?? path24.join(projectRoot, ".cleargate", "knowledge", "readiness-gates.md");
-  if (!fs24.existsSync(gatesDocPath)) {
+  const gatesDocPath = cli?.gatesDocPath ?? path25.join(projectRoot, ".cleargate", "knowledge", "readiness-gates.md");
+  if (!fs25.existsSync(gatesDocPath)) {
     stderrFn(`[cleargate gate] error: readiness-gates.md not found at: ${gatesDocPath}`);
     return exitFn(1);
   }
@@ -5069,8 +5134,8 @@ async function gateExplainHandler(file, cli) {
   const stderrFn = cli?.stderr ?? ((s) => process.stderr.write(s + "\n"));
   const exitFn = cli?.exit ?? ((code) => process.exit(code));
   const cwd = cli?.cwd ?? process.cwd();
-  const absPath = path24.isAbsolute(file) ? file : path24.resolve(cwd, file);
-  if (!fs24.existsSync(absPath)) {
+  const absPath = path25.isAbsolute(file) ? file : path25.resolve(cwd, file);
+  if (!fs25.existsSync(absPath)) {
     stderrFn(`[cleargate gate] error: file not found: ${absPath}`);
     return exitFn(1);
   }
@@ -5081,7 +5146,7 @@ async function gateExplainHandler(file, cli) {
   }
   let raw;
   try {
-    raw = fs24.readFileSync(absPath, "utf8");
+    raw = fs25.readFileSync(absPath, "utf8");
   } catch {
     stderrFn(`[cleargate gate] error: cannot read file: ${absPath}`);
     return exitFn(1);
@@ -5102,7 +5167,7 @@ async function gateExplainHandler(file, cli) {
 function resolveRunScriptForGate(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path24.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path25.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function gateQaHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -5194,15 +5259,15 @@ function gateRunHandler(name, opts, cli) {
 }
 // src/commands/sprint.ts
-import * as fs25 from "fs";
-import * as path25 from "path";
+import * as fs26 from "fs";
+import * as path26 from "path";
 import { spawnSync as spawnSync9 } from "child_process";
 import yaml7 from "js-yaml";
 var TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["Completed", "Done", "Abandoned", "Closed", "Resolved"]);
 function resolveRunScript(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path25.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path26.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function defaultExit(code) {
   return process.exit(code);
@@ -5296,8 +5361,8 @@ ${body}`;
 }
 function atomicWriteStr(filePath, content) {
   const tmp = `${filePath}.tmp.${process.pid}`;
-  fs25.writeFileSync(tmp, content, "utf8");
-  fs25.renameSync(tmp, filePath);
+  fs26.writeFileSync(tmp, content, "utf8");
+  fs26.renameSync(tmp, filePath);
 }
 function deriveSprintBranchForArchive(sprintId) {
   const match = /^SPRINT-(\d+)/.exec(sprintId);
@@ -5311,7 +5376,7 @@ function stampFile(raw, status, completedAt) {
   return serializeFileContent(fm, body);
 }
 function stampSprintClose(sprintPath, now) {
-  const previousContent = fs25.readFileSync(sprintPath, "utf8");
+  const previousContent = fs26.readFileSync(sprintPath, "utf8");
   const { fm, body } = parseFileFrontmatter(previousContent);
   const currentStatus = typeof fm["status"] === "string" ? fm["status"] : "";
   const alreadyTerminal = TERMINAL_STATUSES2.has(currentStatus);
@@ -5371,14 +5436,14 @@ async function sprintArchiveHandler(opts, cli) {
     if (mode === "v1") {
       return printInertAndExit(stdoutFn, exitFn);
     }
-    const stateFile = path25.join(cwd, ".cleargate", "sprint-runs", opts.sprintId, "state.json");
-    if (!fs25.existsSync(stateFile)) {
+    const stateFile = path26.join(cwd, ".cleargate", "sprint-runs", opts.sprintId, "state.json");
+    if (!fs26.existsSync(stateFile)) {
       stderrFn(`[cleargate sprint archive] state.json not found at ${stateFile}`);
       return exitFn(1);
     }
     let state2;
     try {
-      state2 = JSON.parse(fs25.readFileSync(stateFile, "utf8"));
+      state2 = JSON.parse(fs26.readFileSync(stateFile, "utf8"));
     } catch (err) {
       stderrFn(`[cleargate sprint archive] failed to parse state.json: ${err.message}`);
       return exitFn(1);
@@ -5390,18 +5455,18 @@ async function sprintArchiveHandler(opts, cli) {
       return exitFn(1);
     }
     const stateStories = state2.stories ?? {};
-    const pendingDir = path25.join(cwd, ".cleargate", "delivery", "pending-sync");
-    const archiveDir = path25.join(cwd, ".cleargate", "delivery", "archive");
+    const pendingDir = path26.join(cwd, ".cleargate", "delivery", "pending-sync");
+    const archiveDir = path26.join(cwd, ".cleargate", "delivery", "archive");
     let sprintFile = null;
-    for (const entry of fs25.readdirSync(pendingDir)) {
+    for (const entry of fs26.readdirSync(pendingDir)) {
       if ((entry.startsWith(`${opts.sprintId}_`) || entry === `${opts.sprintId}.md`) && entry.endsWith(".md")) {
-        sprintFile = path25.join(pendingDir, entry);
+        sprintFile = path26.join(pendingDir, entry);
         break;
       }
     }
     let epicIds = [];
-    if (sprintFile && fs25.existsSync(sprintFile)) {
-      const { fm } = parseFileFrontmatter(fs25.readFileSync(sprintFile, "utf8"));
+    if (sprintFile && fs26.existsSync(sprintFile)) {
+      const { fm } = parseFileFrontmatter(fs26.readFileSync(sprintFile, "utf8"));
       const epics = fm["epics"];
       if (Array.isArray(epics)) {
         epicIds = epics.map(String);
@@ -5411,15 +5476,15 @@ async function sprintArchiveHandler(opts, cli) {
     if (sprintFile) {
       plan.push({
         src: sprintFile,
-        destName: path25.basename(sprintFile),
+        destName: path26.basename(sprintFile),
         status: "Completed"
       });
     }
     for (const epicId of epicIds) {
-      for (const entry of fs25.readdirSync(pendingDir)) {
+      for (const entry of fs26.readdirSync(pendingDir)) {
         if ((entry.startsWith(`${epicId}_`) || entry === `${epicId}.md`) && entry.endsWith(".md")) {
           plan.push({
-            src: path25.join(pendingDir, entry),
+            src: path26.join(pendingDir, entry),
             destName: entry,
             status: "Approved"
           });
@@ -5428,10 +5493,10 @@ async function sprintArchiveHandler(opts, cli) {
       }
       const storyKeys = storyKeysForEpic(stateStories, epicId);
       for (const storyId of storyKeys) {
-        for (const entry of fs25.readdirSync(pendingDir)) {
+        for (const entry of fs26.readdirSync(pendingDir)) {
           if ((entry.startsWith(`${storyId}_`) || entry === `${storyId}.md`) && entry.endsWith(".md")) {
             plan.push({
-              src: path25.join(pendingDir, entry),
+              src: path26.join(pendingDir, entry),
               destName: entry,
               status: "Done"
             });
@@ -5443,13 +5508,13 @@ async function sprintArchiveHandler(opts, cli) {
     const storyIdsInState = new Set(Object.keys(stateStories));
     const planSrcs = new Set(plan.map((p) => p.src));
     const orphans = [];
-    for (const entry of fs25.readdirSync(pendingDir)) {
+    for (const entry of fs26.readdirSync(pendingDir)) {
       if (!entry.startsWith("STORY-") || !entry.endsWith(".md")) continue;
-      const candidate = path25.join(pendingDir, entry);
+      const candidate = path26.join(pendingDir, entry);
       if (planSrcs.has(candidate)) continue;
       let raw;
       try {
-        raw = fs25.readFileSync(candidate, "utf8");
+        raw = fs26.readFileSync(candidate, "utf8");
       } catch {
         continue;
       }
@@ -5466,18 +5531,18 @@ async function sprintArchiveHandler(opts, cli) {
     }
     const completedAt = (/* @__PURE__ */ new Date()).toISOString();
     const sprintBranch = deriveSprintBranchForArchive(opts.sprintId);
-    const activePath = path25.join(cwd, ".cleargate", "sprint-runs", ".active");
+    const activePath = path26.join(cwd, ".cleargate", "sprint-runs", ".active");
     if (opts.dryRun) {
       stdoutFn(`[dry-run] Sprint archive plan for ${opts.sprintId}:`);
       stdoutFn(`  Sprint branch: ${sprintBranch}`);
       stdoutFn(`  Files to archive (${plan.length}):`);
       for (const entry of plan) {
         stdoutFn(
-          `    ${path25.basename(entry.src)} \u2192 archive/${entry.destName}  [stamp: status=${entry.status}, completed_at=<now>]`
+          `    ${path26.basename(entry.src)} \u2192 archive/${entry.destName}  [stamp: status=${entry.status}, completed_at=<now>]`
         );
       }
       if (orphans.length > 0) {
-        stdoutFn(`  Orphan files (${orphans.length}): ${orphans.map((o) => path25.basename(o)).join(", ")}`);
+        stdoutFn(`  Orphan files (${orphans.length}): ${orphans.map((o) => path26.basename(o)).join(", ")}`);
       }
       stdoutFn(`  .active \u2192 "" (truncate)`);
       stdoutFn(`  git checkout main`);
@@ -5486,9 +5551,9 @@ async function sprintArchiveHandler(opts, cli) {
       return exitFn(0);
     }
     let sprintFileSnapshot = null;
-    const wikiRoot = path25.join(cwd, ".cleargate", "wiki");
-    const wikiInitialised = fs25.existsSync(wikiRoot);
-    if (sprintFile && fs25.existsSync(sprintFile)) {
+    const wikiRoot = path26.join(cwd, ".cleargate", "wiki");
+    const wikiInitialised = fs26.existsSync(wikiRoot);
+    if (sprintFile && fs26.existsSync(sprintFile)) {
       const { previousContent } = stampSprintClose(sprintFile, () => completedAt);
       sprintFileSnapshot = previousContent;
       if (wikiInitialised) {
@@ -5510,15 +5575,15 @@ async function sprintArchiveHandler(opts, cli) {
       }
     }
     for (const entry of plan) {
-      if (!fs25.existsSync(entry.src)) {
+      if (!fs26.existsSync(entry.src)) {
         stderrFn(`[cleargate sprint archive] source not found: ${entry.src} \u2014 skipping`);
         continue;
       }
-      const raw = fs25.readFileSync(entry.src, "utf8");
+      const raw = fs26.readFileSync(entry.src, "utf8");
       const stamped = stampFile(raw, entry.status, completedAt);
-      const dest = path25.join(archiveDir, entry.destName);
+      const dest = path26.join(archiveDir, entry.destName);
       atomicWriteStr(entry.src, stamped);
-      fs25.renameSync(entry.src, dest);
+      fs26.renameSync(entry.src, dest);
       stdoutFn(`archived: ${entry.destName}`);
     }
     try {
@@ -5560,8 +5625,8 @@ async function sprintArchiveHandler(opts, cli) {
 }
 // src/commands/story.ts
-import * as fs26 from "fs";
-import * as path26 from "path";
+import * as fs27 from "fs";
+import * as path27 from "path";
 import { spawnSync as spawnSync10 } from "child_process";
 function defaultExit2(code) {
   return process.exit(code);
@@ -5569,7 +5634,7 @@ function defaultExit2(code) {
 function resolveRunScript2(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path26.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path27.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function deriveSprintBranch(sprintId) {
   const match = /^SPRINT-(\d+)/.exec(sprintId);
@@ -5578,11 +5643,11 @@ function deriveSprintBranch(sprintId) {
 }
 function atomicWriteString(filePath, text) {
   const tmpFile = `${filePath}.tmp.${process.pid}`;
-  fs26.writeFileSync(tmpFile, text, "utf8");
-  fs26.renameSync(tmpFile, filePath);
+  fs27.writeFileSync(tmpFile, text, "utf8");
+  fs27.renameSync(tmpFile, filePath);
 }
 function stateJsonPath(cwd, sprintId) {
-  return path26.join(cwd, ".cleargate", "sprint-runs", sprintId, "state.json");
+  return path27.join(cwd, ".cleargate", "sprint-runs", sprintId, "state.json");
 }
 function storyStartHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -5599,7 +5664,7 @@ function storyStartHandler(opts, cli) {
     return printInertAndExit(stdoutFn, exitFn);
   }
   const sprintBranch = deriveSprintBranch(sprintId);
-  const worktreePath = path26.join(cwd, ".worktrees", opts.storyId);
+  const worktreePath = path27.join(cwd, ".worktrees", opts.storyId);
   const storyBranch = `story/${opts.storyId}`;
   const step1 = spawnFn(
     "git",
@@ -5631,13 +5696,13 @@ function storyStartHandler(opts, cli) {
     return exitFn(step2.status ?? 1);
   }
   const stateFile = stateJsonPath(cwd, sprintId);
-  if (!fs26.existsSync(stateFile)) {
+  if (!fs27.existsSync(stateFile)) {
     stderrFn(`[cleargate story start] step 3: state.json not found at ${stateFile}`);
     return exitFn(1);
   }
   let state2;
   try {
-    state2 = JSON.parse(fs26.readFileSync(stateFile, "utf8"));
+    state2 = JSON.parse(fs27.readFileSync(stateFile, "utf8"));
   } catch (err) {
     stderrFn(`[cleargate story start] step 3: failed to parse state.json: ${err.message}`);
     return exitFn(1);
@@ -5678,7 +5743,7 @@ function storyCompleteHandler(opts, cli) {
   }
   const sprintBranch = deriveSprintBranch(sprintId);
   const storyBranch = `story/${opts.storyId}`;
-  const worktreeRel = path26.join(".worktrees", opts.storyId);
+  const worktreeRel = path27.join(".worktrees", opts.storyId);
   const step1 = spawnFn(
     "git",
     ["rev-list", "--count", `${sprintBranch}..${storyBranch}`],
@@ -5775,7 +5840,7 @@ function storyCompleteHandler(opts, cli) {
 }
 // src/commands/state.ts
-import * as path27 from "path";
+import * as path28 from "path";
 import { spawnSync as spawnSync11 } from "child_process";
 function defaultExit3(code) {
   return process.exit(code);
@@ -5783,7 +5848,7 @@ function defaultExit3(code) {
 function resolveRunScript3(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path27.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path28.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function stateUpdateHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -5839,20 +5904,20 @@ function stateValidateHandler(opts, cli) {
 }
 // src/commands/stamp-tokens.ts
-import * as fs28 from "fs";
-import * as path29 from "path";
+import * as fs29 from "fs";
+import * as path30 from "path";
 // src/lib/ledger-reader.ts
-import * as fs27 from "fs";
-import * as path28 from "path";
+import * as fs28 from "fs";
+import * as path29 from "path";
 function findSprintRunsRoot(startDir) {
   let dir = startDir;
   while (true) {
-    const candidate = path28.join(dir, ".cleargate", "sprint-runs");
-    if (fs27.existsSync(candidate)) {
+    const candidate = path29.join(dir, ".cleargate", "sprint-runs");
+    if (fs28.existsSync(candidate)) {
       return candidate;
     }
-    const parent = path28.dirname(dir);
+    const parent = path29.dirname(dir);
     if (parent === dir) {
       return null;
     }
@@ -5905,13 +5970,13 @@ function readLedgerForWorkItem(workItemId, opts = {}) {
     }
     sprintRunsRoot = found;
   }
-  if (!fs27.existsSync(sprintRunsRoot)) {
+  if (!fs28.existsSync(sprintRunsRoot)) {
     return [];
   }
   let ledgerFiles;
   try {
-    const entries = fs27.readdirSync(sprintRunsRoot, { withFileTypes: true });
-    ledgerFiles = entries.filter((e) => e.isDirectory()).map((e) => path28.join(sprintRunsRoot, e.name, "token-ledger.jsonl")).filter((f) => fs27.existsSync(f));
+    const entries = fs28.readdirSync(sprintRunsRoot, { withFileTypes: true });
+    ledgerFiles = entries.filter((e) => e.isDirectory()).map((e) => path29.join(sprintRunsRoot, e.name, "token-ledger.jsonl")).filter((f) => fs28.existsSync(f));
   } catch {
     return [];
   }
@@ -5919,7 +5984,7 @@ function readLedgerForWorkItem(workItemId, opts = {}) {
   for (const ledgerFile of ledgerFiles) {
     let content;
     try {
-      content = fs27.readFileSync(ledgerFile, "utf-8");
+      content = fs28.readFileSync(ledgerFile, "utf-8");
     } catch {
       continue;
     }
@@ -5970,7 +6035,7 @@ async function stampTokensHandler(file, opts, cli) {
   });
   const nowFn = cli?.now ?? (() => /* @__PURE__ */ new Date());
   const cwd = cli?.cwd ?? process.cwd();
-  const absPath = path29.isAbsolute(file) ? file : path29.resolve(cwd, file);
+  const absPath = path30.isAbsolute(file) ? file : path30.resolve(cwd, file);
   if (/\/\.cleargate\/delivery\/archive\//.test(absPath)) {
     stdoutFn(`[frozen] ${absPath}`);
     exitFn(0);
@@ -5978,7 +6043,7 @@ async function stampTokensHandler(file, opts, cli) {
   }
   let rawContent;
   try {
-    rawContent = fs28.readFileSync(absPath, "utf-8");
+    rawContent = fs29.readFileSync(absPath, "utf-8");
   } catch {
     stdoutFn(`[stamp-tokens] error: cannot read file: ${absPath}`);
     exitFn(1);
@@ -6050,7 +6115,7 @@ async function stampTokensHandler(file, opts, cli) {
     return;
   }
   try {
-    fs28.writeFileSync(absPath, serialized, "utf-8");
+    fs29.writeFileSync(absPath, serialized, "utf-8");
   } catch {
     stdoutFn(`[stamp-tokens] error: cannot write file: ${absPath}`);
     exitFn(1);
@@ -6067,7 +6132,7 @@ function extractWorkItemId(fm, absPath) {
       return val.trim();
     }
   }
-  const basename12 = path29.basename(absPath);
+  const basename12 = path30.basename(absPath);
   const match = basename12.match(/^(STORY|EPIC|PROPOSAL|CR|BUG)-\d+(-\d+)?/i);
   if (match) {
     return match[0].toUpperCase();
@@ -6172,7 +6237,7 @@ ${body}`;
 // src/commands/upgrade.ts
 import * as fsp from "fs/promises";
-import * as path30 from "path";
+import * as path31 from "path";
 // src/lib/claude-md-surgery.ts
 var CLEARGATE_START = "<!-- CLEARGATE:START -->";
@@ -6318,7 +6383,7 @@ async function writeAtomic2(filePath, content) {
   await fsp.rename(tmpPath, filePath);
 }
 async function updateSnapshotEntry(projectRoot, filePath, newSha) {
-  const snapshotPath = path30.join(projectRoot, ".cleargate", ".install-manifest.json");
+  const snapshotPath = path31.join(projectRoot, ".cleargate", ".install-manifest.json");
   let snapshot;
   try {
     const raw = await fsp.readFile(snapshotPath, "utf-8");
@@ -6335,17 +6400,17 @@ async function updateSnapshotEntry(projectRoot, filePath, newSha) {
   await writeAtomic2(snapshotPath, JSON.stringify(updated, null, 2) + "\n");
 }
 function isClaudeMd(filePath) {
-  return path30.basename(filePath) === "CLAUDE.md";
+  return path31.basename(filePath) === "CLAUDE.md";
 }
 function isSettingsJson(filePath) {
-  return path30.basename(filePath) === "settings.json" && filePath.includes(".claude");
+  return path31.basename(filePath) === "settings.json" && filePath.includes(".claude");
 }
 async function applyAlwaysOverwrite(entry, projectRoot, packageRoot, stdout) {
-  const targetPath = path30.join(projectRoot, entry.path);
-  const sourcePath = path30.join(packageRoot, entry.path);
+  const targetPath = path31.join(projectRoot, entry.path);
+  const sourcePath = path31.join(packageRoot, entry.path);
   try {
     const pkgContent = await fsp.readFile(sourcePath, "utf-8");
-    await fsp.mkdir(path30.dirname(targetPath), { recursive: true });
+    await fsp.mkdir(path31.dirname(targetPath), { recursive: true });
     await writeAtomic2(targetPath, pkgContent);
     await updateSnapshotEntry(projectRoot, entry.path, entry.sha256);
     stdout(`[always] overwritten: ${entry.path}`);
@@ -6355,8 +6420,8 @@ async function applyAlwaysOverwrite(entry, projectRoot, packageRoot, stdout) {
 }
 async function applyMerge3Way(entry, projectRoot, packageRoot, installSha, currentSha, flags, opts) {
   const { stdout, stderr, promptMergeChoiceFn, openInEditorFn, stdin } = opts;
-  const targetPath = path30.join(projectRoot, entry.path);
-  const sourcePath = path30.join(packageRoot, entry.path);
+  const targetPath = path31.join(projectRoot, entry.path);
+  const sourcePath = path31.join(packageRoot, entry.path);
   let ours = "";
   let theirs = "";
   try {
@@ -6419,7 +6484,7 @@ async function applyMerge3Way(entry, projectRoot, packageRoot, installSha, curre
         mergedContent = theirs;
       }
     }
-    await fsp.mkdir(path30.dirname(targetPath), { recursive: true });
+    await fsp.mkdir(path31.dirname(targetPath), { recursive: true });
     await writeAtomic2(targetPath, mergedContent);
     const newSha2 = hashNormalized(mergedContent);
     await updateSnapshotEntry(projectRoot, entry.path, newSha2);
@@ -6431,7 +6496,7 @@ async function applyMerge3Way(entry, projectRoot, packageRoot, installSha, curre
 ${ours}=======
 ${theirs}>>>>>>> theirs (upstream)
 `;
-  await fsp.mkdir(path30.dirname(mergeFilePath), { recursive: true });
+  await fsp.mkdir(path31.dirname(mergeFilePath), { recursive: true });
   await writeAtomic2(mergeFilePath, conflictContent);
   try {
     const result = await openInEditorFn(mergeFilePath);
@@ -6565,9 +6630,9 @@ async function upgradeHandler(flags, cli) {
 }
 // src/commands/uninstall.ts
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 import * as fsp2 from "fs/promises";
-import * as path31 from "path";
+import * as path32 from "path";
 import { execSync as execSync2 } from "child_process";
 var USER_ARTIFACT_TIERS = ["user-artifact"];
 var FRAMEWORK_TIERS = ["protocol", "template", "agent", "hook", "skill", "cli-config", "derived"];
@@ -6593,10 +6658,10 @@ function shouldPreserve(entry, preserveSet, removeSet) {
   return false;
 }
 function resolveProjectName(target) {
-  const pkgPath = path31.join(target, "package.json");
-  if (fs29.existsSync(pkgPath)) {
+  const pkgPath = path32.join(target, "package.json");
+  if (fs30.existsSync(pkgPath)) {
     try {
-      const raw = fs29.readFileSync(pkgPath, "utf-8");
+      const raw = fs30.readFileSync(pkgPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.name && typeof parsed.name === "string") {
         return parsed.name;
@@ -6604,7 +6669,7 @@ function resolveProjectName(target) {
     } catch {
     }
   }
-  return path31.basename(target);
+  return path32.basename(target);
 }
 function detectUncommittedChanges(target, manifestPaths, gitRunner) {
   const run = gitRunner ?? ((args) => {
@@ -6633,8 +6698,8 @@ function detectUncommittedChanges(target, manifestPaths, gitRunner) {
   return changedFiles.filter((f) => manifestSet.has(f));
 }
 async function removeFromPackageJson(target, dryRun) {
-  const pkgPath = path31.join(target, "package.json");
-  if (!fs29.existsSync(pkgPath)) return false;
+  const pkgPath = path32.join(target, "package.json");
+  if (!fs30.existsSync(pkgPath)) return false;
   let raw;
   try {
     raw = await fsp2.readFile(pkgPath, "utf-8");
@@ -6675,7 +6740,7 @@ async function removeFile(filePath) {
 }
 async function removeDir(dirPath) {
   try {
-    fs29.rmSync(dirPath, { recursive: true, force: true });
+    fs30.rmSync(dirPath, { recursive: true, force: true });
   } catch {
   }
 }
@@ -6695,12 +6760,12 @@ async function uninstallHandler(opts) {
     for (const t of FRAMEWORK_TIERS) removeSet.add(t);
     for (const u of USER_ARTIFACT_TIERS) removeSet.add(u);
   }
-  const target = opts.path ? path31.resolve(opts.path) : cwd;
-  const cleargateDir = path31.join(target, ".cleargate");
-  const manifestPath = path31.join(cleargateDir, ".install-manifest.json");
-  const uninstalledPath = path31.join(cleargateDir, ".uninstalled");
-  if (!fs29.existsSync(manifestPath)) {
-    if (fs29.existsSync(uninstalledPath)) {
+  const target = opts.path ? path32.resolve(opts.path) : cwd;
+  const cleargateDir = path32.join(target, ".cleargate");
+  const manifestPath = path32.join(cleargateDir, ".install-manifest.json");
+  const uninstalledPath = path32.join(cleargateDir, ".uninstalled");
+  if (!fs30.existsSync(manifestPath)) {
+    if (fs30.existsSync(uninstalledPath)) {
       stdout("already uninstalled");
       exit(0);
       return;
@@ -6709,7 +6774,7 @@ async function uninstallHandler(opts) {
     exit(0);
     return;
   }
-  if (fs29.existsSync(uninstalledPath) && !fs29.existsSync(manifestPath)) {
+  if (fs30.existsSync(uninstalledPath) && !fs30.existsSync(manifestPath)) {
     stdout("already uninstalled");
     exit(0);
     return;
@@ -6731,10 +6796,10 @@ async function uninstallHandler(opts) {
       return;
     }
   }
-  const claudeMdPath = path31.join(target, "CLAUDE.md");
+  const claudeMdPath = path32.join(target, "CLAUDE.md");
   let claudeMdContent = null;
-  if (fs29.existsSync(claudeMdPath)) {
-    claudeMdContent = fs29.readFileSync(claudeMdPath, "utf-8");
+  if (fs30.existsSync(claudeMdPath)) {
+    claudeMdContent = fs30.readFileSync(claudeMdPath, "utf-8");
     if (!claudeMdContent.includes(CLEARGATE_START)) {
       stderr("CLAUDE.md is missing <!-- CLEARGATE:START --> marker");
       exit(1);
@@ -6750,8 +6815,8 @@ async function uninstallHandler(opts) {
   const toPreserve = [];
   const toSkip = [];
   for (const entry of snapshot.files) {
-    const filePath = path31.join(target, entry.path);
-    if (!fs29.existsSync(filePath)) {
+    const filePath = path32.join(target, entry.path);
+    if (!fs30.existsSync(filePath)) {
       toSkip.push(entry);
       continue;
     }
@@ -6808,7 +6873,7 @@ async function uninstallHandler(opts) {
   const removedPaths = [];
   const preservedPaths = [];
   for (const entry of toRemove) {
-    const filePath = path31.join(target, entry.path);
+    const filePath = path32.join(target, entry.path);
     await removeFile(filePath);
     removedPaths.push(entry.path);
   }
@@ -6824,10 +6889,10 @@ async function uninstallHandler(opts) {
       stderr(`Warning: could not strip CLAUDE.md block: ${err.message}`);
     }
   }
-  const settingsPath = path31.join(target, ".claude", "settings.json");
-  if (fs29.existsSync(settingsPath)) {
+  const settingsPath = path32.join(target, ".claude", "settings.json");
+  if (fs30.existsSync(settingsPath)) {
     try {
-      const raw = fs29.readFileSync(settingsPath, "utf-8");
+      const raw = fs30.readFileSync(settingsPath, "utf-8");
       const settings = JSON.parse(raw);
       const cleaned = removeClearGateHooks(settings);
       await writeAtomic3(settingsPath, JSON.stringify(cleaned, null, 2) + "\n");
@@ -6842,7 +6907,7 @@ async function uninstallHandler(opts) {
     stdout("Removed @cleargate/cli from package.json. Run `npm install` to update package-lock.json.");
   }
   await removeFile(manifestPath);
-  await removeFile(path31.join(cleargateDir, ".drift-state.json"));
+  await removeFile(path32.join(cleargateDir, ".drift-state.json"));
   const marker = {
     uninstalled_at: now().toISOString(),
     prior_version: snapshot.cleargate_version,
@@ -6866,29 +6931,29 @@ async function uninstallHandler(opts) {
 // src/commands/sync.ts
 import * as fsPromises8 from "fs/promises";
-import * as path39 from "path";
+import * as path40 from "path";
 // src/lib/sync-log.ts
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import * as fsPromises2 from "fs/promises";
-import * as path32 from "path";
+import * as path33 from "path";
 function resolveActiveSprintDir(projectRoot, _opts) {
-  const sprintRunsRoot = path32.join(projectRoot, ".cleargate", "sprint-runs");
-  const offSprint = path32.join(sprintRunsRoot, "_off-sprint");
-  if (!fs30.existsSync(sprintRunsRoot)) {
-    fs30.mkdirSync(sprintRunsRoot, { recursive: true });
-    fs30.mkdirSync(offSprint, { recursive: true });
+  const sprintRunsRoot = path33.join(projectRoot, ".cleargate", "sprint-runs");
+  const offSprint = path33.join(sprintRunsRoot, "_off-sprint");
+  if (!fs31.existsSync(sprintRunsRoot)) {
+    fs31.mkdirSync(sprintRunsRoot, { recursive: true });
+    fs31.mkdirSync(offSprint, { recursive: true });
     return offSprint;
   }
-  const entries = fs30.readdirSync(sprintRunsRoot, { withFileTypes: true });
+  const entries = fs31.readdirSync(sprintRunsRoot, { withFileTypes: true });
   const sprintDirs = entries.filter((e) => e.isDirectory() && e.name !== "_off-sprint").map((e) => {
-    const fullPath = path32.join(sprintRunsRoot, e.name);
-    const stat = fs30.statSync(fullPath);
+    const fullPath = path33.join(sprintRunsRoot, e.name);
+    const stat = fs31.statSync(fullPath);
     return { name: e.name, fullPath, mtimeMs: stat.mtimeMs };
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
   if (sprintDirs.length === 0) {
-    if (!fs30.existsSync(offSprint)) {
-      fs30.mkdirSync(offSprint, { recursive: true });
+    if (!fs31.existsSync(offSprint)) {
+      fs31.mkdirSync(offSprint, { recursive: true });
     }
     return offSprint;
   }
@@ -6899,7 +6964,7 @@ function redactDetail(detail) {
   return detail.replace(/eyJ[A-Za-z0-9._-]+/g, "[REDACTED]");
 }
 async function appendSyncLog(sprintRoot, entry) {
-  const logPath = path32.join(sprintRoot, "sync-log.jsonl");
+  const logPath = path33.join(sprintRoot, "sync-log.jsonl");
   await fsPromises2.mkdir(sprintRoot, { recursive: true });
   const safeEntry = {
     ...entry,
@@ -6909,7 +6974,7 @@ async function appendSyncLog(sprintRoot, entry) {
   await fsPromises2.appendFile(logPath, line, { encoding: "utf8" });
 }
 async function readSyncLog(sprintRoot, filters) {
-  const logPath = path32.join(sprintRoot, "sync-log.jsonl");
+  const logPath = path33.join(sprintRoot, "sync-log.jsonl");
   let raw;
   try {
     raw = await fsPromises2.readFile(logPath, "utf8");
@@ -7011,9 +7076,9 @@ function classify2(local, remote, since) {
 }
 // src/lib/merge-helper.ts
-import { promises as fs31 } from "fs";
+import { promises as fs32 } from "fs";
 import * as os4 from "os";
-import * as path33 from "path";
+import * as path34 from "path";
 function promptFourChoice(opts) {
   const { stdin, stdout } = opts;
   stdout("[k]eep mine / [t]ake theirs / [e]dit in $EDITOR / [a]bort: ");
@@ -7083,7 +7148,7 @@ async function promptThreeWayMerge(opts) {
       case "a":
         return { resolution: "aborted", body: local };
       case "e": {
-        const tmpFile = path33.join(os4.tmpdir(), `cleargate-merge-${itemId}-${now()}.md`);
+        const tmpFile = path34.join(os4.tmpdir(), `cleargate-merge-${itemId}-${now()}.md`);
         const markerContent = `<<<<<<< local
 ${local}
 =======
@@ -7091,16 +7156,16 @@ ${remote}
 >>>>>>> remote
 `;
         try {
-          await fs31.writeFile(tmpFile, markerContent, "utf-8");
+          await fs32.writeFile(tmpFile, markerContent, "utf-8");
           await openInEditor(tmpFile, { editor: editor ?? process.env["EDITOR"] ?? "vi" });
-          const edited = await fs31.readFile(tmpFile, "utf-8");
+          const edited = await fs32.readFile(tmpFile, "utf-8");
           if (containsConflictMarkers(edited)) {
             stdout("File still contains conflict markers \u2014 please resolve all conflicts.\n");
             continue;
           }
           return { resolution: "edited", body: edited };
         } finally {
-          await fs31.unlink(tmpFile).catch(() => {
+          await fs32.unlink(tmpFile).catch(() => {
           });
         }
       }
@@ -7177,11 +7242,11 @@ function createMcpClient(opts) {
 // src/lib/intake.ts
 import * as fsPromises4 from "fs/promises";
-import * as path35 from "path";
+import * as path36 from "path";
 // src/lib/slug.ts
 import * as fsPromises3 from "fs/promises";
-import * as path34 from "path";
+import * as path35 from "path";
 function slugify(title, max = 40) {
   const normalized = title.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "");
   const lowered = normalized.toLowerCase();
@@ -7196,8 +7261,8 @@ function slugify(title, max = 40) {
 var PROPOSAL_ID_RE = /^proposal_id:\s*"?PROP-(\d+)"?/m;
 async function nextProposalId(projectRoot) {
   const dirs = [
-    path34.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
-    path34.join(projectRoot, ".cleargate", "delivery", "archive")
+    path35.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
+    path35.join(projectRoot, ".cleargate", "delivery", "archive")
   ];
   let maxN = 0;
   for (const dir of dirs) {
@@ -7209,7 +7274,7 @@ async function nextProposalId(projectRoot) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path34.join(dir, entry.name);
+      const fullPath = path35.join(dir, entry.name);
       try {
         const raw = await fsPromises3.readFile(fullPath, "utf8");
         const fmEnd = extractFrontmatterBlock(raw);
@@ -7227,8 +7292,8 @@ async function nextProposalId(projectRoot) {
 }
 async function findByRemoteId(projectRoot, remoteId) {
   const dirs = [
-    path34.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
-    path34.join(projectRoot, ".cleargate", "delivery", "archive")
+    path35.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
+    path35.join(projectRoot, ".cleargate", "delivery", "archive")
   ];
   const escaped = remoteId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const re = new RegExp(`^remote_id:\\s*"?${escaped}"?\\s*$`, "m");
@@ -7241,7 +7306,7 @@ async function findByRemoteId(projectRoot, remoteId) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path34.join(dir, entry.name);
+      const fullPath = path35.join(dir, entry.name);
       try {
         const raw = await fsPromises3.readFile(fullPath, "utf8");
         const fm = extractFrontmatterBlock(raw);
@@ -7278,7 +7343,7 @@ async function runIntakeBranch(opts) {
     labelFilter = "cleargate:proposal",
     now = () => (/* @__PURE__ */ new Date()).toISOString()
   } = opts;
-  const pendingSyncDir = path35.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSyncDir = path36.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   let remoteItems = [];
   try {
     remoteItems = await mcp.call(
@@ -7309,7 +7374,7 @@ async function runIntakeBranch(opts) {
       const slug2 = slugify(item.title ?? "untitled");
       const num2 = proposalId2.replace("PROP-", "");
       const filename2 = `PROPOSAL-${num2}-remote-${slug2}.md`;
-      const targetPath2 = path35.join(pendingSyncDir, filename2);
+      const targetPath2 = path36.join(pendingSyncDir, filename2);
       createdItems.push({
         proposalId: proposalId2,
         remoteId: item.remote_id,
@@ -7322,7 +7387,7 @@ async function runIntakeBranch(opts) {
     const num = proposalId.replace("PROP-", "");
     const slug = slugify(item.title ?? "untitled");
     const filename = `PROPOSAL-${num}-remote-${slug}.md`;
-    const targetPath = path35.join(pendingSyncDir, filename);
+    const targetPath = path36.join(pendingSyncDir, filename);
     const nowTs = now();
     const fm = {
       proposal_id: proposalId,
@@ -7414,8 +7479,8 @@ path/to/new/file.ext - {Explanation of purpose}
 }
 async function hasAnyRemoteAuthored(projectRoot) {
   const dirs = [
-    path35.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
-    path35.join(projectRoot, ".cleargate", "delivery", "archive")
+    path36.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
+    path36.join(projectRoot, ".cleargate", "delivery", "archive")
   ];
   for (const dir of dirs) {
     let entries;
@@ -7426,7 +7491,7 @@ async function hasAnyRemoteAuthored(projectRoot) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path35.join(dir, entry.name);
+      const fullPath = path36.join(dir, entry.name);
       try {
         const raw = await fsPromises4.readFile(fullPath, "utf8");
         const fmEnd = raw.indexOf("\n---", 4);
@@ -7443,9 +7508,9 @@ async function hasAnyRemoteAuthored(projectRoot) {
 }
 // src/lib/active-criteria.ts
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 import * as fsPromises5 from "fs/promises";
-import * as path36 from "path";
+import * as path37 from "path";
 async function resolveActiveItems(projectRoot, localItems, nowFn = () => (/* @__PURE__ */ new Date()).toISOString()) {
   const active = /* @__PURE__ */ new Set();
   const now = Date.parse(nowFn());
@@ -7470,7 +7535,7 @@ async function resolveInSprintIds(projectRoot) {
   const ids = /* @__PURE__ */ new Set();
   try {
     const sprintDir = resolveActiveSprintDir(projectRoot);
-    const sprintId = path36.basename(sprintDir);
+    const sprintId = path37.basename(sprintDir);
     if (sprintId === "_off-sprint") return ids;
     const sprintFile = await findSprintFile(projectRoot, sprintId);
     if (!sprintFile) return ids;
@@ -7485,14 +7550,14 @@ async function resolveInSprintIds(projectRoot) {
   return ids;
 }
 async function findSprintFile(projectRoot, sprintId) {
-  const pendingSync = path36.join(projectRoot, ".cleargate", "delivery", "pending-sync");
-  const archive = path36.join(projectRoot, ".cleargate", "delivery", "archive");
+  const pendingSync = path37.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const archive = path37.join(projectRoot, ".cleargate", "delivery", "archive");
   for (const dir of [pendingSync, archive]) {
     try {
-      const entries = fs32.readdirSync(dir, { withFileTypes: true });
+      const entries = fs33.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && entry.name.startsWith(sprintId) && entry.name.endsWith(".md")) {
-          return path36.join(dir, entry.name);
+          return path37.join(dir, entry.name);
         }
       }
     } catch {
@@ -7503,12 +7568,12 @@ async function findSprintFile(projectRoot, sprintId) {
 // src/lib/comments-cache.ts
 import * as fsPromises6 from "fs/promises";
-import * as path37 from "path";
+import * as path38 from "path";
 function cacheDir(projectRoot) {
-  return path37.join(projectRoot, ".cleargate", ".comments-cache");
+  return path38.join(projectRoot, ".cleargate", ".comments-cache");
 }
 function cachePath(projectRoot, remoteId) {
-  return path37.join(cacheDir(projectRoot), `${remoteId}.json`);
+  return path38.join(cacheDir(projectRoot), `${remoteId}.json`);
 }
 async function writeCommentCache(projectRoot, remoteId, comments) {
   const dir = cacheDir(projectRoot);
@@ -7522,7 +7587,7 @@ async function writeCommentCache(projectRoot, remoteId, comments) {
 // src/lib/wiki-comments-render.ts
 import * as fsPromises7 from "fs/promises";
-import * as path38 from "path";
+import * as path39 from "path";
 var START = "<!-- cleargate:comments:start -->";
 var END = "<!-- cleargate:comments:end -->";
 function resolveBucket(fm) {
@@ -7567,7 +7632,7 @@ async function renderCommentsSection(opts) {
   const bucket = resolveBucket(localItem.fm);
   const primaryId = getPrimaryId(localItem.fm);
   if (!bucket || !primaryId) return;
-  const wikiPath = path38.join(
+  const wikiPath = path39.join(
     projectRoot,
     ".cleargate",
     "wiki",
@@ -7603,7 +7668,7 @@ async function renderCommentsSection(opts) {
   await writeAtomic4(wikiPath, updated);
 }
 async function writeAtomic4(filePath, content) {
-  await fsPromises7.mkdir(path38.dirname(filePath), { recursive: true });
+  await fsPromises7.mkdir(path39.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises7.writeFile(tmpPath, content, "utf8");
   await fsPromises7.rename(tmpPath, filePath);
@@ -7615,11 +7680,11 @@ async function syncCheckHandler(opts = {}) {
   const env = opts.env ?? process.env;
   const stdout = opts.stdout ?? ((s) => process.stdout.write(s));
   const nowFn = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const markerPath = path39.join(projectRoot, ".cleargate", ".sync-marker.json");
+  const markerPath = path40.join(projectRoot, ".cleargate", ".sync-marker.json");
   const updateMarker = async (nowIso2) => {
     try {
       const content = JSON.stringify({ last_check: nowIso2 });
-      await fsPromises8.mkdir(path39.dirname(markerPath), { recursive: true });
+      await fsPromises8.mkdir(path40.dirname(markerPath), { recursive: true });
       const tmpPath = `${markerPath}.tmp.${Date.now()}`;
       await fsPromises8.writeFile(tmpPath, content, "utf8");
       await fsPromises8.rename(tmpPath, markerPath);
@@ -7702,7 +7767,7 @@ async function syncHandler(opts = {}) {
   const nowFn = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const identity = resolveIdentity(projectRoot);
   const sprintRoot = resolveActiveSprintDir(projectRoot);
-  const sprintId = path39.basename(sprintRoot);
+  const sprintId = path40.basename(sprintRoot);
   let mcp;
   if (opts.mcp) {
     mcp = opts.mcp;
@@ -7763,7 +7828,7 @@ async function syncHandler(opts = {}) {
     exit(2);
     return;
   }
-  const wikiMetaPath = path39.join(projectRoot, ".cleargate", "wiki", "meta.json");
+  const wikiMetaPath = path40.join(projectRoot, ".cleargate", "wiki", "meta.json");
   let lastRemoteSync = "1970-01-01T00:00:00.000Z";
   try {
     const metaRaw = await fsPromises8.readFile(wikiMetaPath, "utf8");
@@ -8004,7 +8069,7 @@ async function syncHandler(opts = {}) {
     };
     await appendSyncLog(sprintRoot, entry);
   }
-  const conflictsFile = path39.join(projectRoot, ".cleargate", ".conflicts.json");
+  const conflictsFile = path40.join(projectRoot, ".cleargate", ".conflicts.json");
   const conflictsContent = {
     generated_at: nowFn(),
     sprint_id: sprintId,
@@ -8012,7 +8077,7 @@ async function syncHandler(opts = {}) {
   };
   await writeAtomic5(conflictsFile, JSON.stringify(conflictsContent, null, 2) + "\n");
   try {
-    await fsPromises8.mkdir(path39.dirname(wikiMetaPath), { recursive: true });
+    await fsPromises8.mkdir(path40.dirname(wikiMetaPath), { recursive: true });
     let meta = {};
     try {
       const raw = await fsPromises8.readFile(wikiMetaPath, "utf8");
@@ -8053,13 +8118,13 @@ async function applyPull(item, localPath, fm, actorEmail, nowFn) {
   await writeAtomic5(localPath, newContent);
 }
 async function writeAtomic5(filePath, content) {
-  await fsPromises8.mkdir(path39.dirname(filePath), { recursive: true });
+  await fsPromises8.mkdir(path40.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises8.writeFile(tmpPath, content, "utf8");
   await fsPromises8.rename(tmpPath, filePath);
 }
 async function scanLocalItems(projectRoot) {
-  const pendingSync = path39.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSync = path40.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   const results = [];
   let entries;
   try {
@@ -8069,7 +8134,7 @@ async function scanLocalItems(projectRoot) {
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const fullPath = path39.join(pendingSync, entry.name);
+    const fullPath = path40.join(pendingSync, entry.name);
     try {
       const raw = await fsPromises8.readFile(fullPath, "utf8");
       const { fm, body } = parseFrontmatter(raw);
@@ -8091,7 +8156,7 @@ function getItemId(fm) {
 // src/commands/pull.ts
 import * as fsPromises9 from "fs/promises";
-import * as path40 from "path";
+import * as path41 from "path";
 async function pullHandler(idOrRemoteId, opts = {}) {
   const projectRoot = opts.projectRoot ?? process.cwd();
   const env = opts.env ?? process.env;
@@ -8204,7 +8269,7 @@ async function pullHandler(idOrRemoteId, opts = {}) {
     result: "ok"
   };
   await appendSyncLog(sprintRoot, entry);
-  stdout(`pull: ${remoteId} applied to ${path40.relative(projectRoot, localPath)}
+  stdout(`pull: ${remoteId} applied to ${path41.relative(projectRoot, localPath)}
 `);
   if (opts.comments) {
     const comments = await mcp.call(
@@ -8227,7 +8292,7 @@ async function resolveRemoteId(idOrRemoteId, projectRoot) {
   if (/^[A-Z]+-\d+/.test(idOrRemoteId)) {
     return idOrRemoteId;
   }
-  const pendingSync = path40.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSync = path41.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   let entries;
   try {
     entries = await fsPromises9.readdir(pendingSync, { withFileTypes: true });
@@ -8237,7 +8302,7 @@ async function resolveRemoteId(idOrRemoteId, projectRoot) {
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
     try {
-      const raw = await fsPromises9.readFile(path40.join(pendingSync, entry.name), "utf8");
+      const raw = await fsPromises9.readFile(path41.join(pendingSync, entry.name), "utf8");
       const { fm } = parseFrontmatter(raw);
       for (const key of ["story_id", "epic_id", "proposal_id", "cr_id", "bug_id"]) {
         if (fm[key] === idOrRemoteId && typeof fm["remote_id"] === "string") {
@@ -8250,7 +8315,7 @@ async function resolveRemoteId(idOrRemoteId, projectRoot) {
   return null;
 }
 async function findLocalFile(remoteId, projectRoot) {
-  const pendingSync = path40.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSync = path41.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   let entries;
   try {
     entries = await fsPromises9.readdir(pendingSync, { withFileTypes: true });
@@ -8259,7 +8324,7 @@ async function findLocalFile(remoteId, projectRoot) {
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const fullPath = path40.join(pendingSync, entry.name);
+    const fullPath = path41.join(pendingSync, entry.name);
     try {
       const raw = await fsPromises9.readFile(fullPath, "utf8");
       const { fm } = parseFrontmatter(raw);
@@ -8270,7 +8335,7 @@ async function findLocalFile(remoteId, projectRoot) {
   return null;
 }
 async function writeAtomic6(filePath, content) {
-  await fsPromises9.mkdir(path40.dirname(filePath), { recursive: true });
+  await fsPromises9.mkdir(path41.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises9.writeFile(tmpPath, content, "utf8");
   await fsPromises9.rename(tmpPath, filePath);
@@ -8285,7 +8350,7 @@ function getItemId2(fm) {
 // src/commands/push.ts
 import * as fsPromises10 from "fs/promises";
-import * as path41 from "path";
+import * as path42 from "path";
 async function pushHandler(fileOrId, opts = {}) {
   const projectRoot = opts.projectRoot ?? process.cwd();
   const env = opts.env ?? process.env;
@@ -8359,7 +8424,7 @@ async function pushHandler(fileOrId, opts = {}) {
 }
 async function handlePush(filePath, ctx) {
   const { projectRoot, identity, sprintRoot, nowFn, resolveMcp, stdout, stderr, exit } = ctx;
-  const resolvedPath = path41.isAbsolute(filePath) ? filePath : path41.resolve(projectRoot, filePath);
+  const resolvedPath = path42.isAbsolute(filePath) ? filePath : path42.resolve(projectRoot, filePath);
   let rawContent;
   try {
     rawContent = await fsPromises10.readFile(resolvedPath, "utf8");
@@ -8485,8 +8550,8 @@ async function handleRevert(idOrRemoteId, ctx) {
   void localPath;
 }
 async function resolveLocalItem(idOrRemoteId, projectRoot) {
-  const pendingSync = path41.join(projectRoot, ".cleargate", "delivery", "pending-sync");
-  const archive = path41.join(projectRoot, ".cleargate", "delivery", "archive");
+  const pendingSync = path42.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const archive = path42.join(projectRoot, ".cleargate", "delivery", "archive");
   for (const dir of [pendingSync, archive]) {
     let entries;
     try {
@@ -8496,7 +8561,7 @@ async function resolveLocalItem(idOrRemoteId, projectRoot) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path41.join(dir, entry.name);
+      const fullPath = path42.join(dir, entry.name);
       try {
         const raw = await fsPromises10.readFile(fullPath, "utf8");
         const { fm } = parseFrontmatter(raw);
@@ -8515,7 +8580,7 @@ async function resolveLocalItem(idOrRemoteId, projectRoot) {
   return null;
 }
 async function writeAtomic7(filePath, content) {
-  await fsPromises10.mkdir(path41.dirname(filePath), { recursive: true });
+  await fsPromises10.mkdir(path42.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises10.writeFile(tmpPath, content, "utf8");
   await fsPromises10.rename(tmpPath, filePath);
@@ -8543,7 +8608,7 @@ function getItemType(fm) {
 // src/commands/conflicts.ts
 import * as fsPromises11 from "fs/promises";
-import * as path42 from "path";
+import * as path43 from "path";
 var RESOLUTION_HINTS = {
   "local-delete-remote-edit": "remote-delete: resurrect or delete remote?",
   "remote-delete-local-edit": "local-edit: push your changes or accept remote deletion?",
@@ -8579,7 +8644,7 @@ async function conflictsHandler(opts = {}) {
       }
     }
   }
-  const conflictsFile = path42.join(projectRoot, ".cleargate", ".conflicts.json");
+  const conflictsFile = path43.join(projectRoot, ".cleargate", ".conflicts.json");
   let data;
   try {
     const raw = await fsPromises11.readFile(conflictsFile, "utf8");
@@ -8665,8 +8730,8 @@ function formatEntry(entry) {
 }
 // src/commands/admin-login.ts
-import * as fs33 from "fs";
-import * as path43 from "path";
+import * as fs34 from "fs";
+import * as path44 from "path";
 import * as os5 from "os";
 var DEFAULT_MCP_URL = "http://localhost:3000";
 function resolveMcpUrl(mcpUrlFlag, env) {
@@ -8675,14 +8740,14 @@ function resolveMcpUrl(mcpUrlFlag, env) {
 function resolveAuthFilePath(opts) {
   if (opts.authFilePath) return opts.authFilePath;
   const homedirFn = opts.homedir ?? os5.homedir;
-  return path43.join(homedirFn(), ".cleargate", "admin-auth.json");
+  return path44.join(homedirFn(), ".cleargate", "admin-auth.json");
 }
 function writeAdminAuth(filePath, token) {
-  const dir = path43.dirname(filePath);
-  fs33.mkdirSync(dir, { recursive: true });
+  const dir = path44.dirname(filePath);
+  fs34.mkdirSync(dir, { recursive: true });
   const payload = JSON.stringify({ version: 1, token }, null, 2);
-  fs33.writeFileSync(filePath, payload, { encoding: "utf8", mode: 384 });
-  fs33.chmodSync(filePath, 384);
+  fs34.writeFileSync(filePath, payload, { encoding: "utf8", mode: 384 });
+  fs34.chmodSync(filePath, 384);
 }
 async function adminLoginHandler(opts = {}) {
   const fetchFn = opts.fetch ?? globalThis.fetch;
@@ -8791,8 +8856,8 @@ async function adminLoginHandler(opts = {}) {
 }
 // src/commands/hotfix.ts
-import * as fs34 from "fs";
-import * as path44 from "path";
+import * as fs35 from "fs";
+import * as path45 from "path";
 function defaultExit4(code) {
   return process.exit(code);
 }
@@ -8802,7 +8867,7 @@ function maxHotfixId(pendingDir) {
   let max = 0;
   let entries;
   try {
-    entries = fs34.readdirSync(pendingDir);
+    entries = fs35.readdirSync(pendingDir);
   } catch {
     return 0;
   }
@@ -8816,13 +8881,13 @@ function maxHotfixId(pendingDir) {
   return max;
 }
 function countActiveHotfixes(repoRoot) {
-  const pendingDir = path44.join(repoRoot, ".cleargate", "delivery", "pending-sync");
-  const archiveDir = path44.join(repoRoot, ".cleargate", "delivery", "archive");
+  const pendingDir = path45.join(repoRoot, ".cleargate", "delivery", "pending-sync");
+  const archiveDir = path45.join(repoRoot, ".cleargate", "delivery", "archive");
   const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
   let count = 0;
   let pendingEntries = [];
   try {
-    pendingEntries = fs34.readdirSync(pendingDir);
+    pendingEntries = fs35.readdirSync(pendingDir);
   } catch {
   }
   for (const entry of pendingEntries) {
@@ -8830,13 +8895,13 @@ function countActiveHotfixes(repoRoot) {
   }
   let archiveEntries = [];
   try {
-    archiveEntries = fs34.readdirSync(archiveDir);
+    archiveEntries = fs35.readdirSync(archiveDir);
   } catch {
   }
   for (const entry of archiveEntries) {
     if (entry.startsWith("HOTFIX-") && entry.endsWith(".md")) {
       try {
-        const stat = fs34.statSync(path44.join(archiveDir, entry));
+        const stat = fs35.statSync(path45.join(archiveDir, entry));
         if (stat.mtimeMs >= sevenDaysAgo) count++;
       } catch {
       }
@@ -8845,7 +8910,7 @@ function countActiveHotfixes(repoRoot) {
   return count;
 }
 function resolveTemplatePath(repoRoot) {
-  return path44.join(repoRoot, ".cleargate", "templates", "hotfix.md");
+  return path45.join(repoRoot, ".cleargate", "templates", "hotfix.md");
 }
 function hotfixNewHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -8864,14 +8929,14 @@ function hotfixNewHandler(opts, cli) {
     );
     return exitFn(1);
   }
-  const pendingDir = path44.join(repoRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingDir = path45.join(repoRoot, ".cleargate", "delivery", "pending-sync");
   const maxId = maxHotfixId(pendingDir);
   const nextId = maxId + 1;
   const idStr = `HOTFIX-${String(nextId).padStart(3, "0")}`;
   const templatePath = resolveTemplatePath(repoRoot);
   let templateContent;
   try {
-    templateContent = fs34.readFileSync(templatePath, "utf8");
+    templateContent = fs35.readFileSync(templatePath, "utf8");
   } catch {
     stderrFn(`[cleargate hotfix new] template not found: ${templatePath}`);
     return exitFn(2);
@@ -8879,10 +8944,10 @@ function hotfixNewHandler(opts, cli) {
   const content = templateContent.replace(/\{ID\}/g, idStr).replace(/\{SLUG\}/g, opts.slug).replace(/\{ISO\}/g, now);
   const fileSlug = opts.slug.replace(/-/g, "_");
   const fileName = `${idStr}_${fileSlug}.md`;
-  const outPath = path44.join(pendingDir, fileName);
+  const outPath = path45.join(pendingDir, fileName);
   try {
-    fs34.mkdirSync(pendingDir, { recursive: true });
-    fs34.writeFileSync(outPath, content, "utf8");
+    fs35.mkdirSync(pendingDir, { recursive: true });
+    fs35.writeFileSync(outPath, content, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     stderrFn(`[cleargate hotfix new] write failed: ${msg}`);