cleargate 0.6.2 → 0.7.0

package/dist/cli.js

@@ -14,7 +14,7 @@ import { Command } from "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.",
@@ -1272,8 +1272,8 @@ async function stampHandler(file, opts, cli) {
 }
 
 // src/commands/init.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs14 from "fs";
+import * as path14 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { spawnSync as spawnSync3 } from "child_process";
 
@@ -1319,9 +1319,14 @@ function copyPayload(payloadDir, targetCwd, opts) {
       srcContent = text;
     }
     const srcBuffer = typeof srcContent === "string" ? Buffer.from(srcContent, "utf8") : srcContent;
+    const srcMode = fs5.statSync(srcPath).mode;
+    const needsExec = (srcMode & 73) !== 0 || relPath.endsWith(".sh");
     if (fs5.existsSync(dstPath)) {
       const dstContent = fs5.readFileSync(dstPath);
       if (srcBuffer.equals(dstContent)) {
+        if (needsExec && process.platform !== "win32") {
+          fs5.chmodSync(dstPath, 493);
+        }
         report.skipped++;
         report.actions.push({ action: "skipped", relPath });
         continue;
@@ -1332,10 +1337,16 @@ function copyPayload(payloadDir, targetCwd, opts) {
         continue;
       }
       fs5.writeFileSync(dstPath, srcBuffer);
+      if (needsExec && process.platform !== "win32") {
+        fs5.chmodSync(dstPath, 493);
+      }
       report.overwritten++;
       report.actions.push({ action: "overwritten", relPath });
     } else {
       fs5.writeFileSync(dstPath, srcBuffer);
+      if (needsExec && process.platform !== "win32") {
+        fs5.chmodSync(dstPath, 493);
+      }
       report.created++;
       report.actions.push({ action: "created", relPath });
     }
@@ -1402,13 +1413,46 @@ function injectClaudeMd(existing, block) {
   return existing.trimEnd() + "\n\n" + block + "\n";
 }
 
+// src/init/inject-mcp-json.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+function mergeMcpJson(existing, entry) {
+  const next = existing ? { ...existing } : {};
+  const servers = { ...next.mcpServers ?? {} };
+  servers.cleargate = entry;
+  next.mcpServers = servers;
+  return JSON.stringify(next, null, 2) + "\n";
+}
+function injectMcpJson(cwd, url) {
+  const dst = path5.join(cwd, ".mcp.json");
+  const entry = { type: "http", url };
+  let existing = null;
+  let existingRaw = null;
+  if (fs6.existsSync(dst)) {
+    existingRaw = fs6.readFileSync(dst, "utf8");
+    try {
+      existing = JSON.parse(existingRaw);
+    } catch {
+      throw new Error(
+        `inject-mcp-json: ${dst} is not valid JSON; refusing to overwrite. Fix or remove the file and re-run init.`
+      );
+    }
+  }
+  const next = mergeMcpJson(existing, entry);
+  if (existingRaw !== null && existingRaw === next) {
+    return "unchanged";
+  }
+  fs6.writeFileSync(dst, next);
+  return existingRaw === null ? "created" : "updated";
+}
+
 // src/commands/wiki-build.ts
-import * as fs11 from "fs";
-import * as path10 from "path";
+import * as fs12 from "fs";
+import * as path11 from "path";
 
 // src/wiki/scan.ts
-import * as fs6 from "fs";
-import * as path5 from "path";
+import * as fs7 from "fs";
+import * as path6 from "path";
 
 // src/wiki/derive-bucket.ts
 var PREFIX_MAP = [
@@ -1451,19 +1495,19 @@ var EXCLUDED_SUFFIXES = [
 function scanRawItems(deliveryRoot, repoRoot) {
   const results = [];
   for (const subdir of ["pending-sync", "archive"]) {
-    const dir = path5.join(deliveryRoot, subdir);
-    if (!fs6.existsSync(dir)) continue;
-    const entries = fs6.readdirSync(dir, { recursive: true, encoding: "utf8" });
+    const dir = path6.join(deliveryRoot, subdir);
+    if (!fs7.existsSync(dir)) continue;
+    const entries = fs7.readdirSync(dir, { recursive: true, encoding: "utf8" });
     for (const rel of entries) {
       if (!rel.endsWith(".md")) continue;
       if (rel.includes("~") || rel.startsWith(".")) continue;
-      const absPath = path5.join(dir, rel);
-      const stat = fs6.statSync(absPath);
+      const absPath = path6.join(dir, rel);
+      const stat = fs7.statSync(absPath);
       if (!stat.isFile()) continue;
-      const rawPath = path5.relative(repoRoot, absPath).replace(/\\/g, "/");
+      const rawPath = path6.relative(repoRoot, absPath).replace(/\\/g, "/");
       const isExcluded = EXCLUDED_SUFFIXES.some((excl) => rawPath.startsWith(excl));
       if (isExcluded) continue;
-      const filename = path5.basename(absPath);
+      const filename = path6.basename(absPath);
       let bucketInfo;
       try {
         bucketInfo = deriveBucket(filename);
@@ -1476,7 +1520,7 @@ function scanRawItems(deliveryRoot, repoRoot) {
       } catch {
         continue;
       }
-      const raw = fs6.readFileSync(absPath, "utf8");
+      const raw = fs7.readFileSync(absPath, "utf8");
       let fm;
       let body;
       try {
@@ -1588,8 +1632,8 @@ function parseFmRaw(raw) {
 }
 
 // src/wiki/synthesis/active-sprint.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path7 from "path";
 import { fileURLToPath } from "url";
 
 // src/wiki/synthesis/render.ts
@@ -1628,7 +1672,7 @@ function renderSection(template, ctx) {
 // src/wiki/synthesis/active-sprint.ts
 function compile(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir();
-  const tpl = fs7.readFileSync(path6.join(tplDir, "active-sprint.md"), "utf8");
+  const tpl = fs8.readFileSync(path7.join(tplDir, "active-sprint.md"), "utf8");
   const sprints = state2.filter((i) => i.bucket === "sprints");
   const active = sprints.filter((s) => isSet(s.fm["activated_at"]) && !isSet(s.fm["completed_at"]));
   const completed = sprints.filter((s) => isSet(s.fm["completed_at"]));
@@ -1652,17 +1696,17 @@ function isSet(val) {
   return s !== "" && s !== "null";
 }
 function resolveDefaultTemplateDir() {
-  const __dirname2 = path6.dirname(fileURLToPath(import.meta.url));
-  return path6.resolve(__dirname2, "..", "templates", "synthesis");
+  const __dirname2 = path7.dirname(fileURLToPath(import.meta.url));
+  return path7.resolve(__dirname2, "..", "templates", "synthesis");
 }
 
 // src/wiki/synthesis/open-gates.ts
-import * as fs8 from "fs";
-import * as path7 from "path";
+import * as fs9 from "fs";
+import * as path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function compile2(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir2();
-  const tpl = fs8.readFileSync(path7.join(tplDir, "open-gates.md"), "utf8");
+  const tpl = fs9.readFileSync(path8.join(tplDir, "open-gates.md"), "utf8");
   const gate1 = state2.filter((i) => {
     if (i.bucket !== "proposals") return false;
     const status = String(i.fm["status"] ?? "");
@@ -1691,17 +1735,17 @@ function compile2(state2, templateDir) {
   return renderTemplate(tpl, data);
 }
 function resolveDefaultTemplateDir2() {
-  const __dirname2 = path7.dirname(fileURLToPath2(import.meta.url));
-  return path7.resolve(__dirname2, "..", "templates", "synthesis");
+  const __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
+  return path8.resolve(__dirname2, "..", "templates", "synthesis");
 }
 
 // src/wiki/synthesis/product-state.ts
-import * as fs9 from "fs";
-import * as path8 from "path";
+import * as fs10 from "fs";
+import * as path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function compile3(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir3();
-  const tpl = fs9.readFileSync(path8.join(tplDir, "product-state.md"), "utf8");
+  const tpl = fs10.readFileSync(path9.join(tplDir, "product-state.md"), "utf8");
   function countBucket(bucket) {
     return state2.filter((i) => i.bucket === bucket);
   }
@@ -1748,17 +1792,17 @@ function compile3(state2, templateDir) {
   return renderTemplate(tpl, data);
 }
 function resolveDefaultTemplateDir3() {
-  const __dirname2 = path8.dirname(fileURLToPath3(import.meta.url));
-  return path8.resolve(__dirname2, "..", "templates", "synthesis");
+  const __dirname2 = path9.dirname(fileURLToPath3(import.meta.url));
+  return path9.resolve(__dirname2, "..", "templates", "synthesis");
 }
 
 // src/wiki/synthesis/roadmap.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path10 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function compile4(state2, templateDir) {
   const tplDir = templateDir ?? resolveDefaultTemplateDir4();
-  const tpl = fs10.readFileSync(path9.join(tplDir, "roadmap.md"), "utf8");
+  const tpl = fs11.readFileSync(path10.join(tplDir, "roadmap.md"), "utf8");
   const sprints = state2.filter((i) => i.bucket === "sprints");
   const epics = state2.filter((i) => i.bucket === "epics");
   const inFlightSprints = sprints.filter(
@@ -1811,8 +1855,8 @@ function isShippedStatus(status) {
   return status === "Completed" || status === "Approved";
 }
 function resolveDefaultTemplateDir4() {
-  const __dirname2 = path9.dirname(fileURLToPath4(import.meta.url));
-  return path9.resolve(__dirname2, "..", "templates", "synthesis");
+  const __dirname2 = path10.dirname(fileURLToPath4(import.meta.url));
+  return path10.resolve(__dirname2, "..", "templates", "synthesis");
 }
 
 // src/commands/wiki-build.ts
@@ -1837,16 +1881,16 @@ async function wikiBuildHandler(opts = {}) {
   const exit = opts.exit ?? ((c) => process.exit(c));
   const gitRunner = opts.gitRunner;
   const templateDir = opts.templateDir;
-  const deliveryRoot = path10.join(cwd, ".cleargate", "delivery");
-  const wikiRoot = path10.join(cwd, ".cleargate", "wiki");
-  if (!fs11.existsSync(deliveryRoot)) {
+  const deliveryRoot = path11.join(cwd, ".cleargate", "delivery");
+  const wikiRoot = path11.join(cwd, ".cleargate", "wiki");
+  if (!fs12.existsSync(deliveryRoot)) {
     stderr(`wiki build: .cleargate/delivery/ not found at ${deliveryRoot}
 `);
     exit(1);
     return;
   }
   for (const bucket of BUCKET_ORDER) {
-    fs11.mkdirSync(path10.join(wikiRoot, bucket), { recursive: true });
+    fs12.mkdirSync(path11.join(wikiRoot, bucket), { recursive: true });
   }
   const items = scanRawItems(deliveryRoot, cwd);
   const timestamp = now();
@@ -1869,19 +1913,19 @@ async function wikiBuildHandler(opts = {}) {
     };
     const body = buildPageBody(item, wikiPage);
     const content = serializePage(wikiPage, body);
-    const pageDir = path10.join(wikiRoot, item.bucket);
-    fs11.mkdirSync(pageDir, { recursive: true });
-    fs11.writeFileSync(path10.join(pageDir, `${item.id}.md`), content, "utf8");
+    const pageDir = path11.join(wikiRoot, item.bucket);
+    fs12.mkdirSync(pageDir, { recursive: true });
+    fs12.writeFileSync(path11.join(pageDir, `${item.id}.md`), content, "utf8");
     pagesWritten++;
   }
   const indexContent = buildIndex(items);
-  fs11.writeFileSync(path10.join(wikiRoot, "index.md"), indexContent, "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "index.md"), indexContent, "utf8");
   const logContent = buildLog(items, timestamp);
-  fs11.writeFileSync(path10.join(wikiRoot, "log.md"), logContent, "utf8");
-  fs11.writeFileSync(path10.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
-  fs11.writeFileSync(path10.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
-  fs11.writeFileSync(path10.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
-  fs11.writeFileSync(path10.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "log.md"), logContent, "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
+  fs12.writeFileSync(path11.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
   stdout(`wiki build: OK (${pagesWritten} pages written)
 `);
 }
@@ -2046,8 +2090,8 @@ function buildLog(items, timestamp) {
 
 // src/lib/manifest.ts
 import { readFile as readFile3, writeFile as writeFile2, rename, mkdir } from "fs/promises";
-import { existsSync as existsSync7, readFileSync as readFileSync10 } from "fs";
-import * as path11 from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync11 } from "fs";
+import * as path12 from "path";
 
 // src/lib/sha256.ts
 import { createHash } from "crypto";
@@ -2070,31 +2114,31 @@ function shortHash(full) {
 // src/lib/manifest.ts
 function resolveDefaultPackageRoot() {
   const here = new URL(".", import.meta.url).pathname;
-  const distCandidate = path11.join(here, "MANIFEST.json");
-  if (existsSync7(distCandidate)) {
+  const distCandidate = path12.join(here, "MANIFEST.json");
+  if (existsSync8(distCandidate)) {
     return here;
   }
-  const oneLevelUp = path11.join(here, "..", "MANIFEST.json");
-  if (existsSync7(oneLevelUp)) {
-    return path11.join(here, "..");
+  const oneLevelUp = path12.join(here, "..", "MANIFEST.json");
+  if (existsSync8(oneLevelUp)) {
+    return path12.join(here, "..");
   }
-  const devCandidate = path11.join(here, "..", "..", "..", "cleargate-planning", "MANIFEST.json");
-  if (existsSync7(devCandidate)) {
-    return path11.join(here, "..", "..", "..", "cleargate-planning");
+  const devCandidate = path12.join(here, "..", "..", "..", "cleargate-planning", "MANIFEST.json");
+  if (existsSync8(devCandidate)) {
+    return path12.join(here, "..", "..", "..", "cleargate-planning");
   }
   return here;
 }
 function loadPackageManifest(opts) {
   const packageRoot = opts?.packageRoot ?? resolveDefaultPackageRoot();
-  const manifestPath = path11.join(packageRoot, "MANIFEST.json");
-  if (!existsSync7(manifestPath)) {
+  const manifestPath = path12.join(packageRoot, "MANIFEST.json");
+  if (!existsSync8(manifestPath)) {
     throw new Error(
       `MANIFEST.json not found at ${manifestPath}; run 'npm run build' to generate it.`
     );
   }
   let raw;
   try {
-    raw = readFileSync10(manifestPath, "utf-8");
+    raw = readFileSync11(manifestPath, "utf-8");
   } catch {
     throw new Error(
       `MANIFEST.json not found at ${manifestPath}; run 'npm run build' to generate it.`
@@ -2103,7 +2147,7 @@ function loadPackageManifest(opts) {
   return JSON.parse(raw);
 }
 async function loadInstallSnapshot(projectRoot) {
-  const snapshotPath = path11.join(projectRoot, ".cleargate", ".install-manifest.json");
+  const snapshotPath = path12.join(projectRoot, ".cleargate", ".install-manifest.json");
   try {
     const raw = await readFile3(snapshotPath, "utf-8");
     return JSON.parse(raw);
@@ -2112,7 +2156,7 @@ async function loadInstallSnapshot(projectRoot) {
   }
 }
 async function computeCurrentSha(file, projectRoot) {
-  const filePath = path11.join(projectRoot, file.path);
+  const filePath = path12.join(projectRoot, file.path);
   try {
     const raw = await readFile3(filePath);
     return hashNormalized(raw);
@@ -2141,8 +2185,8 @@ function classify(pkgSha, installSha, currentSha, tier) {
   return "both-changed";
 }
 async function writeDriftState(projectRoot, state2, opts) {
-  const cleargatDir = path11.join(projectRoot, ".cleargate");
-  const finalPath = path11.join(cleargatDir, ".drift-state.json");
+  const cleargatDir = path12.join(projectRoot, ".cleargate");
+  const finalPath = path12.join(cleargatDir, ".drift-state.json");
   const tmpPath = `${finalPath}.tmp`;
   const lastRefreshed = opts?.lastRefreshed ?? (/* @__PURE__ */ new Date()).toISOString();
   const fileContent = { last_refreshed: lastRefreshed, drift: state2 };
@@ -2151,7 +2195,7 @@ async function writeDriftState(projectRoot, state2, opts) {
   await rename(tmpPath, finalPath);
 }
 async function readDriftState(projectRoot) {
-  const driftPath = path11.join(projectRoot, ".cleargate", ".drift-state.json");
+  const driftPath = path12.join(projectRoot, ".cleargate", ".drift-state.json");
   try {
     const raw = await readFile3(driftPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -2224,24 +2268,24 @@ async function promptEmail(question, defaultValue, opts) {
 }
 
 // src/lib/identity.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 import * as fsPromises from "fs/promises";
 import * as os3 from "os";
 import { spawnSync as spawnSync2 } from "child_process";
 function readParticipant(projectRoot) {
-  const filePath = path12.join(projectRoot, ".cleargate", ".participant.json");
+  const filePath = path13.join(projectRoot, ".cleargate", ".participant.json");
   try {
-    const raw = fs12.readFileSync(filePath, "utf8");
+    const raw = fs13.readFileSync(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 async function writeParticipant(projectRoot, email, source, now = () => (/* @__PURE__ */ new Date()).toISOString()) {
-  const cleargateDir = path12.join(projectRoot, ".cleargate");
+  const cleargateDir = path13.join(projectRoot, ".cleargate");
   await fsPromises.mkdir(cleargateDir, { recursive: true });
-  const filePath = path12.join(cleargateDir, ".participant.json");
+  const filePath = path13.join(cleargateDir, ".participant.json");
   const tmpPath = filePath + ".tmp." + Date.now();
   const content = {
     email,
@@ -2317,16 +2361,16 @@ var HOOK_ADDITION = {
 };
 function resolveDefaultPayloadDir() {
   const thisFile = fileURLToPath5(import.meta.url);
-  const pkgRoot = path13.resolve(path13.dirname(thisFile), "..");
-  return path13.join(pkgRoot, "templates", "cleargate-planning");
+  const pkgRoot = path14.resolve(path14.dirname(thisFile), "..");
+  return path14.join(pkgRoot, "templates", "cleargate-planning");
 }
 function countDeliveryItems(cwd) {
-  const pendingSync = path13.join(cwd, ".cleargate", "delivery", "pending-sync");
-  const archive = path13.join(cwd, ".cleargate", "delivery", "archive");
+  const pendingSync = path14.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const archive = path14.join(cwd, ".cleargate", "delivery", "archive");
   let count = 0;
   for (const dir of [pendingSync, archive]) {
-    if (!fs13.existsSync(dir)) continue;
-    const entries = fs13.readdirSync(dir);
+    if (!fs14.existsSync(dir)) continue;
+    const entries = fs14.readdirSync(dir);
     for (const f of entries) {
       if (f.endsWith(".md") && f !== ".gitkeep") count++;
     }
@@ -2335,12 +2379,12 @@ function countDeliveryItems(cwd) {
 }
 function writeAtomic(filePath, content) {
   const tmpPath = filePath + ".tmp." + Date.now();
-  fs13.writeFileSync(tmpPath, content, "utf8");
-  fs13.renameSync(tmpPath, filePath);
+  fs14.writeFileSync(tmpPath, content, "utf8");
+  fs14.renameSync(tmpPath, filePath);
 }
 function readPackageVersion(packageJsonPath) {
   try {
-    const raw = fs13.readFileSync(packageJsonPath, "utf8");
+    const raw = fs14.readFileSync(packageJsonPath, "utf8");
     const pkg = JSON.parse(raw);
     if (typeof pkg.version === "string" && pkg.version.length > 0) {
       return pkg.version;
@@ -2360,16 +2404,16 @@ async function initHandler(opts = {}) {
   const promptYesNoFn = opts.promptYesNo ?? promptYesNo;
   const promptEmailFn = opts.promptEmail ?? promptEmail;
   const spawnSyncFn = opts.spawnSyncFn ?? spawnSync3;
-  if (!fs13.existsSync(cwd)) {
+  if (!fs14.existsSync(cwd)) {
     stderr(`[cleargate init] ERROR: target directory does not exist: ${cwd}
 `);
     exit(1);
     return;
   }
-  const testWritePath = path13.join(cwd, `.cleargate-init-write-test-${Date.now()}`);
+  const testWritePath = path14.join(cwd, `.cleargate-init-write-test-${Date.now()}`);
   try {
-    fs13.writeFileSync(testWritePath, "");
-    fs13.unlinkSync(testWritePath);
+    fs14.writeFileSync(testWritePath, "");
+    fs14.unlinkSync(testWritePath);
   } catch {
     stderr(`[cleargate init] ERROR: target directory is not writable: ${cwd}
 `);
@@ -2379,7 +2423,7 @@ async function initHandler(opts = {}) {
   stdout(`[cleargate init] Target: ${cwd}
 `);
   const payloadDir = opts.payloadDir ?? resolveDefaultPayloadDir();
-  if (!fs13.existsSync(payloadDir)) {
+  if (!fs14.existsSync(payloadDir)) {
     stderr(`[cleargate init] ERROR: payload directory not found: ${payloadDir}
 `);
     stderr(`[cleargate init] Run \`npm run prebuild\` to copy the payload first.
@@ -2387,12 +2431,12 @@ async function initHandler(opts = {}) {
     exit(1);
     return;
   }
-  const uninstalledMarkerPath = path13.join(cwd, ".cleargate", ".uninstalled");
+  const uninstalledMarkerPath = path14.join(cwd, ".cleargate", ".uninstalled");
   let uninstalledMarker = null;
   let userChoseRestore = false;
-  if (fs13.existsSync(uninstalledMarkerPath)) {
+  if (fs14.existsSync(uninstalledMarkerPath)) {
     try {
-      const raw = fs13.readFileSync(uninstalledMarkerPath, "utf8");
+      const raw = fs14.readFileSync(uninstalledMarkerPath, "utf8");
       uninstalledMarker = JSON.parse(raw);
     } catch {
       stderr(`[cleargate init] WARNING: .uninstalled marker is malformed; ignoring it.
@@ -2404,8 +2448,8 @@ async function initHandler(opts = {}) {
       userChoseRestore = await promptYesNoFn(question, true);
       if (userChoseRestore) {
         for (const preservedPath of preserved) {
-          const absPreserved = path13.isAbsolute(preservedPath) ? preservedPath : path13.join(cwd, preservedPath);
-          if (fs13.existsSync(absPreserved)) {
+          const absPreserved = path14.isAbsolute(preservedPath) ? preservedPath : path14.join(cwd, preservedPath);
+          if (fs14.existsSync(absPreserved)) {
             stdout(`[cleargate init] [preserved] ${preservedPath}
 `);
           } else {
@@ -2425,8 +2469,8 @@ async function initHandler(opts = {}) {
   if (opts.pin) {
     pinVersion = opts.pin;
   } else {
-    const payloadParent = path13.resolve(payloadDir, "..", "..");
-    pinVersion = readPackageVersion(path13.join(payloadParent, "package.json")) ?? readPackageVersion(path13.join(path13.dirname(fileURLToPath5(import.meta.url)), "..", "package.json")) ?? "latest";
+    const payloadParent = path14.resolve(payloadDir, "..", "..");
+    pinVersion = readPackageVersion(path14.join(payloadParent, "package.json")) ?? readPackageVersion(path14.join(path14.dirname(fileURLToPath5(import.meta.url)), "..", "package.json")) ?? "latest";
   }
   const copyReport = copyPayload(payloadDir, cwd, { force, pinVersion });
   for (const action of copyReport.actions) {
@@ -2434,33 +2478,33 @@ async function initHandler(opts = {}) {
     stdout(`[cleargate init] ${verb} ${action.relPath}
 `);
   }
-  const settingsPath = path13.join(cwd, ".claude", "settings.json");
+  const settingsPath = path14.join(cwd, ".claude", "settings.json");
   let existingSettings = null;
-  if (fs13.existsSync(settingsPath)) {
+  if (fs14.existsSync(settingsPath)) {
     try {
-      existingSettings = JSON.parse(fs13.readFileSync(settingsPath, "utf8"));
+      existingSettings = JSON.parse(fs14.readFileSync(settingsPath, "utf8"));
     } catch {
       stderr(`[cleargate init] WARNING: could not parse ${settingsPath}; treating as empty.
 `);
     }
   }
   const mergedSettings = mergeSettings(existingSettings, HOOK_ADDITION);
-  fs13.mkdirSync(path13.dirname(settingsPath), { recursive: true });
+  fs14.mkdirSync(path14.dirname(settingsPath), { recursive: true });
   writeAtomic(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n");
   stdout(`[cleargate init] Updated .claude/settings.json: merged PostToolUse hook
 `);
-  const claudeMdPath = path13.join(cwd, "CLAUDE.md");
-  const claudeMdSrcPath = path13.join(payloadDir, "CLAUDE.md");
+  const claudeMdPath = path14.join(cwd, "CLAUDE.md");
+  const claudeMdSrcPath = path14.join(payloadDir, "CLAUDE.md");
   let claudeMdBlock;
   try {
-    const claudeMdSrc = fs13.readFileSync(claudeMdSrcPath, "utf8");
+    const claudeMdSrc = fs14.readFileSync(claudeMdSrcPath, "utf8");
     claudeMdBlock = extractBlock(claudeMdSrc);
   } catch (e) {
     stderr(`[cleargate init] WARNING: could not read CLAUDE.md block from payload: ${String(e)}
 `);
     claudeMdBlock = "<!-- CLEARGATE:START -->\n<!-- CLEARGATE:END -->";
   }
-  const existingClaudeMd = fs13.existsSync(claudeMdPath) ? fs13.readFileSync(claudeMdPath, "utf8") : null;
+  const existingClaudeMd = fs14.existsSync(claudeMdPath) ? fs14.readFileSync(claudeMdPath, "utf8") : null;
   const newClaudeMd = injectClaudeMd(existingClaudeMd, claudeMdBlock);
   writeAtomic(claudeMdPath, newClaudeMd);
   if (existingClaudeMd === null) {
@@ -2471,6 +2515,26 @@ async function initHandler(opts = {}) {
 `);
   } else {
     stdout(`[cleargate init] CLAUDE.md unchanged (block already up to date)
+`);
+  }
+  try {
+    const action = injectMcpJson(cwd, "https://cleargate-mcp.soula.ge/mcp");
+    if (action === "created") {
+      stdout(
+        `[cleargate init] Created .mcp.json (cleargate MCP server registered) \u2014 restart Claude Code to load it.
+`
+      );
+    } else if (action === "updated") {
+      stdout(
+        `[cleargate init] Updated .mcp.json (cleargate MCP server entry merged) \u2014 restart Claude Code to pick up changes.
+`
+      );
+    } else {
+      stdout(`[cleargate init] .mcp.json unchanged (cleargate entry already present)
+`);
+    }
+  } catch (e) {
+    stderr(`[cleargate init] WARNING: ${String(e instanceof Error ? e.message : e)}
 `);
   }
   const itemCount = countDeliveryItems(cwd);
@@ -2484,9 +2548,9 @@ async function initHandler(opts = {}) {
     stdout(`[cleargate init] Bootstrap: no items to ingest, skipping build
 `);
   }
-  const cleargateDir = path13.join(cwd, ".cleargate");
-  fs13.mkdirSync(cleargateDir, { recursive: true });
-  const snapshotPath = path13.join(cleargateDir, ".install-manifest.json");
+  const cleargateDir = path14.join(cwd, ".cleargate");
+  fs14.mkdirSync(cleargateDir, { recursive: true });
+  const snapshotPath = path14.join(cleargateDir, ".install-manifest.json");
   try {
     const readManifest = opts.readInstallManifest ?? (() => loadPackageManifest({ packageRoot: payloadDir }));
     const pkgManifest = readManifest();
@@ -2501,19 +2565,19 @@ async function initHandler(opts = {}) {
     stderr(`[cleargate init] WARNING: could not write install snapshot: ${String(e)}
 `);
   }
-  if (uninstalledMarker !== null && fs13.existsSync(uninstalledMarkerPath)) {
+  if (uninstalledMarker !== null && fs14.existsSync(uninstalledMarkerPath)) {
     try {
-      fs13.unlinkSync(uninstalledMarkerPath);
+      fs14.unlinkSync(uninstalledMarkerPath);
     } catch (e) {
       stderr(`[cleargate init] WARNING: could not remove .uninstalled marker: ${String(e)}
 `);
     }
   }
   {
-    const distCliPath = path13.join(cwd, "cleargate-cli", "dist", "cli.js");
+    const distCliPath = path14.join(cwd, "cleargate-cli", "dist", "cli.js");
     let branch = null;
     let branchLabel = "";
-    if (fs13.existsSync(distCliPath)) {
+    if (fs14.existsSync(distCliPath)) {
       branch = { cmd: "node", args: [distCliPath, "--version"] };
       branchLabel = `local dist (${distCliPath})`;
     } else {
@@ -2584,8 +2648,8 @@ async function initHandler(opts = {}) {
 }
 
 // src/commands/wiki-ingest.ts
-import * as fs14 from "fs";
-import * as path14 from "path";
+import * as fs15 from "fs";
+import * as path15 from "path";
 import { spawnSync as spawnSync4 } from "child_process";
 var EXCLUDED_SUFFIXES2 = [
   ".cleargate/knowledge/",
@@ -2611,16 +2675,16 @@ async function wikiIngestHandler(opts) {
   const stderr = opts.stderr ?? ((s) => process.stderr.write(s));
   const exit = opts.exit ?? ((c) => process.exit(c));
   const gitRunner = opts.gitRunner;
-  const rename11 = opts.rename ?? fs14.renameSync;
+  const rename11 = opts.rename ?? fs15.renameSync;
   const templateDir = opts.templateDir;
   const rawPath = opts.rawPath;
-  const absRawPath = path14.isAbsolute(rawPath) ? rawPath : path14.resolve(cwd, rawPath);
-  const relRawPath = path14.relative(cwd, absRawPath).replace(/\\/g, "/");
-  const deliveryRoot = path14.join(cwd, ".cleargate", "delivery");
+  const absRawPath = path15.isAbsolute(rawPath) ? rawPath : path15.resolve(cwd, rawPath);
+  const relRawPath = path15.relative(cwd, absRawPath).replace(/\\/g, "/");
+  const deliveryRoot = path15.join(cwd, ".cleargate", "delivery");
   const deliveryRootNorm = deliveryRoot.replace(/\\/g, "/");
   const absDeliveryRoot = deliveryRoot;
-  const relToDelivery = path14.relative(absDeliveryRoot, absRawPath);
-  if (relToDelivery.startsWith("..") || path14.isAbsolute(relToDelivery)) {
+  const relToDelivery = path15.relative(absDeliveryRoot, absRawPath);
+  if (relToDelivery.startsWith("..") || path15.isAbsolute(relToDelivery)) {
     stderr(`wiki ingest: ${rawPath} not under .cleargate/delivery/
 `);
     exit(2);
@@ -2634,7 +2698,7 @@ async function wikiIngestHandler(opts) {
     exit(0);
     return;
   }
-  const filename = path14.basename(absRawPath);
+  const filename = path15.basename(absRawPath);
   let bucketInfo;
   try {
     bucketInfo = deriveBucket(filename);
@@ -2654,12 +2718,12 @@ async function wikiIngestHandler(opts) {
     return;
   }
   const { type, id, bucket } = bucketInfo;
-  const wikiRoot = path14.join(cwd, ".cleargate", "wiki");
-  const pageDir = path14.join(wikiRoot, bucket);
-  const pagePath = path14.join(pageDir, `${id}.md`);
+  const wikiRoot = path15.join(cwd, ".cleargate", "wiki");
+  const pageDir = path15.join(wikiRoot, bucket);
+  const pagePath = path15.join(pageDir, `${id}.md`);
   let rawContent;
   try {
-    rawContent = fs14.readFileSync(absRawPath, "utf8");
+    rawContent = fs15.readFileSync(absRawPath, "utf8");
   } catch (e) {
     stderr(`wiki ingest: cannot read ${rawPath}: ${e.message}
 `);
@@ -2679,11 +2743,11 @@ async function wikiIngestHandler(opts) {
     return;
   }
   const currentSha = getGitSha(absRawPath, gitRunner) ?? "";
-  const pageExists = fs14.existsSync(pagePath);
+  const pageExists = fs15.existsSync(pagePath);
   if (pageExists && currentSha !== "") {
     let isNoOp = false;
     try {
-      const existingPageContent = fs14.readFileSync(pagePath, "utf8");
+      const existingPageContent = fs15.readFileSync(pagePath, "utf8");
       const existingPage = parsePage(existingPageContent);
       if (existingPage.last_ingest_commit === currentSha) {
         const contentUnchanged = checkContentUnchanged(absRawPath, currentSha, relRawPath, gitRunner);
@@ -2718,8 +2782,8 @@ async function wikiIngestHandler(opts) {
   };
   const pageBody = buildPageBody2({ id, fm, body });
   const pageContent = serializePage(wikiPage, pageBody);
-  fs14.mkdirSync(pageDir, { recursive: true });
-  fs14.writeFileSync(pagePath, pageContent, "utf8");
+  fs15.mkdirSync(pageDir, { recursive: true });
+  fs15.writeFileSync(pagePath, pageContent, "utf8");
   appendLogEntry(wikiRoot, { timestamp, action, id, relRawPath });
   updateIndex(wikiRoot, { id, type, status: wikiPage.status, relRawPath, rename: rename11 });
   recompileSynthesis(wikiRoot, cwd, templateDir);
@@ -2731,7 +2795,7 @@ function checkContentUnchanged(absRawPath, sha, relRawPath, gitRunner) {
     const run = gitRunner ?? defaultGitRunner;
     const gitContent = run("git", ["show", `${sha}:${relRawPath}`]);
     if (!gitContent && gitContent !== "") return false;
-    const currentContent = fs14.readFileSync(absRawPath, "utf8");
+    const currentContent = fs15.readFileSync(absRawPath, "utf8");
     return gitContent === currentContent;
   } catch {
     return false;
@@ -2784,7 +2848,7 @@ function buildPageBody2(item) {
   ].join("\n");
 }
 function appendLogEntry(wikiRoot, entry) {
-  const logPath = path14.join(wikiRoot, "log.md");
+  const logPath = path15.join(wikiRoot, "log.md");
   const logEntry = [
     `- timestamp: "${entry.timestamp}"`,
     `  actor: "cleargate wiki ingest"`,
@@ -2792,25 +2856,25 @@ function appendLogEntry(wikiRoot, entry) {
     `  target: "${entry.id}"`,
     `  path: "${entry.relRawPath}"`
   ].join("\n");
-  if (fs14.existsSync(logPath)) {
-    const existing = fs14.readFileSync(logPath, "utf8");
+  if (fs15.existsSync(logPath)) {
+    const existing = fs15.readFileSync(logPath, "utf8");
     const newContent = existing.trimEnd() + "\n" + logEntry + "\n";
-    fs14.writeFileSync(logPath, newContent, "utf8");
+    fs15.writeFileSync(logPath, newContent, "utf8");
   } else {
-    fs14.mkdirSync(wikiRoot, { recursive: true });
-    fs14.writeFileSync(logPath, `# Wiki Event Log
+    fs15.mkdirSync(wikiRoot, { recursive: true });
+    fs15.writeFileSync(logPath, `# Wiki Event Log
 
 ${logEntry}
 `, "utf8");
   }
 }
 function updateIndex(wikiRoot, opts) {
-  const indexPath = path14.join(wikiRoot, "index.md");
+  const indexPath = path15.join(wikiRoot, "index.md");
   const tmpPath = `${indexPath}.tmp`;
   const newRow = `| [[${opts.id}]] | ${opts.type} | ${opts.status} | ${opts.relRawPath} |`;
   let content;
-  if (fs14.existsSync(indexPath)) {
-    content = fs14.readFileSync(indexPath, "utf8");
+  if (fs15.existsSync(indexPath)) {
+    content = fs15.readFileSync(indexPath, "utf8");
     const idPattern = `[[${opts.id}]]`;
     const lines = content.split("\n");
     let replaced = false;
@@ -2829,7 +2893,7 @@ function updateIndex(wikiRoot, opts) {
   } else {
     content = buildMinimalIndex(opts.id, opts.type, opts.status, opts.relRawPath);
   }
-  fs14.writeFileSync(tmpPath, content, "utf8");
+  fs15.writeFileSync(tmpPath, content, "utf8");
   opts.rename(tmpPath, indexPath);
 }
 function insertIntoSection(content, id, newRow) {
@@ -2924,39 +2988,39 @@ function buildMinimalIndex(id, type, status, relRawPath) {
   return lines.join("\n");
 }
 function recompileSynthesis(wikiRoot, cwd, templateDir) {
-  const deliveryRoot = path14.join(cwd, ".cleargate", "delivery");
+  const deliveryRoot = path15.join(cwd, ".cleargate", "delivery");
   let items = [];
-  if (fs14.existsSync(deliveryRoot)) {
+  if (fs15.existsSync(deliveryRoot)) {
     try {
       items = scanRawItems(deliveryRoot, cwd);
     } catch {
     }
   }
-  fs14.writeFileSync(path14.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
-  fs14.writeFileSync(path14.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
-  fs14.writeFileSync(path14.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
-  fs14.writeFileSync(path14.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
+  fs15.writeFileSync(path15.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
+  fs15.writeFileSync(path15.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
+  fs15.writeFileSync(path15.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
+  fs15.writeFileSync(path15.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
 }
 
 // src/commands/wiki-lint.ts
-import * as path18 from "path";
+import * as path19 from "path";
 
 // src/wiki/load-wiki.ts
-import * as fs15 from "fs";
-import * as path15 from "path";
+import * as fs16 from "fs";
+import * as path16 from "path";
 var BUCKET_DIRS = ["epics", "stories", "sprints", "proposals", "crs", "bugs", "topics"];
 function loadWikiPages(wikiRoot) {
   const results = [];
   for (const bucket of BUCKET_DIRS) {
-    const dir = path15.join(wikiRoot, bucket);
-    if (!fs15.existsSync(dir)) continue;
-    const entries = fs15.readdirSync(dir, { encoding: "utf8" });
+    const dir = path16.join(wikiRoot, bucket);
+    if (!fs16.existsSync(dir)) continue;
+    const entries = fs16.readdirSync(dir, { encoding: "utf8" });
     for (const filename of entries) {
       if (!filename.endsWith(".md")) continue;
-      const absPath = path15.join(dir, filename);
-      const stat = fs15.statSync(absPath);
+      const absPath = path16.join(dir, filename);
+      const stat = fs16.statSync(absPath);
       if (!stat.isFile()) continue;
-      const raw = fs15.readFileSync(absPath, "utf8");
+      const raw = fs16.readFileSync(absPath, "utf8");
       let fm;
       let body;
       try {
@@ -2985,8 +3049,8 @@ function loadWikiPages(wikiRoot) {
 }
 
 // src/wiki/lint-checks.ts
-import * as fs16 from "fs";
-import * as path16 from "path";
+import * as fs17 from "fs";
+import * as path17 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import yaml3 from "js-yaml";
 
@@ -3045,9 +3109,9 @@ function checkOrphan(page, repoRoot) {
   if (!rawPath) return null;
   const isExcluded = EXCLUDED_DIRS.some((excl) => rawPath.startsWith(excl));
   if (isExcluded) return null;
-  const absRaw = path16.join(repoRoot, rawPath);
-  if (!fs16.existsSync(absRaw)) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+  const absRaw = path17.join(repoRoot, rawPath);
+  if (!fs17.existsSync(absRaw)) {
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "orphan",
       line: `orphan: ${relPage} -> missing ${rawPath} (raw missing)`
@@ -3065,7 +3129,7 @@ function checkRepoMismatch(page, repoRoot) {
     return null;
   }
   if (page.page.repo !== derivedRepo) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "repo-mismatch",
       line: `repo-mismatch: ${relPage} declares repo:${page.page.repo} but raw_path implies repo:${derivedRepo}`
@@ -3090,7 +3154,7 @@ function checkStaleCommit(page, repoRoot, gitRunner) {
   }
   if (!currentSha) return null;
   if (storedSha !== currentSha) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "stale-commit",
       line: `stale-commit: ${relPage} at ${storedSha}, current ${currentSha}`
@@ -3101,14 +3165,14 @@ function checkStaleCommit(page, repoRoot, gitRunner) {
 function checkMissingIngest(page, repoRoot) {
   const rawPath = page.page.raw_path;
   if (!rawPath) return null;
-  const absRaw = path16.join(repoRoot, rawPath);
-  if (!fs16.existsSync(absRaw)) return null;
-  const rawStat = fs16.statSync(absRaw);
-  const pageStat = fs16.statSync(page.absPath);
+  const absRaw = path17.join(repoRoot, rawPath);
+  if (!fs17.existsSync(absRaw)) return null;
+  const rawStat = fs17.statSync(absRaw);
+  const pageStat = fs17.statSync(page.absPath);
   const rawMtimeMs = rawStat.mtimeMs;
   const pageMtimeMs = pageStat.mtimeMs;
   if (rawMtimeMs - pageMtimeMs > 2e3) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     const rawMtime = rawStat.mtime.toISOString();
     const pageMtime = pageStat.mtime.toISOString();
     return {
@@ -3119,7 +3183,7 @@ function checkMissingIngest(page, repoRoot) {
   return null;
 }
 function checkBrokenBacklinks(pages, repoRoot) {
-  const wikiRoot = path16.join(repoRoot, ".cleargate", "wiki");
+  const wikiRoot = path17.join(repoRoot, ".cleargate", "wiki");
   const byId = /* @__PURE__ */ new Map();
   for (const p of pages) {
     if (p.page.id) byId.set(p.page.id, p);
@@ -3133,7 +3197,7 @@ function checkBrokenBacklinks(pages, repoRoot) {
     const parentId = match[1];
     const parentPage = byId.get(parentId);
     if (!parentPage) {
-      const relChild = path16.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
+      const relChild = path17.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
       findings.push({
         category: "broken-backlink",
         line: `broken-backlink: ${relChild} -> ${parentId} (parent missing child entry)`
@@ -3146,7 +3210,7 @@ function checkBrokenBacklinks(pages, repoRoot) {
       (c) => c === childRef || c === childId
     );
     if (!parentHasChild) {
-      const relChild = path16.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
+      const relChild = path17.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
       findings.push({
         category: "broken-backlink",
         line: `broken-backlink: ${relChild} -> ${parentId} (parent missing child entry)`
@@ -3156,7 +3220,7 @@ function checkBrokenBacklinks(pages, repoRoot) {
   return findings;
 }
 function checkInvalidatedCitations(pages, repoRoot) {
-  const wikiRoot = path16.join(repoRoot, ".cleargate", "wiki");
+  const wikiRoot = path17.join(repoRoot, ".cleargate", "wiki");
   const byId = /* @__PURE__ */ new Map();
   for (const p of pages) {
     if (p.page.id) byId.set(p.page.id, p);
@@ -3164,10 +3228,10 @@ function checkInvalidatedCitations(pages, repoRoot) {
   const findings = [];
   const topicPages = pages.filter((p) => p.page.type === "topic");
   for (const topicPage of topicPages) {
-    const relTopic = path16.relative(wikiRoot, topicPage.absPath).replace(/\\/g, "/");
+    const relTopic = path17.relative(wikiRoot, topicPage.absPath).replace(/\\/g, "/");
     let citesList = [];
     try {
-      const raw = fs16.readFileSync(topicPage.absPath, "utf8");
+      const raw = fs17.readFileSync(topicPage.absPath, "utf8");
       const { fm } = parseFrontmatter(raw);
       const rawCites = fm["cites"];
       if (Array.isArray(rawCites)) {
@@ -3203,7 +3267,7 @@ function checkExcludedPathIngested(page, repoRoot) {
   if (!rawPath) return null;
   const isExcluded = EXCLUDED_DIRS.some((excl) => rawPath.startsWith(excl));
   if (isExcluded) {
-    const relPage = path16.relative(path16.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(path17.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
     return {
       category: "excluded-path-ingested",
       line: `excluded-path-ingested: ${relPage} (raw_path ${rawPath} is under an excluded directory)`
@@ -3214,7 +3278,7 @@ function checkExcludedPathIngested(page, repoRoot) {
 function checkPaginationNeeded(pages) {
   const bucketCounts = /* @__PURE__ */ new Map();
   for (const p of pages) {
-    const bucket = path16.basename(path16.dirname(p.absPath));
+    const bucket = path17.basename(path17.dirname(p.absPath));
     bucketCounts.set(bucket, (bucketCounts.get(bucket) ?? 0) + 1);
   }
   const findings = [];
@@ -3252,11 +3316,11 @@ function parseCachedGateResult(raw) {
 function checkGateFailure(page, repoRoot) {
   const rawPath = page.page.raw_path;
   if (!rawPath) return null;
-  const absRaw = path16.join(repoRoot, rawPath);
-  if (!fs16.existsSync(absRaw)) return null;
+  const absRaw = path17.join(repoRoot, rawPath);
+  if (!fs17.existsSync(absRaw)) return null;
   let rawFm;
   try {
-    const raw = fs16.readFileSync(absRaw, "utf8");
+    const raw = fs17.readFileSync(absRaw, "utf8");
     const { fm } = parseFrontmatter(raw);
     rawFm = fm;
   } catch {
@@ -3290,11 +3354,11 @@ function checkGateFailure(page, repoRoot) {
 function checkGateStaleness(page, repoRoot) {
   const rawPath = page.page.raw_path;
   if (!rawPath) return null;
-  const absRaw = path16.join(repoRoot, rawPath);
-  if (!fs16.existsSync(absRaw)) return null;
+  const absRaw = path17.join(repoRoot, rawPath);
+  if (!fs17.existsSync(absRaw)) return null;
   let rawFm;
   try {
-    const raw = fs16.readFileSync(absRaw, "utf8");
+    const raw = fs17.readFileSync(absRaw, "utf8");
     const { fm } = parseFrontmatter(raw);
     rawFm = fm;
   } catch {
@@ -3317,7 +3381,7 @@ function checkGateStaleness(page, repoRoot) {
   return null;
 }
 function discoverPlainTextMentions(pages, repoRoot) {
-  const wikiRoot = path16.join(repoRoot, ".cleargate", "wiki");
+  const wikiRoot = path17.join(repoRoot, ".cleargate", "wiki");
   const byId = /* @__PURE__ */ new Map();
   for (const p of pages) {
     if (p.page.id) byId.set(p.page.id, true);
@@ -3326,7 +3390,7 @@ function discoverPlainTextMentions(pages, repoRoot) {
   const ID_PATTERN = /\b((?:EPIC|STORY|SPRINT|PROPOSAL|CR|BUG)-[\w-]+)\b/g;
   const LINK_PATTERN = /\[\[[\w-]+\]\]/g;
   for (const page of pages) {
-    const relPage = path16.relative(wikiRoot, page.absPath).replace(/\\/g, "/");
+    const relPage = path17.relative(wikiRoot, page.absPath).replace(/\\/g, "/");
     const wrappedRefs = /* @__PURE__ */ new Set();
     for (const m of page.body.matchAll(LINK_PATTERN)) {
       const inner = m[0].slice(2, -2);
@@ -3343,11 +3407,11 @@ function discoverPlainTextMentions(pages, repoRoot) {
   return suggestions;
 }
 function checkIndexBudget(repoRoot, indexTokenCeiling) {
-  const indexPath = path16.join(repoRoot, ".cleargate", "wiki", "index.md");
-  if (!fs16.existsSync(indexPath)) {
+  const indexPath = path17.join(repoRoot, ".cleargate", "wiki", "index.md");
+  if (!fs17.existsSync(indexPath)) {
     return { finding: null };
   }
-  const bytes = fs16.statSync(indexPath).size;
+  const bytes = fs17.statSync(indexPath).size;
   const tokens = Math.round(bytes / 4);
   const ceiling = indexTokenCeiling;
   if (tokens > ceiling) {
@@ -3364,18 +3428,18 @@ function checkIndexBudget(repoRoot, indexTokenCeiling) {
 }
 
 // src/lib/wiki-config.ts
-import * as fs17 from "fs";
-import * as path17 from "path";
+import * as fs18 from "fs";
+import * as path18 from "path";
 import yaml4 from "js-yaml";
 var DEFAULT_INDEX_TOKEN_CEILING = 8e3;
 function loadWikiConfig(repoRoot) {
-  const configPath = path17.join(repoRoot, ".cleargate", "config.yml");
-  if (!fs17.existsSync(configPath)) {
+  const configPath = path18.join(repoRoot, ".cleargate", "config.yml");
+  if (!fs18.existsSync(configPath)) {
     return { wiki: { index_token_ceiling: DEFAULT_INDEX_TOKEN_CEILING }, gates: {} };
   }
   let raw;
   try {
-    raw = fs17.readFileSync(configPath, "utf8");
+    raw = fs18.readFileSync(configPath, "utf8");
   } catch (err) {
     throw new Error(`Failed to read ${configPath}: ${String(err)}`);
   }
@@ -3436,7 +3500,7 @@ async function wikiLintHandler(opts = {}) {
   const exit = opts.exit ?? ((c) => process.exit(c));
   const gitRunner = opts.gitRunner;
   const mode = opts.mode ?? "enforce";
-  const wikiRoot = path18.join(cwd, ".cleargate", "wiki");
+  const wikiRoot = path19.join(cwd, ".cleargate", "wiki");
   const repoRoot = cwd;
   let pages = loadWikiPages(wikiRoot);
   const findings = [];
@@ -3507,8 +3571,8 @@ async function wikiLintHandler(opts = {}) {
 }
 
 // src/commands/wiki-query.ts
-import * as fs18 from "fs";
-import * as path19 from "path";
+import * as fs19 from "fs";
+import * as path20 from "path";
 function computeSlug(query) {
   return query.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 40).replace(/-+$/, "");
 }
@@ -3538,9 +3602,9 @@ async function wikiQueryHandler(opts) {
   const query = opts.query;
   const persist = opts.persist ?? false;
   void stderr;
-  const wikiRoot = path19.join(cwd, ".cleargate", "wiki");
-  const indexPath = path19.join(wikiRoot, "index.md");
-  if (!fs18.existsSync(indexPath)) {
+  const wikiRoot = path20.join(cwd, ".cleargate", "wiki");
+  const indexPath = path20.join(wikiRoot, "index.md");
+  if (!fs19.existsSync(indexPath)) {
     stdout(`wiki query: no index.md found at ${indexPath}
 `);
     stdout(`Run \`cleargate wiki build\` first.
@@ -3548,7 +3612,7 @@ async function wikiQueryHandler(opts) {
     exit(1);
     return;
   }
-  const indexContent = fs18.readFileSync(indexPath, "utf8");
+  const indexContent = fs19.readFileSync(indexPath, "utf8");
   const matches = searchIndex(indexContent, query);
   if (matches.length === 0) {
     stdout(`wiki query: no matches for "${query}"
@@ -3573,8 +3637,8 @@ async function wikiQueryHandler(opts) {
     return;
   }
   const slug = computeSlug(query);
-  const topicsDir = path19.join(wikiRoot, "topics");
-  fs18.mkdirSync(topicsDir, { recursive: true });
+  const topicsDir = path20.join(wikiRoot, "topics");
+  fs19.mkdirSync(topicsDir, { recursive: true });
   const citesArray = matches.map(({ id }) => `"[[${id}]]"`);
   const createdAt = now();
   const frontmatter = [
@@ -3589,13 +3653,13 @@ async function wikiQueryHandler(opts) {
   const topicContent = `${frontmatter}
 
 ${body}`;
-  const topicPath = path19.join(topicsDir, `${slug}.md`);
-  fs18.writeFileSync(topicPath, topicContent, "utf8");
+  const topicPath = path20.join(topicsDir, `${slug}.md`);
+  fs19.writeFileSync(topicPath, topicContent, "utf8");
   updateIndexTopicsSection(indexPath, slug, query, createdAt);
   exit(0);
 }
 function updateIndexTopicsSection(indexPath, slug, query, createdAt) {
-  let content = fs18.readFileSync(indexPath, "utf8");
+  let content = fs19.readFileSync(indexPath, "utf8");
   const row = `| ${slug} | ${query} | ${createdAt} |`;
   if (content.includes("## Topics")) {
     const topicsIdx = content.indexOf("## Topics");
@@ -3618,12 +3682,12 @@ ${row}
 ${row}
 `;
   }
-  fs18.writeFileSync(indexPath, content, "utf8");
+  fs19.writeFileSync(indexPath, content, "utf8");
 }
 
 // src/commands/wiki-audit-status.ts
-import * as fs19 from "fs";
-import * as path20 from "path";
+import * as fs20 from "fs";
+import * as path21 from "path";
 import * as readline4 from "readline";
 var TERMINAL = /* @__PURE__ */ new Set(["Completed", "Done", "Abandoned", "Closed", "Resolved"]);
 async function wikiAuditStatusHandler(opts = {}) {
@@ -3636,8 +3700,8 @@ async function wikiAuditStatusHandler(opts = {}) {
   });
   const exit = opts.exit ?? ((c) => process.exit(c));
   const isTTY = opts.isTTY ?? Boolean(process.stdout.isTTY);
-  const deliveryRoot = path20.join(cwd, ".cleargate", "delivery");
-  if (!fs19.existsSync(deliveryRoot)) {
+  const deliveryRoot = path21.join(cwd, ".cleargate", "delivery");
+  if (!fs20.existsSync(deliveryRoot)) {
     stderr(`audit-status: .cleargate/delivery/ not found at ${deliveryRoot}
 `);
     exit(1);
@@ -3777,7 +3841,7 @@ async function wikiAuditStatusHandler(opts = {}) {
     }
   }
   for (const d of fixable) {
-    const rawText = fs19.readFileSync(d.absPath, "utf8");
+    const rawText = fs20.readFileSync(d.absPath, "utf8");
     const updated = applyStatusFix(rawText, d.suggestedStatus);
     if (!opts.quiet) {
       stdout(`--- ${d.rawPath}
@@ -3793,7 +3857,7 @@ async function wikiAuditStatusHandler(opts = {}) {
       stdout(`+${newLine}
 `);
     }
-    fs19.writeFileSync(d.absPath, updated, "utf8");
+    fs20.writeFileSync(d.absPath, updated, "utf8");
   }
   stdout(`audit-status: applied ${fixable.length} fix(es)
 `);
@@ -3821,8 +3885,8 @@ function applyStatusFix(rawText, newStatus) {
 }
 
 // src/commands/doctor.ts
-import * as fs20 from "fs";
-import * as path21 from "path";
+import * as fs21 from "fs";
+import * as path22 from "path";
 import { spawnSync as spawnSync6 } from "child_process";
 
 // src/lib/pricing.ts
@@ -3898,24 +3962,24 @@ function parseHookLogLine(line) {
   };
 }
 function runHookHealth(stdout, cwd, now, outcome) {
-  const cleargateDir = path21.join(cwd, ".cleargate");
-  if (!fs20.existsSync(cleargateDir)) {
+  const cleargateDir = path22.join(cwd, ".cleargate");
+  if (!fs21.existsSync(cleargateDir)) {
     stdout("cleargate misconfigured: no .cleargate/ found. Run: cleargate init");
     if (outcome) outcome.configError = true;
     return;
   }
-  const manifestPath = path21.join(cwd, "cleargate-planning", "MANIFEST.json");
-  if (!fs20.existsSync(manifestPath)) {
+  const manifestPath = path22.join(cwd, "cleargate-planning", "MANIFEST.json");
+  if (!fs21.existsSync(manifestPath)) {
     stdout(`cleargate misconfigured: cleargate-planning/MANIFEST.json not found. Run: cleargate init`);
     if (outcome) outcome.configError = true;
   }
-  const settingsPath = path21.join(cwd, ".claude", "settings.json");
-  if (!fs20.existsSync(settingsPath)) {
+  const settingsPath = path22.join(cwd, ".claude", "settings.json");
+  if (!fs21.existsSync(settingsPath)) {
     stdout("[doctor] No .claude/settings.json found \u2014 hook config unavailable.");
     return;
   }
   try {
-    const raw = fs20.readFileSync(settingsPath, "utf-8");
+    const raw = fs21.readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(raw);
     const hasHooks = typeof settings === "object" && settings !== null && "hooks" in settings;
     if (hasHooks) {
@@ -3926,13 +3990,13 @@ function runHookHealth(stdout, cwd, now, outcome) {
   } catch {
     stdout("[doctor] .claude/settings.json is not valid JSON \u2014 cannot verify hook config.");
   }
-  const logPath = path21.join(cwd, ".cleargate", "hook-log", "gate-check.log");
-  if (!fs20.existsSync(logPath)) {
+  const logPath = path22.join(cwd, ".cleargate", "hook-log", "gate-check.log");
+  if (!fs21.existsSync(logPath)) {
     return;
   }
   let logContent;
   try {
-    logContent = fs20.readFileSync(logPath, "utf-8");
+    logContent = fs21.readFileSync(logPath, "utf-8");
   } catch {
     return;
   }
@@ -4046,8 +4110,8 @@ function parseCachedGateResult2(raw) {
   };
 }
 function emitResolverStatusLine(cwd, stdout) {
-  const distCliPath = path21.join(cwd, "cleargate-cli", "dist", "cli.js");
-  if (fs20.existsSync(distCliPath)) {
+  const distCliPath = path22.join(cwd, "cleargate-cli", "dist", "cli.js");
+  if (fs21.existsSync(distCliPath)) {
     stdout(`cleargate CLI: local dist \u2014 ${distCliPath}`);
     return;
   }
@@ -4061,10 +4125,10 @@ function emitResolverStatusLine(cwd, stdout) {
     return;
   }
   let pinVersion = "unknown";
-  const hookPath = path21.join(cwd, ".claude", "hooks", "stamp-and-gate.sh");
-  if (fs20.existsSync(hookPath)) {
+  const hookPath = path22.join(cwd, ".claude", "hooks", "stamp-and-gate.sh");
+  if (fs21.existsSync(hookPath)) {
     try {
-      const hookContent = fs20.readFileSync(hookPath, "utf-8");
+      const hookContent = fs21.readFileSync(hookPath, "utf-8");
       const pinMatch = hookContent.match(/^#\s*cleargate-pin:\s*(\S+)\s*$/m);
       if (pinMatch?.[1]) {
         pinVersion = pinMatch[1];
@@ -4096,10 +4160,10 @@ async function runSessionStart(cwd, stdout, outcome) {
   if (outcome && resolverLines.some((l) => l.includes("\u{1F534}"))) {
     outcome.configError = true;
   }
-  const pendingSyncDir = path21.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const pendingSyncDir = path22.join(cwd, ".cleargate", "delivery", "pending-sync");
   let files;
   try {
-    files = fs20.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path21.join(pendingSyncDir, f));
+    files = fs21.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path22.join(pendingSyncDir, f));
   } catch {
     return;
   }
@@ -4108,7 +4172,7 @@ async function runSessionStart(cwd, stdout, outcome) {
   for (const filePath of files) {
     let raw;
     try {
-      raw = fs20.readFileSync(filePath, "utf-8");
+      raw = fs21.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -4134,13 +4198,13 @@ async function runSessionStart(cwd, stdout, outcome) {
       }
     }
     if (!itemId) {
-      itemId = path21.basename(filePath, ".md");
+      itemId = path22.basename(filePath, ".md");
     }
     const firstCriterionId = gate2.failing_criteria.length > 0 ? gate2.failing_criteria[0]?.id ?? "" : "";
     blocked.push({ id: itemId, firstCriterionId });
   }
-  const activesentinel = path21.join(cwd, ".cleargate", "sprint-runs", ".active");
-  const sprintActive = fs20.existsSync(activesentinel);
+  const activesentinel = path22.join(cwd, ".cleargate", "sprint-runs", ".active");
+  const sprintActive = fs21.existsSync(activesentinel);
   const shouldRemind = !hasApprovedStory && !sprintActive;
   if (shouldRemind) {
     stdout(PLANNING_FIRST_REMINDER);
@@ -4175,10 +4239,10 @@ async function runPricing(filePath, cwd, stdout, stderr, exit, outcome) {
     exit(2);
     return;
   }
-  const absPath = path21.isAbsolute(filePath) ? filePath : path21.resolve(cwd, filePath);
+  const absPath = path22.isAbsolute(filePath) ? filePath : path22.resolve(cwd, filePath);
   let raw;
   try {
-    raw = fs20.readFileSync(absPath, "utf-8");
+    raw = fs21.readFileSync(absPath, "utf-8");
   } catch {
     stderr(`cleargate doctor --pricing: cannot read file: ${absPath}`);
     if (outcome) outcome.configError = true;
@@ -4240,7 +4304,7 @@ async function runPricing(filePath, cwd, stdout, stderr, exit, outcome) {
   const output = draftTokens.output ?? 0;
   const cacheRead = draftTokens.cache_read ?? 0;
   const cacheCreation = draftTokens.cache_creation ?? 0;
-  const fileName = path21.basename(absPath);
+  const fileName = path22.basename(absPath);
   stdout(
     `${fileName}: ${model} \u2014 input:${input} output:${output} cache_read:${cacheRead} cache_creation:${cacheCreation} \u2248 $${usd.toFixed(4)}`
   );
@@ -4253,15 +4317,15 @@ function globMatch(pattern, filePath) {
   return re.test(normalFile);
 }
 async function runCanEdit(filePath, cwd, stdout, exit, outcome) {
-  const activeSentinel = path21.join(cwd, ".cleargate", "sprint-runs", ".active");
-  if (fs20.existsSync(activeSentinel)) {
+  const activeSentinel = path22.join(cwd, ".cleargate", "sprint-runs", ".active");
+  if (fs21.existsSync(activeSentinel)) {
     stdout("allowed: sprint active");
     return;
   }
-  const pendingSyncDir = path21.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const pendingSyncDir = path22.join(cwd, ".cleargate", "delivery", "pending-sync");
   let files;
   try {
-    files = fs20.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path21.join(pendingSyncDir, f));
+    files = fs21.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path22.join(pendingSyncDir, f));
   } catch {
     stdout("blocked: no_approved_stories");
     if (outcome) outcome.blocker = true;
@@ -4273,7 +4337,7 @@ async function runCanEdit(filePath, cwd, stdout, exit, outcome) {
   for (const storyPath of files) {
     let raw;
     try {
-      raw = fs20.readFileSync(storyPath, "utf-8");
+      raw = fs21.readFileSync(storyPath, "utf-8");
     } catch {
       continue;
     }
@@ -4370,13 +4434,13 @@ async function doctorHandler(flags, cli) {
 }
 
 // src/commands/gate.ts
-import * as fs24 from "fs";
-import * as path24 from "path";
+import * as fs25 from "fs";
+import * as path25 from "path";
 import { spawnSync as spawnSync7 } from "child_process";
 
 // src/commands/execution-mode.ts
-import * as fs21 from "fs";
-import * as path22 from "path";
+import * as fs22 from "fs";
+import * as path23 from "path";
 var V1_INERT_MESSAGE = "v1 mode active \u2014 command inert. Set execution_mode: v2 in sprint frontmatter to enable.";
 function parseFrontmatterSimple(raw) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
@@ -4394,24 +4458,24 @@ function parseFrontmatterSimple(raw) {
 }
 function discoverSprintFile(sprintId, cwd) {
   const searchDirs = [
-    path22.join(cwd, ".cleargate", "delivery", "pending-sync"),
-    path22.join(cwd, ".cleargate", "delivery", "archive")
+    path23.join(cwd, ".cleargate", "delivery", "pending-sync"),
+    path23.join(cwd, ".cleargate", "delivery", "archive")
   ];
   for (const dir of searchDirs) {
-    if (!fs21.existsSync(dir)) continue;
+    if (!fs22.existsSync(dir)) continue;
     let entries;
     try {
-      entries = fs21.readdirSync(dir);
+      entries = fs22.readdirSync(dir);
     } catch {
       continue;
     }
     const prefix = `${sprintId}_`;
     for (const entry of entries) {
       if (entry.startsWith(prefix) && entry.endsWith(".md")) {
-        return path22.join(dir, entry);
+        return path23.join(dir, entry);
       }
       if (entry === `${sprintId}.md`) {
-        return path22.join(dir, entry);
+        return path23.join(dir, entry);
       }
     }
   }
@@ -4419,9 +4483,9 @@ function discoverSprintFile(sprintId, cwd) {
 }
 function resolveSprintIdFromSentinel(cwd) {
   const resolvedCwd = cwd ?? process.cwd();
-  const sentinelPath = path22.join(resolvedCwd, ".cleargate", "sprint-runs", ".active");
+  const sentinelPath = path23.join(resolvedCwd, ".cleargate", "sprint-runs", ".active");
   try {
-    const content = fs21.readFileSync(sentinelPath, "utf8").trim();
+    const content = fs22.readFileSync(sentinelPath, "utf8").trim();
     return content.length > 0 ? content : null;
   } catch {
     return null;
@@ -4440,12 +4504,12 @@ function readSprintExecutionMode(sprintId, opts = {}) {
   if (!filePath) {
     filePath = discoverSprintFile(resolvedSprintId, cwd);
   }
-  if (!filePath || !fs21.existsSync(filePath)) {
+  if (!filePath || !fs22.existsSync(filePath)) {
     return "v1";
   }
   let raw;
   try {
-    raw = fs21.readFileSync(filePath, "utf8");
+    raw = fs22.readFileSync(filePath, "utf8");
   } catch {
     return "v1";
   }
@@ -4463,8 +4527,8 @@ function printInertAndExit(stdoutFn, exitFn) {
 import yaml6 from "js-yaml";
 
 // src/lib/readiness-predicates.ts
-import * as fs22 from "fs";
-import * as path23 from "path";
+import * as fs23 from "fs";
+import * as path24 from "path";
 function parsePredicate(src) {
   const s = src.trim();
   const fmMatch = s.match(
@@ -4628,18 +4692,18 @@ function compareValues(actual, op, expected) {
 }
 function resolveLinkedPath(ref, docAbsPath, projectRoot) {
   const candidates = [
-    path23.resolve(path23.dirname(docAbsPath), ref),
-    path23.resolve(projectRoot, ref)
+    path24.resolve(path24.dirname(docAbsPath), ref),
+    path24.resolve(projectRoot, ref)
   ];
   for (const candidate of candidates) {
     if (!candidate.startsWith(projectRoot)) continue;
-    if (fs22.existsSync(candidate)) return candidate;
+    if (fs23.existsSync(candidate)) return candidate;
   }
   return null;
 }
 function readFrontmatterFromFile(absPath) {
   try {
-    const raw = fs22.readFileSync(absPath, "utf8");
+    const raw = fs23.readFileSync(absPath, "utf8");
     const lines = raw.split("\n");
     if (lines[0] !== "---") return {};
     let closeIdx = -1;
@@ -4783,14 +4847,14 @@ function applyCountOp(actual, op, n) {
   }
 }
 function evalFileExists(parsed, projectRoot) {
-  const resolved = path23.resolve(projectRoot, parsed.path);
-  if (!resolved.startsWith(projectRoot + path23.sep) && resolved !== projectRoot) {
+  const resolved = path24.resolve(projectRoot, parsed.path);
+  if (!resolved.startsWith(projectRoot + path24.sep) && resolved !== projectRoot) {
     return {
       pass: false,
       detail: `path '${parsed.path}' resolves outside project root (sandbox violation)`
     };
   }
-  const exists = fs22.existsSync(resolved);
+  const exists = fs23.existsSync(resolved);
   return {
     pass: exists,
     detail: exists ? `${parsed.path} exists` : `${parsed.path} not found`
@@ -4798,13 +4862,13 @@ function evalFileExists(parsed, projectRoot) {
 }
 function evalLinkTargetExists(parsed, opts) {
   const projectRoot = opts?.projectRoot ?? process.cwd();
-  const wikiIndexPath = opts?.wikiIndexPath ?? path23.join(projectRoot, ".cleargate", "wiki", "index.md");
+  const wikiIndexPath = opts?.wikiIndexPath ?? path24.join(projectRoot, ".cleargate", "wiki", "index.md");
   if (!wikiIndexPath.startsWith(projectRoot)) {
     return { pass: false, detail: "wikiIndexPath resolves outside project root" };
   }
   let indexContent;
   try {
-    indexContent = fs22.readFileSync(wikiIndexPath, "utf8");
+    indexContent = fs23.readFileSync(wikiIndexPath, "utf8");
   } catch {
     return { pass: false, detail: `wiki index not found at ${wikiIndexPath}` };
   }
@@ -4815,13 +4879,13 @@ function evalLinkTargetExists(parsed, opts) {
   };
 }
 function evalStatusOf(parsed, opts, projectRoot) {
-  const wikiIndexPath = opts?.wikiIndexPath ?? path23.join(projectRoot, ".cleargate", "wiki", "index.md");
+  const wikiIndexPath = opts?.wikiIndexPath ?? path24.join(projectRoot, ".cleargate", "wiki", "index.md");
   if (!wikiIndexPath.startsWith(projectRoot)) {
     return { pass: false, detail: "wikiIndexPath resolves outside project root" };
   }
   let indexContent;
   try {
-    indexContent = fs22.readFileSync(wikiIndexPath, "utf8");
+    indexContent = fs23.readFileSync(wikiIndexPath, "utf8");
   } catch {
     return { pass: false, detail: `wiki index not found at ${wikiIndexPath}` };
   }
@@ -4832,7 +4896,7 @@ function evalStatusOf(parsed, opts, projectRoot) {
     return { pass: false, detail: `[[${parsed.id}]] not found in wiki index` };
   }
   const rawPath = rowMatch[1].trim();
-  const fullPath = path23.resolve(projectRoot, rawPath);
+  const fullPath = path24.resolve(projectRoot, rawPath);
   if (!fullPath.startsWith(projectRoot)) {
     return { pass: false, detail: `wiki path for ${parsed.id} resolves outside project root` };
   }
@@ -4849,12 +4913,12 @@ function evalStatusOf(parsed, opts, projectRoot) {
 }
 
 // src/lib/frontmatter-cache.ts
-import * as fs23 from "fs/promises";
+import * as fs24 from "fs/promises";
 import yaml5 from "js-yaml";
 async function readCachedGate(absPath) {
   let raw;
   try {
-    raw = await fs23.readFile(absPath, "utf8");
+    raw = await fs24.readFile(absPath, "utf8");
   } catch {
     return null;
   }
@@ -4874,7 +4938,7 @@ async function writeCachedGate(absPath, result, opts) {
     failing_criteria: result.failing_criteria,
     last_gate_check: lastGateCheck
   };
-  const raw = await fs23.readFile(absPath, "utf8");
+  const raw = await fs24.readFile(absPath, "utf8");
   let fm;
   let body;
   try {
@@ -4904,7 +4968,7 @@ async function writeCachedGate(absPath, result, opts) {
 
 ${body}` : `${fmBlock}
 `;
-  await fs23.writeFile(absPath, newContent, "utf8");
+  await fs24.writeFile(absPath, newContent, "utf8");
 }
 function coerceCachedGate(val) {
   if (val === void 0 || val === null) return null;
@@ -4935,7 +4999,7 @@ function coerceCachedGate(val) {
 
 // src/commands/gate.ts
 function loadGateBlocks(gatesDocPath) {
-  const raw = fs24.readFileSync(gatesDocPath, "utf8");
+  const raw = fs25.readFileSync(gatesDocPath, "utf8");
   const blocks = [];
   const fenceRe = /^```yaml\n([\s\S]*?)^```/gm;
   let match;
@@ -4970,14 +5034,14 @@ async function gateCheckHandler(file, opts, cli) {
   const exitFn = cli?.exit ?? ((code) => process.exit(code));
   const cwd = cli?.cwd ?? process.cwd();
   const nowFn = cli?.now ?? (() => /* @__PURE__ */ new Date());
-  const absPath = path24.isAbsolute(file) ? file : path24.resolve(cwd, file);
-  if (!fs24.existsSync(absPath)) {
+  const absPath = path25.isAbsolute(file) ? file : path25.resolve(cwd, file);
+  if (!fs25.existsSync(absPath)) {
     stderrFn(`[cleargate gate] error: file not found: ${absPath}`);
     return exitFn(1);
   }
   let raw;
   try {
-    raw = fs24.readFileSync(absPath, "utf8");
+    raw = fs25.readFileSync(absPath, "utf8");
   } catch (err) {
     stderrFn(`[cleargate gate] error: cannot read file: ${absPath}`);
     return exitFn(1);
@@ -4996,8 +5060,8 @@ async function gateCheckHandler(file, opts, cli) {
     return exitFn(1);
   }
   const projectRoot = cwd;
-  const gatesDocPath = cli?.gatesDocPath ?? path24.join(projectRoot, ".cleargate", "knowledge", "readiness-gates.md");
-  if (!fs24.existsSync(gatesDocPath)) {
+  const gatesDocPath = cli?.gatesDocPath ?? path25.join(projectRoot, ".cleargate", "knowledge", "readiness-gates.md");
+  if (!fs25.existsSync(gatesDocPath)) {
     stderrFn(`[cleargate gate] error: readiness-gates.md not found at: ${gatesDocPath}`);
     return exitFn(1);
   }
@@ -5070,8 +5134,8 @@ async function gateExplainHandler(file, cli) {
   const stderrFn = cli?.stderr ?? ((s) => process.stderr.write(s + "\n"));
   const exitFn = cli?.exit ?? ((code) => process.exit(code));
   const cwd = cli?.cwd ?? process.cwd();
-  const absPath = path24.isAbsolute(file) ? file : path24.resolve(cwd, file);
-  if (!fs24.existsSync(absPath)) {
+  const absPath = path25.isAbsolute(file) ? file : path25.resolve(cwd, file);
+  if (!fs25.existsSync(absPath)) {
     stderrFn(`[cleargate gate] error: file not found: ${absPath}`);
     return exitFn(1);
   }
@@ -5082,7 +5146,7 @@ async function gateExplainHandler(file, cli) {
   }
   let raw;
   try {
-    raw = fs24.readFileSync(absPath, "utf8");
+    raw = fs25.readFileSync(absPath, "utf8");
   } catch {
     stderrFn(`[cleargate gate] error: cannot read file: ${absPath}`);
     return exitFn(1);
@@ -5103,7 +5167,7 @@ async function gateExplainHandler(file, cli) {
 function resolveRunScriptForGate(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path24.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path25.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function gateQaHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -5195,15 +5259,15 @@ function gateRunHandler(name, opts, cli) {
 }
 
 // src/commands/sprint.ts
-import * as fs25 from "fs";
-import * as path25 from "path";
+import * as fs26 from "fs";
+import * as path26 from "path";
 import { spawnSync as spawnSync9 } from "child_process";
 import yaml7 from "js-yaml";
 var TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["Completed", "Done", "Abandoned", "Closed", "Resolved"]);
 function resolveRunScript(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path25.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path26.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function defaultExit(code) {
   return process.exit(code);
@@ -5297,8 +5361,8 @@ ${body}`;
 }
 function atomicWriteStr(filePath, content) {
   const tmp = `${filePath}.tmp.${process.pid}`;
-  fs25.writeFileSync(tmp, content, "utf8");
-  fs25.renameSync(tmp, filePath);
+  fs26.writeFileSync(tmp, content, "utf8");
+  fs26.renameSync(tmp, filePath);
 }
 function deriveSprintBranchForArchive(sprintId) {
   const match = /^SPRINT-(\d+)/.exec(sprintId);
@@ -5312,7 +5376,7 @@ function stampFile(raw, status, completedAt) {
   return serializeFileContent(fm, body);
 }
 function stampSprintClose(sprintPath, now) {
-  const previousContent = fs25.readFileSync(sprintPath, "utf8");
+  const previousContent = fs26.readFileSync(sprintPath, "utf8");
   const { fm, body } = parseFileFrontmatter(previousContent);
   const currentStatus = typeof fm["status"] === "string" ? fm["status"] : "";
   const alreadyTerminal = TERMINAL_STATUSES2.has(currentStatus);
@@ -5372,14 +5436,14 @@ async function sprintArchiveHandler(opts, cli) {
     if (mode === "v1") {
       return printInertAndExit(stdoutFn, exitFn);
     }
-    const stateFile = path25.join(cwd, ".cleargate", "sprint-runs", opts.sprintId, "state.json");
-    if (!fs25.existsSync(stateFile)) {
+    const stateFile = path26.join(cwd, ".cleargate", "sprint-runs", opts.sprintId, "state.json");
+    if (!fs26.existsSync(stateFile)) {
       stderrFn(`[cleargate sprint archive] state.json not found at ${stateFile}`);
       return exitFn(1);
     }
     let state2;
     try {
-      state2 = JSON.parse(fs25.readFileSync(stateFile, "utf8"));
+      state2 = JSON.parse(fs26.readFileSync(stateFile, "utf8"));
     } catch (err) {
       stderrFn(`[cleargate sprint archive] failed to parse state.json: ${err.message}`);
       return exitFn(1);
@@ -5391,18 +5455,18 @@ async function sprintArchiveHandler(opts, cli) {
       return exitFn(1);
     }
     const stateStories = state2.stories ?? {};
-    const pendingDir = path25.join(cwd, ".cleargate", "delivery", "pending-sync");
-    const archiveDir = path25.join(cwd, ".cleargate", "delivery", "archive");
+    const pendingDir = path26.join(cwd, ".cleargate", "delivery", "pending-sync");
+    const archiveDir = path26.join(cwd, ".cleargate", "delivery", "archive");
     let sprintFile = null;
-    for (const entry of fs25.readdirSync(pendingDir)) {
+    for (const entry of fs26.readdirSync(pendingDir)) {
       if ((entry.startsWith(`${opts.sprintId}_`) || entry === `${opts.sprintId}.md`) && entry.endsWith(".md")) {
-        sprintFile = path25.join(pendingDir, entry);
+        sprintFile = path26.join(pendingDir, entry);
         break;
       }
     }
     let epicIds = [];
-    if (sprintFile && fs25.existsSync(sprintFile)) {
-      const { fm } = parseFileFrontmatter(fs25.readFileSync(sprintFile, "utf8"));
+    if (sprintFile && fs26.existsSync(sprintFile)) {
+      const { fm } = parseFileFrontmatter(fs26.readFileSync(sprintFile, "utf8"));
       const epics = fm["epics"];
       if (Array.isArray(epics)) {
         epicIds = epics.map(String);
@@ -5412,15 +5476,15 @@ async function sprintArchiveHandler(opts, cli) {
     if (sprintFile) {
       plan.push({
         src: sprintFile,
-        destName: path25.basename(sprintFile),
+        destName: path26.basename(sprintFile),
         status: "Completed"
       });
     }
     for (const epicId of epicIds) {
-      for (const entry of fs25.readdirSync(pendingDir)) {
+      for (const entry of fs26.readdirSync(pendingDir)) {
         if ((entry.startsWith(`${epicId}_`) || entry === `${epicId}.md`) && entry.endsWith(".md")) {
           plan.push({
-            src: path25.join(pendingDir, entry),
+            src: path26.join(pendingDir, entry),
             destName: entry,
             status: "Approved"
           });
@@ -5429,10 +5493,10 @@ async function sprintArchiveHandler(opts, cli) {
       }
       const storyKeys = storyKeysForEpic(stateStories, epicId);
       for (const storyId of storyKeys) {
-        for (const entry of fs25.readdirSync(pendingDir)) {
+        for (const entry of fs26.readdirSync(pendingDir)) {
           if ((entry.startsWith(`${storyId}_`) || entry === `${storyId}.md`) && entry.endsWith(".md")) {
             plan.push({
-              src: path25.join(pendingDir, entry),
+              src: path26.join(pendingDir, entry),
               destName: entry,
               status: "Done"
             });
@@ -5444,13 +5508,13 @@ async function sprintArchiveHandler(opts, cli) {
     const storyIdsInState = new Set(Object.keys(stateStories));
     const planSrcs = new Set(plan.map((p) => p.src));
     const orphans = [];
-    for (const entry of fs25.readdirSync(pendingDir)) {
+    for (const entry of fs26.readdirSync(pendingDir)) {
       if (!entry.startsWith("STORY-") || !entry.endsWith(".md")) continue;
-      const candidate = path25.join(pendingDir, entry);
+      const candidate = path26.join(pendingDir, entry);
       if (planSrcs.has(candidate)) continue;
       let raw;
       try {
-        raw = fs25.readFileSync(candidate, "utf8");
+        raw = fs26.readFileSync(candidate, "utf8");
       } catch {
         continue;
       }
@@ -5467,18 +5531,18 @@ async function sprintArchiveHandler(opts, cli) {
     }
     const completedAt = (/* @__PURE__ */ new Date()).toISOString();
     const sprintBranch = deriveSprintBranchForArchive(opts.sprintId);
-    const activePath = path25.join(cwd, ".cleargate", "sprint-runs", ".active");
+    const activePath = path26.join(cwd, ".cleargate", "sprint-runs", ".active");
     if (opts.dryRun) {
       stdoutFn(`[dry-run] Sprint archive plan for ${opts.sprintId}:`);
       stdoutFn(`  Sprint branch: ${sprintBranch}`);
       stdoutFn(`  Files to archive (${plan.length}):`);
       for (const entry of plan) {
         stdoutFn(
-          `    ${path25.basename(entry.src)} \u2192 archive/${entry.destName}  [stamp: status=${entry.status}, completed_at=<now>]`
+          `    ${path26.basename(entry.src)} \u2192 archive/${entry.destName}  [stamp: status=${entry.status}, completed_at=<now>]`
         );
       }
       if (orphans.length > 0) {
-        stdoutFn(`  Orphan files (${orphans.length}): ${orphans.map((o) => path25.basename(o)).join(", ")}`);
+        stdoutFn(`  Orphan files (${orphans.length}): ${orphans.map((o) => path26.basename(o)).join(", ")}`);
       }
       stdoutFn(`  .active \u2192 "" (truncate)`);
       stdoutFn(`  git checkout main`);
@@ -5487,9 +5551,9 @@ async function sprintArchiveHandler(opts, cli) {
       return exitFn(0);
     }
     let sprintFileSnapshot = null;
-    const wikiRoot = path25.join(cwd, ".cleargate", "wiki");
-    const wikiInitialised = fs25.existsSync(wikiRoot);
-    if (sprintFile && fs25.existsSync(sprintFile)) {
+    const wikiRoot = path26.join(cwd, ".cleargate", "wiki");
+    const wikiInitialised = fs26.existsSync(wikiRoot);
+    if (sprintFile && fs26.existsSync(sprintFile)) {
       const { previousContent } = stampSprintClose(sprintFile, () => completedAt);
       sprintFileSnapshot = previousContent;
       if (wikiInitialised) {
@@ -5511,15 +5575,15 @@ async function sprintArchiveHandler(opts, cli) {
       }
     }
     for (const entry of plan) {
-      if (!fs25.existsSync(entry.src)) {
+      if (!fs26.existsSync(entry.src)) {
         stderrFn(`[cleargate sprint archive] source not found: ${entry.src} \u2014 skipping`);
         continue;
       }
-      const raw = fs25.readFileSync(entry.src, "utf8");
+      const raw = fs26.readFileSync(entry.src, "utf8");
       const stamped = stampFile(raw, entry.status, completedAt);
-      const dest = path25.join(archiveDir, entry.destName);
+      const dest = path26.join(archiveDir, entry.destName);
       atomicWriteStr(entry.src, stamped);
-      fs25.renameSync(entry.src, dest);
+      fs26.renameSync(entry.src, dest);
       stdoutFn(`archived: ${entry.destName}`);
     }
     try {
@@ -5561,8 +5625,8 @@ async function sprintArchiveHandler(opts, cli) {
 }
 
 // src/commands/story.ts
-import * as fs26 from "fs";
-import * as path26 from "path";
+import * as fs27 from "fs";
+import * as path27 from "path";
 import { spawnSync as spawnSync10 } from "child_process";
 function defaultExit2(code) {
   return process.exit(code);
@@ -5570,7 +5634,7 @@ function defaultExit2(code) {
 function resolveRunScript2(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path26.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path27.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function deriveSprintBranch(sprintId) {
   const match = /^SPRINT-(\d+)/.exec(sprintId);
@@ -5579,11 +5643,11 @@ function deriveSprintBranch(sprintId) {
 }
 function atomicWriteString(filePath, text) {
   const tmpFile = `${filePath}.tmp.${process.pid}`;
-  fs26.writeFileSync(tmpFile, text, "utf8");
-  fs26.renameSync(tmpFile, filePath);
+  fs27.writeFileSync(tmpFile, text, "utf8");
+  fs27.renameSync(tmpFile, filePath);
 }
 function stateJsonPath(cwd, sprintId) {
-  return path26.join(cwd, ".cleargate", "sprint-runs", sprintId, "state.json");
+  return path27.join(cwd, ".cleargate", "sprint-runs", sprintId, "state.json");
 }
 function storyStartHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -5600,7 +5664,7 @@ function storyStartHandler(opts, cli) {
     return printInertAndExit(stdoutFn, exitFn);
   }
   const sprintBranch = deriveSprintBranch(sprintId);
-  const worktreePath = path26.join(cwd, ".worktrees", opts.storyId);
+  const worktreePath = path27.join(cwd, ".worktrees", opts.storyId);
   const storyBranch = `story/${opts.storyId}`;
   const step1 = spawnFn(
     "git",
@@ -5632,13 +5696,13 @@ function storyStartHandler(opts, cli) {
     return exitFn(step2.status ?? 1);
   }
   const stateFile = stateJsonPath(cwd, sprintId);
-  if (!fs26.existsSync(stateFile)) {
+  if (!fs27.existsSync(stateFile)) {
     stderrFn(`[cleargate story start] step 3: state.json not found at ${stateFile}`);
     return exitFn(1);
   }
   let state2;
   try {
-    state2 = JSON.parse(fs26.readFileSync(stateFile, "utf8"));
+    state2 = JSON.parse(fs27.readFileSync(stateFile, "utf8"));
   } catch (err) {
     stderrFn(`[cleargate story start] step 3: failed to parse state.json: ${err.message}`);
     return exitFn(1);
@@ -5679,7 +5743,7 @@ function storyCompleteHandler(opts, cli) {
   }
   const sprintBranch = deriveSprintBranch(sprintId);
   const storyBranch = `story/${opts.storyId}`;
-  const worktreeRel = path26.join(".worktrees", opts.storyId);
+  const worktreeRel = path27.join(".worktrees", opts.storyId);
   const step1 = spawnFn(
     "git",
     ["rev-list", "--count", `${sprintBranch}..${storyBranch}`],
@@ -5776,7 +5840,7 @@ function storyCompleteHandler(opts, cli) {
 }
 
 // src/commands/state.ts
-import * as path27 from "path";
+import * as path28 from "path";
 import { spawnSync as spawnSync11 } from "child_process";
 function defaultExit3(code) {
   return process.exit(code);
@@ -5784,7 +5848,7 @@ function defaultExit3(code) {
 function resolveRunScript3(opts) {
   if (opts.runScriptPath) return opts.runScriptPath;
   const cwd = opts.cwd ?? process.cwd();
-  return path27.join(cwd, ".cleargate", "scripts", "run_script.sh");
+  return path28.join(cwd, ".cleargate", "scripts", "run_script.sh");
 }
 function stateUpdateHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -5840,20 +5904,20 @@ function stateValidateHandler(opts, cli) {
 }
 
 // src/commands/stamp-tokens.ts
-import * as fs28 from "fs";
-import * as path29 from "path";
+import * as fs29 from "fs";
+import * as path30 from "path";
 
 // src/lib/ledger-reader.ts
-import * as fs27 from "fs";
-import * as path28 from "path";
+import * as fs28 from "fs";
+import * as path29 from "path";
 function findSprintRunsRoot(startDir) {
   let dir = startDir;
   while (true) {
-    const candidate = path28.join(dir, ".cleargate", "sprint-runs");
-    if (fs27.existsSync(candidate)) {
+    const candidate = path29.join(dir, ".cleargate", "sprint-runs");
+    if (fs28.existsSync(candidate)) {
       return candidate;
     }
-    const parent = path28.dirname(dir);
+    const parent = path29.dirname(dir);
     if (parent === dir) {
       return null;
     }
@@ -5906,13 +5970,13 @@ function readLedgerForWorkItem(workItemId, opts = {}) {
     }
     sprintRunsRoot = found;
   }
-  if (!fs27.existsSync(sprintRunsRoot)) {
+  if (!fs28.existsSync(sprintRunsRoot)) {
     return [];
   }
   let ledgerFiles;
   try {
-    const entries = fs27.readdirSync(sprintRunsRoot, { withFileTypes: true });
-    ledgerFiles = entries.filter((e) => e.isDirectory()).map((e) => path28.join(sprintRunsRoot, e.name, "token-ledger.jsonl")).filter((f) => fs27.existsSync(f));
+    const entries = fs28.readdirSync(sprintRunsRoot, { withFileTypes: true });
+    ledgerFiles = entries.filter((e) => e.isDirectory()).map((e) => path29.join(sprintRunsRoot, e.name, "token-ledger.jsonl")).filter((f) => fs28.existsSync(f));
   } catch {
     return [];
   }
@@ -5920,7 +5984,7 @@ function readLedgerForWorkItem(workItemId, opts = {}) {
   for (const ledgerFile of ledgerFiles) {
     let content;
     try {
-      content = fs27.readFileSync(ledgerFile, "utf-8");
+      content = fs28.readFileSync(ledgerFile, "utf-8");
     } catch {
       continue;
     }
@@ -5971,7 +6035,7 @@ async function stampTokensHandler(file, opts, cli) {
   });
   const nowFn = cli?.now ?? (() => /* @__PURE__ */ new Date());
   const cwd = cli?.cwd ?? process.cwd();
-  const absPath = path29.isAbsolute(file) ? file : path29.resolve(cwd, file);
+  const absPath = path30.isAbsolute(file) ? file : path30.resolve(cwd, file);
   if (/\/\.cleargate\/delivery\/archive\//.test(absPath)) {
     stdoutFn(`[frozen] ${absPath}`);
     exitFn(0);
@@ -5979,7 +6043,7 @@ async function stampTokensHandler(file, opts, cli) {
   }
   let rawContent;
   try {
-    rawContent = fs28.readFileSync(absPath, "utf-8");
+    rawContent = fs29.readFileSync(absPath, "utf-8");
   } catch {
     stdoutFn(`[stamp-tokens] error: cannot read file: ${absPath}`);
     exitFn(1);
@@ -6051,7 +6115,7 @@ async function stampTokensHandler(file, opts, cli) {
     return;
   }
   try {
-    fs28.writeFileSync(absPath, serialized, "utf-8");
+    fs29.writeFileSync(absPath, serialized, "utf-8");
   } catch {
     stdoutFn(`[stamp-tokens] error: cannot write file: ${absPath}`);
     exitFn(1);
@@ -6068,7 +6132,7 @@ function extractWorkItemId(fm, absPath) {
       return val.trim();
     }
   }
-  const basename12 = path29.basename(absPath);
+  const basename12 = path30.basename(absPath);
   const match = basename12.match(/^(STORY|EPIC|PROPOSAL|CR|BUG)-\d+(-\d+)?/i);
   if (match) {
     return match[0].toUpperCase();
@@ -6173,7 +6237,7 @@ ${body}`;
 
 // src/commands/upgrade.ts
 import * as fsp from "fs/promises";
-import * as path30 from "path";
+import * as path31 from "path";
 
 // src/lib/claude-md-surgery.ts
 var CLEARGATE_START = "<!-- CLEARGATE:START -->";
@@ -6319,7 +6383,7 @@ async function writeAtomic2(filePath, content) {
   await fsp.rename(tmpPath, filePath);
 }
 async function updateSnapshotEntry(projectRoot, filePath, newSha) {
-  const snapshotPath = path30.join(projectRoot, ".cleargate", ".install-manifest.json");
+  const snapshotPath = path31.join(projectRoot, ".cleargate", ".install-manifest.json");
   let snapshot;
   try {
     const raw = await fsp.readFile(snapshotPath, "utf-8");
@@ -6336,17 +6400,17 @@ async function updateSnapshotEntry(projectRoot, filePath, newSha) {
   await writeAtomic2(snapshotPath, JSON.stringify(updated, null, 2) + "\n");
 }
 function isClaudeMd(filePath) {
-  return path30.basename(filePath) === "CLAUDE.md";
+  return path31.basename(filePath) === "CLAUDE.md";
 }
 function isSettingsJson(filePath) {
-  return path30.basename(filePath) === "settings.json" && filePath.includes(".claude");
+  return path31.basename(filePath) === "settings.json" && filePath.includes(".claude");
 }
 async function applyAlwaysOverwrite(entry, projectRoot, packageRoot, stdout) {
-  const targetPath = path30.join(projectRoot, entry.path);
-  const sourcePath = path30.join(packageRoot, entry.path);
+  const targetPath = path31.join(projectRoot, entry.path);
+  const sourcePath = path31.join(packageRoot, entry.path);
   try {
     const pkgContent = await fsp.readFile(sourcePath, "utf-8");
-    await fsp.mkdir(path30.dirname(targetPath), { recursive: true });
+    await fsp.mkdir(path31.dirname(targetPath), { recursive: true });
     await writeAtomic2(targetPath, pkgContent);
     await updateSnapshotEntry(projectRoot, entry.path, entry.sha256);
     stdout(`[always] overwritten: ${entry.path}`);
@@ -6356,8 +6420,8 @@ async function applyAlwaysOverwrite(entry, projectRoot, packageRoot, stdout) {
 }
 async function applyMerge3Way(entry, projectRoot, packageRoot, installSha, currentSha, flags, opts) {
   const { stdout, stderr, promptMergeChoiceFn, openInEditorFn, stdin } = opts;
-  const targetPath = path30.join(projectRoot, entry.path);
-  const sourcePath = path30.join(packageRoot, entry.path);
+  const targetPath = path31.join(projectRoot, entry.path);
+  const sourcePath = path31.join(packageRoot, entry.path);
   let ours = "";
   let theirs = "";
   try {
@@ -6420,7 +6484,7 @@ async function applyMerge3Way(entry, projectRoot, packageRoot, installSha, curre
         mergedContent = theirs;
       }
     }
-    await fsp.mkdir(path30.dirname(targetPath), { recursive: true });
+    await fsp.mkdir(path31.dirname(targetPath), { recursive: true });
     await writeAtomic2(targetPath, mergedContent);
     const newSha2 = hashNormalized(mergedContent);
     await updateSnapshotEntry(projectRoot, entry.path, newSha2);
@@ -6432,7 +6496,7 @@ async function applyMerge3Way(entry, projectRoot, packageRoot, installSha, curre
 ${ours}=======
 ${theirs}>>>>>>> theirs (upstream)
 `;
-  await fsp.mkdir(path30.dirname(mergeFilePath), { recursive: true });
+  await fsp.mkdir(path31.dirname(mergeFilePath), { recursive: true });
   await writeAtomic2(mergeFilePath, conflictContent);
   try {
     const result = await openInEditorFn(mergeFilePath);
@@ -6566,9 +6630,9 @@ async function upgradeHandler(flags, cli) {
 }
 
 // src/commands/uninstall.ts
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 import * as fsp2 from "fs/promises";
-import * as path31 from "path";
+import * as path32 from "path";
 import { execSync as execSync2 } from "child_process";
 var USER_ARTIFACT_TIERS = ["user-artifact"];
 var FRAMEWORK_TIERS = ["protocol", "template", "agent", "hook", "skill", "cli-config", "derived"];
@@ -6594,10 +6658,10 @@ function shouldPreserve(entry, preserveSet, removeSet) {
   return false;
 }
 function resolveProjectName(target) {
-  const pkgPath = path31.join(target, "package.json");
-  if (fs29.existsSync(pkgPath)) {
+  const pkgPath = path32.join(target, "package.json");
+  if (fs30.existsSync(pkgPath)) {
     try {
-      const raw = fs29.readFileSync(pkgPath, "utf-8");
+      const raw = fs30.readFileSync(pkgPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.name && typeof parsed.name === "string") {
         return parsed.name;
@@ -6605,7 +6669,7 @@ function resolveProjectName(target) {
     } catch {
     }
   }
-  return path31.basename(target);
+  return path32.basename(target);
 }
 function detectUncommittedChanges(target, manifestPaths, gitRunner) {
   const run = gitRunner ?? ((args) => {
@@ -6634,8 +6698,8 @@ function detectUncommittedChanges(target, manifestPaths, gitRunner) {
   return changedFiles.filter((f) => manifestSet.has(f));
 }
 async function removeFromPackageJson(target, dryRun) {
-  const pkgPath = path31.join(target, "package.json");
-  if (!fs29.existsSync(pkgPath)) return false;
+  const pkgPath = path32.join(target, "package.json");
+  if (!fs30.existsSync(pkgPath)) return false;
   let raw;
   try {
     raw = await fsp2.readFile(pkgPath, "utf-8");
@@ -6676,7 +6740,7 @@ async function removeFile(filePath) {
 }
 async function removeDir(dirPath) {
   try {
-    fs29.rmSync(dirPath, { recursive: true, force: true });
+    fs30.rmSync(dirPath, { recursive: true, force: true });
   } catch {
   }
 }
@@ -6696,12 +6760,12 @@ async function uninstallHandler(opts) {
     for (const t of FRAMEWORK_TIERS) removeSet.add(t);
     for (const u of USER_ARTIFACT_TIERS) removeSet.add(u);
   }
-  const target = opts.path ? path31.resolve(opts.path) : cwd;
-  const cleargateDir = path31.join(target, ".cleargate");
-  const manifestPath = path31.join(cleargateDir, ".install-manifest.json");
-  const uninstalledPath = path31.join(cleargateDir, ".uninstalled");
-  if (!fs29.existsSync(manifestPath)) {
-    if (fs29.existsSync(uninstalledPath)) {
+  const target = opts.path ? path32.resolve(opts.path) : cwd;
+  const cleargateDir = path32.join(target, ".cleargate");
+  const manifestPath = path32.join(cleargateDir, ".install-manifest.json");
+  const uninstalledPath = path32.join(cleargateDir, ".uninstalled");
+  if (!fs30.existsSync(manifestPath)) {
+    if (fs30.existsSync(uninstalledPath)) {
       stdout("already uninstalled");
       exit(0);
       return;
@@ -6710,7 +6774,7 @@ async function uninstallHandler(opts) {
     exit(0);
     return;
   }
-  if (fs29.existsSync(uninstalledPath) && !fs29.existsSync(manifestPath)) {
+  if (fs30.existsSync(uninstalledPath) && !fs30.existsSync(manifestPath)) {
     stdout("already uninstalled");
     exit(0);
     return;
@@ -6732,10 +6796,10 @@ async function uninstallHandler(opts) {
       return;
     }
   }
-  const claudeMdPath = path31.join(target, "CLAUDE.md");
+  const claudeMdPath = path32.join(target, "CLAUDE.md");
   let claudeMdContent = null;
-  if (fs29.existsSync(claudeMdPath)) {
-    claudeMdContent = fs29.readFileSync(claudeMdPath, "utf-8");
+  if (fs30.existsSync(claudeMdPath)) {
+    claudeMdContent = fs30.readFileSync(claudeMdPath, "utf-8");
     if (!claudeMdContent.includes(CLEARGATE_START)) {
       stderr("CLAUDE.md is missing <!-- CLEARGATE:START --> marker");
       exit(1);
@@ -6751,8 +6815,8 @@ async function uninstallHandler(opts) {
   const toPreserve = [];
   const toSkip = [];
   for (const entry of snapshot.files) {
-    const filePath = path31.join(target, entry.path);
-    if (!fs29.existsSync(filePath)) {
+    const filePath = path32.join(target, entry.path);
+    if (!fs30.existsSync(filePath)) {
       toSkip.push(entry);
       continue;
     }
@@ -6809,7 +6873,7 @@ async function uninstallHandler(opts) {
   const removedPaths = [];
   const preservedPaths = [];
   for (const entry of toRemove) {
-    const filePath = path31.join(target, entry.path);
+    const filePath = path32.join(target, entry.path);
     await removeFile(filePath);
     removedPaths.push(entry.path);
   }
@@ -6825,10 +6889,10 @@ async function uninstallHandler(opts) {
       stderr(`Warning: could not strip CLAUDE.md block: ${err.message}`);
     }
   }
-  const settingsPath = path31.join(target, ".claude", "settings.json");
-  if (fs29.existsSync(settingsPath)) {
+  const settingsPath = path32.join(target, ".claude", "settings.json");
+  if (fs30.existsSync(settingsPath)) {
     try {
-      const raw = fs29.readFileSync(settingsPath, "utf-8");
+      const raw = fs30.readFileSync(settingsPath, "utf-8");
       const settings = JSON.parse(raw);
       const cleaned = removeClearGateHooks(settings);
       await writeAtomic3(settingsPath, JSON.stringify(cleaned, null, 2) + "\n");
@@ -6843,7 +6907,7 @@ async function uninstallHandler(opts) {
     stdout("Removed @cleargate/cli from package.json. Run `npm install` to update package-lock.json.");
   }
   await removeFile(manifestPath);
-  await removeFile(path31.join(cleargateDir, ".drift-state.json"));
+  await removeFile(path32.join(cleargateDir, ".drift-state.json"));
   const marker = {
     uninstalled_at: now().toISOString(),
     prior_version: snapshot.cleargate_version,
@@ -6867,29 +6931,29 @@ async function uninstallHandler(opts) {
 
 // src/commands/sync.ts
 import * as fsPromises8 from "fs/promises";
-import * as path39 from "path";
+import * as path40 from "path";
 
 // src/lib/sync-log.ts
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import * as fsPromises2 from "fs/promises";
-import * as path32 from "path";
+import * as path33 from "path";
 function resolveActiveSprintDir(projectRoot, _opts) {
-  const sprintRunsRoot = path32.join(projectRoot, ".cleargate", "sprint-runs");
-  const offSprint = path32.join(sprintRunsRoot, "_off-sprint");
-  if (!fs30.existsSync(sprintRunsRoot)) {
-    fs30.mkdirSync(sprintRunsRoot, { recursive: true });
-    fs30.mkdirSync(offSprint, { recursive: true });
+  const sprintRunsRoot = path33.join(projectRoot, ".cleargate", "sprint-runs");
+  const offSprint = path33.join(sprintRunsRoot, "_off-sprint");
+  if (!fs31.existsSync(sprintRunsRoot)) {
+    fs31.mkdirSync(sprintRunsRoot, { recursive: true });
+    fs31.mkdirSync(offSprint, { recursive: true });
     return offSprint;
   }
-  const entries = fs30.readdirSync(sprintRunsRoot, { withFileTypes: true });
+  const entries = fs31.readdirSync(sprintRunsRoot, { withFileTypes: true });
   const sprintDirs = entries.filter((e) => e.isDirectory() && e.name !== "_off-sprint").map((e) => {
-    const fullPath = path32.join(sprintRunsRoot, e.name);
-    const stat = fs30.statSync(fullPath);
+    const fullPath = path33.join(sprintRunsRoot, e.name);
+    const stat = fs31.statSync(fullPath);
     return { name: e.name, fullPath, mtimeMs: stat.mtimeMs };
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
   if (sprintDirs.length === 0) {
-    if (!fs30.existsSync(offSprint)) {
-      fs30.mkdirSync(offSprint, { recursive: true });
+    if (!fs31.existsSync(offSprint)) {
+      fs31.mkdirSync(offSprint, { recursive: true });
     }
     return offSprint;
   }
@@ -6900,7 +6964,7 @@ function redactDetail(detail) {
   return detail.replace(/eyJ[A-Za-z0-9._-]+/g, "[REDACTED]");
 }
 async function appendSyncLog(sprintRoot, entry) {
-  const logPath = path32.join(sprintRoot, "sync-log.jsonl");
+  const logPath = path33.join(sprintRoot, "sync-log.jsonl");
   await fsPromises2.mkdir(sprintRoot, { recursive: true });
   const safeEntry = {
     ...entry,
@@ -6910,7 +6974,7 @@ async function appendSyncLog(sprintRoot, entry) {
   await fsPromises2.appendFile(logPath, line, { encoding: "utf8" });
 }
 async function readSyncLog(sprintRoot, filters) {
-  const logPath = path32.join(sprintRoot, "sync-log.jsonl");
+  const logPath = path33.join(sprintRoot, "sync-log.jsonl");
   let raw;
   try {
     raw = await fsPromises2.readFile(logPath, "utf8");
@@ -7012,9 +7076,9 @@ function classify2(local, remote, since) {
 }
 
 // src/lib/merge-helper.ts
-import { promises as fs31 } from "fs";
+import { promises as fs32 } from "fs";
 import * as os4 from "os";
-import * as path33 from "path";
+import * as path34 from "path";
 function promptFourChoice(opts) {
   const { stdin, stdout } = opts;
   stdout("[k]eep mine / [t]ake theirs / [e]dit in $EDITOR / [a]bort: ");
@@ -7084,7 +7148,7 @@ async function promptThreeWayMerge(opts) {
       case "a":
         return { resolution: "aborted", body: local };
       case "e": {
-        const tmpFile = path33.join(os4.tmpdir(), `cleargate-merge-${itemId}-${now()}.md`);
+        const tmpFile = path34.join(os4.tmpdir(), `cleargate-merge-${itemId}-${now()}.md`);
         const markerContent = `<<<<<<< local
 ${local}
 =======
@@ -7092,16 +7156,16 @@ ${remote}
 >>>>>>> remote
 `;
         try {
-          await fs31.writeFile(tmpFile, markerContent, "utf-8");
+          await fs32.writeFile(tmpFile, markerContent, "utf-8");
           await openInEditor(tmpFile, { editor: editor ?? process.env["EDITOR"] ?? "vi" });
-          const edited = await fs31.readFile(tmpFile, "utf-8");
+          const edited = await fs32.readFile(tmpFile, "utf-8");
           if (containsConflictMarkers(edited)) {
             stdout("File still contains conflict markers \u2014 please resolve all conflicts.\n");
             continue;
           }
           return { resolution: "edited", body: edited };
         } finally {
-          await fs31.unlink(tmpFile).catch(() => {
+          await fs32.unlink(tmpFile).catch(() => {
           });
         }
       }
@@ -7178,11 +7242,11 @@ function createMcpClient(opts) {
 
 // src/lib/intake.ts
 import * as fsPromises4 from "fs/promises";
-import * as path35 from "path";
+import * as path36 from "path";
 
 // src/lib/slug.ts
 import * as fsPromises3 from "fs/promises";
-import * as path34 from "path";
+import * as path35 from "path";
 function slugify(title, max = 40) {
   const normalized = title.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "");
   const lowered = normalized.toLowerCase();
@@ -7197,8 +7261,8 @@ function slugify(title, max = 40) {
 var PROPOSAL_ID_RE = /^proposal_id:\s*"?PROP-(\d+)"?/m;
 async function nextProposalId(projectRoot) {
   const dirs = [
-    path34.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
-    path34.join(projectRoot, ".cleargate", "delivery", "archive")
+    path35.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
+    path35.join(projectRoot, ".cleargate", "delivery", "archive")
   ];
   let maxN = 0;
   for (const dir of dirs) {
@@ -7210,7 +7274,7 @@ async function nextProposalId(projectRoot) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path34.join(dir, entry.name);
+      const fullPath = path35.join(dir, entry.name);
       try {
         const raw = await fsPromises3.readFile(fullPath, "utf8");
         const fmEnd = extractFrontmatterBlock(raw);
@@ -7228,8 +7292,8 @@ async function nextProposalId(projectRoot) {
 }
 async function findByRemoteId(projectRoot, remoteId) {
   const dirs = [
-    path34.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
-    path34.join(projectRoot, ".cleargate", "delivery", "archive")
+    path35.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
+    path35.join(projectRoot, ".cleargate", "delivery", "archive")
   ];
   const escaped = remoteId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const re = new RegExp(`^remote_id:\\s*"?${escaped}"?\\s*$`, "m");
@@ -7242,7 +7306,7 @@ async function findByRemoteId(projectRoot, remoteId) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path34.join(dir, entry.name);
+      const fullPath = path35.join(dir, entry.name);
       try {
         const raw = await fsPromises3.readFile(fullPath, "utf8");
         const fm = extractFrontmatterBlock(raw);
@@ -7279,7 +7343,7 @@ async function runIntakeBranch(opts) {
     labelFilter = "cleargate:proposal",
     now = () => (/* @__PURE__ */ new Date()).toISOString()
   } = opts;
-  const pendingSyncDir = path35.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSyncDir = path36.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   let remoteItems = [];
   try {
     remoteItems = await mcp.call(
@@ -7310,7 +7374,7 @@ async function runIntakeBranch(opts) {
       const slug2 = slugify(item.title ?? "untitled");
       const num2 = proposalId2.replace("PROP-", "");
       const filename2 = `PROPOSAL-${num2}-remote-${slug2}.md`;
-      const targetPath2 = path35.join(pendingSyncDir, filename2);
+      const targetPath2 = path36.join(pendingSyncDir, filename2);
       createdItems.push({
         proposalId: proposalId2,
         remoteId: item.remote_id,
@@ -7323,7 +7387,7 @@ async function runIntakeBranch(opts) {
     const num = proposalId.replace("PROP-", "");
     const slug = slugify(item.title ?? "untitled");
     const filename = `PROPOSAL-${num}-remote-${slug}.md`;
-    const targetPath = path35.join(pendingSyncDir, filename);
+    const targetPath = path36.join(pendingSyncDir, filename);
     const nowTs = now();
     const fm = {
       proposal_id: proposalId,
@@ -7415,8 +7479,8 @@ path/to/new/file.ext - {Explanation of purpose}
 }
 async function hasAnyRemoteAuthored(projectRoot) {
   const dirs = [
-    path35.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
-    path35.join(projectRoot, ".cleargate", "delivery", "archive")
+    path36.join(projectRoot, ".cleargate", "delivery", "pending-sync"),
+    path36.join(projectRoot, ".cleargate", "delivery", "archive")
   ];
   for (const dir of dirs) {
     let entries;
@@ -7427,7 +7491,7 @@ async function hasAnyRemoteAuthored(projectRoot) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path35.join(dir, entry.name);
+      const fullPath = path36.join(dir, entry.name);
       try {
         const raw = await fsPromises4.readFile(fullPath, "utf8");
         const fmEnd = raw.indexOf("\n---", 4);
@@ -7444,9 +7508,9 @@ async function hasAnyRemoteAuthored(projectRoot) {
 }
 
 // src/lib/active-criteria.ts
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 import * as fsPromises5 from "fs/promises";
-import * as path36 from "path";
+import * as path37 from "path";
 async function resolveActiveItems(projectRoot, localItems, nowFn = () => (/* @__PURE__ */ new Date()).toISOString()) {
   const active = /* @__PURE__ */ new Set();
   const now = Date.parse(nowFn());
@@ -7471,7 +7535,7 @@ async function resolveInSprintIds(projectRoot) {
   const ids = /* @__PURE__ */ new Set();
   try {
     const sprintDir = resolveActiveSprintDir(projectRoot);
-    const sprintId = path36.basename(sprintDir);
+    const sprintId = path37.basename(sprintDir);
     if (sprintId === "_off-sprint") return ids;
     const sprintFile = await findSprintFile(projectRoot, sprintId);
     if (!sprintFile) return ids;
@@ -7486,14 +7550,14 @@ async function resolveInSprintIds(projectRoot) {
   return ids;
 }
 async function findSprintFile(projectRoot, sprintId) {
-  const pendingSync = path36.join(projectRoot, ".cleargate", "delivery", "pending-sync");
-  const archive = path36.join(projectRoot, ".cleargate", "delivery", "archive");
+  const pendingSync = path37.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const archive = path37.join(projectRoot, ".cleargate", "delivery", "archive");
   for (const dir of [pendingSync, archive]) {
     try {
-      const entries = fs32.readdirSync(dir, { withFileTypes: true });
+      const entries = fs33.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && entry.name.startsWith(sprintId) && entry.name.endsWith(".md")) {
-          return path36.join(dir, entry.name);
+          return path37.join(dir, entry.name);
         }
       }
     } catch {
@@ -7504,12 +7568,12 @@ async function findSprintFile(projectRoot, sprintId) {
 
 // src/lib/comments-cache.ts
 import * as fsPromises6 from "fs/promises";
-import * as path37 from "path";
+import * as path38 from "path";
 function cacheDir(projectRoot) {
-  return path37.join(projectRoot, ".cleargate", ".comments-cache");
+  return path38.join(projectRoot, ".cleargate", ".comments-cache");
 }
 function cachePath(projectRoot, remoteId) {
-  return path37.join(cacheDir(projectRoot), `${remoteId}.json`);
+  return path38.join(cacheDir(projectRoot), `${remoteId}.json`);
 }
 async function writeCommentCache(projectRoot, remoteId, comments) {
   const dir = cacheDir(projectRoot);
@@ -7523,7 +7587,7 @@ async function writeCommentCache(projectRoot, remoteId, comments) {
 
 // src/lib/wiki-comments-render.ts
 import * as fsPromises7 from "fs/promises";
-import * as path38 from "path";
+import * as path39 from "path";
 var START = "<!-- cleargate:comments:start -->";
 var END = "<!-- cleargate:comments:end -->";
 function resolveBucket(fm) {
@@ -7568,7 +7632,7 @@ async function renderCommentsSection(opts) {
   const bucket = resolveBucket(localItem.fm);
   const primaryId = getPrimaryId(localItem.fm);
   if (!bucket || !primaryId) return;
-  const wikiPath = path38.join(
+  const wikiPath = path39.join(
     projectRoot,
     ".cleargate",
     "wiki",
@@ -7604,7 +7668,7 @@ async function renderCommentsSection(opts) {
   await writeAtomic4(wikiPath, updated);
 }
 async function writeAtomic4(filePath, content) {
-  await fsPromises7.mkdir(path38.dirname(filePath), { recursive: true });
+  await fsPromises7.mkdir(path39.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises7.writeFile(tmpPath, content, "utf8");
   await fsPromises7.rename(tmpPath, filePath);
@@ -7616,11 +7680,11 @@ async function syncCheckHandler(opts = {}) {
   const env = opts.env ?? process.env;
   const stdout = opts.stdout ?? ((s) => process.stdout.write(s));
   const nowFn = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const markerPath = path39.join(projectRoot, ".cleargate", ".sync-marker.json");
+  const markerPath = path40.join(projectRoot, ".cleargate", ".sync-marker.json");
   const updateMarker = async (nowIso2) => {
     try {
       const content = JSON.stringify({ last_check: nowIso2 });
-      await fsPromises8.mkdir(path39.dirname(markerPath), { recursive: true });
+      await fsPromises8.mkdir(path40.dirname(markerPath), { recursive: true });
       const tmpPath = `${markerPath}.tmp.${Date.now()}`;
       await fsPromises8.writeFile(tmpPath, content, "utf8");
       await fsPromises8.rename(tmpPath, markerPath);
@@ -7703,7 +7767,7 @@ async function syncHandler(opts = {}) {
   const nowFn = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const identity = resolveIdentity(projectRoot);
   const sprintRoot = resolveActiveSprintDir(projectRoot);
-  const sprintId = path39.basename(sprintRoot);
+  const sprintId = path40.basename(sprintRoot);
   let mcp;
   if (opts.mcp) {
     mcp = opts.mcp;
@@ -7764,7 +7828,7 @@ async function syncHandler(opts = {}) {
     exit(2);
     return;
   }
-  const wikiMetaPath = path39.join(projectRoot, ".cleargate", "wiki", "meta.json");
+  const wikiMetaPath = path40.join(projectRoot, ".cleargate", "wiki", "meta.json");
   let lastRemoteSync = "1970-01-01T00:00:00.000Z";
   try {
     const metaRaw = await fsPromises8.readFile(wikiMetaPath, "utf8");
@@ -8005,7 +8069,7 @@ async function syncHandler(opts = {}) {
     };
     await appendSyncLog(sprintRoot, entry);
   }
-  const conflictsFile = path39.join(projectRoot, ".cleargate", ".conflicts.json");
+  const conflictsFile = path40.join(projectRoot, ".cleargate", ".conflicts.json");
   const conflictsContent = {
     generated_at: nowFn(),
     sprint_id: sprintId,
@@ -8013,7 +8077,7 @@ async function syncHandler(opts = {}) {
   };
   await writeAtomic5(conflictsFile, JSON.stringify(conflictsContent, null, 2) + "\n");
   try {
-    await fsPromises8.mkdir(path39.dirname(wikiMetaPath), { recursive: true });
+    await fsPromises8.mkdir(path40.dirname(wikiMetaPath), { recursive: true });
     let meta = {};
     try {
       const raw = await fsPromises8.readFile(wikiMetaPath, "utf8");
@@ -8054,13 +8118,13 @@ async function applyPull(item, localPath, fm, actorEmail, nowFn) {
   await writeAtomic5(localPath, newContent);
 }
 async function writeAtomic5(filePath, content) {
-  await fsPromises8.mkdir(path39.dirname(filePath), { recursive: true });
+  await fsPromises8.mkdir(path40.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises8.writeFile(tmpPath, content, "utf8");
   await fsPromises8.rename(tmpPath, filePath);
 }
 async function scanLocalItems(projectRoot) {
-  const pendingSync = path39.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSync = path40.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   const results = [];
   let entries;
   try {
@@ -8070,7 +8134,7 @@ async function scanLocalItems(projectRoot) {
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const fullPath = path39.join(pendingSync, entry.name);
+    const fullPath = path40.join(pendingSync, entry.name);
     try {
       const raw = await fsPromises8.readFile(fullPath, "utf8");
       const { fm, body } = parseFrontmatter(raw);
@@ -8092,7 +8156,7 @@ function getItemId(fm) {
 
 // src/commands/pull.ts
 import * as fsPromises9 from "fs/promises";
-import * as path40 from "path";
+import * as path41 from "path";
 async function pullHandler(idOrRemoteId, opts = {}) {
   const projectRoot = opts.projectRoot ?? process.cwd();
   const env = opts.env ?? process.env;
@@ -8205,7 +8269,7 @@ async function pullHandler(idOrRemoteId, opts = {}) {
     result: "ok"
   };
   await appendSyncLog(sprintRoot, entry);
-  stdout(`pull: ${remoteId} applied to ${path40.relative(projectRoot, localPath)}
+  stdout(`pull: ${remoteId} applied to ${path41.relative(projectRoot, localPath)}
 `);
   if (opts.comments) {
     const comments = await mcp.call(
@@ -8228,7 +8292,7 @@ async function resolveRemoteId(idOrRemoteId, projectRoot) {
   if (/^[A-Z]+-\d+/.test(idOrRemoteId)) {
     return idOrRemoteId;
   }
-  const pendingSync = path40.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSync = path41.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   let entries;
   try {
     entries = await fsPromises9.readdir(pendingSync, { withFileTypes: true });
@@ -8238,7 +8302,7 @@ async function resolveRemoteId(idOrRemoteId, projectRoot) {
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
     try {
-      const raw = await fsPromises9.readFile(path40.join(pendingSync, entry.name), "utf8");
+      const raw = await fsPromises9.readFile(path41.join(pendingSync, entry.name), "utf8");
       const { fm } = parseFrontmatter(raw);
       for (const key of ["story_id", "epic_id", "proposal_id", "cr_id", "bug_id"]) {
         if (fm[key] === idOrRemoteId && typeof fm["remote_id"] === "string") {
@@ -8251,7 +8315,7 @@ async function resolveRemoteId(idOrRemoteId, projectRoot) {
   return null;
 }
 async function findLocalFile(remoteId, projectRoot) {
-  const pendingSync = path40.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingSync = path41.join(projectRoot, ".cleargate", "delivery", "pending-sync");
   let entries;
   try {
     entries = await fsPromises9.readdir(pendingSync, { withFileTypes: true });
@@ -8260,7 +8324,7 @@ async function findLocalFile(remoteId, projectRoot) {
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const fullPath = path40.join(pendingSync, entry.name);
+    const fullPath = path41.join(pendingSync, entry.name);
     try {
       const raw = await fsPromises9.readFile(fullPath, "utf8");
       const { fm } = parseFrontmatter(raw);
@@ -8271,7 +8335,7 @@ async function findLocalFile(remoteId, projectRoot) {
   return null;
 }
 async function writeAtomic6(filePath, content) {
-  await fsPromises9.mkdir(path40.dirname(filePath), { recursive: true });
+  await fsPromises9.mkdir(path41.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises9.writeFile(tmpPath, content, "utf8");
   await fsPromises9.rename(tmpPath, filePath);
@@ -8286,7 +8350,7 @@ function getItemId2(fm) {
 
 // src/commands/push.ts
 import * as fsPromises10 from "fs/promises";
-import * as path41 from "path";
+import * as path42 from "path";
 async function pushHandler(fileOrId, opts = {}) {
   const projectRoot = opts.projectRoot ?? process.cwd();
   const env = opts.env ?? process.env;
@@ -8360,7 +8424,7 @@ async function pushHandler(fileOrId, opts = {}) {
 }
 async function handlePush(filePath, ctx) {
   const { projectRoot, identity, sprintRoot, nowFn, resolveMcp, stdout, stderr, exit } = ctx;
-  const resolvedPath = path41.isAbsolute(filePath) ? filePath : path41.resolve(projectRoot, filePath);
+  const resolvedPath = path42.isAbsolute(filePath) ? filePath : path42.resolve(projectRoot, filePath);
   let rawContent;
   try {
     rawContent = await fsPromises10.readFile(resolvedPath, "utf8");
@@ -8486,8 +8550,8 @@ async function handleRevert(idOrRemoteId, ctx) {
   void localPath;
 }
 async function resolveLocalItem(idOrRemoteId, projectRoot) {
-  const pendingSync = path41.join(projectRoot, ".cleargate", "delivery", "pending-sync");
-  const archive = path41.join(projectRoot, ".cleargate", "delivery", "archive");
+  const pendingSync = path42.join(projectRoot, ".cleargate", "delivery", "pending-sync");
+  const archive = path42.join(projectRoot, ".cleargate", "delivery", "archive");
   for (const dir of [pendingSync, archive]) {
     let entries;
     try {
@@ -8497,7 +8561,7 @@ async function resolveLocalItem(idOrRemoteId, projectRoot) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const fullPath = path41.join(dir, entry.name);
+      const fullPath = path42.join(dir, entry.name);
       try {
         const raw = await fsPromises10.readFile(fullPath, "utf8");
         const { fm } = parseFrontmatter(raw);
@@ -8516,7 +8580,7 @@ async function resolveLocalItem(idOrRemoteId, projectRoot) {
   return null;
 }
 async function writeAtomic7(filePath, content) {
-  await fsPromises10.mkdir(path41.dirname(filePath), { recursive: true });
+  await fsPromises10.mkdir(path42.dirname(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
   await fsPromises10.writeFile(tmpPath, content, "utf8");
   await fsPromises10.rename(tmpPath, filePath);
@@ -8544,7 +8608,7 @@ function getItemType(fm) {
 
 // src/commands/conflicts.ts
 import * as fsPromises11 from "fs/promises";
-import * as path42 from "path";
+import * as path43 from "path";
 var RESOLUTION_HINTS = {
   "local-delete-remote-edit": "remote-delete: resurrect or delete remote?",
   "remote-delete-local-edit": "local-edit: push your changes or accept remote deletion?",
@@ -8580,7 +8644,7 @@ async function conflictsHandler(opts = {}) {
       }
     }
   }
-  const conflictsFile = path42.join(projectRoot, ".cleargate", ".conflicts.json");
+  const conflictsFile = path43.join(projectRoot, ".cleargate", ".conflicts.json");
   let data;
   try {
     const raw = await fsPromises11.readFile(conflictsFile, "utf8");
@@ -8666,8 +8730,8 @@ function formatEntry(entry) {
 }
 
 // src/commands/admin-login.ts
-import * as fs33 from "fs";
-import * as path43 from "path";
+import * as fs34 from "fs";
+import * as path44 from "path";
 import * as os5 from "os";
 var DEFAULT_MCP_URL = "http://localhost:3000";
 function resolveMcpUrl(mcpUrlFlag, env) {
@@ -8676,14 +8740,14 @@ function resolveMcpUrl(mcpUrlFlag, env) {
 function resolveAuthFilePath(opts) {
   if (opts.authFilePath) return opts.authFilePath;
   const homedirFn = opts.homedir ?? os5.homedir;
-  return path43.join(homedirFn(), ".cleargate", "admin-auth.json");
+  return path44.join(homedirFn(), ".cleargate", "admin-auth.json");
 }
 function writeAdminAuth(filePath, token) {
-  const dir = path43.dirname(filePath);
-  fs33.mkdirSync(dir, { recursive: true });
+  const dir = path44.dirname(filePath);
+  fs34.mkdirSync(dir, { recursive: true });
   const payload = JSON.stringify({ version: 1, token }, null, 2);
-  fs33.writeFileSync(filePath, payload, { encoding: "utf8", mode: 384 });
-  fs33.chmodSync(filePath, 384);
+  fs34.writeFileSync(filePath, payload, { encoding: "utf8", mode: 384 });
+  fs34.chmodSync(filePath, 384);
 }
 async function adminLoginHandler(opts = {}) {
   const fetchFn = opts.fetch ?? globalThis.fetch;
@@ -8792,8 +8856,8 @@ async function adminLoginHandler(opts = {}) {
 }
 
 // src/commands/hotfix.ts
-import * as fs34 from "fs";
-import * as path44 from "path";
+import * as fs35 from "fs";
+import * as path45 from "path";
 function defaultExit4(code) {
   return process.exit(code);
 }
@@ -8803,7 +8867,7 @@ function maxHotfixId(pendingDir) {
   let max = 0;
   let entries;
   try {
-    entries = fs34.readdirSync(pendingDir);
+    entries = fs35.readdirSync(pendingDir);
   } catch {
     return 0;
   }
@@ -8817,13 +8881,13 @@ function maxHotfixId(pendingDir) {
   return max;
 }
 function countActiveHotfixes(repoRoot) {
-  const pendingDir = path44.join(repoRoot, ".cleargate", "delivery", "pending-sync");
-  const archiveDir = path44.join(repoRoot, ".cleargate", "delivery", "archive");
+  const pendingDir = path45.join(repoRoot, ".cleargate", "delivery", "pending-sync");
+  const archiveDir = path45.join(repoRoot, ".cleargate", "delivery", "archive");
   const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
   let count = 0;
   let pendingEntries = [];
   try {
-    pendingEntries = fs34.readdirSync(pendingDir);
+    pendingEntries = fs35.readdirSync(pendingDir);
   } catch {
   }
   for (const entry of pendingEntries) {
@@ -8831,13 +8895,13 @@ function countActiveHotfixes(repoRoot) {
   }
   let archiveEntries = [];
   try {
-    archiveEntries = fs34.readdirSync(archiveDir);
+    archiveEntries = fs35.readdirSync(archiveDir);
   } catch {
   }
   for (const entry of archiveEntries) {
     if (entry.startsWith("HOTFIX-") && entry.endsWith(".md")) {
       try {
-        const stat = fs34.statSync(path44.join(archiveDir, entry));
+        const stat = fs35.statSync(path45.join(archiveDir, entry));
         if (stat.mtimeMs >= sevenDaysAgo) count++;
       } catch {
       }
@@ -8846,7 +8910,7 @@ function countActiveHotfixes(repoRoot) {
   return count;
 }
 function resolveTemplatePath(repoRoot) {
-  return path44.join(repoRoot, ".cleargate", "templates", "hotfix.md");
+  return path45.join(repoRoot, ".cleargate", "templates", "hotfix.md");
 }
 function hotfixNewHandler(opts, cli) {
   const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
@@ -8865,14 +8929,14 @@ function hotfixNewHandler(opts, cli) {
     );
     return exitFn(1);
   }
-  const pendingDir = path44.join(repoRoot, ".cleargate", "delivery", "pending-sync");
+  const pendingDir = path45.join(repoRoot, ".cleargate", "delivery", "pending-sync");
   const maxId = maxHotfixId(pendingDir);
   const nextId = maxId + 1;
   const idStr = `HOTFIX-${String(nextId).padStart(3, "0")}`;
   const templatePath = resolveTemplatePath(repoRoot);
   let templateContent;
   try {
-    templateContent = fs34.readFileSync(templatePath, "utf8");
+    templateContent = fs35.readFileSync(templatePath, "utf8");
   } catch {
     stderrFn(`[cleargate hotfix new] template not found: ${templatePath}`);
     return exitFn(2);
@@ -8880,10 +8944,10 @@ function hotfixNewHandler(opts, cli) {
   const content = templateContent.replace(/\{ID\}/g, idStr).replace(/\{SLUG\}/g, opts.slug).replace(/\{ISO\}/g, now);
   const fileSlug = opts.slug.replace(/-/g, "_");
   const fileName = `${idStr}_${fileSlug}.md`;
-  const outPath = path44.join(pendingDir, fileName);
+  const outPath = path45.join(pendingDir, fileName);
   try {
-    fs34.mkdirSync(pendingDir, { recursive: true });
-    fs34.writeFileSync(outPath, content, "utf8");
+    fs35.mkdirSync(pendingDir, { recursive: true });
+    fs35.writeFileSync(outPath, content, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     stderrFn(`[cleargate hotfix new] write failed: ${msg}`);