cleargate 0.6.2 → 0.7.0

package/dist/cli.cjs

@@ -627,7 +627,7 @@ var import_commander = require("commander");
 // package.json
 var package_default = {
   name: "cleargate",
-  version: "0.6.2",
+  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.",
@@ -1897,8 +1897,8 @@ async function stampHandler(file, opts, cli) {
 
 // src/commands/init.ts
 init_cjs_shims();
-var fs15 = __toESM(require("fs"), 1);
-var path16 = __toESM(require("path"), 1);
+var fs16 = __toESM(require("fs"), 1);
+var path17 = __toESM(require("path"), 1);
 var import_node_url5 = require("url");
 var import_node_child_process3 = require("child_process");
 
@@ -1945,9 +1945,14 @@ function copyPayload(payloadDir, targetCwd, opts) {
       srcContent = text;
     }
     const srcBuffer = typeof srcContent === "string" ? Buffer.from(srcContent, "utf8") : srcContent;
+    const srcMode = fs7.statSync(srcPath).mode;
+    const needsExec = (srcMode & 73) !== 0 || relPath.endsWith(".sh");
     if (fs7.existsSync(dstPath)) {
       const dstContent = fs7.readFileSync(dstPath);
       if (srcBuffer.equals(dstContent)) {
+        if (needsExec && process.platform !== "win32") {
+          fs7.chmodSync(dstPath, 493);
+        }
         report.skipped++;
         report.actions.push({ action: "skipped", relPath });
         continue;
@@ -1958,10 +1963,16 @@ function copyPayload(payloadDir, targetCwd, opts) {
         continue;
       }
       fs7.writeFileSync(dstPath, srcBuffer);
+      if (needsExec && process.platform !== "win32") {
+        fs7.chmodSync(dstPath, 493);
+      }
       report.overwritten++;
       report.actions.push({ action: "overwritten", relPath });
     } else {
       fs7.writeFileSync(dstPath, srcBuffer);
+      if (needsExec && process.platform !== "win32") {
+        fs7.chmodSync(dstPath, 493);
+      }
       report.created++;
       report.actions.push({ action: "created", relPath });
     }
@@ -2030,15 +2041,49 @@ function injectClaudeMd(existing, block) {
   return existing.trimEnd() + "\n\n" + block + "\n";
 }
 
+// src/init/inject-mcp-json.ts
+init_cjs_shims();
+var fs8 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
+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 = path8.join(cwd, ".mcp.json");
+  const entry = { type: "http", url };
+  let existing = null;
+  let existingRaw = null;
+  if (fs8.existsSync(dst)) {
+    existingRaw = fs8.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";
+  }
+  fs8.writeFileSync(dst, next);
+  return existingRaw === null ? "created" : "updated";
+}
+
 // src/commands/wiki-build.ts
 init_cjs_shims();
-var fs13 = __toESM(require("fs"), 1);
-var path13 = __toESM(require("path"), 1);
+var fs14 = __toESM(require("fs"), 1);
+var path14 = __toESM(require("path"), 1);
 
 // src/wiki/scan.ts
 init_cjs_shims();
-var fs8 = __toESM(require("fs"), 1);
-var path8 = __toESM(require("path"), 1);
+var fs9 = __toESM(require("fs"), 1);
+var path9 = __toESM(require("path"), 1);
 
 // src/wiki/derive-bucket.ts
 init_cjs_shims();
@@ -2083,19 +2128,19 @@ var EXCLUDED_SUFFIXES = [
 function scanRawItems(deliveryRoot, repoRoot) {
   const results = [];
   for (const subdir of ["pending-sync", "archive"]) {
-    const dir = path8.join(deliveryRoot, subdir);
-    if (!fs8.existsSync(dir)) continue;
-    const entries = fs8.readdirSync(dir, { recursive: true, encoding: "utf8" });
+    const dir = path9.join(deliveryRoot, subdir);
+    if (!fs9.existsSync(dir)) continue;
+    const entries = fs9.readdirSync(dir, { recursive: true, encoding: "utf8" });
     for (const rel of entries) {
       if (!rel.endsWith(".md")) continue;
       if (rel.includes("~") || rel.startsWith(".")) continue;
-      const absPath = path8.join(dir, rel);
-      const stat = fs8.statSync(absPath);
+      const absPath = path9.join(dir, rel);
+      const stat = fs9.statSync(absPath);
       if (!stat.isFile()) continue;
-      const rawPath = path8.relative(repoRoot, absPath).replace(/\\/g, "/");
+      const rawPath = path9.relative(repoRoot, absPath).replace(/\\/g, "/");
       const isExcluded = EXCLUDED_SUFFIXES.some((excl) => rawPath.startsWith(excl));
       if (isExcluded) continue;
-      const filename = path8.basename(absPath);
+      const filename = path9.basename(absPath);
       let bucketInfo;
       try {
         bucketInfo = deriveBucket(filename);
@@ -2108,7 +2153,7 @@ function scanRawItems(deliveryRoot, repoRoot) {
       } catch {
         continue;
       }
-      const raw = fs8.readFileSync(absPath, "utf8");
+      const raw = fs9.readFileSync(absPath, "utf8");
       let fm;
       let body;
       try {
@@ -2223,8 +2268,8 @@ function parseFmRaw(raw) {
 
 // src/wiki/synthesis/active-sprint.ts
 init_cjs_shims();
-var fs9 = __toESM(require("fs"), 1);
-var path9 = __toESM(require("path"), 1);
+var fs10 = __toESM(require("fs"), 1);
+var path10 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 
 // src/wiki/synthesis/render.ts
@@ -2264,7 +2309,7 @@ function renderSection(template, ctx) {
 // src/wiki/synthesis/active-sprint.ts
 function compile(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir();
-  const tpl = fs9.readFileSync(path9.join(tplDir, "active-sprint.md"), "utf8");
+  const tpl = fs10.readFileSync(path10.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"]));
@@ -2288,18 +2333,18 @@ function isSet(val) {
   return s !== "" && s !== "null";
 }
 function resolveDefaultTemplateDir() {
-  const __dirname = path9.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
-  return path9.resolve(__dirname, "..", "templates", "synthesis");
+  const __dirname = path10.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  return path10.resolve(__dirname, "..", "templates", "synthesis");
 }
 
 // src/wiki/synthesis/open-gates.ts
 init_cjs_shims();
-var fs10 = __toESM(require("fs"), 1);
-var path10 = __toESM(require("path"), 1);
+var fs11 = __toESM(require("fs"), 1);
+var path11 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 function compile2(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir2();
-  const tpl = fs10.readFileSync(path10.join(tplDir, "open-gates.md"), "utf8");
+  const tpl = fs11.readFileSync(path11.join(tplDir, "open-gates.md"), "utf8");
   const gate1 = state2.filter((i) => {
     if (i.bucket !== "proposals") return false;
     const status = String(i.fm["status"] ?? "");
@@ -2328,18 +2373,18 @@ function compile2(state2, templateDir) {
   return renderTemplate(tpl, data);
 }
 function resolveDefaultTemplateDir2() {
-  const __dirname = path10.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-  return path10.resolve(__dirname, "..", "templates", "synthesis");
+  const __dirname = path11.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  return path11.resolve(__dirname, "..", "templates", "synthesis");
 }
 
 // src/wiki/synthesis/product-state.ts
 init_cjs_shims();
-var fs11 = __toESM(require("fs"), 1);
-var path11 = __toESM(require("path"), 1);
+var fs12 = __toESM(require("fs"), 1);
+var path12 = __toESM(require("path"), 1);
 var import_node_url3 = require("url");
 function compile3(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir3();
-  const tpl = fs11.readFileSync(path11.join(tplDir, "product-state.md"), "utf8");
+  const tpl = fs12.readFileSync(path12.join(tplDir, "product-state.md"), "utf8");
   function countBucket(bucket) {
     return state2.filter((i) => i.bucket === bucket);
   }
@@ -2386,18 +2431,18 @@ function compile3(state2, templateDir) {
   return renderTemplate(tpl, data);
 }
 function resolveDefaultTemplateDir3() {
-  const __dirname = path11.dirname((0, import_node_url3.fileURLToPath)(importMetaUrl));
-  return path11.resolve(__dirname, "..", "templates", "synthesis");
+  const __dirname = path12.dirname((0, import_node_url3.fileURLToPath)(importMetaUrl));
+  return path12.resolve(__dirname, "..", "templates", "synthesis");
 }
 
 // src/wiki/synthesis/roadmap.ts
 init_cjs_shims();
-var fs12 = __toESM(require("fs"), 1);
-var path12 = __toESM(require("path"), 1);
+var fs13 = __toESM(require("fs"), 1);
+var path13 = __toESM(require("path"), 1);
 var import_node_url4 = require("url");
 function compile4(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir4();
-  const tpl = fs12.readFileSync(path12.join(tplDir, "roadmap.md"), "utf8");
+  const tpl = fs13.readFileSync(path13.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(
@@ -2450,8 +2495,8 @@ function isShippedStatus(status) {
   return status === "Completed" || status === "Approved";
 }
 function resolveDefaultTemplateDir4() {
-  const __dirname = path12.dirname((0, import_node_url4.fileURLToPath)(importMetaUrl));
-  return path12.resolve(__dirname, "..", "templates", "synthesis");
+  const __dirname = path13.dirname((0, import_node_url4.fileURLToPath)(importMetaUrl));
+  return path13.resolve(__dirname, "..", "templates", "synthesis");
 }
 
 // src/commands/wiki-build.ts
@@ -2476,16 +2521,16 @@ async function wikiBuildHandler(opts = {}) {
   const exit = opts.exit ?? ((c) => process.exit(c));
   const gitRunner = opts.gitRunner;
   const templateDir = opts.templateDir;
-  const deliveryRoot = path13.join(cwd, ".cleargate", "delivery");
-  const wikiRoot = path13.join(cwd, ".cleargate", "wiki");
-  if (!fs13.existsSync(deliveryRoot)) {
+  const deliveryRoot = path14.join(cwd, ".cleargate", "delivery");
+  const wikiRoot = path14.join(cwd, ".cleargate", "wiki");
+  if (!fs14.existsSync(deliveryRoot)) {
     stderr(`wiki build: .cleargate/delivery/ not found at ${deliveryRoot}
 `);
     exit(1);
     return;
   }
   for (const bucket of BUCKET_ORDER) {
-    fs13.mkdirSync(path13.join(wikiRoot, bucket), { recursive: true });
+    fs14.mkdirSync(path14.join(wikiRoot, bucket), { recursive: true });
   }
   const items = scanRawItems(deliveryRoot, cwd);
   const timestamp = now();
@@ -2508,19 +2553,19 @@ async function wikiBuildHandler(opts = {}) {
     };
     const body = buildPageBody(item, wikiPage);
     const content = serializePage(wikiPage, body);
-    const pageDir = path13.join(wikiRoot, item.bucket);
-    fs13.mkdirSync(pageDir, { recursive: true });
-    fs13.writeFileSync(path13.join(pageDir, `${item.id}.md`), content, "utf8");
+    const pageDir = path14.join(wikiRoot, item.bucket);
+    fs14.mkdirSync(pageDir, { recursive: true });
+    fs14.writeFileSync(path14.join(pageDir, `${item.id}.md`), content, "utf8");
     pagesWritten++;
   }
   const indexContent = buildIndex(items);
-  fs13.writeFileSync(path13.join(wikiRoot, "index.md"), indexContent, "utf8");
+  fs14.writeFileSync(path14.join(wikiRoot, "index.md"), indexContent, "utf8");
   const logContent = buildLog(items, timestamp);
-  fs13.writeFileSync(path13.join(wikiRoot, "log.md"), logContent, "utf8");
-  fs13.writeFileSync(path13.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
-  fs13.writeFileSync(path13.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
-  fs13.writeFileSync(path13.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
-  fs13.writeFileSync(path13.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
+  fs14.writeFileSync(path14.join(wikiRoot, "log.md"), logContent, "utf8");
+  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");
   stdout(`wiki build: OK (${pagesWritten} pages written)
 `);
 }
@@ -2687,7 +2732,7 @@ function buildLog(items, timestamp) {
 init_cjs_shims();
 var import_promises2 = require("fs/promises");
 var import_node_fs = require("fs");
-var path14 = __toESM(require("path"), 1);
+var path15 = __toESM(require("path"), 1);
 
 // src/lib/sha256.ts
 init_cjs_shims();
@@ -2711,23 +2756,23 @@ function shortHash(full) {
 // src/lib/manifest.ts
 function resolveDefaultPackageRoot() {
   const here = new URL(".", importMetaUrl).pathname;
-  const distCandidate = path14.join(here, "MANIFEST.json");
+  const distCandidate = path15.join(here, "MANIFEST.json");
   if ((0, import_node_fs.existsSync)(distCandidate)) {
     return here;
   }
-  const oneLevelUp = path14.join(here, "..", "MANIFEST.json");
+  const oneLevelUp = path15.join(here, "..", "MANIFEST.json");
   if ((0, import_node_fs.existsSync)(oneLevelUp)) {
-    return path14.join(here, "..");
+    return path15.join(here, "..");
   }
-  const devCandidate = path14.join(here, "..", "..", "..", "cleargate-planning", "MANIFEST.json");
+  const devCandidate = path15.join(here, "..", "..", "..", "cleargate-planning", "MANIFEST.json");
   if ((0, import_node_fs.existsSync)(devCandidate)) {
-    return path14.join(here, "..", "..", "..", "cleargate-planning");
+    return path15.join(here, "..", "..", "..", "cleargate-planning");
   }
   return here;
 }
 function loadPackageManifest(opts) {
   const packageRoot = opts?.packageRoot ?? resolveDefaultPackageRoot();
-  const manifestPath = path14.join(packageRoot, "MANIFEST.json");
+  const manifestPath = path15.join(packageRoot, "MANIFEST.json");
   if (!(0, import_node_fs.existsSync)(manifestPath)) {
     throw new Error(
       `MANIFEST.json not found at ${manifestPath}; run 'npm run build' to generate it.`
@@ -2744,7 +2789,7 @@ function loadPackageManifest(opts) {
   return JSON.parse(raw);
 }
 async function loadInstallSnapshot(projectRoot) {
-  const snapshotPath = path14.join(projectRoot, ".cleargate", ".install-manifest.json");
+  const snapshotPath = path15.join(projectRoot, ".cleargate", ".install-manifest.json");
   try {
     const raw = await (0, import_promises2.readFile)(snapshotPath, "utf-8");
     return JSON.parse(raw);
@@ -2753,7 +2798,7 @@ async function loadInstallSnapshot(projectRoot) {
   }
 }
 async function computeCurrentSha(file, projectRoot) {
-  const filePath = path14.join(projectRoot, file.path);
+  const filePath = path15.join(projectRoot, file.path);
   try {
     const raw = await (0, import_promises2.readFile)(filePath);
     return hashNormalized(raw);
@@ -2782,8 +2827,8 @@ function classify(pkgSha, installSha, currentSha, tier) {
   return "both-changed";
 }
 async function writeDriftState(projectRoot, state2, opts) {
-  const cleargatDir = path14.join(projectRoot, ".cleargate");
-  const finalPath = path14.join(cleargatDir, ".drift-state.json");
+  const cleargatDir = path15.join(projectRoot, ".cleargate");
+  const finalPath = path15.join(cleargatDir, ".drift-state.json");
   const tmpPath = `${finalPath}.tmp`;
   const lastRefreshed = opts?.lastRefreshed ?? (/* @__PURE__ */ new Date()).toISOString();
   const fileContent = { last_refreshed: lastRefreshed, drift: state2 };
@@ -2792,7 +2837,7 @@ async function writeDriftState(projectRoot, state2, opts) {
   await (0, import_promises2.rename)(tmpPath, finalPath);
 }
 async function readDriftState(projectRoot) {
-  const driftPath = path14.join(projectRoot, ".cleargate", ".drift-state.json");
+  const driftPath = path15.join(projectRoot, ".cleargate", ".drift-state.json");
   try {
     const raw = await (0, import_promises2.readFile)(driftPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -2867,24 +2912,24 @@ async function promptEmail(question, defaultValue, opts) {
 
 // src/lib/identity.ts
 init_cjs_shims();
-var fs14 = __toESM(require("fs"), 1);
-var path15 = __toESM(require("path"), 1);
+var fs15 = __toESM(require("fs"), 1);
+var path16 = __toESM(require("path"), 1);
 var fsPromises = __toESM(require("fs/promises"), 1);
 var os5 = __toESM(require("os"), 1);
 var import_node_child_process2 = require("child_process");
 function readParticipant(projectRoot) {
-  const filePath = path15.join(projectRoot, ".cleargate", ".participant.json");
+  const filePath = path16.join(projectRoot, ".cleargate", ".participant.json");
   try {
-    const raw = fs14.readFileSync(filePath, "utf8");
+    const raw = fs15.readFileSync(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function writeParticipant(projectRoot, email, source, now = () => (/* @__PURE__ */ new Date()).toISOString()) {
-  const cleargateDir = path15.join(projectRoot, ".cleargate");
+  const cleargateDir = path16.join(projectRoot, ".cleargate");
   await fsPromises.mkdir(cleargateDir, { recursive: true });
-  const filePath = path15.join(cleargateDir, ".participant.json");
+  const filePath = path16.join(cleargateDir, ".participant.json");
   const tmpPath = filePath + ".tmp." + Date.now();
   const content = {
     email,
@@ -2960,16 +3005,16 @@ var HOOK_ADDITION = {
 };
 function resolveDefaultPayloadDir() {
   const thisFile = (0, import_node_url5.fileURLToPath)(importMetaUrl);
-  const pkgRoot = path16.resolve(path16.dirname(thisFile), "..");
-  return path16.join(pkgRoot, "templates", "cleargate-planning");
+  const pkgRoot = path17.resolve(path17.dirname(thisFile), "..");
+  return path17.join(pkgRoot, "templates", "cleargate-planning");
 }
 function countDeliveryItems(cwd) {
-  const pendingSync = path16.join(cwd, ".cleargate", "delivery", "pending-sync");
-  const archive = path16.join(cwd, ".cleargate", "delivery", "archive");
+  const pendingSync = path17.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const archive = path17.join(cwd, ".cleargate", "delivery", "archive");
   let count = 0;
   for (const dir of [pendingSync, archive]) {
-    if (!fs15.existsSync(dir)) continue;
-    const entries = fs15.readdirSync(dir);
+    if (!fs16.existsSync(dir)) continue;
+    const entries = fs16.readdirSync(dir);
     for (const f of entries) {
       if (f.endsWith(".md") && f !== ".gitkeep") count++;
     }
@@ -2978,12 +3023,12 @@ function countDeliveryItems(cwd) {
 }
 function writeAtomic(filePath, content) {
   const tmpPath = filePath + ".tmp." + Date.now();
-  fs15.writeFileSync(tmpPath, content, "utf8");
-  fs15.renameSync(tmpPath, filePath);
+  fs16.writeFileSync(tmpPath, content, "utf8");
+  fs16.renameSync(tmpPath, filePath);
 }
 function readPackageVersion(packageJsonPath) {
   try {
-    const raw = fs15.readFileSync(packageJsonPath, "utf8");
+    const raw = fs16.readFileSync(packageJsonPath, "utf8");
     const pkg = JSON.parse(raw);
     if (typeof pkg.version === "string" && pkg.version.length > 0) {
       return pkg.version;
@@ -3003,16 +3048,16 @@ async function initHandler(opts = {}) {
   const promptYesNoFn = opts.promptYesNo ?? promptYesNo;
   const promptEmailFn = opts.promptEmail ?? promptEmail;
   const spawnSyncFn = opts.spawnSyncFn ?? import_node_child_process3.spawnSync;
-  if (!fs15.existsSync(cwd)) {
+  if (!fs16.existsSync(cwd)) {
     stderr(`[cleargate init] ERROR: target directory does not exist: ${cwd}
 `);
     exit(1);
     return;
   }
-  const testWritePath = path16.join(cwd, `.cleargate-init-write-test-${Date.now()}`);
+  const testWritePath = path17.join(cwd, `.cleargate-init-write-test-${Date.now()}`);
   try {
-    fs15.writeFileSync(testWritePath, "");
-    fs15.unlinkSync(testWritePath);
+    fs16.writeFileSync(testWritePath, "");
+    fs16.unlinkSync(testWritePath);
   } catch {
     stderr(`[cleargate init] ERROR: target directory is not writable: ${cwd}
 `);
@@ -3022,7 +3067,7 @@ async function initHandler(opts = {}) {
   stdout(`[cleargate init] Target: ${cwd}
 `);
   const payloadDir = opts.payloadDir ?? resolveDefaultPayloadDir();
-  if (!fs15.existsSync(payloadDir)) {
+  if (!fs16.existsSync(payloadDir)) {
     stderr(`[cleargate init] ERROR: payload directory not found: ${payloadDir}
 `);
     stderr(`[cleargate init] Run \`npm run prebuild\` to copy the payload first.
@@ -3030,12 +3075,12 @@ async function initHandler(opts = {}) {
     exit(1);
     return;
   }
-  const uninstalledMarkerPath = path16.join(cwd, ".cleargate", ".uninstalled");
+  const uninstalledMarkerPath = path17.join(cwd, ".cleargate", ".uninstalled");
   let uninstalledMarker = null;
   let userChoseRestore = false;
-  if (fs15.existsSync(uninstalledMarkerPath)) {
+  if (fs16.existsSync(uninstalledMarkerPath)) {
     try {
-      const raw = fs15.readFileSync(uninstalledMarkerPath, "utf8");
+      const raw = fs16.readFileSync(uninstalledMarkerPath, "utf8");
       uninstalledMarker = JSON.parse(raw);
     } catch {
       stderr(`[cleargate init] WARNING: .uninstalled marker is malformed; ignoring it.
@@ -3047,8 +3092,8 @@ async function initHandler(opts = {}) {
       userChoseRestore = await promptYesNoFn(question, true);
       if (userChoseRestore) {
         for (const preservedPath of preserved) {
-          const absPreserved = path16.isAbsolute(preservedPath) ? preservedPath : path16.join(cwd, preservedPath);
-          if (fs15.existsSync(absPreserved)) {
+          const absPreserved = path17.isAbsolute(preservedPath) ? preservedPath : path17.join(cwd, preservedPath);
+          if (fs16.existsSync(absPreserved)) {
             stdout(`[cleargate init] [preserved] ${preservedPath}
 `);
           } else {
@@ -3068,8 +3113,8 @@ async function initHandler(opts = {}) {
   if (opts.pin) {
     pinVersion = opts.pin;
   } else {
-    const payloadParent = path16.resolve(payloadDir, "..", "..");
-    pinVersion = readPackageVersion(path16.join(payloadParent, "package.json")) ?? readPackageVersion(path16.join(path16.dirname((0, import_node_url5.fileURLToPath)(importMetaUrl)), "..", "package.json")) ?? "latest";
+    const payloadParent = path17.resolve(payloadDir, "..", "..");
+    pinVersion = readPackageVersion(path17.join(payloadParent, "package.json")) ?? readPackageVersion(path17.join(path17.dirname((0, import_node_url5.fileURLToPath)(importMetaUrl)), "..", "package.json")) ?? "latest";
   }
   const copyReport = copyPayload(payloadDir, cwd, { force, pinVersion });
   for (const action of copyReport.actions) {
@@ -3077,33 +3122,33 @@ async function initHandler(opts = {}) {
     stdout(`[cleargate init] ${verb} ${action.relPath}
 `);
   }
-  const settingsPath = path16.join(cwd, ".claude", "settings.json");
+  const settingsPath = path17.join(cwd, ".claude", "settings.json");
   let existingSettings = null;
-  if (fs15.existsSync(settingsPath)) {
+  if (fs16.existsSync(settingsPath)) {
     try {
-      existingSettings = JSON.parse(fs15.readFileSync(settingsPath, "utf8"));
+      existingSettings = JSON.parse(fs16.readFileSync(settingsPath, "utf8"));
     } catch {
       stderr(`[cleargate init] WARNING: could not parse ${settingsPath}; treating as empty.
 `);
     }
   }
   const mergedSettings = mergeSettings(existingSettings, HOOK_ADDITION);
-  fs15.mkdirSync(path16.dirname(settingsPath), { recursive: true });
+  fs16.mkdirSync(path17.dirname(settingsPath), { recursive: true });
   writeAtomic(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n");
   stdout(`[cleargate init] Updated .claude/settings.json: merged PostToolUse hook
 `);
-  const claudeMdPath = path16.join(cwd, "CLAUDE.md");
-  const claudeMdSrcPath = path16.join(payloadDir, "CLAUDE.md");
+  const claudeMdPath = path17.join(cwd, "CLAUDE.md");
+  const claudeMdSrcPath = path17.join(payloadDir, "CLAUDE.md");
   let claudeMdBlock;
   try {
-    const claudeMdSrc = fs15.readFileSync(claudeMdSrcPath, "utf8");
+    const claudeMdSrc = fs16.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 = fs15.existsSync(claudeMdPath) ? fs15.readFileSync(claudeMdPath, "utf8") : null;
+  const existingClaudeMd = fs16.existsSync(claudeMdPath) ? fs16.readFileSync(claudeMdPath, "utf8") : null;
   const newClaudeMd = injectClaudeMd(existingClaudeMd, claudeMdBlock);
   writeAtomic(claudeMdPath, newClaudeMd);
   if (existingClaudeMd === null) {
@@ -3114,6 +3159,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);
@@ -3127,9 +3192,9 @@ async function initHandler(opts = {}) {
     stdout(`[cleargate init] Bootstrap: no items to ingest, skipping build
 `);
   }
-  const cleargateDir = path16.join(cwd, ".cleargate");
-  fs15.mkdirSync(cleargateDir, { recursive: true });
-  const snapshotPath = path16.join(cleargateDir, ".install-manifest.json");
+  const cleargateDir = path17.join(cwd, ".cleargate");
+  fs16.mkdirSync(cleargateDir, { recursive: true });
+  const snapshotPath = path17.join(cleargateDir, ".install-manifest.json");
   try {
     const readManifest = opts.readInstallManifest ?? (() => loadPackageManifest({ packageRoot: payloadDir }));
     const pkgManifest = readManifest();
@@ -3144,19 +3209,19 @@ async function initHandler(opts = {}) {
     stderr(`[cleargate init] WARNING: could not write install snapshot: ${String(e)}
 `);
   }
-  if (uninstalledMarker !== null && fs15.existsSync(uninstalledMarkerPath)) {
+  if (uninstalledMarker !== null && fs16.existsSync(uninstalledMarkerPath)) {
     try {
-      fs15.unlinkSync(uninstalledMarkerPath);
+      fs16.unlinkSync(uninstalledMarkerPath);
     } catch (e) {
       stderr(`[cleargate init] WARNING: could not remove .uninstalled marker: ${String(e)}
 `);
     }
   }
   {
-    const distCliPath = path16.join(cwd, "cleargate-cli", "dist", "cli.js");
+    const distCliPath = path17.join(cwd, "cleargate-cli", "dist", "cli.js");
     let branch = null;
     let branchLabel = "";
-    if (fs15.existsSync(distCliPath)) {
+    if (fs16.existsSync(distCliPath)) {
       branch = { cmd: "node", args: [distCliPath, "--version"] };
       branchLabel = `local dist (${distCliPath})`;
     } else {
@@ -3228,8 +3293,8 @@ async function initHandler(opts = {}) {
 
 // src/commands/wiki-ingest.ts
 init_cjs_shims();
-var fs16 = __toESM(require("fs"), 1);
-var path17 = __toESM(require("path"), 1);
+var fs17 = __toESM(require("fs"), 1);
+var path18 = __toESM(require("path"), 1);
 var import_node_child_process4 = require("child_process");
 var EXCLUDED_SUFFIXES2 = [
   ".cleargate/knowledge/",
@@ -3255,16 +3320,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 rename12 = opts.rename ?? fs16.renameSync;
+  const rename12 = opts.rename ?? fs17.renameSync;
   const templateDir = opts.templateDir;
   const rawPath = opts.rawPath;
-  const absRawPath = path17.isAbsolute(rawPath) ? rawPath : path17.resolve(cwd, rawPath);
-  const relRawPath = path17.relative(cwd, absRawPath).replace(/\\/g, "/");
-  const deliveryRoot = path17.join(cwd, ".cleargate", "delivery");
+  const absRawPath = path18.isAbsolute(rawPath) ? rawPath : path18.resolve(cwd, rawPath);
+  const relRawPath = path18.relative(cwd, absRawPath).replace(/\\/g, "/");
+  const deliveryRoot = path18.join(cwd, ".cleargate", "delivery");
   const deliveryRootNorm = deliveryRoot.replace(/\\/g, "/");
   const absDeliveryRoot = deliveryRoot;
-  const relToDelivery = path17.relative(absDeliveryRoot, absRawPath);
-  if (relToDelivery.startsWith("..") || path17.isAbsolute(relToDelivery)) {
+  const relToDelivery = path18.relative(absDeliveryRoot, absRawPath);
+  if (relToDelivery.startsWith("..") || path18.isAbsolute(relToDelivery)) {
     stderr(`wiki ingest: ${rawPath} not under .cleargate/delivery/
 `);
     exit(2);
@@ -3278,7 +3343,7 @@ async function wikiIngestHandler(opts) {
     exit(0);
     return;
   }
-  const filename = path17.basename(absRawPath);
+  const filename = path18.basename(absRawPath);
   let bucketInfo;
   try {
     bucketInfo = deriveBucket(filename);
@@ -3298,12 +3363,12 @@ async function wikiIngestHandler(opts) {
     return;
   }
   const { type, id, bucket } = bucketInfo;
-  const wikiRoot = path17.join(cwd, ".cleargate", "wiki");
-  const pageDir = path17.join(wikiRoot, bucket);
-  const pagePath = path17.join(pageDir, `${id}.md`);
+  const wikiRoot = path18.join(cwd, ".cleargate", "wiki");
+  const pageDir = path18.join(wikiRoot, bucket);
+  const pagePath = path18.join(pageDir, `${id}.md`);
   let rawContent;
   try {
-    rawContent = fs16.readFileSync(absRawPath, "utf8");
+    rawContent = fs17.readFileSync(absRawPath, "utf8");
   } catch (e) {
     stderr(`wiki ingest: cannot read ${rawPath}: ${e.message}
 `);
@@ -3323,11 +3388,11 @@ async function wikiIngestHandler(opts) {
     return;
   }
   const currentSha = getGitSha(absRawPath, gitRunner) ?? "";
-  const pageExists = fs16.existsSync(pagePath);
+  const pageExists = fs17.existsSync(pagePath);
   if (pageExists && currentSha !== "") {
     let isNoOp = false;
     try {
-      const existingPageContent = fs16.readFileSync(pagePath, "utf8");
+      const existingPageContent = fs17.readFileSync(pagePath, "utf8");
       const existingPage = parsePage(existingPageContent);
       if (existingPage.last_ingest_commit === currentSha) {
         const contentUnchanged = checkContentUnchanged(absRawPath, currentSha, relRawPath, gitRunner);
@@ -3362,8 +3427,8 @@ async function wikiIngestHandler(opts) {
   };
   const pageBody = buildPageBody2({ id, fm, body });
   const pageContent = serializePage(wikiPage, pageBody);
-  fs16.mkdirSync(pageDir, { recursive: true });
-  fs16.writeFileSync(pagePath, pageContent, "utf8");
+  fs17.mkdirSync(pageDir, { recursive: true });
+  fs17.writeFileSync(pagePath, pageContent, "utf8");
   appendLogEntry(wikiRoot, { timestamp, action, id, relRawPath });
   updateIndex(wikiRoot, { id, type, status: wikiPage.status, relRawPath, rename: rename12 });
   recompileSynthesis(wikiRoot, cwd, templateDir);
@@ -3375,7 +3440,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 = fs16.readFileSync(absRawPath, "utf8");
+    const currentContent = fs17.readFileSync(absRawPath, "utf8");
     return gitContent === currentContent;
   } catch {
     return false;
@@ -3428,7 +3493,7 @@ function buildPageBody2(item) {
   ].join("\n");
 }
 function appendLogEntry(wikiRoot, entry) {
-  const logPath = path17.join(wikiRoot, "log.md");
+  const logPath = path18.join(wikiRoot, "log.md");
   const logEntry = [
     `- timestamp: "${entry.timestamp}"`,
     `  actor: "cleargate wiki ingest"`,
@@ -3436,25 +3501,25 @@ function appendLogEntry(wikiRoot, entry) {
     `  target: "${entry.id}"`,
     `  path: "${entry.relRawPath}"`
   ].join("\n");
-  if (fs16.existsSync(logPath)) {
-    const existing = fs16.readFileSync(logPath, "utf8");
+  if (fs17.existsSync(logPath)) {
+    const existing = fs17.readFileSync(logPath, "utf8");
     const newContent = existing.trimEnd() + "\n" + logEntry + "\n";
-    fs16.writeFileSync(logPath, newContent, "utf8");
+    fs17.writeFileSync(logPath, newContent, "utf8");
   } else {
-    fs16.mkdirSync(wikiRoot, { recursive: true });
-    fs16.writeFileSync(logPath, `# Wiki Event Log
+    fs17.mkdirSync(wikiRoot, { recursive: true });
+    fs17.writeFileSync(logPath, `# Wiki Event Log
 
 ${logEntry}
 `, "utf8");
   }
 }
 function updateIndex(wikiRoot, opts) {
-  const indexPath = path17.join(wikiRoot, "index.md");
+  const indexPath = path18.join(wikiRoot, "index.md");
   const tmpPath = `${indexPath}.tmp`;
   const newRow = `| [[${opts.id}]] | ${opts.type} | ${opts.status} | ${opts.relRawPath} |`;
   let content;
-  if (fs16.existsSync(indexPath)) {
-    content = fs16.readFileSync(indexPath, "utf8");
+  if (fs17.existsSync(indexPath)) {
+    content = fs17.readFileSync(indexPath, "utf8");
     const idPattern = `[[${opts.id}]]`;
     const lines = content.split("\n");
     let replaced = false;
@@ -3473,7 +3538,7 @@ function updateIndex(wikiRoot, opts) {
   } else {
     content = buildMinimalIndex(opts.id, opts.type, opts.status, opts.relRawPath);
   }
-  fs16.writeFileSync(tmpPath, content, "utf8");
+  fs17.writeFileSync(tmpPath, content, "utf8");
   opts.rename(tmpPath, indexPath);
 }
 function insertIntoSection(content, id, newRow) {
@@ -3568,41 +3633,41 @@ function buildMinimalIndex(id, type, status, relRawPath) {
   return lines.join("\n");
 }
 function recompileSynthesis(wikiRoot, cwd, templateDir) {
-  const deliveryRoot = path17.join(cwd, ".cleargate", "delivery");
+  const deliveryRoot = path18.join(cwd, ".cleargate", "delivery");
   let items = [];
-  if (fs16.existsSync(deliveryRoot)) {
+  if (fs17.existsSync(deliveryRoot)) {
     try {
       items = scanRawItems(deliveryRoot, cwd);
     } catch {
     }
   }
-  fs16.writeFileSync(path17.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
-  fs16.writeFileSync(path17.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
-  fs16.writeFileSync(path17.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
-  fs16.writeFileSync(path17.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
+  fs17.writeFileSync(path18.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
+  fs17.writeFileSync(path18.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
+  fs17.writeFileSync(path18.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
+  fs17.writeFileSync(path18.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
 }
 
 // src/commands/wiki-lint.ts
 init_cjs_shims();
-var path21 = __toESM(require("path"), 1);
+var path22 = __toESM(require("path"), 1);
 
 // src/wiki/load-wiki.ts
 init_cjs_shims();
-var fs17 = __toESM(require("fs"), 1);
-var path18 = __toESM(require("path"), 1);
+var fs18 = __toESM(require("fs"), 1);
+var path19 = __toESM(require("path"), 1);
 var BUCKET_DIRS = ["epics", "stories", "sprints", "proposals", "crs", "bugs", "topics"];
 function loadWikiPages(wikiRoot) {
   const results = [];
   for (const bucket of BUCKET_DIRS) {
-    const dir = path18.join(wikiRoot, bucket);
-    if (!fs17.existsSync(dir)) continue;
-    const entries = fs17.readdirSync(dir, { encoding: "utf8" });
+    const dir = path19.join(wikiRoot, bucket);
+    if (!fs18.existsSync(dir)) continue;
+    const entries = fs18.readdirSync(dir, { encoding: "utf8" });
     for (const filename of entries) {
       if (!filename.endsWith(".md")) continue;
-      const absPath = path18.join(dir, filename);
-      const stat = fs17.statSync(absPath);
+      const absPath = path19.join(dir, filename);
+      const stat = fs18.statSync(absPath);
       if (!stat.isFile()) continue;
-      const raw = fs17.readFileSync(absPath, "utf8");
+      const raw = fs18.readFileSync(absPath, "utf8");
       let fm;
       let body;
       try {
@@ -3632,8 +3697,8 @@ function loadWikiPages(wikiRoot) {
 
 // src/wiki/lint-checks.ts
 init_cjs_shims();
-var fs18 = __toESM(require("fs"), 1);
-var path19 = __toESM(require("path"), 1);
+var fs19 = __toESM(require("fs"), 1);
+var path20 = __toESM(require("path"), 1);
 var import_node_child_process5 = require("child_process");
 var import_js_yaml3 = __toESM(require("js-yaml"), 1);
 
@@ -3693,9 +3758,9 @@ function checkOrphan(page, repoRoot) {
   if (!rawPath) return null;
   const isExcluded = EXCLUDED_DIRS.some((excl) => rawPath.startsWith(excl));
   if (isExcluded) return null;
-  const absRaw = path19.join(repoRoot, rawPath);
-  if (!fs18.existsSync(absRaw)) {
-    const relPage = path19.relative(path19.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+  const absRaw = path20.join(repoRoot, rawPath);
+  if (!fs19.existsSync(absRaw)) {
+    const relPage = path20.relative(path20.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "orphan",
       line: `orphan: ${relPage} -> missing ${rawPath} (raw missing)`
@@ -3713,7 +3778,7 @@ function checkRepoMismatch(page, repoRoot) {
     return null;
   }
   if (page.page.repo !== derivedRepo) {
-    const relPage = path19.relative(path19.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path20.relative(path20.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}`
@@ -3738,7 +3803,7 @@ function checkStaleCommit(page, repoRoot, gitRunner) {
   }
   if (!currentSha) return null;
   if (storedSha !== currentSha) {
-    const relPage = path19.relative(path19.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path20.relative(path20.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "stale-commit",
       line: `stale-commit: ${relPage} at ${storedSha}, current ${currentSha}`
@@ -3749,14 +3814,14 @@ function checkStaleCommit(page, repoRoot, gitRunner) {
 function checkMissingIngest(page, repoRoot) {
   const rawPath = page.page.raw_path;
   if (!rawPath) return null;
-  const absRaw = path19.join(repoRoot, rawPath);
-  if (!fs18.existsSync(absRaw)) return null;
-  const rawStat = fs18.statSync(absRaw);
-  const pageStat = fs18.statSync(page.absPath);
+  const absRaw = path20.join(repoRoot, rawPath);
+  if (!fs19.existsSync(absRaw)) return null;
+  const rawStat = fs19.statSync(absRaw);
+  const pageStat = fs19.statSync(page.absPath);
   const rawMtimeMs = rawStat.mtimeMs;
   const pageMtimeMs = pageStat.mtimeMs;
   if (rawMtimeMs - pageMtimeMs > 2e3) {
-    const relPage = path19.relative(path19.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path20.relative(path20.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     const rawMtime = rawStat.mtime.toISOString();
     const pageMtime = pageStat.mtime.toISOString();
     return {
@@ -3767,7 +3832,7 @@ function checkMissingIngest(page, repoRoot) {
   return null;
 }
 function checkBrokenBacklinks(pages, repoRoot) {
-  const wikiRoot = path19.join(repoRoot, ".cleargate", "wiki");
+  const wikiRoot = path20.join(repoRoot, ".cleargate", "wiki");
   const byId = /* @__PURE__ */ new Map();
   for (const p of pages) {
     if (p.page.id) byId.set(p.page.id, p);
@@ -3781,7 +3846,7 @@ function checkBrokenBacklinks(pages, repoRoot) {
     const parentId = match[1];
     const parentPage = byId.get(parentId);
     if (!parentPage) {
-      const relChild = path19.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
+      const relChild = path20.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
       findings.push({
         category: "broken-backlink",
         line: `broken-backlink: ${relChild} -> ${parentId} (parent missing child entry)`
@@ -3794,7 +3859,7 @@ function checkBrokenBacklinks(pages, repoRoot) {
       (c) => c === childRef || c === childId
     );
     if (!parentHasChild) {
-      const relChild = path19.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
+      const relChild = path20.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
       findings.push({
         category: "broken-backlink",
         line: `broken-backlink: ${relChild} -> ${parentId} (parent missing child entry)`
@@ -3804,7 +3869,7 @@ function checkBrokenBacklinks(pages, repoRoot) {
   return findings;
 }
 function checkInvalidatedCitations(pages, repoRoot) {
-  const wikiRoot = path19.join(repoRoot, ".cleargate", "wiki");
+  const wikiRoot = path20.join(repoRoot, ".cleargate", "wiki");
   const byId = /* @__PURE__ */ new Map();
   for (const p of pages) {
     if (p.page.id) byId.set(p.page.id, p);
@@ -3812,10 +3877,10 @@ function checkInvalidatedCitations(pages, repoRoot) {
   const findings = [];
   const topicPages = pages.filter((p) => p.page.type === "topic");
   for (const topicPage of topicPages) {
-    const relTopic = path19.relative(wikiRoot, topicPage.absPath).replace(/\\/g, "/");
+    const relTopic = path20.relative(wikiRoot, topicPage.absPath).replace(/\\/g, "/");
     let citesList = [];
     try {
-      const raw = fs18.readFileSync(topicPage.absPath, "utf8");
+      const raw = fs19.readFileSync(topicPage.absPath, "utf8");
       const { fm } = parseFrontmatter(raw);
       const rawCites = fm["cites"];
       if (Array.isArray(rawCites)) {
@@ -3851,7 +3916,7 @@ function checkExcludedPathIngested(page, repoRoot) {
   if (!rawPath) return null;
   const isExcluded = EXCLUDED_DIRS.some((excl) => rawPath.startsWith(excl));
   if (isExcluded) {
-    const relPage = path19.relative(path19.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path20.relative(path20.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)`
@@ -3862,7 +3927,7 @@ function checkExcludedPathIngested(page, repoRoot) {
 function checkPaginationNeeded(pages) {
   const bucketCounts = /* @__PURE__ */ new Map();
   for (const p of pages) {
-    const bucket = path19.basename(path19.dirname(p.absPath));
+    const bucket = path20.basename(path20.dirname(p.absPath));
     bucketCounts.set(bucket, (bucketCounts.get(bucket) ?? 0) + 1);
   }
   const findings = [];
@@ -3900,11 +3965,11 @@ function parseCachedGateResult(raw) {
 function checkGateFailure(page, repoRoot) {
   const rawPath = page.page.raw_path;
   if (!rawPath) return null;
-  const absRaw = path19.join(repoRoot, rawPath);
-  if (!fs18.existsSync(absRaw)) return null;
+  const absRaw = path20.join(repoRoot, rawPath);
+  if (!fs19.existsSync(absRaw)) return null;
   let rawFm;
   try {
-    const raw = fs18.readFileSync(absRaw, "utf8");
+    const raw = fs19.readFileSync(absRaw, "utf8");
     const { fm } = parseFrontmatter(raw);
     rawFm = fm;
   } catch {
@@ -3938,11 +4003,11 @@ function checkGateFailure(page, repoRoot) {
 function checkGateStaleness(page, repoRoot) {
   const rawPath = page.page.raw_path;
   if (!rawPath) return null;
-  const absRaw = path19.join(repoRoot, rawPath);
-  if (!fs18.existsSync(absRaw)) return null;
+  const absRaw = path20.join(repoRoot, rawPath);
+  if (!fs19.existsSync(absRaw)) return null;
   let rawFm;
   try {
-    const raw = fs18.readFileSync(absRaw, "utf8");
+    const raw = fs19.readFileSync(absRaw, "utf8");
     const { fm } = parseFrontmatter(raw);
     rawFm = fm;
   } catch {
@@ -3965,7 +4030,7 @@ function checkGateStaleness(page, repoRoot) {
   return null;
 }
 function discoverPlainTextMentions(pages, repoRoot) {
-  const wikiRoot = path19.join(repoRoot, ".cleargate", "wiki");
+  const wikiRoot = path20.join(repoRoot, ".cleargate", "wiki");
   const byId = /* @__PURE__ */ new Map();
   for (const p of pages) {
     if (p.page.id) byId.set(p.page.id, true);
@@ -3974,7 +4039,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 = path19.relative(wikiRoot, page.absPath).replace(/\\/g, "/");
+    const relPage = path20.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);
@@ -3991,11 +4056,11 @@ function discoverPlainTextMentions(pages, repoRoot) {
   return suggestions;
 }
 function checkIndexBudget(repoRoot, indexTokenCeiling) {
-  const indexPath = path19.join(repoRoot, ".cleargate", "wiki", "index.md");
-  if (!fs18.existsSync(indexPath)) {
+  const indexPath = path20.join(repoRoot, ".cleargate", "wiki", "index.md");
+  if (!fs19.existsSync(indexPath)) {
     return { finding: null };
   }
-  const bytes = fs18.statSync(indexPath).size;
+  const bytes = fs19.statSync(indexPath).size;
   const tokens = Math.round(bytes / 4);
   const ceiling = indexTokenCeiling;
   if (tokens > ceiling) {
@@ -4013,18 +4078,18 @@ function checkIndexBudget(repoRoot, indexTokenCeiling) {
 
 // src/lib/wiki-config.ts
 init_cjs_shims();
-var fs19 = __toESM(require("fs"), 1);
-var path20 = __toESM(require("path"), 1);
+var fs20 = __toESM(require("fs"), 1);
+var path21 = __toESM(require("path"), 1);
 var import_js_yaml4 = __toESM(require("js-yaml"), 1);
 var DEFAULT_INDEX_TOKEN_CEILING = 8e3;
 function loadWikiConfig(repoRoot) {
-  const configPath = path20.join(repoRoot, ".cleargate", "config.yml");
-  if (!fs19.existsSync(configPath)) {
+  const configPath = path21.join(repoRoot, ".cleargate", "config.yml");
+  if (!fs20.existsSync(configPath)) {
     return { wiki: { index_token_ceiling: DEFAULT_INDEX_TOKEN_CEILING }, gates: {} };
   }
   let raw;
   try {
-    raw = fs19.readFileSync(configPath, "utf8");
+    raw = fs20.readFileSync(configPath, "utf8");
   } catch (err) {
     throw new Error(`Failed to read ${configPath}: ${String(err)}`);
   }
@@ -4085,7 +4150,7 @@ async function wikiLintHandler(opts = {}) {
   const exit = opts.exit ?? ((c) => process.exit(c));
   const gitRunner = opts.gitRunner;
   const mode = opts.mode ?? "enforce";
-  const wikiRoot = path21.join(cwd, ".cleargate", "wiki");
+  const wikiRoot = path22.join(cwd, ".cleargate", "wiki");
   const repoRoot = cwd;
   let pages = loadWikiPages(wikiRoot);
   const findings = [];
@@ -4157,8 +4222,8 @@ async function wikiLintHandler(opts = {}) {
 
 // src/commands/wiki-query.ts
 init_cjs_shims();
-var fs20 = __toESM(require("fs"), 1);
-var path22 = __toESM(require("path"), 1);
+var fs21 = __toESM(require("fs"), 1);
+var path23 = __toESM(require("path"), 1);
 function computeSlug(query) {
   return query.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 40).replace(/-+$/, "");
 }
@@ -4188,9 +4253,9 @@ async function wikiQueryHandler(opts) {
   const query = opts.query;
   const persist = opts.persist ?? false;
   void stderr;
-  const wikiRoot = path22.join(cwd, ".cleargate", "wiki");
-  const indexPath = path22.join(wikiRoot, "index.md");
-  if (!fs20.existsSync(indexPath)) {
+  const wikiRoot = path23.join(cwd, ".cleargate", "wiki");
+  const indexPath = path23.join(wikiRoot, "index.md");
+  if (!fs21.existsSync(indexPath)) {
     stdout(`wiki query: no index.md found at ${indexPath}
 `);
     stdout(`Run \`cleargate wiki build\` first.
@@ -4198,7 +4263,7 @@ async function wikiQueryHandler(opts) {
     exit(1);
     return;
   }
-  const indexContent = fs20.readFileSync(indexPath, "utf8");
+  const indexContent = fs21.readFileSync(indexPath, "utf8");
   const matches = searchIndex(indexContent, query);
   if (matches.length === 0) {
     stdout(`wiki query: no matches for "${query}"
@@ -4223,8 +4288,8 @@ async function wikiQueryHandler(opts) {
     return;
   }
   const slug = computeSlug(query);
-  const topicsDir = path22.join(wikiRoot, "topics");
-  fs20.mkdirSync(topicsDir, { recursive: true });
+  const topicsDir = path23.join(wikiRoot, "topics");
+  fs21.mkdirSync(topicsDir, { recursive: true });
   const citesArray = matches.map(({ id }) => `"[[${id}]]"`);
   const createdAt = now();
   const frontmatter = [
@@ -4239,13 +4304,13 @@ async function wikiQueryHandler(opts) {
   const topicContent = `${frontmatter}
 
 ${body}`;
-  const topicPath = path22.join(topicsDir, `${slug}.md`);
-  fs20.writeFileSync(topicPath, topicContent, "utf8");
+  const topicPath = path23.join(topicsDir, `${slug}.md`);
+  fs21.writeFileSync(topicPath, topicContent, "utf8");
   updateIndexTopicsSection(indexPath, slug, query, createdAt);
   exit(0);
 }
 function updateIndexTopicsSection(indexPath, slug, query, createdAt) {
-  let content = fs20.readFileSync(indexPath, "utf8");
+  let content = fs21.readFileSync(indexPath, "utf8");
   const row = `| ${slug} | ${query} | ${createdAt} |`;
   if (content.includes("## Topics")) {
     const topicsIdx = content.indexOf("## Topics");
@@ -4268,13 +4333,13 @@ ${row}
 ${row}
 `;
   }
-  fs20.writeFileSync(indexPath, content, "utf8");
+  fs21.writeFileSync(indexPath, content, "utf8");
 }
 
 // src/commands/wiki-audit-status.ts
 init_cjs_shims();
-var fs21 = __toESM(require("fs"), 1);
-var path23 = __toESM(require("path"), 1);
+var fs22 = __toESM(require("fs"), 1);
+var path24 = __toESM(require("path"), 1);
 var readline4 = __toESM(require("readline"), 1);
 var TERMINAL = /* @__PURE__ */ new Set(["Completed", "Done", "Abandoned", "Closed", "Resolved"]);
 async function wikiAuditStatusHandler(opts = {}) {
@@ -4287,8 +4352,8 @@ async function wikiAuditStatusHandler(opts = {}) {
   });
   const exit = opts.exit ?? ((c) => process.exit(c));
   const isTTY = opts.isTTY ?? Boolean(process.stdout.isTTY);
-  const deliveryRoot = path23.join(cwd, ".cleargate", "delivery");
-  if (!fs21.existsSync(deliveryRoot)) {
+  const deliveryRoot = path24.join(cwd, ".cleargate", "delivery");
+  if (!fs22.existsSync(deliveryRoot)) {
     stderr(`audit-status: .cleargate/delivery/ not found at ${deliveryRoot}
 `);
     exit(1);
@@ -4428,7 +4493,7 @@ async function wikiAuditStatusHandler(opts = {}) {
     }
   }
   for (const d of fixable) {
-    const rawText = fs21.readFileSync(d.absPath, "utf8");
+    const rawText = fs22.readFileSync(d.absPath, "utf8");
     const updated = applyStatusFix(rawText, d.suggestedStatus);
     if (!opts.quiet) {
       stdout(`--- ${d.rawPath}
@@ -4444,7 +4509,7 @@ async function wikiAuditStatusHandler(opts = {}) {
       stdout(`+${newLine}
 `);
     }
-    fs21.writeFileSync(d.absPath, updated, "utf8");
+    fs22.writeFileSync(d.absPath, updated, "utf8");
   }
   stdout(`audit-status: applied ${fixable.length} fix(es)
 `);
@@ -4473,8 +4538,8 @@ function applyStatusFix(rawText, newStatus) {
 
 // src/commands/doctor.ts
 init_cjs_shims();
-var fs22 = __toESM(require("fs"), 1);
-var path24 = __toESM(require("path"), 1);
+var fs23 = __toESM(require("fs"), 1);
+var path25 = __toESM(require("path"), 1);
 var import_node_child_process6 = require("child_process");
 
 // src/lib/pricing.ts
@@ -4551,24 +4616,24 @@ function parseHookLogLine(line) {
   };
 }
 function runHookHealth(stdout, cwd, now, outcome) {
-  const cleargateDir = path24.join(cwd, ".cleargate");
-  if (!fs22.existsSync(cleargateDir)) {
+  const cleargateDir = path25.join(cwd, ".cleargate");
+  if (!fs23.existsSync(cleargateDir)) {
     stdout("cleargate misconfigured: no .cleargate/ found. Run: cleargate init");
     if (outcome) outcome.configError = true;
     return;
   }
-  const manifestPath = path24.join(cwd, "cleargate-planning", "MANIFEST.json");
-  if (!fs22.existsSync(manifestPath)) {
+  const manifestPath = path25.join(cwd, "cleargate-planning", "MANIFEST.json");
+  if (!fs23.existsSync(manifestPath)) {
     stdout(`cleargate misconfigured: cleargate-planning/MANIFEST.json not found. Run: cleargate init`);
     if (outcome) outcome.configError = true;
   }
-  const settingsPath = path24.join(cwd, ".claude", "settings.json");
-  if (!fs22.existsSync(settingsPath)) {
+  const settingsPath = path25.join(cwd, ".claude", "settings.json");
+  if (!fs23.existsSync(settingsPath)) {
     stdout("[doctor] No .claude/settings.json found \u2014 hook config unavailable.");
     return;
   }
   try {
-    const raw = fs22.readFileSync(settingsPath, "utf-8");
+    const raw = fs23.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(raw);
     const hasHooks = typeof settings === "object" && settings !== null && "hooks" in settings;
     if (hasHooks) {
@@ -4579,13 +4644,13 @@ function runHookHealth(stdout, cwd, now, outcome) {
   } catch {
     stdout("[doctor] .claude/settings.json is not valid JSON \u2014 cannot verify hook config.");
   }
-  const logPath = path24.join(cwd, ".cleargate", "hook-log", "gate-check.log");
-  if (!fs22.existsSync(logPath)) {
+  const logPath = path25.join(cwd, ".cleargate", "hook-log", "gate-check.log");
+  if (!fs23.existsSync(logPath)) {
     return;
   }
   let logContent;
   try {
-    logContent = fs22.readFileSync(logPath, "utf-8");
+    logContent = fs23.readFileSync(logPath, "utf-8");
   } catch {
     return;
   }
@@ -4699,8 +4764,8 @@ function parseCachedGateResult2(raw) {
   };
 }
 function emitResolverStatusLine(cwd, stdout) {
-  const distCliPath = path24.join(cwd, "cleargate-cli", "dist", "cli.js");
-  if (fs22.existsSync(distCliPath)) {
+  const distCliPath = path25.join(cwd, "cleargate-cli", "dist", "cli.js");
+  if (fs23.existsSync(distCliPath)) {
     stdout(`cleargate CLI: local dist \u2014 ${distCliPath}`);
     return;
   }
@@ -4714,10 +4779,10 @@ function emitResolverStatusLine(cwd, stdout) {
     return;
   }
   let pinVersion = "unknown";
-  const hookPath = path24.join(cwd, ".claude", "hooks", "stamp-and-gate.sh");
-  if (fs22.existsSync(hookPath)) {
+  const hookPath = path25.join(cwd, ".claude", "hooks", "stamp-and-gate.sh");
+  if (fs23.existsSync(hookPath)) {
     try {
-      const hookContent = fs22.readFileSync(hookPath, "utf-8");
+      const hookContent = fs23.readFileSync(hookPath, "utf-8");
       const pinMatch = hookContent.match(/^#\s*cleargate-pin:\s*(\S+)\s*$/m);
       if (pinMatch?.[1]) {
         pinVersion = pinMatch[1];
@@ -4749,10 +4814,10 @@ async function runSessionStart(cwd, stdout, outcome) {
   if (outcome && resolverLines.some((l) => l.includes("\u{1F534}"))) {
     outcome.configError = true;
   }
-  const pendingSyncDir = path24.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const pendingSyncDir = path25.join(cwd, ".cleargate", "delivery", "pending-sync");
   let files;
   try {
-    files = fs22.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path24.join(pendingSyncDir, f));
+    files = fs23.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path25.join(pendingSyncDir, f));
   } catch {
     return;
   }
@@ -4761,7 +4826,7 @@ async function runSessionStart(cwd, stdout, outcome) {
   for (const filePath of files) {
     let raw;
     try {
-      raw = fs22.readFileSync(filePath, "utf-8");
+      raw = fs23.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -4787,13 +4852,13 @@ async function runSessionStart(cwd, stdout, outcome) {
       }
     }
     if (!itemId) {
-      itemId = path24.basename(filePath, ".md");
+      itemId = path25.basename(filePath, ".md");
     }
     const firstCriterionId = gate2.failing_criteria.length > 0 ? gate2.failing_criteria[0]?.id ?? "" : "";
     blocked.push({ id: itemId, firstCriterionId });
   }
-  const activesentinel = path24.join(cwd, ".cleargate", "sprint-runs", ".active");
-  const sprintActive = fs22.existsSync(activesentinel);
+  const activesentinel = path25.join(cwd, ".cleargate", "sprint-runs", ".active");
+  const sprintActive = fs23.existsSync(activesentinel);
   const shouldRemind = !hasApprovedStory && !sprintActive;
   if (shouldRemind) {
     stdout(PLANNING_FIRST_REMINDER);
@@ -4828,10 +4893,10 @@ async function runPricing(filePath, cwd, stdout, stderr, exit, outcome) {
     exit(2);
     return;
   }
-  const absPath = path24.isAbsolute(filePath) ? filePath : path24.resolve(cwd, filePath);
+  const absPath = path25.isAbsolute(filePath) ? filePath : path25.resolve(cwd, filePath);
   let raw;
   try {
-    raw = fs22.readFileSync(absPath, "utf-8");
+    raw = fs23.readFileSync(absPath, "utf-8");
   } catch {
     stderr(`cleargate doctor --pricing: cannot read file: ${absPath}`);
     if (outcome) outcome.configError = true;
@@ -4893,7 +4958,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 = path24.basename(absPath);
+  const fileName = path25.basename(absPath);
   stdout(
     `${fileName}: ${model} \u2014 input:${input} output:${output} cache_read:${cacheRead} cache_creation:${cacheCreation} \u2248 $${usd.toFixed(4)}`
   );
@@ -4906,15 +4971,15 @@ function globMatch(pattern, filePath) {
   return re.test(normalFile);
 }
 async function runCanEdit(filePath, cwd, stdout, exit, outcome) {
-  const activeSentinel = path24.join(cwd, ".cleargate", "sprint-runs", ".active");
-  if (fs22.existsSync(activeSentinel)) {
+  const activeSentinel = path25.join(cwd, ".cleargate", "sprint-runs", ".active");
+  if (fs23.existsSync(activeSentinel)) {
     stdout("allowed: sprint active");
     return;
   }
-  const pendingSyncDir = path24.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const pendingSyncDir = path25.join(cwd, ".cleargate", "delivery", "pending-sync");
   let files;
   try {
-    files = fs22.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path24.join(pendingSyncDir, f));
+    files = fs23.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path25.join(pendingSyncDir, f));
   } catch {
     stdout("blocked: no_approved_stories");
     if (outcome) outcome.blocker = true;
@@ -4926,7 +4991,7 @@ async function runCanEdit(filePath, cwd, stdout, exit, outcome) {
   for (const storyPath of files) {
     let raw;
     try {
-      raw = fs22.readFileSync(storyPath, "utf-8");
+      raw = fs23.readFileSync(storyPath, "utf-8");
     } catch {
       continue;
     }
@@ -5024,14 +5089,14 @@ async function doctorHandler(flags, cli) {
 
 // src/commands/gate.ts
 init_cjs_shims();
-var fs26 = __toESM(require("fs"), 1);
-var path27 = __toESM(require("path"), 1);
+var fs27 = __toESM(require("fs"), 1);
+var path28 = __toESM(require("path"), 1);
 var import_node_child_process7 = require("child_process");
 
 // src/commands/execution-mode.ts
 init_cjs_shims();
-var fs23 = __toESM(require("fs"), 1);
-var path25 = __toESM(require("path"), 1);
+var fs24 = __toESM(require("fs"), 1);
+var path26 = __toESM(require("path"), 1);
 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);
@@ -5049,24 +5114,24 @@ function parseFrontmatterSimple(raw) {
 }
 function discoverSprintFile(sprintId, cwd) {
   const searchDirs = [
-    path25.join(cwd, ".cleargate", "delivery", "pending-sync"),
-    path25.join(cwd, ".cleargate", "delivery", "archive")
+    path26.join(cwd, ".cleargate", "delivery", "pending-sync"),
+    path26.join(cwd, ".cleargate", "delivery", "archive")
   ];
   for (const dir of searchDirs) {
-    if (!fs23.existsSync(dir)) continue;
+    if (!fs24.existsSync(dir)) continue;
     let entries;
     try {
-      entries = fs23.readdirSync(dir);
+      entries = fs24.readdirSync(dir);
     } catch {
       continue;
     }
     const prefix = `${sprintId}_`;
     for (const entry of entries) {
       if (entry.startsWith(prefix) && entry.endsWith(".md")) {
-        return path25.join(dir, entry);
+        return path26.join(dir, entry);
       }
       if (entry === `${sprintId}.md`) {
-        return path25.join(dir, entry);
+        return path26.join(dir, entry);
       }
     }
   }
@@ -5074,9 +5139,9 @@ function discoverSprintFile(sprintId, cwd) {
 }
 function resolveSprintIdFromSentinel(cwd) {
   const resolvedCwd = cwd ?? process.cwd();
-  const sentinelPath = path25.join(resolvedCwd, ".cleargate", "sprint-runs", ".active");
+  const sentinelPath = path26.join(resolvedCwd, ".cleargate", "sprint-runs", ".active");
   try {
-    const content = fs23.readFileSync(sentinelPath, "utf8").trim();
+    const content = fs24.readFileSync(sentinelPath, "utf8").trim();
     return content.length > 0 ? content : null;
   } catch {
     return null;
@@ -5095,12 +5160,12 @@ function readSprintExecutionMode(sprintId, opts = {}) {
   if (!filePath) {
     filePath = discoverSprintFile(resolvedSprintId, cwd);
   }
-  if (!filePath || !fs23.existsSync(filePath)) {
+  if (!filePath || !fs24.existsSync(filePath)) {
     return "v1";
   }
   let raw;
   try {
-    raw = fs23.readFileSync(filePath, "utf8");
+    raw = fs24.readFileSync(filePath, "utf8");
   } catch {
     return "v1";
   }
@@ -5119,8 +5184,8 @@ var import_js_yaml6 = __toESM(require("js-yaml"), 1);
 
 // src/lib/readiness-predicates.ts
 init_cjs_shims();
-var fs24 = __toESM(require("fs"), 1);
-var path26 = __toESM(require("path"), 1);
+var fs25 = __toESM(require("fs"), 1);
+var path27 = __toESM(require("path"), 1);
 function parsePredicate(src) {
   const s = src.trim();
   const fmMatch = s.match(
@@ -5284,18 +5349,18 @@ function compareValues(actual, op, expected) {
 }
 function resolveLinkedPath(ref, docAbsPath, projectRoot) {
   const candidates = [
-    path26.resolve(path26.dirname(docAbsPath), ref),
-    path26.resolve(projectRoot, ref)
+    path27.resolve(path27.dirname(docAbsPath), ref),
+    path27.resolve(projectRoot, ref)
   ];
   for (const candidate of candidates) {
     if (!candidate.startsWith(projectRoot)) continue;
-    if (fs24.existsSync(candidate)) return candidate;
+    if (fs25.existsSync(candidate)) return candidate;
   }
   return null;
 }
 function readFrontmatterFromFile(absPath) {
   try {
-    const raw = fs24.readFileSync(absPath, "utf8");
+    const raw = fs25.readFileSync(absPath, "utf8");
     const lines = raw.split("\n");
     if (lines[0] !== "---") return {};
     let closeIdx = -1;
@@ -5439,14 +5504,14 @@ function applyCountOp(actual, op, n) {
   }
 }
 function evalFileExists(parsed, projectRoot) {
-  const resolved = path26.resolve(projectRoot, parsed.path);
-  if (!resolved.startsWith(projectRoot + path26.sep) && resolved !== projectRoot) {
+  const resolved = path27.resolve(projectRoot, parsed.path);
+  if (!resolved.startsWith(projectRoot + path27.sep) && resolved !== projectRoot) {
     return {
       pass: false,
       detail: `path '${parsed.path}' resolves outside project root (sandbox violation)`
     };
   }
-  const exists = fs24.existsSync(resolved);
+  const exists = fs25.existsSync(resolved);
   return {
     pass: exists,
     detail: exists ? `${parsed.path} exists` : `${parsed.path} not found`
@@ -5454,13 +5519,13 @@ function evalFileExists(parsed, projectRoot) {
 }
 function evalLinkTargetExists(parsed, opts) {
   const projectRoot = opts?.projectRoot ?? process.cwd();
-  const wikiIndexPath = opts?.wikiIndexPath ?? path26.join(projectRoot, ".cleargate", "wiki", "index.md");
+  const wikiIndexPath = opts?.wikiIndexPath ?? path27.join(projectRoot, ".cleargate", "wiki", "index.md");
   if (!wikiIndexPath.startsWith(projectRoot)) {
     return { pass: false, detail: "wikiIndexPath resolves outside project root" };
   }
   let indexContent;
   try {
-    indexContent = fs24.readFileSync(wikiIndexPath, "utf8");
+    indexContent = fs25.readFileSync(wikiIndexPath, "utf8");
   } catch {
     return { pass: false, detail: `wiki index not found at ${wikiIndexPath}` };
   }
@@ -5471,13 +5536,13 @@ function evalLinkTargetExists(parsed, opts) {
   };
 }
 function evalStatusOf(parsed, opts, projectRoot) {
-  const wikiIndexPath = opts?.wikiIndexPath ?? path26.join(projectRoot, ".cleargate", "wiki", "index.md");
+  const wikiIndexPath = opts?.wikiIndexPath ?? path27.join(projectRoot, ".cleargate", "wiki", "index.md");
   if (!wikiIndexPath.startsWith(projectRoot)) {
     return { pass: false, detail: "wikiIndexPath resolves outside project root" };
   }
   let indexContent;
   try {
-    indexContent = fs24.readFileSync(wikiIndexPath, "utf8");
+    indexContent = fs25.readFileSync(wikiIndexPath, "utf8");
   } catch {
     return { pass: false, detail: `wiki index not found at ${wikiIndexPath}` };
   }
@@ -5488,7 +5553,7 @@ function evalStatusOf(parsed, opts, projectRoot) {
     return { pass: false, detail: `[[${parsed.id}]] not found in wiki index` };
   }
   const rawPath = rowMatch[1].trim();
-  const fullPath = path26.resolve(projectRoot, rawPath);
+  const fullPath = path27.resolve(projectRoot, rawPath);
   if (!fullPath.startsWith(projectRoot)) {
     return { pass: false, detail: `wiki path for ${parsed.id} resolves outside project root` };
   }
@@ -5506,12 +5571,12 @@ function evalStatusOf(parsed, opts, projectRoot) {
 
 // src/lib/frontmatter-cache.ts
 init_cjs_shims();
-var fs25 = __toESM(require("fs/promises"), 1);
+var fs26 = __toESM(require("fs/promises"), 1);
 var import_js_yaml5 = __toESM(require("js-yaml"), 1);
 async function readCachedGate(absPath) {
   let raw;
   try {
-    raw = await fs25.readFile(absPath, "utf8");
+    raw = await fs26.readFile(absPath, "utf8");
   } catch {
     return null;
   }
@@ -5531,7 +5596,7 @@ async function writeCachedGate(absPath, result, opts) {
     failing_criteria: result.failing_criteria,
     last_gate_check: lastGateCheck
   };
-  const raw = await fs25.readFile(absPath, "utf8");
+  const raw = await fs26.readFile(absPath, "utf8");
   let fm;
   let body;
   try {
@@ -5561,7 +5626,7 @@ async function writeCachedGate(absPath, result, opts) {
 
 ${body}` : `${fmBlock}
 `;
-  await fs25.writeFile(absPath, newContent, "utf8");
+  await fs26.writeFile(absPath, newContent, "utf8");
 }
 function coerceCachedGate(val) {
   if (val === void 0 || val === null) return null;
@@ -5592,7 +5657,7 @@ function coerceCachedGate(val) {
 
 // src/commands/gate.ts
 function loadGateBlocks(gatesDocPath) {
-  const raw = fs26.readFileSync(gatesDocPath, "utf8");
+  const raw = fs27.readFileSync(gatesDocPath, "utf8");
   const blocks = [];
   const fenceRe = /^```yaml\n([\s\S]*?)^```/gm;
   let match;
@@ -5627,14 +5692,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 = path27.isAbsolute(file) ? file : path27.resolve(cwd, file);
-  if (!fs26.existsSync(absPath)) {
+  const absPath = path28.isAbsolute(file) ? file : path28.resolve(cwd, file);
+  if (!fs27.existsSync(absPath)) {
     stderrFn(`[cleargate gate] error: file not found: ${absPath}`);
     return exitFn(1);
   }
   let raw;
   try {
-    raw = fs26.readFileSync(absPath, "utf8");
+    raw = fs27.readFileSync(absPath, "utf8");
   } catch (err) {
     stderrFn(`[cleargate gate] error: cannot read file: ${absPath}`);
     return exitFn(1);
@@ -5653,8 +5718,8 @@ async function gateCheckHandler(file, opts, cli) {
     return exitFn(1);
   }
   const projectRoot = cwd;
-  const gatesDocPath = cli?.gatesDocPath ?? path27.join(projectRoot, ".cleargate", "knowledge", "readiness-gates.md");
-  if (!fs26.existsSync(gatesDocPath)) {
+  const gatesDocPath = cli?.gatesDocPath ?? path28.join(projectRoot, ".cleargate", "knowledge", "readiness-gates.md");
+  if (!fs27.existsSync(gatesDocPath)) {
     stderrFn(`[cleargate gate] error: readiness-gates.md not found at: ${gatesDocPath}`);
     return exitFn(1);
   }
@@ -5727,8 +5792,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 = path27.isAbsolute(file) ? file : path27.resolve(cwd, file);
-  if (!fs26.existsSync(absPath)) {
+  const absPath = path28.isAbsolute(file) ? file : path28.resolve(cwd, file);
+  if (!fs27.existsSync(absPath)) {
     stderrFn(`[cleargate gate] error: file not found: ${absPath}`);
     return exitFn(1);
   }
@@ -5739,7 +5804,7 @@ async function gateExplainHandler(file, cli) {
   }
   let raw;
   try {
-    raw = fs26.readFileSync(absPath, "utf8");
+    raw = fs27.readFileSync(absPath, "utf8");
   } catch {
     stderrFn(`[cleargate gate] error: cannot read file: ${absPath}`);
     return exitFn(1);
@@ -5760,7 +5825,7 @@ async function gateExplainHandler(file, cli) {
 function resolveRunScriptForGate(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 gateQaHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -5854,15 +5919,15 @@ function gateRunHandler(name, opts, cli) {
 
 // src/commands/sprint.ts
 init_cjs_shims();
-var fs27 = __toESM(require("fs"), 1);
-var path28 = __toESM(require("path"), 1);
+var fs28 = __toESM(require("fs"), 1);
+var path29 = __toESM(require("path"), 1);
 var import_node_child_process9 = require("child_process");
 var import_js_yaml7 = __toESM(require("js-yaml"), 1);
 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 path28.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path29.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function defaultExit(code) {
   return process.exit(code);
@@ -5956,8 +6021,8 @@ ${body}`;
 }
 function atomicWriteStr(filePath, content) {
   const tmp = `${filePath}.tmp.${process.pid}`;
-  fs27.writeFileSync(tmp, content, "utf8");
-  fs27.renameSync(tmp, filePath);
+  fs28.writeFileSync(tmp, content, "utf8");
+  fs28.renameSync(tmp, filePath);
 }
 function deriveSprintBranchForArchive(sprintId) {
   const match = /^SPRINT-(\d+)/.exec(sprintId);
@@ -5971,7 +6036,7 @@ function stampFile(raw, status, completedAt) {
   return serializeFileContent(fm, body);
 }
 function stampSprintClose(sprintPath, now) {
-  const previousContent = fs27.readFileSync(sprintPath, "utf8");
+  const previousContent = fs28.readFileSync(sprintPath, "utf8");
   const { fm, body } = parseFileFrontmatter(previousContent);
   const currentStatus = typeof fm["status"] === "string" ? fm["status"] : "";
   const alreadyTerminal = TERMINAL_STATUSES2.has(currentStatus);
@@ -6031,14 +6096,14 @@ async function sprintArchiveHandler(opts, cli) {
     if (mode === "v1") {
       return printInertAndExit(stdoutFn, exitFn);
     }
-    const stateFile = path28.join(cwd, ".cleargate", "sprint-runs", opts.sprintId, "state.json");
-    if (!fs27.existsSync(stateFile)) {
+    const stateFile = path29.join(cwd, ".cleargate", "sprint-runs", opts.sprintId, "state.json");
+    if (!fs28.existsSync(stateFile)) {
       stderrFn(`[cleargate sprint archive] state.json not found at ${stateFile}`);
       return exitFn(1);
     }
     let state2;
     try {
-      state2 = JSON.parse(fs27.readFileSync(stateFile, "utf8"));
+      state2 = JSON.parse(fs28.readFileSync(stateFile, "utf8"));
     } catch (err) {
       stderrFn(`[cleargate sprint archive] failed to parse state.json: ${err.message}`);
       return exitFn(1);
@@ -6050,18 +6115,18 @@ async function sprintArchiveHandler(opts, cli) {
       return exitFn(1);
     }
     const stateStories = state2.stories ?? {};
-    const pendingDir = path28.join(cwd, ".cleargate", "delivery", "pending-sync");
-    const archiveDir = path28.join(cwd, ".cleargate", "delivery", "archive");
+    const pendingDir = path29.join(cwd, ".cleargate", "delivery", "pending-sync");
+    const archiveDir = path29.join(cwd, ".cleargate", "delivery", "archive");
     let sprintFile = null;
-    for (const entry of fs27.readdirSync(pendingDir)) {
+    for (const entry of fs28.readdirSync(pendingDir)) {
       if ((entry.startsWith(`${opts.sprintId}_`) || entry === `${opts.sprintId}.md`) && entry.endsWith(".md")) {
-        sprintFile = path28.join(pendingDir, entry);
+        sprintFile = path29.join(pendingDir, entry);
         break;
       }
     }
     let epicIds = [];
-    if (sprintFile && fs27.existsSync(sprintFile)) {
-      const { fm } = parseFileFrontmatter(fs27.readFileSync(sprintFile, "utf8"));
+    if (sprintFile && fs28.existsSync(sprintFile)) {
+      const { fm } = parseFileFrontmatter(fs28.readFileSync(sprintFile, "utf8"));
       const epics = fm["epics"];
       if (Array.isArray(epics)) {
         epicIds = epics.map(String);
@@ -6071,15 +6136,15 @@ async function sprintArchiveHandler(opts, cli) {
     if (sprintFile) {
       plan.push({
         src: sprintFile,
-        destName: path28.basename(sprintFile),
+        destName: path29.basename(sprintFile),
         status: "Completed"
       });
     }
     for (const epicId of epicIds) {
-      for (const entry of fs27.readdirSync(pendingDir)) {
+      for (const entry of fs28.readdirSync(pendingDir)) {
         if ((entry.startsWith(`${epicId}_`) || entry === `${epicId}.md`) && entry.endsWith(".md")) {
           plan.push({
-            src: path28.join(pendingDir, entry),
+            src: path29.join(pendingDir, entry),
             destName: entry,
             status: "Approved"
           });
@@ -6088,10 +6153,10 @@ async function sprintArchiveHandler(opts, cli) {
       }
       const storyKeys = storyKeysForEpic(stateStories, epicId);
       for (const storyId of storyKeys) {
-        for (const entry of fs27.readdirSync(pendingDir)) {
+        for (const entry of fs28.readdirSync(pendingDir)) {
           if ((entry.startsWith(`${storyId}_`) || entry === `${storyId}.md`) && entry.endsWith(".md")) {
             plan.push({
-              src: path28.join(pendingDir, entry),
+              src: path29.join(pendingDir, entry),
               destName: entry,
               status: "Done"
             });
@@ -6103,13 +6168,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 fs27.readdirSync(pendingDir)) {
+    for (const entry of fs28.readdirSync(pendingDir)) {
       if (!entry.startsWith("STORY-") || !entry.endsWith(".md")) continue;
-      const candidate = path28.join(pendingDir, entry);
+      const candidate = path29.join(pendingDir, entry);
       if (planSrcs.has(candidate)) continue;
       let raw;
       try {
-        raw = fs27.readFileSync(candidate, "utf8");
+        raw = fs28.readFileSync(candidate, "utf8");
       } catch {
         continue;
       }
@@ -6126,18 +6191,18 @@ async function sprintArchiveHandler(opts, cli) {
     }
     const completedAt = (/* @__PURE__ */ new Date()).toISOString();
     const sprintBranch = deriveSprintBranchForArchive(opts.sprintId);
-    const activePath = path28.join(cwd, ".cleargate", "sprint-runs", ".active");
+    const activePath = path29.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(
-          `    ${path28.basename(entry.src)} \u2192 archive/${entry.destName}  [stamp: status=${entry.status}, completed_at=<now>]`
+          `    ${path29.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) => path28.basename(o)).join(", ")}`);
+        stdoutFn(`  Orphan files (${orphans.length}): ${orphans.map((o) => path29.basename(o)).join(", ")}`);
       }
       stdoutFn(`  .active \u2192 "" (truncate)`);
       stdoutFn(`  git checkout main`);
@@ -6146,9 +6211,9 @@ async function sprintArchiveHandler(opts, cli) {
       return exitFn(0);
     }
     let sprintFileSnapshot = null;
-    const wikiRoot = path28.join(cwd, ".cleargate", "wiki");
-    const wikiInitialised = fs27.existsSync(wikiRoot);
-    if (sprintFile && fs27.existsSync(sprintFile)) {
+    const wikiRoot = path29.join(cwd, ".cleargate", "wiki");
+    const wikiInitialised = fs28.existsSync(wikiRoot);
+    if (sprintFile && fs28.existsSync(sprintFile)) {
       const { previousContent } = stampSprintClose(sprintFile, () => completedAt);
       sprintFileSnapshot = previousContent;
       if (wikiInitialised) {
@@ -6170,15 +6235,15 @@ async function sprintArchiveHandler(opts, cli) {
       }
     }
     for (const entry of plan) {
-      if (!fs27.existsSync(entry.src)) {
+      if (!fs28.existsSync(entry.src)) {
         stderrFn(`[cleargate sprint archive] source not found: ${entry.src} \u2014 skipping`);
         continue;
       }
-      const raw = fs27.readFileSync(entry.src, "utf8");
+      const raw = fs28.readFileSync(entry.src, "utf8");
       const stamped = stampFile(raw, entry.status, completedAt);
-      const dest = path28.join(archiveDir, entry.destName);
+      const dest = path29.join(archiveDir, entry.destName);
       atomicWriteStr(entry.src, stamped);
-      fs27.renameSync(entry.src, dest);
+      fs28.renameSync(entry.src, dest);
       stdoutFn(`archived: ${entry.destName}`);
     }
     try {
@@ -6221,8 +6286,8 @@ async function sprintArchiveHandler(opts, cli) {
 
 // src/commands/story.ts
 init_cjs_shims();
-var fs28 = __toESM(require("fs"), 1);
-var path29 = __toESM(require("path"), 1);
+var fs29 = __toESM(require("fs"), 1);
+var path30 = __toESM(require("path"), 1);
 var import_node_child_process10 = require("child_process");
 function defaultExit2(code) {
   return process.exit(code);
@@ -6230,7 +6295,7 @@ function defaultExit2(code) {
 function resolveRunScript2(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path29.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path30.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function deriveSprintBranch(sprintId) {
   const match = /^SPRINT-(\d+)/.exec(sprintId);
@@ -6239,11 +6304,11 @@ function deriveSprintBranch(sprintId) {
 }
 function atomicWriteString(filePath, text) {
   const tmpFile = `${filePath}.tmp.${process.pid}`;
-  fs28.writeFileSync(tmpFile, text, "utf8");
-  fs28.renameSync(tmpFile, filePath);
+  fs29.writeFileSync(tmpFile, text, "utf8");
+  fs29.renameSync(tmpFile, filePath);
 }
 function stateJsonPath(cwd, sprintId) {
-  return path29.join(cwd, ".cleargate", "sprint-runs", sprintId, "state.json");
+  return path30.join(cwd, ".cleargate", "sprint-runs", sprintId, "state.json");
 }
 function storyStartHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -6260,7 +6325,7 @@ function storyStartHandler(opts, cli) {
     return printInertAndExit(stdoutFn, exitFn);
   }
   const sprintBranch = deriveSprintBranch(sprintId);
-  const worktreePath = path29.join(cwd, ".worktrees", opts.storyId);
+  const worktreePath = path30.join(cwd, ".worktrees", opts.storyId);
   const storyBranch = `story/${opts.storyId}`;
   const step1 = spawnFn(
     "git",
@@ -6292,13 +6357,13 @@ function storyStartHandler(opts, cli) {
     return exitFn(step2.status ?? 1);
   }
   const stateFile = stateJsonPath(cwd, sprintId);
-  if (!fs28.existsSync(stateFile)) {
+  if (!fs29.existsSync(stateFile)) {
     stderrFn(`[cleargate story start] step 3: state.json not found at ${stateFile}`);
     return exitFn(1);
   }
   let state2;
   try {
-    state2 = JSON.parse(fs28.readFileSync(stateFile, "utf8"));
+    state2 = JSON.parse(fs29.readFileSync(stateFile, "utf8"));
   } catch (err) {
     stderrFn(`[cleargate story start] step 3: failed to parse state.json: ${err.message}`);
     return exitFn(1);
@@ -6339,7 +6404,7 @@ function storyCompleteHandler(opts, cli) {
   }
   const sprintBranch = deriveSprintBranch(sprintId);
   const storyBranch = `story/${opts.storyId}`;
-  const worktreeRel = path29.join(".worktrees", opts.storyId);
+  const worktreeRel = path30.join(".worktrees", opts.storyId);
   const step1 = spawnFn(
     "git",
     ["rev-list", "--count", `${sprintBranch}..${storyBranch}`],
@@ -6437,7 +6502,7 @@ function storyCompleteHandler(opts, cli) {
 
 // src/commands/state.ts
 init_cjs_shims();
-var path30 = __toESM(require("path"), 1);
+var path31 = __toESM(require("path"), 1);
 var import_node_child_process11 = require("child_process");
 function defaultExit3(code) {
   return process.exit(code);
@@ -6445,7 +6510,7 @@ function defaultExit3(code) {
 function resolveRunScript3(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path30.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path31.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function stateUpdateHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -6502,21 +6567,21 @@ function stateValidateHandler(opts, cli) {
 
 // src/commands/stamp-tokens.ts
 init_cjs_shims();
-var fs30 = __toESM(require("fs"), 1);
-var path32 = __toESM(require("path"), 1);
+var fs31 = __toESM(require("fs"), 1);
+var path33 = __toESM(require("path"), 1);
 
 // src/lib/ledger-reader.ts
 init_cjs_shims();
-var fs29 = __toESM(require("fs"), 1);
-var path31 = __toESM(require("path"), 1);
+var fs30 = __toESM(require("fs"), 1);
+var path32 = __toESM(require("path"), 1);
 function findSprintRunsRoot(startDir) {
   let dir = startDir;
   while (true) {
-    const candidate = path31.join(dir, ".cleargate", "sprint-runs");
-    if (fs29.existsSync(candidate)) {
+    const candidate = path32.join(dir, ".cleargate", "sprint-runs");
+    if (fs30.existsSync(candidate)) {
       return candidate;
     }
-    const parent = path31.dirname(dir);
+    const parent = path32.dirname(dir);
     if (parent === dir) {
       return null;
     }
@@ -6569,13 +6634,13 @@ function readLedgerForWorkItem(workItemId, opts = {}) {
     }
     sprintRunsRoot = found;
   }
-  if (!fs29.existsSync(sprintRunsRoot)) {
+  if (!fs30.existsSync(sprintRunsRoot)) {
     return [];
   }
   let ledgerFiles;
   try {
-    const entries = fs29.readdirSync(sprintRunsRoot, { withFileTypes: true });
-    ledgerFiles = entries.filter((e) => e.isDirectory()).map((e) => path31.join(sprintRunsRoot, e.name, "token-ledger.jsonl")).filter((f) => fs29.existsSync(f));
+    const entries = fs30.readdirSync(sprintRunsRoot, { withFileTypes: true });
+    ledgerFiles = entries.filter((e) => e.isDirectory()).map((e) => path32.join(sprintRunsRoot, e.name, "token-ledger.jsonl")).filter((f) => fs30.existsSync(f));
   } catch {
     return [];
   }
@@ -6583,7 +6648,7 @@ function readLedgerForWorkItem(workItemId, opts = {}) {
   for (const ledgerFile of ledgerFiles) {
     let content;
     try {
-      content = fs29.readFileSync(ledgerFile, "utf-8");
+      content = fs30.readFileSync(ledgerFile, "utf-8");
     } catch {
       continue;
     }
@@ -6634,7 +6699,7 @@ async function stampTokensHandler(file, opts, cli) {
   });
   const nowFn = cli?.now ?? (() => /* @__PURE__ */ new Date());
   const cwd = cli?.cwd ?? process.cwd();
-  const absPath = path32.isAbsolute(file) ? file : path32.resolve(cwd, file);
+  const absPath = path33.isAbsolute(file) ? file : path33.resolve(cwd, file);
   if (/\/\.cleargate\/delivery\/archive\//.test(absPath)) {
     stdoutFn(`[frozen] ${absPath}`);
     exitFn(0);
@@ -6642,7 +6707,7 @@ async function stampTokensHandler(file, opts, cli) {
   }
   let rawContent;
   try {
-    rawContent = fs30.readFileSync(absPath, "utf-8");
+    rawContent = fs31.readFileSync(absPath, "utf-8");
   } catch {
     stdoutFn(`[stamp-tokens] error: cannot read file: ${absPath}`);
     exitFn(1);
@@ -6714,7 +6779,7 @@ async function stampTokensHandler(file, opts, cli) {
     return;
   }
   try {
-    fs30.writeFileSync(absPath, serialized, "utf-8");
+    fs31.writeFileSync(absPath, serialized, "utf-8");
   } catch {
     stdoutFn(`[stamp-tokens] error: cannot write file: ${absPath}`);
     exitFn(1);
@@ -6731,7 +6796,7 @@ function extractWorkItemId(fm, absPath) {
       return val.trim();
     }
   }
-  const basename12 = path32.basename(absPath);
+  const basename12 = path33.basename(absPath);
   const match = basename12.match(/^(STORY|EPIC|PROPOSAL|CR|BUG)-\d+(-\d+)?/i);
   if (match) {
     return match[0].toUpperCase();
@@ -6837,7 +6902,7 @@ ${body}`;
 // src/commands/upgrade.ts
 init_cjs_shims();
 var fsp = __toESM(require("fs/promises"), 1);
-var path33 = __toESM(require("path"), 1);
+var path34 = __toESM(require("path"), 1);
 
 // src/lib/claude-md-surgery.ts
 init_cjs_shims();
@@ -6987,7 +7052,7 @@ async function writeAtomic2(filePath, content) {
   await fsp.rename(tmpPath, filePath);
 }
 async function updateSnapshotEntry(projectRoot, filePath, newSha) {
-  const snapshotPath = path33.join(projectRoot, ".cleargate", ".install-manifest.json");
+  const snapshotPath = path34.join(projectRoot, ".cleargate", ".install-manifest.json");
   let snapshot;
   try {
     const raw = await fsp.readFile(snapshotPath, "utf-8");
@@ -7004,17 +7069,17 @@ async function updateSnapshotEntry(projectRoot, filePath, newSha) {
   await writeAtomic2(snapshotPath, JSON.stringify(updated, null, 2) + "\n");
 }
 function isClaudeMd(filePath) {
-  return path33.basename(filePath) === "CLAUDE.md";
+  return path34.basename(filePath) === "CLAUDE.md";
 }
 function isSettingsJson(filePath) {
-  return path33.basename(filePath) === "settings.json" && filePath.includes(".claude");
+  return path34.basename(filePath) === "settings.json" && filePath.includes(".claude");
 }
 async function applyAlwaysOverwrite(entry, projectRoot, packageRoot, stdout) {
-  const targetPath = path33.join(projectRoot, entry.path);
-  const sourcePath = path33.join(packageRoot, entry.path);
+  const targetPath = path34.join(projectRoot, entry.path);
+  const sourcePath = path34.join(packageRoot, entry.path);
   try {
     const pkgContent = await fsp.readFile(sourcePath, "utf-8");
-    await fsp.mkdir(path33.dirname(targetPath), { recursive: true });
+    await fsp.mkdir(path34.dirname(targetPath), { recursive: true });
     await writeAtomic2(targetPath, pkgContent);
     await updateSnapshotEntry(projectRoot, entry.path, entry.sha256);
     stdout(`[always] overwritten: ${entry.path}`);
@@ -7024,8 +7089,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 = path33.join(projectRoot, entry.path);
-  const sourcePath = path33.join(packageRoot, entry.path);
+  const targetPath = path34.join(projectRoot, entry.path);
+  const sourcePath = path34.join(packageRoot, entry.path);
   let ours = "";
   let theirs = "";
   try {
@@ -7088,7 +7153,7 @@ async function applyMerge3Way(entry, projectRoot, packageRoot, installSha, curre
         mergedContent = theirs;
       }
     }
-    await fsp.mkdir(path33.dirname(targetPath), { recursive: true });
+    await fsp.mkdir(path34.dirname(targetPath), { recursive: true });
     await writeAtomic2(targetPath, mergedContent);
     const newSha2 = hashNormalized(mergedContent);
     await updateSnapshotEntry(projectRoot, entry.path, newSha2);
@@ -7100,7 +7165,7 @@ async function applyMerge3Way(entry, projectRoot, packageRoot, installSha, curre
 ${ours}=======
 ${theirs}>>>>>>> theirs (upstream)
 `;
-  await fsp.mkdir(path33.dirname(mergeFilePath), { recursive: true });
+  await fsp.mkdir(path34.dirname(mergeFilePath), { recursive: true });
   await writeAtomic2(mergeFilePath, conflictContent);
   try {
     const result = await openInEditorFn(mergeFilePath);
@@ -7235,9 +7300,9 @@ async function upgradeHandler(flags, cli) {
 
 // src/commands/uninstall.ts
 init_cjs_shims();
-var fs31 = __toESM(require("fs"), 1);
+var fs32 = __toESM(require("fs"), 1);
 var fsp2 = __toESM(require("fs/promises"), 1);
-var path34 = __toESM(require("path"), 1);
+var path35 = __toESM(require("path"), 1);
 var import_node_child_process13 = require("child_process");
 var USER_ARTIFACT_TIERS = ["user-artifact"];
 var FRAMEWORK_TIERS = ["protocol", "template", "agent", "hook", "skill", "cli-config", "derived"];
@@ -7263,10 +7328,10 @@ function shouldPreserve(entry, preserveSet, removeSet) {
   return false;
 }
 function resolveProjectName(target) {
-  const pkgPath = path34.join(target, "package.json");
-  if (fs31.existsSync(pkgPath)) {
+  const pkgPath = path35.join(target, "package.json");
+  if (fs32.existsSync(pkgPath)) {
     try {
-      const raw = fs31.readFileSync(pkgPath, "utf-8");
+      const raw = fs32.readFileSync(pkgPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.name && typeof parsed.name === "string") {
         return parsed.name;
@@ -7274,7 +7339,7 @@ function resolveProjectName(target) {
     } catch {
     }
   }
-  return path34.basename(target);
+  return path35.basename(target);
 }
 function detectUncommittedChanges(target, manifestPaths, gitRunner) {
   const run = gitRunner ?? ((args) => {
@@ -7303,8 +7368,8 @@ function detectUncommittedChanges(target, manifestPaths, gitRunner) {
   return changedFiles.filter((f) => manifestSet.has(f));
 }
 async function removeFromPackageJson(target, dryRun) {
-  const pkgPath = path34.join(target, "package.json");
-  if (!fs31.existsSync(pkgPath)) return false;
+  const pkgPath = path35.join(target, "package.json");
+  if (!fs32.existsSync(pkgPath)) return false;
   let raw;
   try {
     raw = await fsp2.readFile(pkgPath, "utf-8");
@@ -7345,7 +7410,7 @@ async function removeFile(filePath) {
 }
 async function removeDir(dirPath) {
   try {
-    fs31.rmSync(dirPath, { recursive: true, force: true });
+    fs32.rmSync(dirPath, { recursive: true, force: true });
   } catch {
   }
 }
@@ -7365,12 +7430,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 ? path34.resolve(opts.path) : cwd;
-  const cleargateDir = path34.join(target, ".cleargate");
-  const manifestPath = path34.join(cleargateDir, ".install-manifest.json");
-  const uninstalledPath = path34.join(cleargateDir, ".uninstalled");
-  if (!fs31.existsSync(manifestPath)) {
-    if (fs31.existsSync(uninstalledPath)) {
+  const target = opts.path ? path35.resolve(opts.path) : cwd;
+  const cleargateDir = path35.join(target, ".cleargate");
+  const manifestPath = path35.join(cleargateDir, ".install-manifest.json");
+  const uninstalledPath = path35.join(cleargateDir, ".uninstalled");
+  if (!fs32.existsSync(manifestPath)) {
+    if (fs32.existsSync(uninstalledPath)) {
       stdout("already uninstalled");
       exit(0);
       return;
@@ -7379,7 +7444,7 @@ async function uninstallHandler(opts) {
     exit(0);
     return;
   }
-  if (fs31.existsSync(uninstalledPath) && !fs31.existsSync(manifestPath)) {
+  if (fs32.existsSync(uninstalledPath) && !fs32.existsSync(manifestPath)) {
     stdout("already uninstalled");
     exit(0);
     return;
@@ -7401,10 +7466,10 @@ async function uninstallHandler(opts) {
       return;
     }
   }
-  const claudeMdPath = path34.join(target, "CLAUDE.md");
+  const claudeMdPath = path35.join(target, "CLAUDE.md");
   let claudeMdContent = null;
-  if (fs31.existsSync(claudeMdPath)) {
-    claudeMdContent = fs31.readFileSync(claudeMdPath, "utf-8");
+  if (fs32.existsSync(claudeMdPath)) {
+    claudeMdContent = fs32.readFileSync(claudeMdPath, "utf-8");
     if (!claudeMdContent.includes(CLEARGATE_START)) {
       stderr("CLAUDE.md is missing <!-- CLEARGATE:START --> marker");
       exit(1);
@@ -7420,8 +7485,8 @@ async function uninstallHandler(opts) {
   const toPreserve = [];
   const toSkip = [];
   for (const entry of snapshot.files) {
-    const filePath = path34.join(target, entry.path);
-    if (!fs31.existsSync(filePath)) {
+    const filePath = path35.join(target, entry.path);
+    if (!fs32.existsSync(filePath)) {
       toSkip.push(entry);
       continue;
     }
@@ -7478,7 +7543,7 @@ async function uninstallHandler(opts) {
   const removedPaths = [];
   const preservedPaths = [];
   for (const entry of toRemove) {
-    const filePath = path34.join(target, entry.path);
+    const filePath = path35.join(target, entry.path);
     await removeFile(filePath);
     removedPaths.push(entry.path);
   }
@@ -7494,10 +7559,10 @@ async function uninstallHandler(opts) {
       stderr(`Warning: could not strip CLAUDE.md block: ${err.message}`);
     }
   }
-  const settingsPath = path34.join(target, ".claude", "settings.json");
-  if (fs31.existsSync(settingsPath)) {
+  const settingsPath = path35.join(target, ".claude", "settings.json");
+  if (fs32.existsSync(settingsPath)) {
     try {
-      const raw = fs31.readFileSync(settingsPath, "utf-8");
+      const raw = fs32.readFileSync(settingsPath, "utf-8");
       const settings = JSON.parse(raw);
       const cleaned = removeClearGateHooks(settings);
       await writeAtomic3(settingsPath, JSON.stringify(cleaned, null, 2) + "\n");
@@ -7512,7 +7577,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(path34.join(cleargateDir, ".drift-state.json"));
+  await removeFile(path35.join(cleargateDir, ".drift-state.json"));
   const marker = {
     uninstalled_at: now().toISOString(),
     prior_version: snapshot.cleargate_version,
@@ -7537,30 +7602,30 @@ async function uninstallHandler(opts) {
 // src/commands/sync.ts
 init_cjs_shims();
 var fsPromises8 = __toESM(require("fs/promises"), 1);
-var path42 = __toESM(require("path"), 1);
+var path43 = __toESM(require("path"), 1);
 
 // src/lib/sync-log.ts
 init_cjs_shims();
-var fs32 = __toESM(require("fs"), 1);
+var fs33 = __toESM(require("fs"), 1);
 var fsPromises2 = __toESM(require("fs/promises"), 1);
-var path35 = __toESM(require("path"), 1);
+var path36 = __toESM(require("path"), 1);
 function resolveActiveSprintDir(projectRoot, _opts) {
-  const sprintRunsRoot = path35.join(projectRoot, ".cleargate", "sprint-runs");
-  const offSprint = path35.join(sprintRunsRoot, "_off-sprint");
-  if (!fs32.existsSync(sprintRunsRoot)) {
-    fs32.mkdirSync(sprintRunsRoot, { recursive: true });
-    fs32.mkdirSync(offSprint, { recursive: true });
+  const sprintRunsRoot = path36.join(projectRoot, ".cleargate", "sprint-runs");
+  const offSprint = path36.join(sprintRunsRoot, "_off-sprint");
+  if (!fs33.existsSync(sprintRunsRoot)) {
+    fs33.mkdirSync(sprintRunsRoot, { recursive: true });
+    fs33.mkdirSync(offSprint, { recursive: true });
     return offSprint;
   }
-  const entries = fs32.readdirSync(sprintRunsRoot, { withFileTypes: true });
+  const entries = fs33.readdirSync(sprintRunsRoot, { withFileTypes: true });
   const sprintDirs = entries.filter((e) => e.isDirectory() && e.name !== "_off-sprint").map((e) => {
-    const fullPath = path35.join(sprintRunsRoot, e.name);
-    const stat = fs32.statSync(fullPath);
+    const fullPath = path36.join(sprintRunsRoot, e.name);
+    const stat = fs33.statSync(fullPath);
     return { name: e.name, fullPath, mtimeMs: stat.mtimeMs };
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
   if (sprintDirs.length === 0) {
-    if (!fs32.existsSync(offSprint)) {
-      fs32.mkdirSync(offSprint, { recursive: true });
+    if (!fs33.existsSync(offSprint)) {
+      fs33.mkdirSync(offSprint, { recursive: true });
     }
     return offSprint;
   }
@@ -7571,7 +7636,7 @@ function redactDetail(detail) {
   return detail.replace(/eyJ[A-Za-z0-9._-]+/g, "[REDACTED]");
 }
 async function appendSyncLog(sprintRoot, entry) {
-  const logPath = path35.join(sprintRoot, "sync-log.jsonl");
+  const logPath = path36.join(sprintRoot, "sync-log.jsonl");
   await fsPromises2.mkdir(sprintRoot, { recursive: true });
   const safeEntry = {
     ...entry,
@@ -7581,7 +7646,7 @@ async function appendSyncLog(sprintRoot, entry) {
   await fsPromises2.appendFile(logPath, line, { encoding: "utf8" });
 }
 async function readSyncLog(sprintRoot, filters) {
-  const logPath = path35.join(sprintRoot, "sync-log.jsonl");
+  const logPath = path36.join(sprintRoot, "sync-log.jsonl");
   let raw;
   try {
     raw = await fsPromises2.readFile(logPath, "utf8");
@@ -7687,7 +7752,7 @@ function classify2(local, remote, since) {
 init_cjs_shims();
 var import_node_fs2 = require("fs");
 var os6 = __toESM(require("os"), 1);
-var path36 = __toESM(require("path"), 1);
+var path37 = __toESM(require("path"), 1);
 function promptFourChoice(opts) {
   const { stdin, stdout } = opts;
   stdout("[k]eep mine / [t]ake theirs / [e]dit in $EDITOR / [a]bort: ");
@@ -7757,7 +7822,7 @@ async function promptThreeWayMerge(opts) {
       case "a":
         return { resolution: "aborted", body: local };
       case "e": {
-        const tmpFile = path36.join(os6.tmpdir(), `cleargate-merge-${itemId}-${now()}.md`);
+        const tmpFile = path37.join(os6.tmpdir(), `cleargate-merge-${itemId}-${now()}.md`);
         const markerContent = `<<<<<<< local
 ${local}
 =======
@@ -7857,12 +7922,12 @@ init_config();
 // src/lib/intake.ts
 init_cjs_shims();
 var fsPromises4 = __toESM(require("fs/promises"), 1);
-var path38 = __toESM(require("path"), 1);
+var path39 = __toESM(require("path"), 1);
 
 // src/lib/slug.ts
 init_cjs_shims();
 var fsPromises3 = __toESM(require("fs/promises"), 1);
-var path37 = __toESM(require("path"), 1);
+var path38 = __toESM(require("path"), 1);
 function slugify(title, max = 40) {
   const normalized = title.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "");
   const lowered = normalized.toLowerCase();
@@ -7877,8 +7942,8 @@ function slugify(title, max = 40) {
 var PROPOSAL_ID_RE = /^proposal_id:\s*"?PROP-(\d+)"?/m;
 async function nextProposalId(projectRoot) {
   const dirs = [
-    path37.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
-    path37.join(projectRoot, ".cleargate", "delivery", "archive")
+    path38.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
+    path38.join(projectRoot, ".cleargate", "delivery", "archive")
   ];
   let maxN = 0;
   for (const dir of dirs) {
@@ -7890,7 +7955,7 @@ async function nextProposalId(projectRoot) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path37.join(dir, entry.name);
+      const fullPath = path38.join(dir, entry.name);
       try {
         const raw = await fsPromises3.readFile(fullPath, "utf8");
         const fmEnd = extractFrontmatterBlock(raw);
@@ -7908,8 +7973,8 @@ async function nextProposalId(projectRoot) {
 }
 async function findByRemoteId(projectRoot, remoteId) {
   const dirs = [
-    path37.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
-    path37.join(projectRoot, ".cleargate", "delivery", "archive")
+    path38.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
+    path38.join(projectRoot, ".cleargate", "delivery", "archive")
   ];
   const escaped = remoteId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const re = new RegExp(`^remote_id:\\s*"?${escaped}"?\\s*$`, "m");
@@ -7922,7 +7987,7 @@ async function findByRemoteId(projectRoot, remoteId) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path37.join(dir, entry.name);
+      const fullPath = path38.join(dir, entry.name);
       try {
         const raw = await fsPromises3.readFile(fullPath, "utf8");
         const fm = extractFrontmatterBlock(raw);
@@ -7959,7 +8024,7 @@ async function runIntakeBranch(opts) {
     labelFilter = "cleargate:proposal",
     now = () => (/* @__PURE__ */ new Date()).toISOString()
   } = opts;
-  const pendingSyncDir = path38.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSyncDir = path39.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   let remoteItems = [];
   try {
     remoteItems = await mcp.call(
@@ -7990,7 +8055,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 = path38.join(pendingSyncDir, filename2);
+      const targetPath2 = path39.join(pendingSyncDir, filename2);
       createdItems.push({
         proposalId: proposalId2,
         remoteId: item.remote_id,
@@ -8003,7 +8068,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 = path38.join(pendingSyncDir, filename);
+    const targetPath = path39.join(pendingSyncDir, filename);
     const nowTs = now();
     const fm = {
       proposal_id: proposalId,
@@ -8095,8 +8160,8 @@ path/to/new/file.ext - {Explanation of purpose}
 }
 async function hasAnyRemoteAuthored(projectRoot) {
   const dirs = [
-    path38.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
-    path38.join(projectRoot, ".cleargate", "delivery", "archive")
+    path39.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
+    path39.join(projectRoot, ".cleargate", "delivery", "archive")
   ];
   for (const dir of dirs) {
     let entries;
@@ -8107,7 +8172,7 @@ async function hasAnyRemoteAuthored(projectRoot) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path38.join(dir, entry.name);
+      const fullPath = path39.join(dir, entry.name);
       try {
         const raw = await fsPromises4.readFile(fullPath, "utf8");
         const fmEnd = raw.indexOf("\n---", 4);
@@ -8125,9 +8190,9 @@ async function hasAnyRemoteAuthored(projectRoot) {
 
 // src/lib/active-criteria.ts
 init_cjs_shims();
-var fs34 = __toESM(require("fs"), 1);
+var fs35 = __toESM(require("fs"), 1);
 var fsPromises5 = __toESM(require("fs/promises"), 1);
-var path39 = __toESM(require("path"), 1);
+var path40 = __toESM(require("path"), 1);
 async function resolveActiveItems(projectRoot, localItems, nowFn = () => (/* @__PURE__ */ new Date()).toISOString()) {
   const active = /* @__PURE__ */ new Set();
   const now = Date.parse(nowFn());
@@ -8152,7 +8217,7 @@ async function resolveInSprintIds(projectRoot) {
   const ids = /* @__PURE__ */ new Set();
   try {
     const sprintDir = resolveActiveSprintDir(projectRoot);
-    const sprintId = path39.basename(sprintDir);
+    const sprintId = path40.basename(sprintDir);
     if (sprintId === "_off-sprint") return ids;
     const sprintFile = await findSprintFile(projectRoot, sprintId);
     if (!sprintFile) return ids;
@@ -8167,14 +8232,14 @@ async function resolveInSprintIds(projectRoot) {
   return ids;
 }
 async function findSprintFile(projectRoot, sprintId) {
-  const pendingSync = path39.join(projectRoot, ".cleargate", "delivery", "pending-sync");
-  const archive = path39.join(projectRoot, ".cleargate", "delivery", "archive");
+  const pendingSync = path40.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const archive = path40.join(projectRoot, ".cleargate", "delivery", "archive");
   for (const dir of [pendingSync, archive]) {
     try {
-      const entries = fs34.readdirSync(dir, { withFileTypes: true });
+      const entries = fs35.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && entry.name.startsWith(sprintId) && entry.name.endsWith(".md")) {
-          return path39.join(dir, entry.name);
+          return path40.join(dir, entry.name);
         }
       }
     } catch {
@@ -8186,12 +8251,12 @@ async function findSprintFile(projectRoot, sprintId) {
 // src/lib/comments-cache.ts
 init_cjs_shims();
 var fsPromises6 = __toESM(require("fs/promises"), 1);
-var path40 = __toESM(require("path"), 1);
+var path41 = __toESM(require("path"), 1);
 function cacheDir(projectRoot) {
-  return path40.join(projectRoot, ".cleargate", ".comments-cache");
+  return path41.join(projectRoot, ".cleargate", ".comments-cache");
 }
 function cachePath(projectRoot, remoteId) {
-  return path40.join(cacheDir(projectRoot), `${remoteId}.json`);
+  return path41.join(cacheDir(projectRoot), `${remoteId}.json`);
 }
 async function writeCommentCache(projectRoot, remoteId, comments) {
   const dir = cacheDir(projectRoot);
@@ -8206,7 +8271,7 @@ async function writeCommentCache(projectRoot, remoteId, comments) {
 // src/lib/wiki-comments-render.ts
 init_cjs_shims();
 var fsPromises7 = __toESM(require("fs/promises"), 1);
-var path41 = __toESM(require("path"), 1);
+var path42 = __toESM(require("path"), 1);
 var START = "<!-- cleargate:comments:start -->";
 var END = "<!-- cleargate:comments:end -->";
 function resolveBucket(fm) {
@@ -8251,7 +8316,7 @@ async function renderCommentsSection(opts) {
   const bucket = resolveBucket(localItem.fm);
   const primaryId = getPrimaryId(localItem.fm);
   if (!bucket || !primaryId) return;
-  const wikiPath = path41.join(
+  const wikiPath = path42.join(
     projectRoot,
     ".cleargate",
     "wiki",
@@ -8287,7 +8352,7 @@ async function renderCommentsSection(opts) {
   await writeAtomic4(wikiPath, updated);
 }
 async function writeAtomic4(filePath, content) {
-  await fsPromises7.mkdir(path41.dirname(filePath), { recursive: true });
+  await fsPromises7.mkdir(path42.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises7.writeFile(tmpPath, content, "utf8");
   await fsPromises7.rename(tmpPath, filePath);
@@ -8299,11 +8364,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 = path42.join(projectRoot, ".cleargate", ".sync-marker.json");
+  const markerPath = path43.join(projectRoot, ".cleargate", ".sync-marker.json");
   const updateMarker = async (nowIso2) => {
     try {
       const content = JSON.stringify({ last_check: nowIso2 });
-      await fsPromises8.mkdir(path42.dirname(markerPath), { recursive: true });
+      await fsPromises8.mkdir(path43.dirname(markerPath), { recursive: true });
       const tmpPath = `${markerPath}.tmp.${Date.now()}`;
       await fsPromises8.writeFile(tmpPath, content, "utf8");
       await fsPromises8.rename(tmpPath, markerPath);
@@ -8386,7 +8451,7 @@ async function syncHandler(opts = {}) {
   const nowFn = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const identity = resolveIdentity(projectRoot);
   const sprintRoot = resolveActiveSprintDir(projectRoot);
-  const sprintId = path42.basename(sprintRoot);
+  const sprintId = path43.basename(sprintRoot);
   let mcp;
   if (opts.mcp) {
     mcp = opts.mcp;
@@ -8447,7 +8512,7 @@ async function syncHandler(opts = {}) {
     exit(2);
     return;
   }
-  const wikiMetaPath = path42.join(projectRoot, ".cleargate", "wiki", "meta.json");
+  const wikiMetaPath = path43.join(projectRoot, ".cleargate", "wiki", "meta.json");
   let lastRemoteSync = "1970-01-01T00:00:00.000Z";
   try {
     const metaRaw = await fsPromises8.readFile(wikiMetaPath, "utf8");
@@ -8688,7 +8753,7 @@ async function syncHandler(opts = {}) {
     };
     await appendSyncLog(sprintRoot, entry);
   }
-  const conflictsFile = path42.join(projectRoot, ".cleargate", ".conflicts.json");
+  const conflictsFile = path43.join(projectRoot, ".cleargate", ".conflicts.json");
   const conflictsContent = {
     generated_at: nowFn(),
     sprint_id: sprintId,
@@ -8696,7 +8761,7 @@ async function syncHandler(opts = {}) {
   };
   await writeAtomic5(conflictsFile, JSON.stringify(conflictsContent, null, 2) + "\n");
   try {
-    await fsPromises8.mkdir(path42.dirname(wikiMetaPath), { recursive: true });
+    await fsPromises8.mkdir(path43.dirname(wikiMetaPath), { recursive: true });
     let meta = {};
     try {
       const raw = await fsPromises8.readFile(wikiMetaPath, "utf8");
@@ -8737,13 +8802,13 @@ async function applyPull(item, localPath, fm, actorEmail, nowFn) {
   await writeAtomic5(localPath, newContent);
 }
 async function writeAtomic5(filePath, content) {
-  await fsPromises8.mkdir(path42.dirname(filePath), { recursive: true });
+  await fsPromises8.mkdir(path43.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 = path42.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSync = path43.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   const results = [];
   let entries;
   try {
@@ -8753,7 +8818,7 @@ async function scanLocalItems(projectRoot) {
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const fullPath = path42.join(pendingSync, entry.name);
+    const fullPath = path43.join(pendingSync, entry.name);
     try {
       const raw = await fsPromises8.readFile(fullPath, "utf8");
       const { fm, body } = parseFrontmatter(raw);
@@ -8776,7 +8841,7 @@ function getItemId(fm) {
 // src/commands/pull.ts
 init_cjs_shims();
 var fsPromises9 = __toESM(require("fs/promises"), 1);
-var path43 = __toESM(require("path"), 1);
+var path44 = __toESM(require("path"), 1);
 init_acquire();
 init_config();
 async function pullHandler(idOrRemoteId, opts = {}) {
@@ -8891,7 +8956,7 @@ async function pullHandler(idOrRemoteId, opts = {}) {
     result: "ok"
   };
   await appendSyncLog(sprintRoot, entry);
-  stdout(`pull: ${remoteId} applied to ${path43.relative(projectRoot, localPath)}
+  stdout(`pull: ${remoteId} applied to ${path44.relative(projectRoot, localPath)}
 `);
   if (opts.comments) {
     const comments = await mcp.call(
@@ -8914,7 +8979,7 @@ async function resolveRemoteId(idOrRemoteId, projectRoot) {
   if (/^[A-Z]+-\d+/.test(idOrRemoteId)) {
     return idOrRemoteId;
   }
-  const pendingSync = path43.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSync = path44.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   let entries;
   try {
     entries = await fsPromises9.readdir(pendingSync, { withFileTypes: true });
@@ -8924,7 +8989,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(path43.join(pendingSync, entry.name), "utf8");
+      const raw = await fsPromises9.readFile(path44.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") {
@@ -8937,7 +9002,7 @@ async function resolveRemoteId(idOrRemoteId, projectRoot) {
   return null;
 }
 async function findLocalFile(remoteId, projectRoot) {
-  const pendingSync = path43.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSync = path44.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   let entries;
   try {
     entries = await fsPromises9.readdir(pendingSync, { withFileTypes: true });
@@ -8946,7 +9011,7 @@ async function findLocalFile(remoteId, projectRoot) {
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const fullPath = path43.join(pendingSync, entry.name);
+    const fullPath = path44.join(pendingSync, entry.name);
     try {
       const raw = await fsPromises9.readFile(fullPath, "utf8");
       const { fm } = parseFrontmatter(raw);
@@ -8957,7 +9022,7 @@ async function findLocalFile(remoteId, projectRoot) {
   return null;
 }
 async function writeAtomic6(filePath, content) {
-  await fsPromises9.mkdir(path43.dirname(filePath), { recursive: true });
+  await fsPromises9.mkdir(path44.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises9.writeFile(tmpPath, content, "utf8");
   await fsPromises9.rename(tmpPath, filePath);
@@ -8973,7 +9038,7 @@ function getItemId2(fm) {
 // src/commands/push.ts
 init_cjs_shims();
 var fsPromises10 = __toESM(require("fs/promises"), 1);
-var path44 = __toESM(require("path"), 1);
+var path45 = __toESM(require("path"), 1);
 init_acquire();
 init_config();
 async function pushHandler(fileOrId, opts = {}) {
@@ -9049,7 +9114,7 @@ async function pushHandler(fileOrId, opts = {}) {
 }
 async function handlePush(filePath, ctx) {
   const { projectRoot, identity, sprintRoot, nowFn, resolveMcp, stdout, stderr, exit } = ctx;
-  const resolvedPath = path44.isAbsolute(filePath) ? filePath : path44.resolve(projectRoot, filePath);
+  const resolvedPath = path45.isAbsolute(filePath) ? filePath : path45.resolve(projectRoot, filePath);
   let rawContent;
   try {
     rawContent = await fsPromises10.readFile(resolvedPath, "utf8");
@@ -9175,8 +9240,8 @@ async function handleRevert(idOrRemoteId, ctx) {
   void localPath;
 }
 async function resolveLocalItem(idOrRemoteId, projectRoot) {
-  const pendingSync = path44.join(projectRoot, ".cleargate", "delivery", "pending-sync");
-  const archive = path44.join(projectRoot, ".cleargate", "delivery", "archive");
+  const pendingSync = path45.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const archive = path45.join(projectRoot, ".cleargate", "delivery", "archive");
   for (const dir of [pendingSync, archive]) {
     let entries;
     try {
@@ -9186,7 +9251,7 @@ async function resolveLocalItem(idOrRemoteId, projectRoot) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path44.join(dir, entry.name);
+      const fullPath = path45.join(dir, entry.name);
       try {
         const raw = await fsPromises10.readFile(fullPath, "utf8");
         const { fm } = parseFrontmatter(raw);
@@ -9205,7 +9270,7 @@ async function resolveLocalItem(idOrRemoteId, projectRoot) {
   return null;
 }
 async function writeAtomic7(filePath, content) {
-  await fsPromises10.mkdir(path44.dirname(filePath), { recursive: true });
+  await fsPromises10.mkdir(path45.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises10.writeFile(tmpPath, content, "utf8");
   await fsPromises10.rename(tmpPath, filePath);
@@ -9234,7 +9299,7 @@ function getItemType(fm) {
 // src/commands/conflicts.ts
 init_cjs_shims();
 var fsPromises11 = __toESM(require("fs/promises"), 1);
-var path45 = __toESM(require("path"), 1);
+var path46 = __toESM(require("path"), 1);
 init_acquire();
 init_config();
 var RESOLUTION_HINTS = {
@@ -9272,7 +9337,7 @@ async function conflictsHandler(opts = {}) {
       }
     }
   }
-  const conflictsFile = path45.join(projectRoot, ".cleargate", ".conflicts.json");
+  const conflictsFile = path46.join(projectRoot, ".cleargate", ".conflicts.json");
   let data;
   try {
     const raw = await fsPromises11.readFile(conflictsFile, "utf8");
@@ -9360,8 +9425,8 @@ function formatEntry(entry) {
 
 // src/commands/admin-login.ts
 init_cjs_shims();
-var fs35 = __toESM(require("fs"), 1);
-var path46 = __toESM(require("path"), 1);
+var fs36 = __toESM(require("fs"), 1);
+var path47 = __toESM(require("path"), 1);
 var os7 = __toESM(require("os"), 1);
 var DEFAULT_MCP_URL = "http://localhost:3000";
 function resolveMcpUrl(mcpUrlFlag, env) {
@@ -9370,14 +9435,14 @@ function resolveMcpUrl(mcpUrlFlag, env) {
 function resolveAuthFilePath(opts) {
   if (opts.authFilePath) return opts.authFilePath;
   const homedirFn = opts.homedir ?? os7.homedir;
-  return path46.join(homedirFn(), ".cleargate", "admin-auth.json");
+  return path47.join(homedirFn(), ".cleargate", "admin-auth.json");
 }
 function writeAdminAuth(filePath, token) {
-  const dir = path46.dirname(filePath);
-  fs35.mkdirSync(dir, { recursive: true });
+  const dir = path47.dirname(filePath);
+  fs36.mkdirSync(dir, { recursive: true });
   const payload = JSON.stringify({ version: 1, token }, null, 2);
-  fs35.writeFileSync(filePath, payload, { encoding: "utf8", mode: 384 });
-  fs35.chmodSync(filePath, 384);
+  fs36.writeFileSync(filePath, payload, { encoding: "utf8", mode: 384 });
+  fs36.chmodSync(filePath, 384);
 }
 async function adminLoginHandler(opts = {}) {
   const fetchFn = opts.fetch ?? globalThis.fetch;
@@ -9487,8 +9552,8 @@ async function adminLoginHandler(opts = {}) {
 
 // src/commands/hotfix.ts
 init_cjs_shims();
-var fs36 = __toESM(require("fs"), 1);
-var path47 = __toESM(require("path"), 1);
+var fs37 = __toESM(require("fs"), 1);
+var path48 = __toESM(require("path"), 1);
 function defaultExit4(code) {
   return process.exit(code);
 }
@@ -9498,7 +9563,7 @@ function maxHotfixId(pendingDir) {
   let max = 0;
   let entries;
   try {
-    entries = fs36.readdirSync(pendingDir);
+    entries = fs37.readdirSync(pendingDir);
   } catch {
     return 0;
   }
@@ -9512,13 +9577,13 @@ function maxHotfixId(pendingDir) {
   return max;
 }
 function countActiveHotfixes(repoRoot) {
-  const pendingDir = path47.join(repoRoot, ".cleargate", "delivery", "pending-sync");
-  const archiveDir = path47.join(repoRoot, ".cleargate", "delivery", "archive");
+  const pendingDir = path48.join(repoRoot, ".cleargate", "delivery", "pending-sync");
+  const archiveDir = path48.join(repoRoot, ".cleargate", "delivery", "archive");
   const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
   let count = 0;
   let pendingEntries = [];
   try {
-    pendingEntries = fs36.readdirSync(pendingDir);
+    pendingEntries = fs37.readdirSync(pendingDir);
   } catch {
   }
   for (const entry of pendingEntries) {
@@ -9526,13 +9591,13 @@ function countActiveHotfixes(repoRoot) {
   }
   let archiveEntries = [];
   try {
-    archiveEntries = fs36.readdirSync(archiveDir);
+    archiveEntries = fs37.readdirSync(archiveDir);
   } catch {
   }
   for (const entry of archiveEntries) {
     if (entry.startsWith("HOTFIX-") && entry.endsWith(".md")) {
       try {
-        const stat = fs36.statSync(path47.join(archiveDir, entry));
+        const stat = fs37.statSync(path48.join(archiveDir, entry));
         if (stat.mtimeMs >= sevenDaysAgo) count++;
       } catch {
       }
@@ -9541,7 +9606,7 @@ function countActiveHotfixes(repoRoot) {
   return count;
 }
 function resolveTemplatePath(repoRoot) {
-  return path47.join(repoRoot, ".cleargate", "templates", "hotfix.md");
+  return path48.join(repoRoot, ".cleargate", "templates", "hotfix.md");
 }
 function hotfixNewHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -9560,14 +9625,14 @@ function hotfixNewHandler(opts, cli) {
     );
     return exitFn(1);
   }
-  const pendingDir = path47.join(repoRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingDir = path48.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 = fs36.readFileSync(templatePath, "utf8");
+    templateContent = fs37.readFileSync(templatePath, "utf8");
   } catch {
     stderrFn(`[cleargate hotfix new] template not found: ${templatePath}`);
     return exitFn(2);
@@ -9575,10 +9640,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 = path47.join(pendingDir, fileName);
+  const outPath = path48.join(pendingDir, fileName);
   try {
-    fs36.mkdirSync(pendingDir, { recursive: true });
-    fs36.writeFileSync(outPath, content, "utf8");
+    fs37.mkdirSync(pendingDir, { recursive: true });
+    fs37.writeFileSync(outPath, content, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     stderrFn(`[cleargate hotfix new] write failed: ${msg}`);