cleargate 0.1.0-alpha.1 → 0.2.1

package/dist/cli.js

@@ -9,10 +9,10 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "cleargate",
-  version: "0.1.0-alpha.1",
+  version: "0.2.1",
   private: false,
   type: "module",
-  description: "ClearGate CLI \u2014 connects AI agent teams to the ClearGate MCP server",
+  description: "Planning framework for Claude Code agents \u2014 sprint/epic/story protocol, four-agent loop (architect/developer/qa/reporter), Karpathy-style awareness wiki.",
   bin: {
     cleargate: "dist/cli.js"
   },
@@ -32,12 +32,14 @@ var package_default = {
   },
   files: [
     "dist",
+    "templates",
     "README.md"
   ],
   engines: {
     node: ">=24.0.0"
   },
   scripts: {
+    prebuild: "tsx scripts/build-manifest.ts && node scripts/copy-planning-payload.mjs",
     build: "tsup",
     dev: "tsup --watch",
     typecheck: "tsc --noEmit",
@@ -48,11 +50,16 @@ var package_default = {
   dependencies: {
     "@napi-rs/keyring": "^1.2.0",
     commander: "^12",
+    diff: "^5.2.2",
+    "js-yaml": "^4.1.0",
     zod: "^4.3.0"
   },
   devDependencies: {
+    "@types/diff": "^5.2.3",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.0.0",
     tsup: "^8",
+    tsx: "^4.21.0",
     typescript: "^5.8.0",
     vitest: "^2.1.0"
   }
@@ -261,6 +268,4266 @@ async function joinHandler(opts) {
   }
 }
 
+// src/commands/stamp.ts
+import * as fs4 from "fs";
+import * as os3 from "os";
+import * as path3 from "path";
+
+// src/lib/codebase-version.ts
+import { execSync } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
+function makeDefaultExec(cwd) {
+  return (cmd, args) => {
+    try {
+      const stdout = execSync([cmd, ...args].join(" "), {
+        cwd,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return { stdout: stdout.trim(), code: 0 };
+    } catch (err) {
+      const e = err;
+      return {
+        stdout: typeof e.stdout === "string" ? e.stdout.trim() : "",
+        code: typeof e.status === "number" ? e.status : 1
+      };
+    }
+  };
+}
+function findPackageJson(startDir) {
+  let current = startDir;
+  while (true) {
+    const candidate = path2.join(current, "package.json");
+    if (fs2.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function getCodebaseVersion(opts) {
+  const cwd = opts?.cwd ?? process.cwd();
+  const execFn = opts?.exec ?? makeDefaultExec(cwd);
+  const shaResult = execFn("git", ["rev-parse", "--short", "HEAD"]);
+  if (shaResult.code === 0 && shaResult.stdout.length > 0) {
+    const sha = shaResult.stdout.trim();
+    const statusResult = execFn("git", ["status", "--porcelain"]);
+    const dirty = statusResult.code === 0 && statusResult.stdout.trim().length > 0;
+    const version_string = dirty ? `${sha}-dirty` : sha;
+    return {
+      sha,
+      dirty,
+      tag: null,
+      package_version: null,
+      version_string
+    };
+  }
+  const pkgPath = findPackageJson(cwd);
+  if (pkgPath !== null) {
+    try {
+      const raw = fs2.readFileSync(pkgPath, "utf8");
+      const pkg = JSON.parse(raw);
+      const package_version = typeof pkg.version === "string" ? pkg.version : null;
+      if (package_version !== null) {
+        return {
+          sha: null,
+          dirty: false,
+          tag: null,
+          package_version,
+          version_string: package_version
+        };
+      }
+    } catch {
+    }
+  }
+  console.warn("[cleargate] codebase-version: could not determine version (no git, no package.json)");
+  return {
+    sha: null,
+    dirty: false,
+    tag: null,
+    package_version: null,
+    version_string: "unknown"
+  };
+}
+
+// src/lib/stamp-frontmatter.ts
+import * as fs3 from "fs/promises";
+
+// src/wiki/parse-frontmatter.ts
+import yaml from "js-yaml";
+function parseFrontmatter(raw) {
+  const lines = raw.split("\n");
+  if (lines[0] !== "---") {
+    throw new Error("parseFrontmatter: input does not start with ---");
+  }
+  let closeIdx = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i] === "---") {
+      closeIdx = i;
+      break;
+    }
+  }
+  if (closeIdx === -1) {
+    throw new Error("parseFrontmatter: missing closing ---");
+  }
+  const yamlText = lines.slice(1, closeIdx).join("\n");
+  const bodyLines = lines.slice(closeIdx + 1);
+  if (bodyLines[0] === "") bodyLines.shift();
+  const body = bodyLines.join("\n");
+  if (yamlText.trim() === "") {
+    return { fm: {}, body };
+  }
+  let parsed;
+  try {
+    parsed = yaml.load(yamlText, { schema: yaml.CORE_SCHEMA });
+  } catch (err) {
+    throw new Error(`parseFrontmatter: invalid YAML: ${err.message}`);
+  }
+  if (parsed === null || parsed === void 0) {
+    return { fm: {}, body };
+  }
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("parseFrontmatter: frontmatter is not a YAML mapping");
+  }
+  return { fm: parsed, body };
+}
+
+// src/lib/frontmatter-yaml.ts
+import yaml2 from "js-yaml";
+function serializeFrontmatter(fm) {
+  if (Object.keys(fm).length === 0) {
+    return "---\n---";
+  }
+  const yamlBody = yaml2.dump(fm, {
+    schema: yaml2.CORE_SCHEMA,
+    lineWidth: -1,
+    noRefs: true,
+    noCompatMode: true,
+    quotingType: '"',
+    forceQuotes: false
+  });
+  return `---
+${yamlBody.replace(/\n+$/, "")}
+---`;
+}
+function toIsoSecond(d) {
+  return d.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+
+// src/lib/stamp-frontmatter.ts
+var WRITE_TEMPLATE_KEYS = /* @__PURE__ */ new Set([
+  "story_id",
+  "epic_id",
+  "proposal_id",
+  "cr_id",
+  "bug_id"
+]);
+var DEFAULT_ARCHIVE_MATCHER = (absPath) => /\/\.cleargate\/delivery\/archive\//.test(absPath);
+async function stampFrontmatter(absPath, opts) {
+  const isArchive = (opts?.archivePathMatcher ?? DEFAULT_ARCHIVE_MATCHER)(absPath);
+  if (isArchive) {
+    const raw2 = await fs3.readFile(absPath, "utf8");
+    let fm2 = {};
+    try {
+      ({ fm: fm2 } = parseFrontmatter(raw2));
+    } catch {
+    }
+    return {
+      changed: false,
+      frontmatterBefore: fm2,
+      frontmatterAfter: fm2,
+      reason: "noop-archive"
+    };
+  }
+  const raw = await fs3.readFile(absPath, "utf8");
+  const hasFrontmatter = raw.trimStart().startsWith("---");
+  let fm = {};
+  let body = raw;
+  if (hasFrontmatter) {
+    const parsed = parseFrontmatter(raw);
+    fm = parsed.fm;
+    body = parsed.body;
+  }
+  const frontmatterBefore = { ...fm };
+  const nowFn = opts?.now ?? (() => /* @__PURE__ */ new Date());
+  const now = nowFn();
+  const nowIso = toIsoSecond(now);
+  const version = opts?.version ?? { sha: null, dirty: false, tag: null, package_version: null, version_string: "unknown" };
+  const versionString = version.version_string;
+  const hasCreatedAt = "created_at" in fm && fm["created_at"] !== void 0 && fm["created_at"] !== "" && fm["created_at"] !== null;
+  const isWriteTemplate = WRITE_TEMPLATE_KEYS.has(Object.keys(fm).find((k) => WRITE_TEMPLATE_KEYS.has(k)) ?? "");
+  const newFm = {};
+  for (const [k, v] of Object.entries(fm)) {
+    newFm[k] = v;
+  }
+  if (!hasCreatedAt) {
+    newFm["created_at"] = nowIso;
+    newFm["updated_at"] = nowIso;
+    newFm["created_at_version"] = versionString;
+    newFm["updated_at_version"] = versionString;
+    if (isWriteTemplate && !("server_pushed_at_version" in newFm)) {
+      newFm["server_pushed_at_version"] = null;
+    }
+  } else {
+    newFm["updated_at"] = nowIso;
+    newFm["updated_at_version"] = versionString;
+    if (isWriteTemplate && !("server_pushed_at_version" in newFm)) {
+      newFm["server_pushed_at_version"] = null;
+    }
+  }
+  const unchanged = newFm["updated_at"] === fm["updated_at"] && newFm["updated_at_version"] === fm["updated_at_version"] && newFm["created_at"] === fm["created_at"] && newFm["created_at_version"] === fm["created_at_version"];
+  if (unchanged && hasCreatedAt) {
+    return {
+      changed: false,
+      frontmatterBefore,
+      frontmatterAfter: newFm,
+      reason: "noop-unchanged"
+    };
+  }
+  const fmBlock = serializeFrontmatter(newFm);
+  const newContent = body.length > 0 ? `${fmBlock}
+
+${body}` : `${fmBlock}
+`;
+  await fs3.writeFile(absPath, newContent, "utf8");
+  return {
+    changed: true,
+    frontmatterBefore,
+    frontmatterAfter: newFm,
+    reason: hasCreatedAt ? "updated" : "created"
+  };
+}
+
+// src/commands/stamp.ts
+function buildDiffPreview(filePath, before, after) {
+  const lines = [`--- ${filePath}`, `+++ ${filePath} (after stamp)`];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const key of [...Object.keys(before), ...Object.keys(after)]) {
+    if (seenKeys.has(key)) continue;
+    seenKeys.add(key);
+    const bVal = before[key];
+    const aVal = after[key];
+    if (bVal === aVal) {
+      lines.push(` ${key}: ${String(bVal)}`);
+    } else {
+      if (key in before) {
+        lines.push(`-${key}: ${String(bVal)}`);
+      }
+      if (key in after) {
+        lines.push(`+${key}: ${String(aVal)}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+async function stampHandler(file, opts, cli) {
+  const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
+  const exitFn = cli?.exit ?? ((code) => process.exit(code));
+  const cwd = cli?.cwd ?? process.cwd();
+  const absPath = path3.isAbsolute(file) ? file : path3.resolve(cwd, file);
+  if (!fs4.existsSync(absPath)) {
+    process.stderr.write(`[cleargate stamp] error: file not found: ${absPath}
+`);
+    return exitFn(1);
+  }
+  const version = cli?.getVersion ? cli.getVersion() : getCodebaseVersion({ cwd });
+  if (opts.dryRun) {
+    const tmpDir = fs4.mkdtempSync(path3.join(os3.tmpdir(), "cg-stamp-dry-"));
+    try {
+      const tmpFile = path3.join(tmpDir, path3.basename(absPath));
+      fs4.copyFileSync(absPath, tmpFile);
+      let before = {};
+      try {
+        const raw = fs4.readFileSync(absPath, "utf8");
+        if (raw.trimStart().startsWith("---")) {
+          ({ fm: before } = parseFrontmatter(raw));
+        }
+      } catch {
+      }
+      const stampOpts2 = { version };
+      if (cli?.now) {
+        stampOpts2.now = cli.now;
+      }
+      const result2 = await stampFrontmatter(tmpFile, stampOpts2);
+      const diff = buildDiffPreview(file, before, result2.frontmatterAfter);
+      stdoutFn(diff);
+      if (result2.reason === "noop-archive" || result2.reason === "noop-unchanged") {
+        stdoutFn(`[dry-run] no changes (${result2.reason})`);
+      }
+    } finally {
+      fs4.rmSync(tmpDir, { recursive: true, force: true });
+    }
+    return;
+  }
+  const stampOpts = { version };
+  if (cli?.now) {
+    stampOpts.now = cli.now;
+  }
+  const result = await stampFrontmatter(absPath, stampOpts);
+  stdoutFn(`[stamped] ${file} (${result.reason})`);
+}
+
+// src/commands/init.ts
+import * as fs12 from "fs";
+import * as path12 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+
+// src/init/copy-payload.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+function listFilesRecursive(dir) {
+  const results = [];
+  function walk(current, rel) {
+    const entries = fs5.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryRel = rel ? `${rel}/${entry.name}` : entry.name;
+      const entryAbs = path4.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(entryAbs, entryRel);
+      } else {
+        results.push(entryRel);
+      }
+    }
+  }
+  walk(dir, "");
+  return results;
+}
+function copyPayload(payloadDir, targetCwd, opts) {
+  const report = { created: 0, skipped: 0, overwritten: 0, actions: [] };
+  if (!fs5.existsSync(payloadDir)) {
+    throw new Error(`copyPayload: payloadDir does not exist: ${payloadDir}`);
+  }
+  const files = listFilesRecursive(payloadDir);
+  for (const relPath of files) {
+    const srcPath = path4.join(payloadDir, relPath);
+    const dstPath = path4.join(targetCwd, relPath);
+    fs5.mkdirSync(path4.dirname(dstPath), { recursive: true });
+    const srcContent = fs5.readFileSync(srcPath);
+    if (fs5.existsSync(dstPath)) {
+      const dstContent = fs5.readFileSync(dstPath);
+      if (srcContent.equals(dstContent)) {
+        report.skipped++;
+        report.actions.push({ action: "skipped", relPath });
+        continue;
+      }
+      if (!opts.force) {
+        report.skipped++;
+        report.actions.push({ action: "skipped", relPath });
+        continue;
+      }
+      fs5.writeFileSync(dstPath, srcContent);
+      report.overwritten++;
+      report.actions.push({ action: "overwritten", relPath });
+    } else {
+      fs5.writeFileSync(dstPath, srcContent);
+      report.created++;
+      report.actions.push({ action: "created", relPath });
+    }
+  }
+  return report;
+}
+
+// src/init/merge-settings.ts
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function mergeSettings(existing, addition) {
+  if (existing === null) {
+    return deepClone(addition);
+  }
+  const result = deepClone(existing);
+  if (!result.hooks) {
+    result.hooks = {};
+  }
+  for (const [eventName, eventArray] of Object.entries(addition.hooks ?? {})) {
+    if (!result.hooks[eventName]) {
+      result.hooks[eventName] = [];
+    }
+    for (const newEntry of eventArray) {
+      const matchingIdx = result.hooks[eventName].findIndex(
+        (e) => e.matcher === newEntry.matcher
+      );
+      if (matchingIdx === -1) {
+        result.hooks[eventName].push(deepClone(newEntry));
+      } else {
+        const existingEntry = result.hooks[eventName][matchingIdx];
+        const existingInner = Array.isArray(existingEntry.hooks) ? existingEntry.hooks : [];
+        for (const newInner of newEntry.hooks ?? []) {
+          if (!existingInner.some((h) => h.command === newInner.command)) {
+            existingInner.push(deepClone(newInner));
+          }
+        }
+        result.hooks[eventName][matchingIdx] = {
+          ...existingEntry,
+          hooks: existingInner
+        };
+      }
+    }
+  }
+  return result;
+}
+
+// src/init/inject-claude-md.ts
+var BLOCK_REGEX = /<!-- CLEARGATE:START -->[\s\S]*<!-- CLEARGATE:END -->/;
+function extractBlock(sourceContent) {
+  const match = BLOCK_REGEX.exec(sourceContent);
+  if (!match) {
+    throw new Error("inject-claude-md: CLEARGATE:START/END markers not found in source content");
+  }
+  return match[0];
+}
+function injectClaudeMd(existing, block) {
+  if (existing === null) {
+    return block + "\n";
+  }
+  if (BLOCK_REGEX.test(existing)) {
+    return existing.replace(BLOCK_REGEX, block);
+  }
+  return existing.trimEnd() + "\n\n" + block + "\n";
+}
+
+// src/commands/wiki-build.ts
+import * as fs11 from "fs";
+import * as path10 from "path";
+
+// src/wiki/scan.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+
+// src/wiki/derive-bucket.ts
+var PREFIX_MAP = [
+  { prefix: "EPIC-", type: "epic", bucket: "epics" },
+  { prefix: "STORY-", type: "story", bucket: "stories" },
+  { prefix: "SPRINT-", type: "sprint", bucket: "sprints" },
+  { prefix: "PROPOSAL-", type: "proposal", bucket: "proposals" },
+  { prefix: "CR-", type: "cr", bucket: "crs" },
+  { prefix: "BUG-", type: "bug", bucket: "bugs" }
+];
+function deriveBucket(filename) {
+  const base = filename.includes("/") ? filename.split("/").pop() : filename;
+  const stem = base.endsWith(".md") ? base.slice(0, -3) : base;
+  const underscoreIdx = stem.indexOf("_");
+  const id = underscoreIdx === -1 ? stem : stem.slice(0, underscoreIdx);
+  for (const { prefix, type, bucket } of PREFIX_MAP) {
+    if (id.startsWith(prefix)) {
+      return { type, id, bucket };
+    }
+  }
+  throw new Error(`deriveBucket: cannot determine bucket for filename: ${filename}`);
+}
+
+// src/wiki/derive-repo.ts
+function deriveRepo(rawPath) {
+  if (rawPath.startsWith("cleargate-cli/")) return "cli";
+  if (rawPath.startsWith("mcp/")) return "mcp";
+  if (rawPath.startsWith(".cleargate/") || rawPath.startsWith("cleargate-planning/")) return "planning";
+  throw new Error(`cannot derive repo for path: ${rawPath}`);
+}
+
+// src/wiki/scan.ts
+var EXCLUDED_SUFFIXES = [
+  ".cleargate/knowledge/",
+  ".cleargate/templates/",
+  ".cleargate/sprint-runs/",
+  ".cleargate/hook-log/",
+  ".cleargate/wiki/"
+];
+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" });
+    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);
+      if (!stat.isFile()) continue;
+      const rawPath = path5.relative(repoRoot, absPath).replace(/\\/g, "/");
+      const isExcluded = EXCLUDED_SUFFIXES.some((excl) => rawPath.startsWith(excl));
+      if (isExcluded) continue;
+      const filename = path5.basename(absPath);
+      let bucketInfo;
+      try {
+        bucketInfo = deriveBucket(filename);
+      } catch {
+        continue;
+      }
+      let repo;
+      try {
+        repo = deriveRepo(rawPath);
+      } catch {
+        continue;
+      }
+      const raw = fs6.readFileSync(absPath, "utf8");
+      let fm;
+      let body;
+      try {
+        const parsed = parseFrontmatter(raw);
+        fm = parsed.fm;
+        body = parsed.body;
+      } catch {
+        continue;
+      }
+      results.push({
+        absPath,
+        rawPath,
+        id: bucketInfo.id,
+        bucket: bucketInfo.bucket,
+        type: bucketInfo.type,
+        repo,
+        fm,
+        body
+      });
+    }
+  }
+  results.sort((a, b) => a.id.localeCompare(b.id));
+  return results;
+}
+
+// src/wiki/git-sha.ts
+import { spawnSync } from "child_process";
+function getGitSha(rawPath, runner) {
+  const run = runner ?? defaultRunner;
+  const out = run("git", ["log", "-1", "--format=%H", "--", rawPath]).trim();
+  return out.length > 0 ? out : null;
+}
+function defaultRunner(cmd, args) {
+  const result = spawnSync(cmd, args, { encoding: "utf8" });
+  return result.stdout ?? "";
+}
+
+// src/wiki/page-schema.ts
+function serializePage(page, body) {
+  const childrenYaml = page.children.length === 0 ? "[]" : "\n" + page.children.map((c) => `  - "${c}"`).join("\n");
+  const fm = [
+    "---",
+    `type: ${page.type}`,
+    `id: "${page.id}"`,
+    `parent: "${page.parent}"`,
+    `children: ${childrenYaml}`,
+    `status: "${page.status}"`,
+    `remote_id: "${page.remote_id}"`,
+    `raw_path: "${page.raw_path}"`,
+    `last_ingest: "${page.last_ingest}"`,
+    `last_ingest_commit: "${page.last_ingest_commit}"`,
+    `repo: "${page.repo}"`,
+    "---"
+  ].join("\n");
+  return `${fm}
+
+${body}`;
+}
+function parsePage(raw) {
+  const { fm } = parseFmRaw(raw);
+  const type = fm["type"];
+  const id = String(fm["id"] ?? "");
+  const parent = String(fm["parent"] ?? "");
+  const rawChildren = fm["children"];
+  const children = Array.isArray(rawChildren) ? rawChildren.map(String) : [];
+  const status = String(fm["status"] ?? "");
+  const remote_id = String(fm["remote_id"] ?? "");
+  const raw_path = String(fm["raw_path"] ?? "");
+  const last_ingest = String(fm["last_ingest"] ?? "");
+  const last_ingest_commit = String(fm["last_ingest_commit"] ?? "");
+  const repo = fm["repo"];
+  return { type, id, parent, children, status, remote_id, raw_path, last_ingest, last_ingest_commit, repo };
+}
+function parseFmRaw(raw) {
+  const lines = raw.split("\n");
+  if (lines[0] !== "---") throw new Error("parsePage: missing opening ---");
+  let close = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i] === "---") {
+      close = i;
+      break;
+    }
+  }
+  if (close === -1) throw new Error("parsePage: missing closing ---");
+  const fmLines = lines.slice(1, close);
+  const body = lines.slice(close + 1).join("\n").replace(/^\n/, "");
+  const fm = {};
+  for (const line of fmLines) {
+    const colon = line.indexOf(":");
+    if (colon === -1) continue;
+    const key = line.slice(0, colon).trim();
+    const val = line.slice(colon + 1).trim();
+    if (val === "[]") {
+      fm[key] = [];
+      continue;
+    }
+    if (val === "") {
+      fm[key] = [];
+      continue;
+    }
+    if (val.startsWith("[") && val.endsWith("]")) {
+      const inner = val.slice(1, -1);
+      fm[key] = inner.split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+      continue;
+    }
+    fm[key] = val.replace(/^["']|["']$/g, "");
+  }
+  return { fm, body };
+}
+
+// src/wiki/synthesis/active-sprint.ts
+import * as fs7 from "fs";
+import * as path6 from "path";
+import { fileURLToPath } from "url";
+
+// src/wiki/synthesis/render.ts
+function renderTemplate(template, data) {
+  const tagRe = /\{\{([^}]+)\}\}/g;
+  const matches = [...template.matchAll(tagRe)].map((m) => m[1].trim());
+  for (const tag of matches) {
+    if (tag.startsWith("^") || tag.startsWith(">") || tag.startsWith("!") || tag.startsWith("=")) {
+      throw new Error(`renderTemplate: unsupported tag type: {{${tag}}}`);
+    }
+  }
+  return renderSection(template, data);
+}
+function renderSection(template, ctx) {
+  const sectionRe = /\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g;
+  let result = template.replace(sectionRe, (_match, key, inner) => {
+    const val = ctx[key];
+    if (!Array.isArray(val)) {
+      if (!val) return "";
+      return renderSection(inner, ctx);
+    }
+    if (val.length === 0) return "";
+    return val.map((item) => {
+      const itemCtx = item !== null && typeof item === "object" ? item : { ".": item };
+      return renderSection(inner, itemCtx);
+    }).join("");
+  });
+  result = result.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    const val = ctx[key];
+    if (val === void 0 || val === null) return "";
+    return String(val);
+  });
+  return result;
+}
+
+// src/wiki/synthesis/active-sprint.ts
+function compile(state, templateDir) {
+  const tplDir = templateDir ?? resolveDefaultTemplateDir();
+  const tpl = fs7.readFileSync(path6.join(tplDir, "active-sprint.md"), "utf8");
+  const sprints = state.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"]));
+  const planned = sprints.filter((s) => !isSet(s.fm["activated_at"]) && !isSet(s.fm["completed_at"]));
+  const data = {
+    active: active.map((s) => ({ id: s.id, status: String(s.fm["status"] ?? "unknown") })),
+    no_active: active.length === 0 ? [{}] : [],
+    planned: planned.map((s) => ({ id: s.id, status: String(s.fm["status"] ?? "unknown") })),
+    no_planned: planned.length === 0 ? [{}] : [],
+    completed: completed.slice(0, 3).map((s) => ({
+      id: s.id,
+      completed_at: String(s.fm["completed_at"] ?? "")
+    })),
+    no_completed: completed.length === 0 ? [{}] : []
+  };
+  return renderTemplate(tpl, data);
+}
+function isSet(val) {
+  if (val === null || val === void 0) return false;
+  const s = String(val).trim();
+  return s !== "" && s !== "null";
+}
+function resolveDefaultTemplateDir() {
+  const __dirname2 = path6.dirname(fileURLToPath(import.meta.url));
+  return path6.resolve(__dirname2, "..", "templates", "synthesis");
+}
+
+// src/wiki/synthesis/open-gates.ts
+import * as fs8 from "fs";
+import * as path7 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function compile2(state, templateDir) {
+  const tplDir = templateDir ?? resolveDefaultTemplateDir2();
+  const tpl = fs8.readFileSync(path7.join(tplDir, "open-gates.md"), "utf8");
+  const gate1 = state.filter((i) => {
+    if (i.bucket !== "proposals") return false;
+    const status = String(i.fm["status"] ?? "");
+    const approved = i.fm["approved"];
+    return status === "Draft" || approved === false || approved === "false";
+  });
+  const gate2 = state.filter((i) => {
+    if (i.bucket !== "stories") return false;
+    const ambiguity = String(i.fm["ambiguity"] ?? "");
+    return ambiguity.startsWith("\u{1F7E1}") || ambiguity.startsWith("\u{1F534}");
+  });
+  const gate3 = state.filter((i) => {
+    const status = String(i.fm["status"] ?? "");
+    if (status !== "Ready") return false;
+    const remoteId = i.fm["remote_id"];
+    return remoteId === null || remoteId === void 0 || String(remoteId).trim() === "";
+  });
+  const data = {
+    gate1: gate1.map((i) => ({ id: i.id, status: String(i.fm["status"] ?? "") })),
+    no_gate1: gate1.length === 0 ? [{}] : [],
+    gate2: gate2.map((i) => ({ id: i.id, ambiguity: String(i.fm["ambiguity"] ?? "") })),
+    no_gate2: gate2.length === 0 ? [{}] : [],
+    gate3: gate3.map((i) => ({ id: i.id, status: String(i.fm["status"] ?? "") })),
+    no_gate3: gate3.length === 0 ? [{}] : []
+  };
+  return renderTemplate(tpl, data);
+}
+function resolveDefaultTemplateDir2() {
+  const __dirname2 = path7.dirname(fileURLToPath2(import.meta.url));
+  return path7.resolve(__dirname2, "..", "templates", "synthesis");
+}
+
+// src/wiki/synthesis/product-state.ts
+import * as fs9 from "fs";
+import * as path8 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function compile3(state, templateDir) {
+  const tplDir = templateDir ?? resolveDefaultTemplateDir3();
+  const tpl = fs9.readFileSync(path8.join(tplDir, "product-state.md"), "utf8");
+  function countBucket(bucket) {
+    return state.filter((i) => i.bucket === bucket);
+  }
+  function isShipped(item) {
+    return item.rawPath.includes("/archive/");
+  }
+  function isActive(item) {
+    const status = String(item.fm["status"] ?? "");
+    return status === "Active" || status === "In Progress" || status.startsWith("\u{1F7E2}") || status === "\u{1F7E1} in-flight";
+  }
+  const buckets = ["epics", "stories", "sprints", "proposals", "crs", "bugs"];
+  function countFor(bucket, predicate) {
+    return countBucket(bucket).filter(predicate).length;
+  }
+  const epics = countBucket("epics");
+  const activeEpicsList = epics.filter(isActive);
+  const shippedItems = state.filter(isShipped);
+  const data = {
+    // Totals
+    total_epics: epics.length,
+    total_stories: countBucket("stories").length,
+    total_sprints: countBucket("sprints").length,
+    total_proposals: countBucket("proposals").length,
+    total_crs: countBucket("crs").length,
+    total_bugs: countBucket("bugs").length,
+    // Active counts (per bucket)
+    ...Object.fromEntries(buckets.map((b) => [`active_${b}`, countFor(b, isActive)])),
+    // Shipped counts (per bucket)
+    ...Object.fromEntries(buckets.map((b) => [`shipped_${b}`, countFor(b, isShipped)])),
+    // Active epics list
+    active_epics_list: activeEpicsList.map((i) => ({
+      id: i.id,
+      status: String(i.fm["status"] ?? "")
+    })),
+    no_active_epics: activeEpicsList.length === 0 ? [{}] : [],
+    // Shipped items list
+    shipped_items: shippedItems.map((i) => ({
+      id: i.id,
+      bucket: i.bucket,
+      status: String(i.fm["status"] ?? "")
+    })),
+    no_shipped: shippedItems.length === 0 ? [{}] : []
+  };
+  return renderTemplate(tpl, data);
+}
+function resolveDefaultTemplateDir3() {
+  const __dirname2 = path8.dirname(fileURLToPath3(import.meta.url));
+  return path8.resolve(__dirname2, "..", "templates", "synthesis");
+}
+
+// src/wiki/synthesis/roadmap.ts
+import * as fs10 from "fs";
+import * as path9 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function compile4(state, templateDir) {
+  const tplDir = templateDir ?? resolveDefaultTemplateDir4();
+  const tpl = fs10.readFileSync(path9.join(tplDir, "roadmap.md"), "utf8");
+  const sprints = state.filter((i) => i.bucket === "sprints");
+  const epics = state.filter((i) => i.bucket === "epics");
+  const inFlightSprints = sprints.filter(
+    (s) => isSet2(s.fm["activated_at"]) && !isSet2(s.fm["completed_at"])
+  );
+  const plannedSprints = sprints.filter(
+    (s) => !isSet2(s.fm["activated_at"]) && !isSet2(s.fm["completed_at"])
+  );
+  const shippedSprints = sprints.filter((s) => isSet2(s.fm["completed_at"]));
+  const activeEpics = epics.filter((e) => isActiveStatus(String(e.fm["status"] ?? "")));
+  const plannedEpics = epics.filter((e) => isPlannedStatus(String(e.fm["status"] ?? "")));
+  const shippedEpics = epics.filter((e) => isShippedStatus(String(e.fm["status"] ?? "")));
+  const data = {
+    in_flight_sprints: inFlightSprints.map((s) => ({
+      id: s.id,
+      activated_at: String(s.fm["activated_at"] ?? "")
+    })),
+    no_in_flight_sprints: inFlightSprints.length === 0 ? [{}] : [],
+    planned_sprints: plannedSprints.map((s) => ({
+      id: s.id,
+      status: String(s.fm["status"] ?? "")
+    })),
+    no_planned_sprints: plannedSprints.length === 0 ? [{}] : [],
+    shipped_sprints: shippedSprints.map((s) => ({
+      id: s.id,
+      completed_at: String(s.fm["completed_at"] ?? "")
+    })),
+    no_shipped_sprints: shippedSprints.length === 0 ? [{}] : [],
+    active_epics: activeEpics.map((e) => ({ id: e.id, status: String(e.fm["status"] ?? "") })),
+    no_active_epics: activeEpics.length === 0 ? [{}] : [],
+    planned_epics: plannedEpics.map((e) => ({ id: e.id, status: String(e.fm["status"] ?? "") })),
+    no_planned_epics: plannedEpics.length === 0 ? [{}] : [],
+    shipped_epics: shippedEpics.map((e) => ({ id: e.id, status: String(e.fm["status"] ?? "") })),
+    no_shipped_epics: shippedEpics.length === 0 ? [{}] : []
+  };
+  return renderTemplate(tpl, data);
+}
+function isSet2(val) {
+  if (val === null || val === void 0) return false;
+  const s = String(val).trim();
+  return s !== "" && s !== "null";
+}
+function isActiveStatus(status) {
+  return status === "Active" || status === "In Progress" || status.startsWith("\u{1F7E2}") || status === "\u{1F7E1} in-flight";
+}
+function isPlannedStatus(status) {
+  return status === "Ready" || status === "Planned" || status === "Draft";
+}
+function isShippedStatus(status) {
+  return status === "Completed" || status === "Approved";
+}
+function resolveDefaultTemplateDir4() {
+  const __dirname2 = path9.dirname(fileURLToPath4(import.meta.url));
+  return path9.resolve(__dirname2, "..", "templates", "synthesis");
+}
+
+// src/commands/wiki-build.ts
+var BUCKET_ORDER = ["epics", "stories", "sprints", "proposals", "crs", "bugs", "topics"];
+var BUCKET_LABELS = {
+  epics: "Epics",
+  stories: "Stories",
+  sprints: "Sprints",
+  proposals: "Proposals",
+  crs: "CRs",
+  bugs: "Bugs",
+  topics: "Topics"
+};
+async function wikiBuildHandler(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const stdout = opts.stdout ?? ((s) => process.stdout.write(s));
+  const stderr = opts.stderr ?? ((s) => process.stderr.write(s));
+  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)) {
+    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 });
+  }
+  const items = scanRawItems(deliveryRoot, cwd);
+  const timestamp = now();
+  let pagesWritten = 0;
+  for (const item of items) {
+    const sha = getGitSha(item.rawPath, gitRunner) ?? "";
+    const parent = buildParentRef(item.fm);
+    const children = buildChildrenRefs(item.fm);
+    const wikiPage = {
+      type: item.type,
+      id: item.id,
+      parent,
+      children,
+      status: String(item.fm["status"] ?? ""),
+      remote_id: String(item.fm["remote_id"] ?? ""),
+      raw_path: item.rawPath,
+      last_ingest: timestamp,
+      last_ingest_commit: sha,
+      repo: item.repo
+    };
+    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");
+    pagesWritten++;
+  }
+  const indexContent = buildIndex(items);
+  fs11.writeFileSync(path10.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");
+  stdout(`wiki build: OK (${pagesWritten} pages written)
+`);
+}
+function buildParentRef(fm) {
+  const raw = fm["parent_epic_ref"] ?? fm["parent"] ?? "";
+  const s = String(raw);
+  if (!s) return "";
+  if (s.startsWith("[[") && s.endsWith("]]")) return s;
+  return `[[${s}]]`;
+}
+function buildChildrenRefs(fm) {
+  const raw = fm["children"];
+  if (!raw) return [];
+  const arr = Array.isArray(raw) ? raw : [raw];
+  return arr.map((c) => {
+    const s = String(c);
+    if (s.startsWith("[[") && s.endsWith("]]")) return s;
+    return `[[${s}]]`;
+  });
+}
+function buildPageBody(item, page) {
+  const title = String(item.fm["title"] ?? item.id);
+  const summary = String(item.fm["description"] ?? item.body.split("\n")[0] ?? "No summary available.").slice(0, 200);
+  const blastParts = [];
+  if (page.parent) blastParts.push(page.parent);
+  for (const child of page.children) blastParts.push(child);
+  const blastLine = blastParts.length > 0 ? blastParts.join(", ") : "None.";
+  return [
+    `# ${item.id}: ${title}`,
+    "",
+    summary,
+    "",
+    "## Blast radius",
+    `Affects: ${blastLine}`,
+    "",
+    "## Open questions",
+    "None.",
+    ""
+  ].join("\n");
+}
+function buildIndex(items) {
+  const lines = [
+    "# Wiki Index",
+    "",
+    "> Auto-generated by `cleargate wiki build`. Do not edit manually.",
+    "",
+    "| ID | Type | Status | Raw Path |",
+    "|---|---|---|---|"
+  ];
+  if (items.length === 0) {
+    lines.push("| _(no items)_ | \u2014 | \u2014 | \u2014 |");
+    lines.push("");
+  } else {
+    for (const bucket of BUCKET_ORDER) {
+      const bucketItems = items.filter((i) => i.bucket === bucket);
+      if (bucket === "topics") continue;
+      lines.push("", `## ${BUCKET_LABELS[bucket]}`, "");
+      if (bucketItems.length === 0) {
+        lines.push("_No items._");
+      } else {
+        for (const item of bucketItems) {
+          const status = String(item.fm["status"] ?? "");
+          lines.push(`| [[${item.id}]] | ${item.type} | ${status} | ${item.rawPath} |`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildLog(items, timestamp) {
+  if (items.length === 0) {
+    return "# Wiki Event Log\n\n";
+  }
+  const entries = items.map(
+    (item) => [
+      `- timestamp: "${timestamp}"`,
+      `  actor: "cleargate wiki build"`,
+      `  action: "create"`,
+      `  target: "${item.id}"`,
+      `  path: "${item.rawPath}"`
+    ].join("\n")
+  );
+  return ["# Wiki Event Log", "", ...entries, ""].join("\n");
+}
+
+// src/lib/manifest.ts
+import { readFile as readFile3, writeFile as writeFile2, rename, mkdir } from "fs/promises";
+import { existsSync as existsSync6, readFileSync as readFileSync10 } from "fs";
+import * as path11 from "path";
+
+// src/lib/sha256.ts
+import { createHash } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+function hashNormalized(content) {
+  let text = Buffer.isBuffer(content) ? content.toString("utf-8") : content;
+  if (text.startsWith("\uFEFF")) {
+    text = text.slice(1);
+  }
+  text = text.replace(/\r\n/g, "\n");
+  if (!text.endsWith("\n")) {
+    text += "\n";
+  }
+  return createHash("sha256").update(text, "utf-8").digest("hex");
+}
+function shortHash(full) {
+  return full.slice(0, 8);
+}
+
+// src/lib/manifest.ts
+function resolveDefaultPackageRoot() {
+  const here = new URL(".", import.meta.url).pathname;
+  const distCandidate = path11.join(here, "MANIFEST.json");
+  if (existsSync6(distCandidate)) {
+    return here;
+  }
+  const oneLevelUp = path11.join(here, "..", "MANIFEST.json");
+  if (existsSync6(oneLevelUp)) {
+    return path11.join(here, "..");
+  }
+  const devCandidate = path11.join(here, "..", "..", "..", "cleargate-planning", "MANIFEST.json");
+  if (existsSync6(devCandidate)) {
+    return path11.join(here, "..", "..", "..", "cleargate-planning");
+  }
+  return here;
+}
+function loadPackageManifest(opts) {
+  const packageRoot = opts?.packageRoot ?? resolveDefaultPackageRoot();
+  const manifestPath = path11.join(packageRoot, "MANIFEST.json");
+  if (!existsSync6(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");
+  } catch {
+    throw new Error(
+      `MANIFEST.json not found at ${manifestPath}; run 'npm run build' to generate it.`
+    );
+  }
+  return JSON.parse(raw);
+}
+async function loadInstallSnapshot(projectRoot) {
+  const snapshotPath = path11.join(projectRoot, ".cleargate", ".install-manifest.json");
+  try {
+    const raw = await readFile3(snapshotPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function computeCurrentSha(file, projectRoot) {
+  const filePath = path11.join(projectRoot, file.path);
+  try {
+    const raw = await readFile3(filePath);
+    return hashNormalized(raw);
+  } catch {
+    return null;
+  }
+}
+function classify(pkgSha, installSha, currentSha, tier) {
+  if (tier === "user-artifact") {
+    return "untracked";
+  }
+  if (currentSha === null) {
+    return "untracked";
+  }
+  const installEqualsPackage = installSha === pkgSha;
+  const currentEqualsInstall = currentSha === installSha;
+  if (installEqualsPackage && currentEqualsInstall) {
+    return "clean";
+  }
+  if (installEqualsPackage && !currentEqualsInstall) {
+    return "user-modified";
+  }
+  if (!installEqualsPackage && currentEqualsInstall) {
+    return "upstream-changed";
+  }
+  return "both-changed";
+}
+async function writeDriftState(projectRoot, state, opts) {
+  const cleargatDir = path11.join(projectRoot, ".cleargate");
+  const finalPath = path11.join(cleargatDir, ".drift-state.json");
+  const tmpPath = `${finalPath}.tmp`;
+  const lastRefreshed = opts?.lastRefreshed ?? (/* @__PURE__ */ new Date()).toISOString();
+  const fileContent = { last_refreshed: lastRefreshed, drift: state };
+  await mkdir(cleargatDir, { recursive: true });
+  await writeFile2(tmpPath, JSON.stringify(fileContent, null, 2) + "\n", "utf-8");
+  await rename(tmpPath, finalPath);
+}
+async function readDriftState(projectRoot) {
+  const driftPath = path11.join(projectRoot, ".cleargate", ".drift-state.json");
+  try {
+    const raw = await readFile3(driftPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && "last_refreshed" in parsed && "drift" in parsed) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/prompts.ts
+import * as readline from "readline";
+async function promptYesNo(question, defaultYes, opts) {
+  const stdoutFn = opts?.stdout ?? ((s) => process.stdout.write(s));
+  stdoutFn(question + "\n");
+  const inputStream = opts?.stdin ?? process.stdin;
+  return new Promise((resolve13) => {
+    const rl = readline.createInterface({
+      input: inputStream,
+      output: void 0,
+      // we handle output ourselves
+      terminal: false
+    });
+    let answered = false;
+    rl.once("line", (line) => {
+      answered = true;
+      rl.close();
+      const trimmed = line.trim().toLowerCase();
+      if (trimmed === "") {
+        resolve13(defaultYes);
+      } else if (trimmed === "y" || trimmed === "yes") {
+        resolve13(true);
+      } else {
+        resolve13(false);
+      }
+    });
+    rl.once("close", () => {
+      if (!answered) {
+        resolve13(defaultYes);
+      }
+    });
+  });
+}
+
+// src/commands/init.ts
+var HOOK_ADDITION = {
+  hooks: {
+    PostToolUse: [
+      {
+        matcher: "Edit|Write",
+        hooks: [
+          {
+            type: "command",
+            command: "${CLAUDE_PROJECT_DIR}/.claude/hooks/stamp-and-gate.sh"
+          }
+        ]
+      }
+    ]
+  }
+};
+function resolveDefaultPayloadDir() {
+  const thisFile = fileURLToPath5(import.meta.url);
+  const pkgRoot = path12.resolve(path12.dirname(thisFile), "..");
+  return path12.join(pkgRoot, "templates", "cleargate-planning");
+}
+function countDeliveryItems(cwd) {
+  const pendingSync = path12.join(cwd, ".cleargate", "delivery", "pending-sync");
+  const archive = path12.join(cwd, ".cleargate", "delivery", "archive");
+  let count = 0;
+  for (const dir of [pendingSync, archive]) {
+    if (!fs12.existsSync(dir)) continue;
+    const entries = fs12.readdirSync(dir);
+    for (const f of entries) {
+      if (f.endsWith(".md") && f !== ".gitkeep") count++;
+    }
+  }
+  return count;
+}
+function writeAtomic(filePath, content) {
+  const tmpPath = filePath + ".tmp." + Date.now();
+  fs12.writeFileSync(tmpPath, content, "utf8");
+  fs12.renameSync(tmpPath, filePath);
+}
+async function initHandler(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const force = opts.force ?? false;
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const stdout = opts.stdout ?? ((s) => process.stdout.write(s));
+  const stderr = opts.stderr ?? ((s) => process.stderr.write(s));
+  const exit = opts.exit ?? ((c) => process.exit(c));
+  const runWikiBuild = opts.runWikiBuild ?? wikiBuildHandler;
+  const promptYesNoFn = opts.promptYesNo ?? promptYesNo;
+  if (!fs12.existsSync(cwd)) {
+    stderr(`[cleargate init] ERROR: target directory does not exist: ${cwd}
+`);
+    exit(1);
+    return;
+  }
+  const testWritePath = path12.join(cwd, `.cleargate-init-write-test-${Date.now()}`);
+  try {
+    fs12.writeFileSync(testWritePath, "");
+    fs12.unlinkSync(testWritePath);
+  } catch {
+    stderr(`[cleargate init] ERROR: target directory is not writable: ${cwd}
+`);
+    exit(1);
+    return;
+  }
+  stdout(`[cleargate init] Target: ${cwd}
+`);
+  const payloadDir = opts.payloadDir ?? resolveDefaultPayloadDir();
+  if (!fs12.existsSync(payloadDir)) {
+    stderr(`[cleargate init] ERROR: payload directory not found: ${payloadDir}
+`);
+    stderr(`[cleargate init] Run \`npm run prebuild\` to copy the payload first.
+`);
+    exit(1);
+    return;
+  }
+  const uninstalledMarkerPath = path12.join(cwd, ".cleargate", ".uninstalled");
+  let uninstalledMarker = null;
+  let userChoseRestore = false;
+  if (fs12.existsSync(uninstalledMarkerPath)) {
+    try {
+      const raw = fs12.readFileSync(uninstalledMarkerPath, "utf8");
+      uninstalledMarker = JSON.parse(raw);
+    } catch {
+      stderr(`[cleargate init] WARNING: .uninstalled marker is malformed; ignoring it.
+`);
+    }
+    if (uninstalledMarker !== null) {
+      const { uninstalled_at, prior_version, preserved } = uninstalledMarker;
+      const question = `[cleargate init] Detected previous ClearGate install (uninstalled ${uninstalled_at}, prior version ${prior_version}). Restore preserved items? [Y/n]`;
+      userChoseRestore = await promptYesNoFn(question, true);
+      if (userChoseRestore) {
+        for (const preservedPath of preserved) {
+          const absPreserved = path12.isAbsolute(preservedPath) ? preservedPath : path12.join(cwd, preservedPath);
+          if (fs12.existsSync(absPreserved)) {
+            stdout(`[cleargate init] [preserved] ${preservedPath}
+`);
+          } else {
+            stdout(`[cleargate init] [warn] preserved path missing on disk: ${preservedPath}
+`);
+          }
+        }
+      } else {
+        stdout(
+          `[cleargate init] discarding preservation; preserved files untouched on disk
+`
+        );
+      }
+    }
+  }
+  const copyReport = copyPayload(payloadDir, cwd, { force });
+  for (const action of copyReport.actions) {
+    const verb = action.action === "created" ? "Created" : action.action === "overwritten" ? "Overwritten" : "Skipped (exists)";
+    stdout(`[cleargate init] ${verb} ${action.relPath}
+`);
+  }
+  const settingsPath = path12.join(cwd, ".claude", "settings.json");
+  let existingSettings = null;
+  if (fs12.existsSync(settingsPath)) {
+    try {
+      existingSettings = JSON.parse(fs12.readFileSync(settingsPath, "utf8"));
+    } catch {
+      stderr(`[cleargate init] WARNING: could not parse ${settingsPath}; treating as empty.
+`);
+    }
+  }
+  const mergedSettings = mergeSettings(existingSettings, HOOK_ADDITION);
+  fs12.mkdirSync(path12.dirname(settingsPath), { recursive: true });
+  writeAtomic(settingsPath, JSON.stringify(mergedSettings, null, 2) + "\n");
+  stdout(`[cleargate init] Updated .claude/settings.json: merged PostToolUse hook
+`);
+  const claudeMdPath = path12.join(cwd, "CLAUDE.md");
+  const claudeMdSrcPath = path12.join(payloadDir, "CLAUDE.md");
+  let claudeMdBlock;
+  try {
+    const claudeMdSrc = fs12.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 = fs12.existsSync(claudeMdPath) ? fs12.readFileSync(claudeMdPath, "utf8") : null;
+  const newClaudeMd = injectClaudeMd(existingClaudeMd, claudeMdBlock);
+  writeAtomic(claudeMdPath, newClaudeMd);
+  if (existingClaudeMd === null) {
+    stdout(`[cleargate init] Created CLAUDE.md (with bounded block)
+`);
+  } else if (existingClaudeMd !== newClaudeMd) {
+    stdout(`[cleargate init] Updated CLAUDE.md (bounded block injected/replaced)
+`);
+  } else {
+    stdout(`[cleargate init] CLAUDE.md unchanged (block already up to date)
+`);
+  }
+  const itemCount = countDeliveryItems(cwd);
+  if (itemCount > 0) {
+    stdout(`[cleargate init] Bootstrap: running wiki build (${itemCount} items found)...
+`);
+    await runWikiBuild({ cwd, now });
+    stdout(`[cleargate init] Bootstrap: ran wiki build (${itemCount} items ingested)
+`);
+  } else {
+    stdout(`[cleargate init] Bootstrap: no items to ingest, skipping build
+`);
+  }
+  const cleargateDir = path12.join(cwd, ".cleargate");
+  fs12.mkdirSync(cleargateDir, { recursive: true });
+  const snapshotPath = path12.join(cleargateDir, ".install-manifest.json");
+  try {
+    const readManifest = opts.readInstallManifest ?? (() => loadPackageManifest({ packageRoot: payloadDir }));
+    const pkgManifest = readManifest();
+    const snapshot = {
+      ...pkgManifest,
+      installed_at: now()
+    };
+    writeAtomic(snapshotPath, JSON.stringify(snapshot, null, 2) + "\n");
+    stdout(`[cleargate init] Wrote install snapshot: .cleargate/.install-manifest.json
+`);
+  } catch (e) {
+    stderr(`[cleargate init] WARNING: could not write install snapshot: ${String(e)}
+`);
+  }
+  if (uninstalledMarker !== null && fs12.existsSync(uninstalledMarkerPath)) {
+    try {
+      fs12.unlinkSync(uninstalledMarkerPath);
+    } catch (e) {
+      stderr(`[cleargate init] WARNING: could not remove .uninstalled marker: ${String(e)}
+`);
+    }
+  }
+  stdout(
+    `[cleargate init] Done. Read CLAUDE.md and .cleargate/knowledge/cleargate-protocol.md to learn the protocol.
+`
+  );
+  void now;
+}
+
+// src/commands/wiki-ingest.ts
+import * as fs13 from "fs";
+import * as path13 from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+var EXCLUDED_SUFFIXES2 = [
+  ".cleargate/knowledge/",
+  ".cleargate/templates/",
+  ".cleargate/sprint-runs/",
+  ".cleargate/hook-log/",
+  ".cleargate/wiki/"
+];
+var BUCKET_ORDER2 = ["epics", "stories", "sprints", "proposals", "crs", "bugs", "topics"];
+var BUCKET_LABELS2 = {
+  epics: "Epics",
+  stories: "Stories",
+  sprints: "Sprints",
+  proposals: "Proposals",
+  crs: "CRs",
+  bugs: "Bugs",
+  topics: "Topics"
+};
+async function wikiIngestHandler(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const stdout = opts.stdout ?? ((s) => process.stdout.write(s));
+  const stderr = opts.stderr ?? ((s) => process.stderr.write(s));
+  const exit = opts.exit ?? ((c) => process.exit(c));
+  const gitRunner = opts.gitRunner;
+  const rename4 = opts.rename ?? fs13.renameSync;
+  const templateDir = opts.templateDir;
+  const rawPath = opts.rawPath;
+  const absRawPath = path13.isAbsolute(rawPath) ? rawPath : path13.resolve(cwd, rawPath);
+  const relRawPath = path13.relative(cwd, absRawPath).replace(/\\/g, "/");
+  const deliveryRoot = path13.join(cwd, ".cleargate", "delivery");
+  const deliveryRootNorm = deliveryRoot.replace(/\\/g, "/");
+  const absDeliveryRoot = deliveryRoot;
+  const relToDelivery = path13.relative(absDeliveryRoot, absRawPath);
+  if (relToDelivery.startsWith("..") || path13.isAbsolute(relToDelivery)) {
+    stderr(`wiki ingest: ${rawPath} not under .cleargate/delivery/
+`);
+    exit(2);
+    return;
+  }
+  void deliveryRootNorm;
+  const isExcluded = EXCLUDED_SUFFIXES2.some((excl) => relRawPath.startsWith(excl));
+  if (isExcluded) {
+    stdout(`wiki ingest: ${rawPath} excluded (skip)
+`);
+    exit(0);
+    return;
+  }
+  const filename = path13.basename(absRawPath);
+  let bucketInfo;
+  try {
+    bucketInfo = deriveBucket(filename);
+  } catch (e) {
+    stderr(`wiki ingest: cannot determine bucket for ${rawPath}: ${e.message}
+`);
+    exit(1);
+    return;
+  }
+  let repo;
+  try {
+    repo = deriveRepo(relRawPath);
+  } catch (e) {
+    stderr(`wiki ingest: cannot derive repo for ${rawPath}: ${e.message}
+`);
+    exit(1);
+    return;
+  }
+  const { type, id, bucket } = bucketInfo;
+  const wikiRoot = path13.join(cwd, ".cleargate", "wiki");
+  const pageDir = path13.join(wikiRoot, bucket);
+  const pagePath = path13.join(pageDir, `${id}.md`);
+  let rawContent;
+  try {
+    rawContent = fs13.readFileSync(absRawPath, "utf8");
+  } catch (e) {
+    stderr(`wiki ingest: cannot read ${rawPath}: ${e.message}
+`);
+    exit(1);
+    return;
+  }
+  let fm;
+  let body;
+  try {
+    const parsed = parseFrontmatter(rawContent);
+    fm = parsed.fm;
+    body = parsed.body;
+  } catch (e) {
+    stderr(`wiki ingest: malformed frontmatter in ${rawPath}: ${e.message}
+`);
+    exit(1);
+    return;
+  }
+  const currentSha = getGitSha(absRawPath, gitRunner) ?? "";
+  const pageExists = fs13.existsSync(pagePath);
+  if (pageExists && currentSha !== "") {
+    let isNoOp = false;
+    try {
+      const existingPageContent = fs13.readFileSync(pagePath, "utf8");
+      const existingPage = parsePage(existingPageContent);
+      if (existingPage.last_ingest_commit === currentSha) {
+        const contentUnchanged = checkContentUnchanged(absRawPath, currentSha, relRawPath, gitRunner);
+        if (contentUnchanged) {
+          isNoOp = true;
+        }
+      }
+    } catch {
+    }
+    if (isNoOp) {
+      stdout(`wiki ingest: ${id} unchanged (no-op)
+`);
+      exit(0);
+      return;
+    }
+  }
+  const action = pageExists ? "update" : "create";
+  const parent = buildParentRef2(fm);
+  const children = buildChildrenRefs2(fm);
+  const timestamp = now();
+  const wikiPage = {
+    type,
+    id,
+    parent,
+    children,
+    status: String(fm["status"] ?? ""),
+    remote_id: String(fm["remote_id"] ?? ""),
+    raw_path: relRawPath,
+    last_ingest: timestamp,
+    last_ingest_commit: currentSha,
+    repo
+  };
+  const pageBody = buildPageBody2({ id, fm, body });
+  const pageContent = serializePage(wikiPage, pageBody);
+  fs13.mkdirSync(pageDir, { recursive: true });
+  fs13.writeFileSync(pagePath, pageContent, "utf8");
+  appendLogEntry(wikiRoot, { timestamp, action, id, relRawPath });
+  updateIndex(wikiRoot, { id, type, status: wikiPage.status, relRawPath, rename: rename4 });
+  recompileSynthesis(wikiRoot, cwd, templateDir);
+  stdout(`wiki ingest: ${action} ${bucket}/${id}.md
+`);
+}
+function checkContentUnchanged(absRawPath, sha, relRawPath, gitRunner) {
+  try {
+    const run = gitRunner ?? defaultGitRunner;
+    const gitContent = run("git", ["show", `${sha}:${relRawPath}`]);
+    if (!gitContent && gitContent !== "") return false;
+    const currentContent = fs13.readFileSync(absRawPath, "utf8");
+    return gitContent === currentContent;
+  } catch {
+    return false;
+  }
+}
+function defaultGitRunner(cmd, args) {
+  const result = spawnSync2(cmd, args, { encoding: "utf8" });
+  if (result.status !== 0) return "\0__NONZERO__";
+  return result.stdout ?? "";
+}
+function buildParentRef2(fm) {
+  const raw = fm["parent_epic_ref"] ?? fm["parent"] ?? "";
+  const s = String(raw);
+  if (!s) return "";
+  if (s.startsWith("[[") && s.endsWith("]]")) return s;
+  return `[[${s}]]`;
+}
+function buildChildrenRefs2(fm) {
+  const raw = fm["children"];
+  if (!raw) return [];
+  const arr = Array.isArray(raw) ? raw : [raw];
+  return arr.map((c) => {
+    const s = String(c);
+    if (s.startsWith("[[") && s.endsWith("]]")) return s;
+    return `[[${s}]]`;
+  });
+}
+function buildPageBody2(item) {
+  const title = String(item.fm["title"] ?? item.id);
+  const summary = String(
+    item.fm["description"] ?? item.body.split("\n")[0] ?? "No summary available."
+  ).slice(0, 200);
+  const parent = buildParentRef2(item.fm);
+  const children = buildChildrenRefs2(item.fm);
+  const blastParts = [];
+  if (parent) blastParts.push(parent);
+  for (const child of children) blastParts.push(child);
+  const blastLine = blastParts.length > 0 ? blastParts.join(", ") : "None.";
+  return [
+    `# ${item.id}: ${title}`,
+    "",
+    summary,
+    "",
+    "## Blast radius",
+    `Affects: ${blastLine}`,
+    "",
+    "## Open questions",
+    "None.",
+    ""
+  ].join("\n");
+}
+function appendLogEntry(wikiRoot, entry) {
+  const logPath = path13.join(wikiRoot, "log.md");
+  const logEntry = [
+    `- timestamp: "${entry.timestamp}"`,
+    `  actor: "cleargate wiki ingest"`,
+    `  action: "${entry.action}"`,
+    `  target: "${entry.id}"`,
+    `  path: "${entry.relRawPath}"`
+  ].join("\n");
+  if (fs13.existsSync(logPath)) {
+    const existing = fs13.readFileSync(logPath, "utf8");
+    const newContent = existing.trimEnd() + "\n" + logEntry + "\n";
+    fs13.writeFileSync(logPath, newContent, "utf8");
+  } else {
+    fs13.mkdirSync(wikiRoot, { recursive: true });
+    fs13.writeFileSync(logPath, `# Wiki Event Log
+
+${logEntry}
+`, "utf8");
+  }
+}
+function updateIndex(wikiRoot, opts) {
+  const indexPath = path13.join(wikiRoot, "index.md");
+  const tmpPath = `${indexPath}.tmp`;
+  const newRow = `| [[${opts.id}]] | ${opts.type} | ${opts.status} | ${opts.relRawPath} |`;
+  let content;
+  if (fs13.existsSync(indexPath)) {
+    content = fs13.readFileSync(indexPath, "utf8");
+    const idPattern = `[[${opts.id}]]`;
+    const lines = content.split("\n");
+    let replaced = false;
+    const newLines = lines.map((line) => {
+      if (line.includes(idPattern) && line.startsWith("|")) {
+        replaced = true;
+        return newRow;
+      }
+      return line;
+    });
+    if (replaced) {
+      content = newLines.join("\n");
+    } else {
+      content = insertIntoSection(content, opts.id, newRow);
+    }
+  } else {
+    content = buildMinimalIndex(opts.id, opts.type, opts.status, opts.relRawPath);
+  }
+  fs13.writeFileSync(tmpPath, content, "utf8");
+  opts.rename(tmpPath, indexPath);
+}
+function insertIntoSection(content, id, newRow) {
+  const bucket = getBucketFromId(id);
+  const label = BUCKET_LABELS2[bucket] ?? bucket;
+  const sectionHeader = `## ${label}`;
+  const lines = content.split("\n");
+  let sectionStart = -1;
+  let nextSectionStart = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] === sectionHeader) {
+      sectionStart = i;
+      for (let j = i + 1; j < lines.length; j++) {
+        if (lines[j].startsWith("## ")) {
+          nextSectionStart = j;
+          break;
+        }
+      }
+      break;
+    }
+  }
+  if (sectionStart === -1) {
+    const sectionContent = [
+      "",
+      sectionHeader,
+      "",
+      newRow,
+      ""
+    ].join("\n");
+    return content.trimEnd() + sectionContent;
+  }
+  const sectionEnd = nextSectionStart === -1 ? lines.length : nextSectionStart;
+  const sectionLines = lines.slice(sectionStart + 1, sectionEnd);
+  let insertAt = -1;
+  for (let i = 0; i < sectionLines.length; i++) {
+    const line = sectionLines[i];
+    if (line.startsWith("|") && !line.startsWith("|---|")) {
+      const match = /\|\s*\[\[([^\]]+)\]\]/.exec(line);
+      if (match) {
+        const rowId = match[1];
+        if (id.localeCompare(rowId) <= 0) {
+          insertAt = sectionStart + 1 + i;
+          break;
+        }
+      }
+    }
+  }
+  if (insertAt === -1) {
+    let lastRowIdx = sectionStart + 1;
+    for (let i = sectionStart + 1; i < sectionEnd; i++) {
+      if (lines[i].startsWith("|")) {
+        lastRowIdx = i + 1;
+      }
+    }
+    lines.splice(lastRowIdx, 0, newRow);
+  } else {
+    lines.splice(insertAt, 0, newRow);
+  }
+  return lines.join("\n");
+}
+function getBucketFromId(id) {
+  if (id.startsWith("EPIC-")) return "epics";
+  if (id.startsWith("STORY-")) return "stories";
+  if (id.startsWith("SPRINT-")) return "sprints";
+  if (id.startsWith("PROPOSAL-")) return "proposals";
+  if (id.startsWith("CR-")) return "crs";
+  if (id.startsWith("BUG-")) return "bugs";
+  return "topics";
+}
+function buildMinimalIndex(id, type, status, relRawPath) {
+  const bucket = getBucketFromId(id);
+  const label = BUCKET_LABELS2[bucket] ?? bucket;
+  const lines = [
+    "# Wiki Index",
+    "",
+    "> Auto-generated by `cleargate wiki build`. Do not edit manually.",
+    "",
+    "| ID | Type | Status | Raw Path |",
+    "|---|---|---|---|"
+  ];
+  for (const b of BUCKET_ORDER2) {
+    if (b === "topics") continue;
+    lines.push("", `## ${BUCKET_LABELS2[b]}`, "");
+    if (b === bucket) {
+      lines.push(`| [[${id}]] | ${type} | ${status} | ${relRawPath} |`);
+    } else {
+      lines.push("_No items._");
+    }
+  }
+  lines.push("");
+  void label;
+  return lines.join("\n");
+}
+function recompileSynthesis(wikiRoot, cwd, templateDir) {
+  const deliveryRoot = path13.join(cwd, ".cleargate", "delivery");
+  let items = [];
+  if (fs13.existsSync(deliveryRoot)) {
+    try {
+      items = scanRawItems(deliveryRoot, cwd);
+    } catch {
+    }
+  }
+  fs13.writeFileSync(path13.join(wikiRoot, "active-sprint.md"), compile(items, templateDir), "utf8");
+  fs13.writeFileSync(path13.join(wikiRoot, "open-gates.md"), compile2(items, templateDir), "utf8");
+  fs13.writeFileSync(path13.join(wikiRoot, "product-state.md"), compile3(items, templateDir), "utf8");
+  fs13.writeFileSync(path13.join(wikiRoot, "roadmap.md"), compile4(items, templateDir), "utf8");
+}
+
+// src/commands/wiki-lint.ts
+import * as path16 from "path";
+
+// src/wiki/load-wiki.ts
+import * as fs14 from "fs";
+import * as path14 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 = path14.join(wikiRoot, bucket);
+    if (!fs14.existsSync(dir)) continue;
+    const entries = fs14.readdirSync(dir, { encoding: "utf8" });
+    for (const filename of entries) {
+      if (!filename.endsWith(".md")) continue;
+      const absPath = path14.join(dir, filename);
+      const stat = fs14.statSync(absPath);
+      if (!stat.isFile()) continue;
+      const raw = fs14.readFileSync(absPath, "utf8");
+      let fm;
+      let body;
+      try {
+        const parsed = parseFrontmatter(raw);
+        fm = parsed.fm;
+        body = parsed.body;
+      } catch {
+        continue;
+      }
+      const page = {
+        type: fm["type"] ?? "epic",
+        id: String(fm["id"] ?? ""),
+        parent: String(fm["parent"] ?? ""),
+        children: Array.isArray(fm["children"]) ? fm["children"].map(String) : [],
+        status: String(fm["status"] ?? ""),
+        remote_id: String(fm["remote_id"] ?? ""),
+        raw_path: String(fm["raw_path"] ?? ""),
+        last_ingest: String(fm["last_ingest"] ?? ""),
+        last_ingest_commit: String(fm["last_ingest_commit"] ?? ""),
+        repo: fm["repo"] ?? "planning"
+      };
+      results.push({ absPath, page, body });
+    }
+  }
+  return results;
+}
+
+// src/wiki/lint-checks.ts
+import * as fs15 from "fs";
+import * as path15 from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+import yaml3 from "js-yaml";
+
+// src/lib/work-item-type.ts
+var FM_KEY_MAP = [
+  { key: "story_id", type: "story" },
+  { key: "epic_id", type: "epic" },
+  { key: "proposal_id", type: "proposal" },
+  { key: "cr_id", type: "cr" },
+  { key: "bug_id", type: "bug" }
+];
+var PREFIX_MAP2 = [
+  { prefix: "STORY-", type: "story" },
+  { prefix: "EPIC-", type: "epic" },
+  { prefix: "PROPOSAL-", type: "proposal" },
+  { prefix: "CR-", type: "cr" },
+  { prefix: "BUG-", type: "bug" }
+];
+function detectWorkItemTypeFromFm(fm) {
+  for (const { key, type } of FM_KEY_MAP) {
+    if (fm[key] !== void 0 && fm[key] !== null && fm[key] !== "") {
+      return type;
+    }
+  }
+  return null;
+}
+function detectWorkItemType(idOrPath) {
+  const upper = idOrPath.toUpperCase();
+  const basename9 = upper.split("/").pop() ?? upper;
+  for (const { prefix, type } of PREFIX_MAP2) {
+    if (basename9.includes(prefix)) {
+      return type;
+    }
+  }
+  return null;
+}
+var WORK_ITEM_TRANSITIONS = {
+  proposal: ["ready-for-decomposition"],
+  epic: ["ready-for-decomposition", "ready-for-coding"],
+  story: ["ready-for-execution"],
+  cr: ["ready-to-apply"],
+  bug: ["ready-for-fix"]
+};
+
+// src/wiki/lint-checks.ts
+var EXCLUDED_DIRS = [
+  ".cleargate/knowledge/",
+  ".cleargate/templates/",
+  ".cleargate/sprint-runs/",
+  ".cleargate/hook-log/",
+  ".cleargate/wiki/"
+];
+var MAX_BUCKET_ENTRIES = 50;
+function checkOrphan(page, repoRoot) {
+  const rawPath = page.page.raw_path;
+  if (!rawPath) return null;
+  const isExcluded = EXCLUDED_DIRS.some((excl) => rawPath.startsWith(excl));
+  if (isExcluded) return null;
+  const absRaw = path15.join(repoRoot, rawPath);
+  if (!fs15.existsSync(absRaw)) {
+    const relPage = path15.relative(path15.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    return {
+      category: "orphan",
+      line: `orphan: ${relPage} -> missing ${rawPath} (raw missing)`
+    };
+  }
+  return null;
+}
+function checkRepoMismatch(page, repoRoot) {
+  const rawPath = page.page.raw_path;
+  if (!rawPath) return null;
+  let derivedRepo;
+  try {
+    derivedRepo = deriveRepo(rawPath);
+  } catch {
+    return null;
+  }
+  if (page.page.repo !== derivedRepo) {
+    const relPage = path15.relative(path15.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}`
+    };
+  }
+  return null;
+}
+function checkStaleCommit(page, repoRoot, gitRunner) {
+  const rawPath = page.page.raw_path;
+  if (!rawPath) return null;
+  const storedSha = page.page.last_ingest_commit;
+  if (!storedSha) return null;
+  let currentSha;
+  if (gitRunner) {
+    currentSha = gitRunner("git", ["log", "-1", "--format=%H", "--", rawPath]).trim();
+  } else {
+    const result = spawnSync3("git", ["log", "-1", "--format=%H", "--", rawPath], {
+      encoding: "utf8",
+      cwd: repoRoot
+    });
+    currentSha = (result.stdout ?? "").trim();
+  }
+  if (!currentSha) return null;
+  if (storedSha !== currentSha) {
+    const relPage = path15.relative(path15.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    return {
+      category: "stale-commit",
+      line: `stale-commit: ${relPage} at ${storedSha}, current ${currentSha}`
+    };
+  }
+  return null;
+}
+function checkMissingIngest(page, repoRoot) {
+  const rawPath = page.page.raw_path;
+  if (!rawPath) return null;
+  const absRaw = path15.join(repoRoot, rawPath);
+  if (!fs15.existsSync(absRaw)) return null;
+  const rawStat = fs15.statSync(absRaw);
+  const pageStat = fs15.statSync(page.absPath);
+  const rawMtimeMs = rawStat.mtimeMs;
+  const pageMtimeMs = pageStat.mtimeMs;
+  if (rawMtimeMs - pageMtimeMs > 2e3) {
+    const relPage = path15.relative(path15.join(repoRoot, ".cleargate", "wiki"), page.absPath).replace(/\\/g, "/");
+    const rawMtime = rawStat.mtime.toISOString();
+    const pageMtime = pageStat.mtime.toISOString();
+    return {
+      category: "missing-ingest",
+      line: `missing-ingest: ${rawPath} newer than ${relPage} (raw mtime: ${rawMtime}, page mtime: ${pageMtime})`
+    };
+  }
+  return null;
+}
+function checkBrokenBacklinks(pages, repoRoot) {
+  const wikiRoot = path15.join(repoRoot, ".cleargate", "wiki");
+  const byId = /* @__PURE__ */ new Map();
+  for (const p of pages) {
+    if (p.page.id) byId.set(p.page.id, p);
+  }
+  const findings = [];
+  for (const childPage of pages) {
+    const parentRef = childPage.page.parent;
+    if (!parentRef) continue;
+    const match = parentRef.match(/\[\[(.+?)\]\]/);
+    if (!match) continue;
+    const parentId = match[1];
+    const parentPage = byId.get(parentId);
+    if (!parentPage) {
+      const relChild = path15.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
+      findings.push({
+        category: "broken-backlink",
+        line: `broken-backlink: ${relChild} -> ${parentId} (parent missing child entry)`
+      });
+      continue;
+    }
+    const childId = childPage.page.id;
+    const childRef = `[[${childId}]]`;
+    const parentHasChild = parentPage.page.children.some(
+      (c) => c === childRef || c === childId
+    );
+    if (!parentHasChild) {
+      const relChild = path15.relative(wikiRoot, childPage.absPath).replace(/\\/g, "/");
+      findings.push({
+        category: "broken-backlink",
+        line: `broken-backlink: ${relChild} -> ${parentId} (parent missing child entry)`
+      });
+    }
+  }
+  return findings;
+}
+function checkInvalidatedCitations(pages, repoRoot) {
+  const wikiRoot = path15.join(repoRoot, ".cleargate", "wiki");
+  const byId = /* @__PURE__ */ new Map();
+  for (const p of pages) {
+    if (p.page.id) byId.set(p.page.id, p);
+  }
+  const findings = [];
+  const topicPages = pages.filter((p) => p.page.type === "topic");
+  for (const topicPage of topicPages) {
+    const relTopic = path15.relative(wikiRoot, topicPage.absPath).replace(/\\/g, "/");
+    let citesList = [];
+    try {
+      const raw = fs15.readFileSync(topicPage.absPath, "utf8");
+      const { fm } = parseFrontmatter(raw);
+      const rawCites = fm["cites"];
+      if (Array.isArray(rawCites)) {
+        citesList = rawCites.map(String);
+      }
+    } catch {
+      continue;
+    }
+    for (const cite of citesList) {
+      const match = cite.match(/\[\[(.+?)\]\]/);
+      const id = match ? match[1] : cite;
+      const citedPage = byId.get(id);
+      if (!citedPage) {
+        findings.push({
+          category: "invalidated-citation",
+          line: `invalidated-citation: ${relTopic} cites [[${id}]] (missing)`
+        });
+        continue;
+      }
+      const status = citedPage.page.status;
+      if (status === "cancelled" || status.toLowerCase().includes("cancelled")) {
+        findings.push({
+          category: "invalidated-citation",
+          line: `invalidated-citation: ${relTopic} cites [[${id}]] (cancelled)`
+        });
+      }
+    }
+  }
+  return findings;
+}
+function checkExcludedPathIngested(page, repoRoot) {
+  const rawPath = page.page.raw_path;
+  if (!rawPath) return null;
+  const isExcluded = EXCLUDED_DIRS.some((excl) => rawPath.startsWith(excl));
+  if (isExcluded) {
+    const relPage = path15.relative(path15.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)`
+    };
+  }
+  return null;
+}
+function checkPaginationNeeded(pages) {
+  const bucketCounts = /* @__PURE__ */ new Map();
+  for (const p of pages) {
+    const bucket = path15.basename(path15.dirname(p.absPath));
+    bucketCounts.set(bucket, (bucketCounts.get(bucket) ?? 0) + 1);
+  }
+  const findings = [];
+  for (const [bucket, count] of bucketCounts) {
+    if (count > MAX_BUCKET_ENTRIES) {
+      findings.push({
+        category: "pagination-needed",
+        line: `pagination-needed: ${bucket} (${count} entries, max ${MAX_BUCKET_ENTRIES} per bucket)`
+      });
+    }
+  }
+  return findings;
+}
+var ENFORCING_TYPES = /* @__PURE__ */ new Set(["epic", "story", "cr", "bug"]);
+var READY_STATUSES = /* @__PURE__ */ new Set(["Ready", "Active"]);
+function parseCachedGateResult(raw) {
+  if (!raw || raw === null) return null;
+  if (typeof raw === "string") {
+    if (!raw.startsWith("{")) return null;
+    try {
+      const parsed = yaml3.load(raw);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+      const p = parsed;
+      return { pass: p["pass"], failing_criteria: p["failing_criteria"], last_gate_check: p["last_gate_check"] };
+    } catch {
+      return null;
+    }
+  }
+  if (typeof raw === "object" && !Array.isArray(raw)) {
+    const p = raw;
+    return { pass: p["pass"], failing_criteria: p["failing_criteria"], last_gate_check: p["last_gate_check"] };
+  }
+  return null;
+}
+function checkGateFailure(page, repoRoot) {
+  const rawPath = page.page.raw_path;
+  if (!rawPath) return null;
+  const absRaw = path15.join(repoRoot, rawPath);
+  if (!fs15.existsSync(absRaw)) return null;
+  let rawFm;
+  try {
+    const raw = fs15.readFileSync(absRaw, "utf8");
+    const { fm } = parseFrontmatter(raw);
+    rawFm = fm;
+  } catch {
+    return null;
+  }
+  const cgr = parseCachedGateResult(rawFm["cached_gate_result"]);
+  if (!cgr || cgr.pass !== false) return null;
+  const wiType = detectWorkItemTypeFromFm(rawFm);
+  if (!wiType || !ENFORCING_TYPES.has(wiType)) return null;
+  const status = String(rawFm["status"] ?? "");
+  const ambiguity = String(rawFm["ambiguity"] ?? "");
+  const isReadyCandidate = READY_STATUSES.has(status) || ambiguity === "\u{1F7E2} Low";
+  if (!isReadyCandidate) return null;
+  const failingCriteria = cgr.failing_criteria;
+  const criteriaIds = [];
+  if (Array.isArray(failingCriteria)) {
+    for (const criterion of failingCriteria) {
+      if (criterion && typeof criterion === "object" && "id" in criterion) {
+        criteriaIds.push(String(criterion["id"]));
+      } else if (typeof criterion === "string") {
+        criteriaIds.push(criterion);
+      }
+    }
+  }
+  const criteriaStr = criteriaIds.length > 0 ? criteriaIds.join(", ") : "unknown";
+  return {
+    category: "gate-failure",
+    line: `gate-failure: ${rawPath} failed criteria: ${criteriaStr}`
+  };
+}
+function checkGateStaleness(page, repoRoot) {
+  const rawPath = page.page.raw_path;
+  if (!rawPath) return null;
+  const absRaw = path15.join(repoRoot, rawPath);
+  if (!fs15.existsSync(absRaw)) return null;
+  let rawFm;
+  try {
+    const raw = fs15.readFileSync(absRaw, "utf8");
+    const { fm } = parseFrontmatter(raw);
+    rawFm = fm;
+  } catch {
+    return null;
+  }
+  const cgr = parseCachedGateResult(rawFm["cached_gate_result"]);
+  if (!cgr) return null;
+  const lastGateCheck = cgr.last_gate_check;
+  if (!lastGateCheck || lastGateCheck === null) return null;
+  const updatedAt = rawFm["updated_at"];
+  if (!updatedAt) return null;
+  const lastCheckStr = String(lastGateCheck);
+  const updatedAtStr = String(updatedAt);
+  if (lastCheckStr < updatedAtStr) {
+    return {
+      category: "gate-stale",
+      line: `gate-stale: ${rawPath} last_gate_check=${lastCheckStr} < updated_at=${updatedAtStr}`
+    };
+  }
+  return null;
+}
+function discoverPlainTextMentions(pages, repoRoot) {
+  const wikiRoot = path15.join(repoRoot, ".cleargate", "wiki");
+  const byId = /* @__PURE__ */ new Map();
+  for (const p of pages) {
+    if (p.page.id) byId.set(p.page.id, true);
+  }
+  const suggestions = [];
+  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 = path15.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);
+      wrappedRefs.add(inner);
+    }
+    for (const m of page.body.matchAll(ID_PATTERN)) {
+      const mentionedId = m[1];
+      if (!byId.has(mentionedId)) continue;
+      if (wrappedRefs.has(mentionedId)) continue;
+      if (mentionedId === page.page.id) continue;
+      suggestions.push(`suggest: ${relPage} mentions ${mentionedId} in plain text, consider [[${mentionedId}]] wrap`);
+    }
+  }
+  return suggestions;
+}
+
+// src/commands/wiki-lint.ts
+async function wikiLintHandler(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const stdout = opts.stdout ?? ((s) => process.stdout.write(s));
+  opts.stderr;
+  const exit = opts.exit ?? ((c) => process.exit(c));
+  const gitRunner = opts.gitRunner;
+  const mode = opts.mode ?? "enforce";
+  const wikiRoot = path16.join(cwd, ".cleargate", "wiki");
+  const repoRoot = cwd;
+  let pages = loadWikiPages(wikiRoot);
+  const findings = [];
+  const paginationFindings = checkPaginationNeeded(pages);
+  findings.push(...paginationFindings);
+  for (const page of pages) {
+    const orphan = checkOrphan(page, repoRoot);
+    if (orphan) findings.push(orphan);
+    const repoMismatch = checkRepoMismatch(page, repoRoot);
+    if (repoMismatch) findings.push(repoMismatch);
+    const staleCommit = checkStaleCommit(page, repoRoot, gitRunner);
+    if (staleCommit) findings.push(staleCommit);
+    const missingIngest = checkMissingIngest(page, repoRoot);
+    if (missingIngest) findings.push(missingIngest);
+    const excludedPath = checkExcludedPathIngested(page, repoRoot);
+    if (excludedPath) findings.push(excludedPath);
+    const gateFail = checkGateFailure(page, repoRoot);
+    if (gateFail) findings.push(gateFail);
+    const gateStale = checkGateStaleness(page, repoRoot);
+    if (gateStale) findings.push(gateStale);
+  }
+  const backlinkFindings = checkBrokenBacklinks(pages, repoRoot);
+  findings.push(...backlinkFindings);
+  const citationFindings = checkInvalidatedCitations(pages, repoRoot);
+  findings.push(...citationFindings);
+  const pageCount = pages.length;
+  const findingCount = findings.length;
+  if (mode === "suggest") {
+    for (const finding of findings) {
+      stdout(`[advisory] ${finding.line}
+`);
+    }
+    const suggestions = discoverPlainTextMentions(pages, repoRoot);
+    for (const suggestion of suggestions) {
+      stdout(`${suggestion}
+`);
+    }
+    stdout(`lint: OK (${pageCount} pages checked, ${findingCount} findings)
+`);
+    exit(0);
+    return;
+  }
+  for (const finding of findings) {
+    stdout(`${finding.line}
+`);
+  }
+  if (findingCount > 0) {
+    stdout(`lint: FAIL (${pageCount} pages checked, ${findingCount} findings)
+`);
+    exit(1);
+  } else {
+    stdout(`lint: OK (${pageCount} pages checked, 0 findings)
+`);
+    exit(0);
+  }
+}
+
+// src/commands/wiki-query.ts
+import * as fs16 from "fs";
+import * as path17 from "path";
+function computeSlug(query) {
+  return query.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 40).replace(/-+$/, "");
+}
+function searchIndex(indexContent, query) {
+  const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+  const results = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const line of indexContent.split("\n")) {
+    const lower = line.toLowerCase();
+    const matchesAll = terms.every((term) => lower.includes(term));
+    if (!matchesAll) continue;
+    const match = line.match(/\[\[([^\]]+)\]\]/);
+    if (!match) continue;
+    const id = match[1];
+    if (seenIds.has(id)) continue;
+    seenIds.add(id);
+    results.push({ id, excerpt: line.trim() });
+  }
+  return results;
+}
+async function wikiQueryHandler(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const stdout = opts.stdout ?? ((s) => process.stdout.write(s));
+  const stderr = opts.stderr ?? ((s) => process.stderr.write(s));
+  const exit = opts.exit ?? ((c) => process.exit(c));
+  const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const query = opts.query;
+  const persist = opts.persist ?? false;
+  void stderr;
+  const wikiRoot = path17.join(cwd, ".cleargate", "wiki");
+  const indexPath = path17.join(wikiRoot, "index.md");
+  if (!fs16.existsSync(indexPath)) {
+    stdout(`wiki query: no index.md found at ${indexPath}
+`);
+    stdout(`Run \`cleargate wiki build\` first.
+`);
+    exit(1);
+    return;
+  }
+  const indexContent = fs16.readFileSync(indexPath, "utf8");
+  const matches = searchIndex(indexContent, query);
+  if (matches.length === 0) {
+    stdout(`wiki query: no matches for "${query}"
+`);
+    exit(0);
+    return;
+  }
+  const bodyLines = [
+    `# Query: ${query}`,
+    "",
+    `Found ${matches.length} match(es):`,
+    ""
+  ];
+  for (const { id, excerpt } of matches) {
+    bodyLines.push(`- [[${id}]] \u2014 ${excerpt}`);
+  }
+  bodyLines.push("");
+  const body = bodyLines.join("\n");
+  stdout(body);
+  if (!persist) {
+    exit(0);
+    return;
+  }
+  const slug = computeSlug(query);
+  const topicsDir = path17.join(wikiRoot, "topics");
+  fs16.mkdirSync(topicsDir, { recursive: true });
+  const citesArray = matches.map(({ id }) => `"[[${id}]]"`);
+  const createdAt = now();
+  const frontmatter = [
+    "---",
+    `type: topic`,
+    `id: "${slug}"`,
+    `created_by: "cleargate-wiki-query"`,
+    `created_at: "${createdAt}"`,
+    `cites: [${citesArray.join(", ")}]`,
+    "---"
+  ].join("\n");
+  const topicContent = `${frontmatter}
+
+${body}`;
+  const topicPath = path17.join(topicsDir, `${slug}.md`);
+  fs16.writeFileSync(topicPath, topicContent, "utf8");
+  updateIndexTopicsSection(indexPath, slug, query, createdAt);
+  exit(0);
+}
+function updateIndexTopicsSection(indexPath, slug, query, createdAt) {
+  let content = fs16.readFileSync(indexPath, "utf8");
+  const row = `| ${slug} | ${query} | ${createdAt} |`;
+  if (content.includes("## Topics")) {
+    const topicsIdx = content.indexOf("## Topics");
+    const afterTopics = content.slice(topicsIdx);
+    const nextSectionMatch = afterTopics.slice("## Topics".length).match(/\n## /);
+    if (nextSectionMatch && nextSectionMatch.index !== void 0) {
+      const insertPos = topicsIdx + "## Topics".length + nextSectionMatch.index;
+      content = content.slice(0, insertPos) + `
+${row}` + content.slice(insertPos);
+    } else {
+      content = content.trimEnd() + `
+${row}
+`;
+    }
+  } else {
+    content = content.trimEnd() + `
+
+## Topics
+
+${row}
+`;
+  }
+  fs16.writeFileSync(indexPath, content, "utf8");
+}
+
+// src/commands/doctor.ts
+import * as fs17 from "fs";
+import * as path18 from "path";
+
+// src/lib/pricing.ts
+var PRICING_TABLE = {
+  "claude-opus-4-7": {
+    input: 15,
+    output: 75,
+    cache_read: 1.5,
+    cache_creation: 18.75
+  },
+  "claude-sonnet-4-5": {
+    input: 3,
+    output: 15,
+    cache_read: 0.3,
+    cache_creation: 3.75
+  },
+  "claude-sonnet-4-6": {
+    input: 3,
+    output: 15,
+    cache_read: 0.3,
+    cache_creation: 3.75
+  },
+  "claude-haiku-4-5": {
+    input: 0.8,
+    output: 4,
+    cache_read: 0.08,
+    cache_creation: 1
+  }
+};
+function computeUsd(draftTokens, modelOverride) {
+  const model = modelOverride ?? draftTokens.model ?? "";
+  const pricing = PRICING_TABLE[model];
+  if (!pricing) {
+    return { usd: 0, unknownModel: true };
+  }
+  const input = draftTokens.input ?? 0;
+  const output = draftTokens.output ?? 0;
+  const cacheRead = draftTokens.cache_read ?? 0;
+  const cacheCreation = draftTokens.cache_creation ?? 0;
+  const usd = (input * pricing.input + output * pricing.output + cacheRead * pricing.cache_read + cacheCreation * pricing.cache_creation) / 1e6;
+  return { usd, unknownModel: false };
+}
+
+// src/commands/doctor.ts
+function selectMode(flags) {
+  const modes = [];
+  if (flags.checkScaffold) modes.push("check-scaffold");
+  if (flags.sessionStart) modes.push("session-start");
+  if (flags.pricing) modes.push("pricing");
+  if (modes.length > 1) {
+    throw new Error(
+      `cleargate doctor: mutually exclusive flags set: ${modes.join(", ")}. Use only one mode flag at a time.`
+    );
+  }
+  if (modes.length === 1) {
+    return modes[0];
+  }
+  return "hook-health";
+}
+var HOOK_LOG_24H_MS = 24 * 60 * 60 * 1e3;
+function parseHookLogLine(line) {
+  const m = line.match(
+    /^\[([^\]]+)\]\s+stamp=(\d+)\s+gate=(\d+)\s+ingest=(\d+)\s+file=(.+)$/
+  );
+  if (!m) return null;
+  return {
+    ts: m[1],
+    stamp: parseInt(m[2], 10),
+    gate: parseInt(m[3], 10),
+    ingest: parseInt(m[4], 10),
+    file: m[5].trim()
+  };
+}
+function runHookHealth(stdout, cwd, now) {
+  const settingsPath = path18.join(cwd, ".claude", "settings.json");
+  if (!fs17.existsSync(settingsPath)) {
+    stdout("[doctor] No .claude/settings.json found \u2014 hook config unavailable.");
+    return;
+  }
+  try {
+    const raw = fs17.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(raw);
+    const hasHooks = typeof settings === "object" && settings !== null && "hooks" in settings;
+    if (hasHooks) {
+      stdout("[doctor] Hook config present in .claude/settings.json.");
+    } else {
+      stdout("[doctor] .claude/settings.json found but no hooks key \u2014 SubagentStop hook not wired.");
+    }
+  } catch {
+    stdout("[doctor] .claude/settings.json is not valid JSON \u2014 cannot verify hook config.");
+  }
+  const logPath = path18.join(cwd, ".cleargate", "hook-log", "gate-check.log");
+  if (!fs17.existsSync(logPath)) {
+    return;
+  }
+  let logContent;
+  try {
+    logContent = fs17.readFileSync(logPath, "utf-8");
+  } catch {
+    return;
+  }
+  const nowMs = (now ?? /* @__PURE__ */ new Date()).getTime();
+  const lines = logContent.split("\n").filter((l) => l.trim().length > 0);
+  for (const line of lines) {
+    const entry = parseHookLogLine(line);
+    if (!entry) continue;
+    const entryMs = new Date(entry.ts).getTime();
+    if (isNaN(entryMs)) continue;
+    if (nowMs - entryMs > HOOK_LOG_24H_MS) continue;
+    const isFailing = entry.stamp !== 0 || entry.gate !== 0 || entry.ingest !== 0;
+    if (!isFailing) continue;
+    stdout(
+      `\u26A0 hook failure at ${entry.ts}: stamp=${entry.stamp} gate=${entry.gate} ingest=${entry.ingest} file=${entry.file}`
+    );
+  }
+}
+var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
+function shouldUseCache(lastRefreshed, now, sessionStartMode) {
+  if (!sessionStartMode) {
+    return false;
+  }
+  const age = now.getTime() - new Date(lastRefreshed).getTime();
+  return age < TWENTY_FOUR_HOURS_MS;
+}
+function formatVerboseLine(filePath, entry) {
+  const inst = entry.install_sha ? shortHash(entry.install_sha).slice(0, 6) : "null";
+  const curr = entry.current_sha ? shortHash(entry.current_sha).slice(0, 6) : "null";
+  const pkg = entry.package_sha ? shortHash(entry.package_sha).slice(0, 6) : "null";
+  return `  ${filePath}  ${entry.state}  (${inst}\u2192${curr} vs ${pkg})`;
+}
+function zeroCounts() {
+  return {
+    "clean": 0,
+    "user-modified": 0,
+    "upstream-changed": 0,
+    "both-changed": 0,
+    "untracked": 0
+  };
+}
+async function runCheckScaffold(flags, cli, cwd, now, stdout, _stderr) {
+  const sessionStartMode = flags.sessionStartMode ?? false;
+  const existingState = await readDriftState(cwd);
+  if (existingState && shouldUseCache(existingState.last_refreshed, now, sessionStartMode)) {
+    emitSummary(existingState.drift, flags.verbose ?? false, stdout);
+    return;
+  }
+  const pkgManifest = loadPackageManifest({ packageRoot: cli.packageRoot });
+  const installSnapshot = await loadInstallSnapshot(cwd);
+  const driftMap = {};
+  await Promise.all(
+    pkgManifest.files.map(async (entry) => {
+      if (entry.tier === "user-artifact") {
+        return;
+      }
+      const currentSha = await computeCurrentSha(entry, cwd);
+      const installSha = installSnapshot?.files.find((f) => f.path === entry.path)?.sha256 ?? null;
+      const pkgSha = entry.sha256;
+      const state = classify(pkgSha, installSha, currentSha, entry.tier);
+      driftMap[entry.path] = {
+        state,
+        entry,
+        install_sha: installSha,
+        current_sha: currentSha,
+        package_sha: pkgSha
+      };
+    })
+  );
+  await writeDriftState(cwd, driftMap, { lastRefreshed: now.toISOString() });
+  emitSummary(driftMap, flags.verbose ?? false, stdout);
+}
+function emitSummary(driftMap, verbose, stdout) {
+  const counts = zeroCounts();
+  for (const entry of Object.values(driftMap)) {
+    counts[entry.state]++;
+  }
+  stdout(
+    `Scaffold drift: ${counts["user-modified"]} user-modified, ${counts["upstream-changed"]} upstream-changed, ${counts["both-changed"]} both-changed, ${counts["clean"]} clean`
+  );
+  if (counts["upstream-changed"] > 0 || counts["both-changed"] > 0) {
+    stdout("Run cleargate upgrade to review.");
+  }
+  if (verbose) {
+    for (const [filePath, entry] of Object.entries(driftMap)) {
+      if (entry.state !== "clean" && entry.state !== "untracked") {
+        stdout(formatVerboseLine(filePath, entry));
+      }
+    }
+  }
+}
+var SESSION_START_MAX_ITEMS = 10;
+var SESSION_START_MAX_CHARS = 400;
+function parseCachedGateResult2(raw) {
+  if (raw == null) return null;
+  let parsed = null;
+  if (typeof raw === "object" && !Array.isArray(raw)) {
+    parsed = raw;
+  } else if (typeof raw === "string") {
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  } else {
+    return null;
+  }
+  return {
+    pass: parsed.pass ?? null,
+    failing_criteria: parsed.failing_criteria ?? []
+  };
+}
+async function runSessionStart(cwd, stdout) {
+  const pendingSyncDir = path18.join(cwd, ".cleargate", "delivery", "pending-sync");
+  let files;
+  try {
+    files = fs17.readdirSync(pendingSyncDir).filter((f) => f.endsWith(".md")).map((f) => path18.join(pendingSyncDir, f));
+  } catch {
+    return;
+  }
+  const blocked = [];
+  for (const filePath of files) {
+    let raw;
+    try {
+      raw = fs17.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (!raw.trimStart().startsWith("---")) continue;
+    let fm;
+    try {
+      fm = parseFrontmatter(raw).fm;
+    } catch {
+      continue;
+    }
+    const gate2 = parseCachedGateResult2(fm["cached_gate_result"]);
+    if (!gate2 || gate2.pass !== false) continue;
+    const idKeys = ["story_id", "epic_id", "proposal_id", "cr_id", "bug_id", "sprint_id"];
+    let itemId = "";
+    for (const key of idKeys) {
+      const val = fm[key];
+      if (typeof val === "string" && val.trim()) {
+        itemId = val.trim();
+        break;
+      }
+    }
+    if (!itemId) {
+      itemId = path18.basename(filePath, ".md");
+    }
+    const firstCriterionId = gate2.failing_criteria.length > 0 ? gate2.failing_criteria[0]?.id ?? "" : "";
+    blocked.push({ id: itemId, firstCriterionId });
+  }
+  if (blocked.length === 0) {
+    return;
+  }
+  const overflow = blocked.length > SESSION_START_MAX_ITEMS ? blocked.length - SESSION_START_MAX_ITEMS : 0;
+  const visible = blocked.slice(0, SESSION_START_MAX_ITEMS);
+  const lines = [`${blocked.length} items blocked:`];
+  for (const item of visible) {
+    const line = item.firstCriterionId ? `  ${item.id}: ${item.firstCriterionId}` : `  ${item.id}`;
+    lines.push(line);
+  }
+  if (overflow > 0) {
+    lines.push(`\u2026and ${overflow} more \u2014 run cleargate doctor for full list`);
+  }
+  let output = lines.join("\n");
+  if (output.length > SESSION_START_MAX_CHARS) {
+    output = output.slice(0, SESSION_START_MAX_CHARS - 3) + "...";
+  }
+  stdout(output);
+}
+async function runPricing(filePath, cwd, stdout, stderr, exit) {
+  if (!filePath) {
+    stderr("cleargate doctor --pricing: missing <file> argument");
+    exit(1);
+    return;
+  }
+  const absPath = path18.isAbsolute(filePath) ? filePath : path18.resolve(cwd, filePath);
+  let raw;
+  try {
+    raw = fs17.readFileSync(absPath, "utf-8");
+  } catch {
+    stderr(`cleargate doctor --pricing: cannot read file: ${absPath}`);
+    exit(1);
+    return;
+  }
+  if (!raw.trimStart().startsWith("---")) {
+    stderr(`cleargate doctor --pricing: file has no frontmatter: ${absPath}`);
+    exit(1);
+    return;
+  }
+  let fm;
+  try {
+    fm = parseFrontmatter(raw).fm;
+  } catch {
+    stderr(`cleargate doctor --pricing: cannot parse frontmatter in: ${absPath}`);
+    exit(1);
+    return;
+  }
+  const draftTokensRaw = fm["draft_tokens"];
+  if (!draftTokensRaw) {
+    stdout("draft_tokens unpopulated \u2014 run cleargate stamp-tokens first");
+    exit(1);
+    return;
+  }
+  let draftTokens;
+  if (typeof draftTokensRaw === "object" && !Array.isArray(draftTokensRaw)) {
+    draftTokens = draftTokensRaw;
+  } else if (typeof draftTokensRaw === "string") {
+    try {
+      draftTokens = JSON.parse(draftTokensRaw);
+    } catch {
+      stdout("draft_tokens unpopulated \u2014 run cleargate stamp-tokens first");
+      exit(1);
+      return;
+    }
+  } else {
+    stdout("draft_tokens unpopulated \u2014 run cleargate stamp-tokens first");
+    exit(1);
+    return;
+  }
+  if (draftTokens.input === null && draftTokens.output === null && draftTokens.cache_read === null && draftTokens.cache_creation === null) {
+    stdout("draft_tokens unpopulated \u2014 run cleargate stamp-tokens first");
+    exit(1);
+    return;
+  }
+  const { usd, unknownModel } = computeUsd(draftTokens);
+  const model = draftTokens.model ?? "unknown";
+  if (unknownModel) {
+    stderr(`cleargate doctor --pricing: unknown model '${model}' \u2014 no pricing data available`);
+  }
+  const input = draftTokens.input ?? 0;
+  const output = draftTokens.output ?? 0;
+  const cacheRead = draftTokens.cache_read ?? 0;
+  const cacheCreation = draftTokens.cache_creation ?? 0;
+  const fileName = path18.basename(absPath);
+  stdout(
+    `${fileName}: ${model} \u2014 input:${input} output:${output} cache_read:${cacheRead} cache_creation:${cacheCreation} \u2248 $${usd.toFixed(4)}`
+  );
+}
+async function doctorHandler(flags, cli) {
+  const cwd = cli?.cwd ?? process.cwd();
+  const now = cli?.now ? cli.now() : /* @__PURE__ */ new Date();
+  const stdout = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
+  const stderr = cli?.stderr ?? ((s) => process.stderr.write(s + "\n"));
+  const exit = cli?.exit ?? ((code) => process.exit(code));
+  let mode;
+  try {
+    mode = selectMode(flags);
+  } catch (err) {
+    stderr(err.message);
+    exit(1);
+    return;
+  }
+  switch (mode) {
+    case "check-scaffold":
+      await runCheckScaffold(flags, cli ?? {}, cwd, now, stdout, stderr);
+      break;
+    case "hook-health":
+      runHookHealth(stdout, cwd, now);
+      break;
+    case "session-start":
+      await runSessionStart(cwd, stdout);
+      break;
+    case "pricing":
+      await runPricing(flags.pricingFile ?? "", cwd, stdout, stderr, exit);
+      break;
+    default: {
+      const exhaustiveCheck = mode;
+      stderr(`cleargate doctor: unknown mode '${String(exhaustiveCheck)}'`);
+      exit(1);
+    }
+  }
+}
+
+// src/commands/gate.ts
+import * as fs20 from "fs";
+import * as path20 from "path";
+import yaml5 from "js-yaml";
+
+// src/lib/readiness-predicates.ts
+import * as fs18 from "fs";
+import * as path19 from "path";
+function parsePredicate(src) {
+  const s = src.trim();
+  const fmMatch = s.match(
+    /^frontmatter\(([^)]*)\)\.(\w+)\s*(==|!=|>=|<=)\s*(.+)$/
+  );
+  if (fmMatch) {
+    const ref = fmMatch[1].trim();
+    if (ref === "") throw new Error(`unsupported predicate shape: ${src}`);
+    const field = fmMatch[2];
+    const op = fmMatch[3];
+    const rawVal = fmMatch[4].trim();
+    const value = parseValue(rawVal);
+    return { kind: "frontmatter", ref, field, op, value };
+  }
+  const bodyNotMatch = s.match(/^body does not contain ['"](.+)['"]$/);
+  if (bodyNotMatch) {
+    return { kind: "body-contains", needle: bodyNotMatch[1], negated: true };
+  }
+  const bodyMatch = s.match(/^body contains ['"](.+)['"]$/);
+  if (bodyMatch) {
+    return { kind: "body-contains", needle: bodyMatch[1], negated: false };
+  }
+  const sectionMatch = s.match(
+    /^section\((\d+)\) has (≥|>=|==|>)(\d+) (checked-checkbox|unchecked-checkbox|listed-item)$/
+  );
+  if (sectionMatch) {
+    const index = parseInt(sectionMatch[1], 10);
+    const opChar = sectionMatch[2];
+    const n = parseInt(sectionMatch[3], 10);
+    const itemType = sectionMatch[4];
+    let countOp;
+    if (opChar === "\u2265" || opChar === ">=") countOp = ">=";
+    else if (opChar === ">") countOp = ">";
+    else countOp = "==";
+    return { kind: "section", index, count: { op: countOp, n }, itemType };
+  }
+  const fileExistsMatch = s.match(/^file-exists\((.+)\)$/);
+  if (fileExistsMatch) {
+    const filePath = fileExistsMatch[1].trim().replace(/^['"]|['"]$/g, "");
+    return { kind: "file-exists", path: filePath };
+  }
+  const linkMatch = s.match(/^link-target-exists\(\[\[([A-Z0-9\-]+)\]\]\)$/);
+  if (linkMatch) {
+    return { kind: "link-target-exists", id: linkMatch[1] };
+  }
+  const statusMatch = s.match(/^status-of\(\[\[([A-Z0-9\-]+)\]\]\)\s*==\s*(.+)$/);
+  if (statusMatch) {
+    const id = statusMatch[1];
+    const value = statusMatch[2].trim().replace(/^['"]|['"]$/g, "");
+    return { kind: "status-of", id, value };
+  }
+  throw new Error(`unsupported predicate shape: ${src}`);
+}
+function parseValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return "null";
+  const num = Number(raw);
+  if (!isNaN(num) && raw !== "") return num;
+  return raw.replace(/^['"]|['"]$/g, "");
+}
+function evaluate(predicate, doc, opts) {
+  const parsed = parsePredicate(predicate);
+  const projectRoot = opts?.projectRoot ?? process.cwd();
+  switch (parsed.kind) {
+    case "frontmatter":
+      return evalFrontmatter(parsed, doc, projectRoot);
+    case "body-contains":
+      return evalBodyContains(parsed, doc);
+    case "section":
+      return evalSection(parsed, doc);
+    case "file-exists":
+      return evalFileExists(parsed, projectRoot);
+    case "link-target-exists":
+      return evalLinkTargetExists(parsed, opts);
+    case "status-of":
+      return evalStatusOf(parsed, opts, projectRoot);
+  }
+}
+function evalFrontmatter(parsed, doc, projectRoot) {
+  let fm;
+  if (parsed.ref === ".") {
+    fm = doc.fm;
+  } else {
+    const refVal = doc.fm[parsed.ref];
+    if (refVal === void 0 || refVal === null) {
+      return {
+        pass: false,
+        detail: `frontmatter key '${parsed.ref}' is missing or null in ${doc.absPath}`
+      };
+    }
+    const linkedPath = resolveLinkedPath(String(refVal), doc.absPath, projectRoot);
+    if (!linkedPath) {
+      return {
+        pass: false,
+        detail: `linked file not found: ${refVal}`
+      };
+    }
+    fm = readFrontmatterFromFile(linkedPath);
+  }
+  const actual = fm[parsed.field];
+  const pass = compareValues(actual, parsed.op, parsed.value);
+  const detail = pass ? `frontmatter(${parsed.ref}).${parsed.field} ${parsed.op} ${JSON.stringify(parsed.value)} \u2192 actual: ${JSON.stringify(actual)}` : `expected ${parsed.field} ${parsed.op} ${JSON.stringify(parsed.value)}, got ${JSON.stringify(actual)}`;
+  return { pass, detail };
+}
+function compareValues(actual, op, expected) {
+  if (expected === "null") {
+    const isNull = actual === null || actual === void 0 || actual === "" || actual === "null";
+    return op === "==" ? isNull : !isNull;
+  }
+  let a = actual;
+  if (typeof a === "string") {
+    a = a.replace(/^["']|["']$/g, "");
+    if (a === "true") a = true;
+    else if (a === "false") a = false;
+    else {
+      const n = Number(a);
+      if (!isNaN(n) && a !== "") a = n;
+    }
+  }
+  switch (op) {
+    case "==":
+      return a === expected || String(a) === String(expected);
+    case "!=":
+      return a !== expected && String(a) !== String(expected);
+    case ">=":
+      return Number(a) >= Number(expected);
+    case "<=":
+      return Number(a) <= Number(expected);
+  }
+}
+function resolveLinkedPath(ref, docAbsPath, projectRoot) {
+  const candidates = [
+    path19.resolve(path19.dirname(docAbsPath), ref),
+    path19.resolve(projectRoot, ref)
+  ];
+  for (const candidate of candidates) {
+    if (!candidate.startsWith(projectRoot)) continue;
+    if (fs18.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function readFrontmatterFromFile(absPath) {
+  try {
+    const raw = fs18.readFileSync(absPath, "utf8");
+    const lines = raw.split("\n");
+    if (lines[0] !== "---") return {};
+    let closeIdx = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i] === "---") {
+        closeIdx = i;
+        break;
+      }
+    }
+    if (closeIdx === -1) return {};
+    const fmLines = lines.slice(1, closeIdx);
+    const fm = {};
+    for (const line of fmLines) {
+      if (line.trim() === "" || line.trim().startsWith("#")) continue;
+      const colon = line.indexOf(":");
+      if (colon === -1) continue;
+      const key = line.slice(0, colon).trim();
+      const val = line.slice(colon + 1).trim();
+      if (val === "" || val === "[]") {
+        fm[key] = [];
+        continue;
+      }
+      if (val.startsWith("{")) {
+        fm[key] = val;
+        continue;
+      }
+      if (val.startsWith("[") && val.endsWith("]")) {
+        const inner = val.slice(1, -1).trim();
+        fm[key] = inner === "" ? [] : inner.split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+        continue;
+      }
+      fm[key] = val.replace(/^["']|["']$/g, "");
+    }
+    return fm;
+  } catch {
+    return {};
+  }
+}
+function evalBodyContains(parsed, doc) {
+  const body = doc.body;
+  const needle = parsed.needle;
+  let count = 0;
+  let pos = 0;
+  const sections = [];
+  const bodySections = body.split(/^## /m);
+  while ((pos = body.indexOf(needle, pos)) !== -1) {
+    count++;
+    const before = body.slice(0, pos);
+    const sectionCount = (before.match(/^## /gm) || []).length;
+    sections.push(sectionCount + 1);
+    pos += needle.length;
+  }
+  const present = count > 0;
+  void bodySections;
+  if (parsed.negated) {
+    if (present) {
+      const sectionList = [...new Set(sections)].map((s) => `\xA7${s}`).join(", ");
+      return {
+        pass: false,
+        detail: `${count} occurrence${count === 1 ? "" : "s"} at ${sectionList}`
+      };
+    }
+    return { pass: true, detail: `'${needle}' not found in body` };
+  } else {
+    if (present) {
+      return { pass: true, detail: `'${needle}' found ${count} time${count === 1 ? "" : "s"}` };
+    }
+    return { pass: false, detail: `'${needle}' not found in body` };
+  }
+}
+function evalSection(parsed, doc) {
+  const body = doc.body;
+  const rawParts = body.split(/^(?=## )/m);
+  const hasPreamble = rawParts.length > 0 && !rawParts[0].startsWith("## ");
+  const arrayIndex = hasPreamble ? parsed.index : parsed.index - 1;
+  const sectionContent = rawParts[arrayIndex];
+  const totalSections = hasPreamble ? rawParts.length - 1 : rawParts.length;
+  if (!sectionContent) {
+    return {
+      pass: false,
+      detail: `section ${parsed.index} not found (body has ${totalSections} sections)`
+    };
+  }
+  let actualCount;
+  switch (parsed.itemType) {
+    case "checked-checkbox":
+      actualCount = (sectionContent.match(/^\s*- \[x\]/gim) || []).length;
+      break;
+    case "unchecked-checkbox":
+      actualCount = (sectionContent.match(/^\s*- \[ \]/gim) || []).length;
+      break;
+    case "listed-item":
+      actualCount = (sectionContent.match(/^\s*- /gm) || []).length;
+      break;
+  }
+  const pass = applyCountOp(actualCount, parsed.count.op, parsed.count.n);
+  const opStr = parsed.count.op === ">=" ? "\u2265" : parsed.count.op;
+  const detail = pass ? `section ${parsed.index} has ${actualCount} ${parsed.itemType} (${opStr}${parsed.count.n} required)` : `section ${parsed.index} has ${actualCount} ${parsed.itemType} (${opStr}${parsed.count.n} required)`;
+  return { pass, detail };
+}
+function applyCountOp(actual, op, n) {
+  switch (op) {
+    case ">=":
+      return actual >= n;
+    case "==":
+      return actual === n;
+    case ">":
+      return actual > n;
+  }
+}
+function evalFileExists(parsed, projectRoot) {
+  const resolved = path19.resolve(projectRoot, parsed.path);
+  if (!resolved.startsWith(projectRoot + path19.sep) && resolved !== projectRoot) {
+    return {
+      pass: false,
+      detail: `path '${parsed.path}' resolves outside project root (sandbox violation)`
+    };
+  }
+  const exists = fs18.existsSync(resolved);
+  return {
+    pass: exists,
+    detail: exists ? `${parsed.path} exists` : `${parsed.path} not found`
+  };
+}
+function evalLinkTargetExists(parsed, opts) {
+  const projectRoot = opts?.projectRoot ?? process.cwd();
+  const wikiIndexPath = opts?.wikiIndexPath ?? path19.join(projectRoot, ".cleargate", "wiki", "index.md");
+  if (!wikiIndexPath.startsWith(projectRoot)) {
+    return { pass: false, detail: "wikiIndexPath resolves outside project root" };
+  }
+  let indexContent;
+  try {
+    indexContent = fs18.readFileSync(wikiIndexPath, "utf8");
+  } catch {
+    return { pass: false, detail: `wiki index not found at ${wikiIndexPath}` };
+  }
+  const found = indexContent.includes(`[[${parsed.id}]]`);
+  return {
+    pass: found,
+    detail: found ? `[[${parsed.id}]] found in wiki index` : `[[${parsed.id}]] not found in wiki index`
+  };
+}
+function evalStatusOf(parsed, opts, projectRoot) {
+  const wikiIndexPath = opts?.wikiIndexPath ?? path19.join(projectRoot, ".cleargate", "wiki", "index.md");
+  if (!wikiIndexPath.startsWith(projectRoot)) {
+    return { pass: false, detail: "wikiIndexPath resolves outside project root" };
+  }
+  let indexContent;
+  try {
+    indexContent = fs18.readFileSync(wikiIndexPath, "utf8");
+  } catch {
+    return { pass: false, detail: `wiki index not found at ${wikiIndexPath}` };
+  }
+  const rowMatch = indexContent.match(
+    new RegExp(`\\[\\[${parsed.id}\\]\\]\\s*\\|[^|]+\\|[^|]+\\|\\s*([^|\\n]+)`)
+  );
+  if (!rowMatch) {
+    return { pass: false, detail: `[[${parsed.id}]] not found in wiki index` };
+  }
+  const rawPath = rowMatch[1].trim();
+  const fullPath = path19.resolve(projectRoot, rawPath);
+  if (!fullPath.startsWith(projectRoot)) {
+    return { pass: false, detail: `wiki path for ${parsed.id} resolves outside project root` };
+  }
+  const linkedFm = readFrontmatterFromFile(fullPath);
+  const status = linkedFm["status"];
+  if (status === void 0) {
+    return { pass: false, detail: `[[${parsed.id}]] has no status field` };
+  }
+  const pass = String(status).replace(/^["']|["']$/g, "") === parsed.value;
+  return {
+    pass,
+    detail: pass ? `status-of([[${parsed.id}]]) == ${parsed.value}` : `status-of([[${parsed.id}]]) is '${status}', expected '${parsed.value}'`
+  };
+}
+
+// src/lib/frontmatter-cache.ts
+import * as fs19 from "fs/promises";
+import yaml4 from "js-yaml";
+async function readCachedGate(absPath) {
+  let raw;
+  try {
+    raw = await fs19.readFile(absPath, "utf8");
+  } catch {
+    return null;
+  }
+  let fm;
+  try {
+    ({ fm } = parseFrontmatter(raw));
+  } catch {
+    return null;
+  }
+  return coerceCachedGate(fm["cached_gate_result"]);
+}
+async function writeCachedGate(absPath, result, opts) {
+  const nowFn = opts?.now ?? (() => /* @__PURE__ */ new Date());
+  const lastGateCheck = result.last_gate_check || toIsoSecond(nowFn());
+  const newResult = {
+    pass: result.pass,
+    failing_criteria: result.failing_criteria,
+    last_gate_check: lastGateCheck
+  };
+  const raw = await fs19.readFile(absPath, "utf8");
+  let fm;
+  let body;
+  try {
+    ({ fm, body } = parseFrontmatter(raw));
+  } catch {
+    throw new Error(`writeCachedGate: failed to parse frontmatter in ${absPath}`);
+  }
+  const existing = coerceCachedGate(fm["cached_gate_result"]);
+  if (existing && JSON.stringify(existing) === JSON.stringify(newResult)) {
+    return;
+  }
+  const newFm = {};
+  let inserted = false;
+  for (const [k, v] of Object.entries(fm)) {
+    if (k === "cached_gate_result") {
+      newFm["cached_gate_result"] = newResult;
+      inserted = true;
+    } else {
+      newFm[k] = v;
+    }
+  }
+  if (!inserted) {
+    newFm["cached_gate_result"] = newResult;
+  }
+  const fmBlock = serializeFrontmatter(newFm);
+  const newContent = body.length > 0 ? `${fmBlock}
+
+${body}` : `${fmBlock}
+`;
+  await fs19.writeFile(absPath, newContent, "utf8");
+}
+function coerceCachedGate(val) {
+  if (val === void 0 || val === null) return null;
+  if (typeof val === "object" && !Array.isArray(val)) {
+    const c = val;
+    return {
+      pass: Boolean(c["pass"]),
+      failing_criteria: Array.isArray(c["failing_criteria"]) ? c["failing_criteria"] : [],
+      last_gate_check: String(c["last_gate_check"] ?? "")
+    };
+  }
+  if (typeof val === "string" && val.startsWith("{")) {
+    try {
+      const parsed = yaml4.load(val, { schema: yaml4.CORE_SCHEMA });
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+      const p = parsed;
+      return {
+        pass: Boolean(p["pass"]),
+        failing_criteria: Array.isArray(p["failing_criteria"]) ? p["failing_criteria"] : [],
+        last_gate_check: String(p["last_gate_check"] ?? "")
+      };
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/commands/gate.ts
+function loadGateBlocks(gatesDocPath) {
+  const raw = fs20.readFileSync(gatesDocPath, "utf8");
+  const blocks = [];
+  const fenceRe = /^```yaml\n([\s\S]*?)^```/gm;
+  let match;
+  while ((match = fenceRe.exec(raw)) !== null) {
+    const yamlContent = match[1];
+    const parsed = yaml5.load(yamlContent);
+    const block = Array.isArray(parsed) ? parsed[0] : parsed;
+    if (block && typeof block === "object" && "work_item_type" in block && "transition" in block && "severity" in block && "criteria" in block) {
+      blocks.push(block);
+    }
+  }
+  return blocks;
+}
+function findGate(blocks, type, transition) {
+  return blocks.find(
+    (b) => b.work_item_type === type && b.transition === transition
+  ) ?? null;
+}
+function inferTransition(type, cachedGate) {
+  const transitions = WORK_ITEM_TRANSITIONS[type];
+  if (!cachedGate || !cachedGate.pass) {
+    return transitions[0];
+  }
+  if (transitions.length === 1) {
+    return transitions[0];
+  }
+  return transitions[1];
+}
+async function gateCheckHandler(file, opts, cli) {
+  const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
+  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 nowFn = cli?.now ?? (() => /* @__PURE__ */ new Date());
+  const absPath = path20.isAbsolute(file) ? file : path20.resolve(cwd, file);
+  if (!fs20.existsSync(absPath)) {
+    stderrFn(`[cleargate gate] error: file not found: ${absPath}`);
+    return exitFn(1);
+  }
+  let raw;
+  try {
+    raw = fs20.readFileSync(absPath, "utf8");
+  } catch (err) {
+    stderrFn(`[cleargate gate] error: cannot read file: ${absPath}`);
+    return exitFn(1);
+  }
+  let fm;
+  let body;
+  try {
+    ({ fm, body } = parseFrontmatter(raw));
+  } catch {
+    stderrFn(`[cleargate gate] error: cannot parse frontmatter in: ${absPath}`);
+    return exitFn(1);
+  }
+  const detectedType = detectWorkItemTypeFromFm(fm);
+  if (!detectedType) {
+    stderrFn(`[cleargate gate] error: unable to detect work-item type from frontmatter in: ${absPath}`);
+    return exitFn(1);
+  }
+  const projectRoot = cwd;
+  const gatesDocPath = cli?.gatesDocPath ?? path20.join(projectRoot, ".cleargate", "knowledge", "readiness-gates.md");
+  if (!fs20.existsSync(gatesDocPath)) {
+    stderrFn(`[cleargate gate] error: readiness-gates.md not found at: ${gatesDocPath}`);
+    return exitFn(1);
+  }
+  let gateBlocks;
+  try {
+    gateBlocks = loadGateBlocks(gatesDocPath);
+  } catch (err) {
+    stderrFn(`[cleargate gate] error: failed to parse readiness-gates.md: ${String(err)}`);
+    return exitFn(1);
+  }
+  const cachedGate = await readCachedGate(absPath);
+  const transition = opts.transition ?? inferTransition(detectedType, cachedGate);
+  const gate2 = findGate(gateBlocks, detectedType, transition);
+  if (!gate2) {
+    stderrFn(
+      `[cleargate gate] error: no gate definition found for ${detectedType}.${transition}`
+    );
+    return exitFn(1);
+  }
+  const wikiIndexPath = cli?.wikiIndexPath;
+  const parsedDoc = { fm, body, absPath };
+  const evalOpts = { projectRoot, ...wikiIndexPath ? { wikiIndexPath } : {} };
+  const failingCriteria = [];
+  const allResults = [];
+  for (const criterion of gate2.criteria) {
+    let result;
+    try {
+      result = evaluate(criterion.check, parsedDoc, evalOpts);
+    } catch (err) {
+      result = { pass: false, detail: `predicate error: ${String(err)}` };
+    }
+    allResults.push({ id: criterion.id, ...result });
+    if (!result.pass) {
+      failingCriteria.push({ id: criterion.id, detail: result.detail });
+    }
+  }
+  const overallPass = failingCriteria.length === 0;
+  const lastGateCheck = toIsoSecond(nowFn());
+  const cacheResult = {
+    pass: overallPass,
+    failing_criteria: failingCriteria,
+    last_gate_check: lastGateCheck
+  };
+  await writeCachedGate(absPath, cacheResult, { now: nowFn });
+  const isAdvisory = gate2.severity === "advisory";
+  const headerLine = `Gate: ${detectedType}.${transition} (${gate2.severity})`;
+  stdoutFn(headerLine);
+  if (overallPass) {
+    stdoutFn(`\u2705 ${detectedType}.${transition} passed (${gate2.criteria.length} criteria)`);
+  } else {
+    for (const r of allResults) {
+      if (!r.pass) {
+        if (isAdvisory) {
+          stdoutFn(`\u26A0 ${r.id}: ${r.detail} (advisory)`);
+        } else {
+          stdoutFn(`\u274C ${r.id}: ${r.detail}`);
+        }
+      }
+      if (opts.verbose) {
+        stdoutFn(`  [${r.pass ? "pass" : "fail"}] ${r.id}: ${r.detail}`);
+      }
+    }
+  }
+  if (!overallPass && !isAdvisory) {
+    return exitFn(1);
+  }
+}
+async function gateExplainHandler(file, cli) {
+  const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
+  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 = path20.isAbsolute(file) ? file : path20.resolve(cwd, file);
+  if (!fs20.existsSync(absPath)) {
+    stderrFn(`[cleargate gate] error: file not found: ${absPath}`);
+    return exitFn(1);
+  }
+  const cached = await readCachedGate(absPath);
+  if (!cached) {
+    stdoutFn("no gate check cached; run: cleargate gate check <file>");
+    return;
+  }
+  let raw;
+  try {
+    raw = fs20.readFileSync(absPath, "utf8");
+  } catch {
+    stderrFn(`[cleargate gate] error: cannot read file: ${absPath}`);
+    return exitFn(1);
+  }
+  let fm;
+  try {
+    ({ fm } = parseFrontmatter(raw));
+  } catch {
+    stderrFn(`[cleargate gate] error: cannot parse frontmatter in: ${absPath}`);
+    return exitFn(1);
+  }
+  const detectedType = detectWorkItemTypeFromFm(fm) ?? "unknown";
+  const failingIds = cached.failing_criteria.map((c) => c.id).join(", ");
+  const statusStr = cached.pass ? "pass" : "fail";
+  const summary = failingIds ? `${detectedType}: ${statusStr} at ${cached.last_gate_check}; ${cached.failing_criteria.length} failing: ${failingIds}` : `${detectedType}: ${statusStr} at ${cached.last_gate_check}`;
+  stdoutFn(summary);
+}
+
+// src/commands/stamp-tokens.ts
+import * as fs22 from "fs";
+import * as path22 from "path";
+
+// src/lib/ledger-reader.ts
+import * as fs21 from "fs";
+import * as path21 from "path";
+function findSprintRunsRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = path21.join(dir, ".cleargate", "sprint-runs");
+    if (fs21.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path21.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+function normalizeRow(raw) {
+  const story_id = typeof raw["story_id"] === "string" ? raw["story_id"] : "";
+  const work_item_id = typeof raw["work_item_id"] === "string" && raw["work_item_id"] !== "" ? raw["work_item_id"] : story_id;
+  return {
+    ts: typeof raw["ts"] === "string" ? raw["ts"] : "",
+    sprint_id: typeof raw["sprint_id"] === "string" ? raw["sprint_id"] : "",
+    agent_type: typeof raw["agent_type"] === "string" ? raw["agent_type"] : "unknown",
+    story_id,
+    work_item_id,
+    session_id: typeof raw["session_id"] === "string" ? raw["session_id"] : "",
+    transcript: typeof raw["transcript"] === "string" ? raw["transcript"] : "",
+    input: typeof raw["input"] === "number" ? raw["input"] : 0,
+    output: typeof raw["output"] === "number" ? raw["output"] : 0,
+    cache_creation: typeof raw["cache_creation"] === "number" ? raw["cache_creation"] : 0,
+    cache_read: typeof raw["cache_read"] === "number" ? raw["cache_read"] : 0,
+    model: typeof raw["model"] === "string" ? raw["model"] : "",
+    turns: typeof raw["turns"] === "number" ? raw["turns"] : 0
+  };
+}
+function rowMatchesWorkItem(row, workItemId) {
+  return row.work_item_id === workItemId || row.story_id === workItemId;
+}
+function buildBucket(session_id, rows) {
+  const totals = rows.reduce(
+    (acc, r) => ({
+      input: acc.input + r.input,
+      output: acc.output + r.output,
+      cache_creation: acc.cache_creation + r.cache_creation,
+      cache_read: acc.cache_read + r.cache_read,
+      turns: acc.turns + r.turns
+    }),
+    { input: 0, output: 0, cache_creation: 0, cache_read: 0, turns: 0 }
+  );
+  return { session_id, rows, totals };
+}
+function readLedgerForWorkItem(workItemId, opts = {}) {
+  let sprintRunsRoot;
+  if (opts.sprintRunsRoot) {
+    sprintRunsRoot = opts.sprintRunsRoot;
+  } else {
+    const found = findSprintRunsRoot(process.cwd());
+    if (!found) {
+      return [];
+    }
+    sprintRunsRoot = found;
+  }
+  if (!fs21.existsSync(sprintRunsRoot)) {
+    return [];
+  }
+  let ledgerFiles;
+  try {
+    const entries = fs21.readdirSync(sprintRunsRoot, { withFileTypes: true });
+    ledgerFiles = entries.filter((e) => e.isDirectory()).map((e) => path21.join(sprintRunsRoot, e.name, "token-ledger.jsonl")).filter((f) => fs21.existsSync(f));
+  } catch {
+    return [];
+  }
+  const matchingRows = [];
+  for (const ledgerFile of ledgerFiles) {
+    let content;
+    try {
+      content = fs21.readFileSync(ledgerFile, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n").filter((l) => l.trim() !== "");
+    for (const line of lines) {
+      let raw;
+      try {
+        raw = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const row = normalizeRow(raw);
+      if (opts.since && row.ts < opts.since) {
+        continue;
+      }
+      if (rowMatchesWorkItem(row, workItemId)) {
+        matchingRows.push(row);
+      }
+    }
+  }
+  const sessionMap = /* @__PURE__ */ new Map();
+  for (const row of matchingRows) {
+    const key = row.session_id || "(unknown-session)";
+    const existing = sessionMap.get(key);
+    if (existing) {
+      existing.push(row);
+    } else {
+      sessionMap.set(key, [row]);
+    }
+  }
+  const buckets = Array.from(sessionMap.entries()).map(([session_id, rows]) => {
+    rows.sort((a, b) => a.ts.localeCompare(b.ts));
+    return buildBucket(session_id, rows);
+  });
+  buckets.sort((a, b) => {
+    const aTs = a.rows[0]?.ts ?? "";
+    const bTs = b.rows[0]?.ts ?? "";
+    return aTs.localeCompare(bTs);
+  });
+  return buckets;
+}
+
+// src/commands/stamp-tokens.ts
+async function stampTokensHandler(file, opts, cli) {
+  const stdoutFn = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
+  const exitFn = cli?.exit ?? ((code) => {
+    process.exit(code);
+  });
+  const nowFn = cli?.now ?? (() => /* @__PURE__ */ new Date());
+  const cwd = cli?.cwd ?? process.cwd();
+  const absPath = path22.isAbsolute(file) ? file : path22.resolve(cwd, file);
+  if (/\/\.cleargate\/delivery\/archive\//.test(absPath)) {
+    stdoutFn(`[frozen] ${absPath}`);
+    exitFn(0);
+    return;
+  }
+  let rawContent;
+  try {
+    rawContent = fs22.readFileSync(absPath, "utf-8");
+  } catch {
+    stdoutFn(`[stamp-tokens] error: cannot read file: ${absPath}`);
+    exitFn(1);
+    return;
+  }
+  let fm = {};
+  let body = "";
+  const hasFrontmatter = rawContent.trimStart().startsWith("---");
+  if (hasFrontmatter) {
+    try {
+      const parsed = parseFrontmatter(rawContent);
+      fm = parsed.fm;
+      body = parsed.body;
+    } catch {
+      stdoutFn(`[stamp-tokens] error: cannot parse frontmatter in: ${absPath}`);
+      exitFn(1);
+      return;
+    }
+  } else {
+    body = rawContent;
+  }
+  const workItemId = extractWorkItemId(fm, absPath);
+  if (!workItemId) {
+    stdoutFn(`[stamp-tokens] error: cannot determine work_item_id from frontmatter or filename: ${absPath}`);
+    exitFn(1);
+    return;
+  }
+  const existingDraftTokens = coerceDraftTokens(fm["draft_tokens"]);
+  const existingLastStamp = existingDraftTokens?.last_stamp ?? null;
+  const buckets = readLedgerForWorkItem(workItemId, { sprintRunsRoot: cli?.sprintRunsRoot });
+  if (existingLastStamp && buckets.length > 0) {
+    const allRowsOlderThanLastStamp = buckets.every(
+      (bucket) => bucket.rows.every((row) => row.ts < existingLastStamp)
+    );
+    if (allRowsOlderThanLastStamp && existingDraftTokens !== null) {
+      exitFn(0);
+      return;
+    }
+  }
+  const nowIso = toIsoSecond(nowFn());
+  let newFm;
+  let stampError;
+  if (buckets.length === 0) {
+    stampError = `no ledger rows for work_item_id ${workItemId}`;
+    const nullTokens = {
+      input: null,
+      output: null,
+      cache_creation: null,
+      cache_read: null,
+      model: null,
+      last_stamp: nowIso,
+      sessions: []
+    };
+    newFm = buildNewFrontmatter(fm, nullTokens, stampError);
+  } else {
+    const tokens = aggregateBuckets(buckets, nowIso);
+    newFm = buildNewFrontmatter(fm, tokens, void 0);
+    delete newFm["stamp_error"];
+  }
+  const serialized = buildSerializedContent(newFm, body);
+  if (opts.dryRun) {
+    stdoutFn(`[dry-run] stamp-tokens would write draft_tokens for ${workItemId}:`);
+    const draftTokensVal = newFm["draft_tokens"];
+    stdoutFn(`  draft_tokens: ${JSON.stringify(draftTokensVal)}`);
+    if (stampError) {
+      stdoutFn(`  stamp_error: "${stampError}"`);
+    }
+    exitFn(0);
+    return;
+  }
+  try {
+    fs22.writeFileSync(absPath, serialized, "utf-8");
+  } catch {
+    stdoutFn(`[stamp-tokens] error: cannot write file: ${absPath}`);
+    exitFn(1);
+    return;
+  }
+  stdoutFn(`[stamped] ${absPath} (${workItemId})`);
+  exitFn(0);
+}
+function extractWorkItemId(fm, absPath) {
+  const idKeys = ["story_id", "epic_id", "proposal_id", "cr_id", "bug_id"];
+  for (const key of idKeys) {
+    const val = fm[key];
+    if (typeof val === "string" && val.trim() !== "") {
+      return val.trim();
+    }
+  }
+  const basename9 = path22.basename(absPath);
+  const match = basename9.match(/^(STORY|EPIC|PROPOSAL|CR|BUG)-\d+(-\d+)?/i);
+  if (match) {
+    return match[0].toUpperCase();
+  }
+  const typeFromPath = detectWorkItemType(absPath);
+  if (typeFromPath) {
+    const idMatch = basename9.match(/((?:STORY|EPIC|PROPOSAL|CR|BUG)-\d+(?:-\d+)?)/i);
+    if (idMatch) {
+      return idMatch[1].toUpperCase();
+    }
+  }
+  return null;
+}
+function coerceDraftTokens(val) {
+  if (val == null) return null;
+  if (typeof val === "object" && !Array.isArray(val)) {
+    const o = val;
+    return {
+      input: typeof o["input"] === "number" ? o["input"] : null,
+      output: typeof o["output"] === "number" ? o["output"] : null,
+      cache_creation: typeof o["cache_creation"] === "number" ? o["cache_creation"] : null,
+      cache_read: typeof o["cache_read"] === "number" ? o["cache_read"] : null,
+      model: typeof o["model"] === "string" ? o["model"] : null,
+      last_stamp: typeof o["last_stamp"] === "string" ? o["last_stamp"] : "",
+      sessions: Array.isArray(o["sessions"]) ? o["sessions"] : []
+    };
+  }
+  if (typeof val === "string") {
+    try {
+      const parsed = JSON.parse(val);
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function aggregateBuckets(buckets, nowIso) {
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCacheCreation = 0;
+  let totalCacheRead = 0;
+  const uniqueModels = /* @__PURE__ */ new Set();
+  const sessions = [];
+  for (const bucket of buckets) {
+    totalInput += bucket.totals.input;
+    totalOutput += bucket.totals.output;
+    totalCacheCreation += bucket.totals.cache_creation;
+    totalCacheRead += bucket.totals.cache_read;
+    const sessionModels = /* @__PURE__ */ new Set();
+    for (const row of bucket.rows) {
+      if (row.model) {
+        uniqueModels.add(row.model);
+        sessionModels.add(row.model);
+      }
+    }
+    const sessionModel = Array.from(sessionModels).sort().join(", ");
+    sessions.push({
+      session: bucket.session_id,
+      model: sessionModel,
+      input: bucket.totals.input,
+      output: bucket.totals.output,
+      cache_read: bucket.totals.cache_read,
+      cache_creation: bucket.totals.cache_creation,
+      ts: bucket.rows[0]?.ts ?? ""
+    });
+  }
+  const model = Array.from(uniqueModels).sort().join(", ") || null;
+  return {
+    input: totalInput,
+    output: totalOutput,
+    cache_creation: totalCacheCreation,
+    cache_read: totalCacheRead,
+    model,
+    last_stamp: nowIso,
+    sessions
+  };
+}
+function buildNewFrontmatter(existingFm, tokens, stampError) {
+  const newFm = {};
+  for (const [k, v] of Object.entries(existingFm)) {
+    if (k !== "draft_tokens" && k !== "stamp_error") {
+      newFm[k] = v;
+    }
+  }
+  if (stampError) {
+    newFm["stamp_error"] = stampError;
+  }
+  newFm["draft_tokens"] = tokens;
+  return newFm;
+}
+function buildSerializedContent(fm, body) {
+  const fmBlock = serializeFrontmatter(fm);
+  if (body.length > 0) {
+    return `${fmBlock}
+
+${body}`;
+  }
+  return `${fmBlock}
+`;
+}
+
+// src/commands/upgrade.ts
+import * as fsp from "fs/promises";
+import * as path23 from "path";
+
+// src/lib/claude-md-surgery.ts
+var CLEARGATE_START = "<!-- CLEARGATE:START -->";
+var CLEARGATE_END = "<!-- CLEARGATE:END -->";
+var BLOCK_REGEX2 = /<!-- CLEARGATE:START -->([\s\S]*)<!-- CLEARGATE:END -->/;
+function readBlock(content) {
+  const match = BLOCK_REGEX2.exec(content);
+  if (!match) return null;
+  return match[1];
+}
+function writeBlock(content, newBlockBody) {
+  if (!content.includes(CLEARGATE_START)) {
+    throw new Error("CLAUDE.md is missing <!-- CLEARGATE:START --> marker");
+  }
+  if (!content.includes(CLEARGATE_END)) {
+    throw new Error("CLAUDE.md is missing <!-- CLEARGATE:END --> marker");
+  }
+  return content.replace(BLOCK_REGEX2, `${CLEARGATE_START}${newBlockBody}${CLEARGATE_END}`);
+}
+function removeBlock(content) {
+  if (!content.includes(CLEARGATE_START)) {
+    throw new Error("CLAUDE.md is missing <!-- CLEARGATE:START --> marker");
+  }
+  if (!content.includes(CLEARGATE_END)) {
+    throw new Error("CLAUDE.md is missing <!-- CLEARGATE:END --> marker");
+  }
+  return content.replace(BLOCK_REGEX2, "");
+}
+
+// src/lib/settings-json-surgery.ts
+function isClearGateCommand(command) {
+  if (command.includes("wiki ingest")) return true;
+  return /\/\.claude\/hooks\/(token-ledger|stamp-and-gate|session-start|wiki-ingest|cleargate-[^/]*)\.sh/.test(command);
+}
+function removeClearGateHooks(settings) {
+  if (!settings.hooks) return { ...settings };
+  const newHooks = {};
+  for (const [eventName, entries] of Object.entries(settings.hooks)) {
+    if (!entries) continue;
+    const filteredEntries = [];
+    for (const entry of entries) {
+      if (!entry.hooks || entry.hooks.length === 0) {
+        filteredEntries.push(entry);
+        continue;
+      }
+      const remainingInnerHooks = entry.hooks.filter(
+        (h) => !isClearGateCommand(h.command)
+      );
+      if (remainingInnerHooks.length === 0) {
+        continue;
+      }
+      if (remainingInnerHooks.length === entry.hooks.length) {
+        filteredEntries.push(entry);
+      } else {
+        filteredEntries.push({ ...entry, hooks: remainingInnerHooks });
+      }
+    }
+    if (filteredEntries.length > 0) {
+      newHooks[eventName] = filteredEntries;
+    }
+  }
+  const result = { ...settings };
+  if (Object.keys(newHooks).length > 0) {
+    result.hooks = newHooks;
+  } else {
+    delete result.hooks;
+  }
+  return result;
+}
+
+// src/lib/merge-ui.ts
+import { createPatch } from "diff";
+function renderInlineDiff(ours, theirs, filePath) {
+  return createPatch(filePath, ours, theirs, "installed", "upstream");
+}
+async function promptMergeChoice(opts) {
+  const { path: filePath, state, ours, theirs } = opts;
+  const stdout = opts.stdout ?? ((s) => process.stdout.write(s));
+  const stdin = opts.stdin ?? process.stdin;
+  stdout(`
+[merge] ${filePath}  state=${state}
+`);
+  const patch = renderInlineDiff(ours, theirs, filePath);
+  stdout(patch + "\n");
+  stdout("[k]eep mine / [t]ake theirs / [e]dit in $EDITOR: ");
+  return new Promise((resolve13, reject) => {
+    let buf = "";
+    const onData = (chunk) => {
+      buf += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+      const newline = buf.indexOf("\n");
+      if (newline !== -1) {
+        const answer = buf.slice(0, newline).trim().toLowerCase();
+        stdin.removeListener("data", onData);
+        stdin.removeListener("error", onError);
+        if (answer === "k" || answer === "t" || answer === "e") {
+          resolve13(answer);
+        } else {
+          stdout(`Unknown choice '${answer}'; defaulting to [k]eep mine.
+`);
+          resolve13("k");
+        }
+      }
+    };
+    const onError = (err) => {
+      stdin.removeListener("data", onData);
+      reject(err);
+    };
+    stdin.on("data", onData);
+    stdin.once("error", onError);
+  });
+}
+
+// src/lib/editor.ts
+import { spawn } from "child_process";
+async function openInEditor(filePath, opts) {
+  const env = opts?.env ?? process.env;
+  const editor = opts?.editor ?? env["EDITOR"] ?? env["VISUAL"];
+  if (!editor) {
+    throw new Error("$EDITOR not set; cannot [e]dit option. Set the EDITOR environment variable.");
+  }
+  return new Promise((resolve13, reject) => {
+    const child = spawn(editor, [filePath], {
+      stdio: "inherit",
+      env: { ...env }
+    });
+    child.on("error", (err) => {
+      reject(new Error(`Failed to start editor '${editor}': ${err.message}`));
+    });
+    child.on("close", (code) => {
+      resolve13({ exitCode: code ?? 0 });
+    });
+  });
+}
+function containsConflictMarkers(content) {
+  return content.includes("<<<<<<< ours") || content.includes(">>>>>>> theirs") || // Also catch generic git-style markers in case user merged manually
+  /^<<<<<<< /m.test(content) || /^>>>>>>> /m.test(content);
+}
+
+// src/commands/upgrade.ts
+async function writeAtomic2(filePath, content) {
+  const tmpPath = filePath + ".tmp." + Date.now();
+  await fsp.writeFile(tmpPath, content, "utf-8");
+  await fsp.rename(tmpPath, filePath);
+}
+async function updateSnapshotEntry(projectRoot, filePath, newSha) {
+  const snapshotPath = path23.join(projectRoot, ".cleargate", ".install-manifest.json");
+  let snapshot;
+  try {
+    const raw = await fsp.readFile(snapshotPath, "utf-8");
+    snapshot = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const updated = {
+    ...snapshot,
+    files: snapshot.files.map(
+      (entry) => entry.path === filePath ? { ...entry, sha256: newSha } : entry
+    )
+  };
+  await writeAtomic2(snapshotPath, JSON.stringify(updated, null, 2) + "\n");
+}
+function isClaudeMd(filePath) {
+  return path23.basename(filePath) === "CLAUDE.md";
+}
+function isSettingsJson(filePath) {
+  return path23.basename(filePath) === "settings.json" && filePath.includes(".claude");
+}
+async function applyAlwaysOverwrite(entry, projectRoot, packageRoot, stdout) {
+  const targetPath = path23.join(projectRoot, entry.path);
+  const sourcePath = path23.join(packageRoot, entry.path);
+  try {
+    const pkgContent = await fsp.readFile(sourcePath, "utf-8");
+    await fsp.mkdir(path23.dirname(targetPath), { recursive: true });
+    await writeAtomic2(targetPath, pkgContent);
+    await updateSnapshotEntry(projectRoot, entry.path, entry.sha256);
+    stdout(`[always] overwritten: ${entry.path}`);
+  } catch (err) {
+    stdout(`[always] error overwriting ${entry.path}: ${err.message}`);
+  }
+}
+async function applyMerge3Way(entry, projectRoot, packageRoot, installSha, currentSha, flags, opts) {
+  const { stdout, stderr, promptMergeChoiceFn, openInEditorFn, stdin } = opts;
+  const targetPath = path23.join(projectRoot, entry.path);
+  const sourcePath = path23.join(packageRoot, entry.path);
+  let ours = "";
+  let theirs = "";
+  try {
+    ours = await fsp.readFile(targetPath, "utf-8");
+  } catch {
+    ours = "";
+  }
+  try {
+    theirs = await fsp.readFile(sourcePath, "utf-8");
+  } catch {
+    stdout(`[merge] skip: package file not found for ${entry.path}`);
+    return { updated: false, newSha: null };
+  }
+  const state = classify(entry.sha256, installSha, currentSha, entry.tier);
+  let choice;
+  if (flags.yes) {
+    choice = "t";
+    stdout(`[yes] taking theirs: ${entry.path}  state=${state}`);
+  } else {
+    choice = await promptMergeChoiceFn({
+      path: entry.path,
+      state,
+      ours,
+      theirs,
+      stdin,
+      stdout
+    });
+  }
+  if (choice === "k") {
+    stdout(`[keep] ${entry.path}`);
+    await updateSnapshotEntry(projectRoot, entry.path, currentSha);
+    return { updated: true, newSha: currentSha };
+  }
+  if (choice === "t") {
+    let mergedContent = theirs;
+    if (isClaudeMd(entry.path)) {
+      try {
+        const ourBlock = readBlock(ours);
+        const theirBlock = readBlock(theirs);
+        if (ourBlock !== null && theirBlock !== null) {
+          mergedContent = writeBlock(ours, theirBlock);
+        } else if (theirBlock !== null) {
+          mergedContent = theirs;
+        }
+      } catch {
+        mergedContent = theirs;
+      }
+    } else if (isSettingsJson(entry.path)) {
+      try {
+        const ourSettings = JSON.parse(ours);
+        const theirSettings = JSON.parse(theirs);
+        const withoutOurCg = removeClearGateHooks(ourSettings);
+        const cgHooks = theirSettings.hooks ?? {};
+        const merged = { ...withoutOurCg };
+        if (Object.keys(cgHooks).length > 0) {
+          merged.hooks = { ...withoutOurCg.hooks ?? {}, ...cgHooks };
+        }
+        mergedContent = JSON.stringify(merged, null, 2) + "\n";
+      } catch {
+        mergedContent = theirs;
+      }
+    }
+    await fsp.mkdir(path23.dirname(targetPath), { recursive: true });
+    await writeAtomic2(targetPath, mergedContent);
+    const newSha2 = hashNormalized(mergedContent);
+    await updateSnapshotEntry(projectRoot, entry.path, newSha2);
+    stdout(`[take] ${entry.path}`);
+    return { updated: true, newSha: newSha2 };
+  }
+  const mergeFilePath = targetPath + ".cleargate-merge";
+  const conflictContent = `<<<<<<< ours (installed)
+${ours}=======
+${theirs}>>>>>>> theirs (upstream)
+`;
+  await fsp.mkdir(path23.dirname(mergeFilePath), { recursive: true });
+  await writeAtomic2(mergeFilePath, conflictContent);
+  try {
+    const result = await openInEditorFn(mergeFilePath);
+    if (result.exitCode !== 0) {
+      stderr(`[edit] editor exited with code ${result.exitCode}; markers may remain in ${mergeFilePath}`);
+    }
+  } catch (err) {
+    stderr(`[edit] could not open editor: ${err.message}`);
+    stderr(`[edit] resolve markers manually in: ${mergeFilePath}`);
+    return { updated: false, newSha: null };
+  }
+  let edited = "";
+  try {
+    edited = await fsp.readFile(mergeFilePath, "utf-8");
+  } catch {
+    stderr(`[edit] could not read ${mergeFilePath} after editor exit`);
+    return { updated: false, newSha: null };
+  }
+  if (containsConflictMarkers(edited)) {
+    stderr(`[edit] unresolved conflict markers remain in ${mergeFilePath}`);
+    stderr(`[edit] file NOT updated. Resolve manually and re-run upgrade.`);
+    return { updated: false, newSha: null };
+  }
+  await writeAtomic2(targetPath, edited);
+  try {
+    await fsp.unlink(mergeFilePath);
+  } catch {
+  }
+  const newSha = hashNormalized(edited);
+  await updateSnapshotEntry(projectRoot, entry.path, newSha);
+  stdout(`[edit] resolved: ${entry.path}`);
+  return { updated: true, newSha };
+}
+async function upgradeHandler(flags, cli) {
+  const cwd = cli?.cwd ?? process.cwd();
+  const now = cli?.now ? cli.now() : /* @__PURE__ */ new Date();
+  const stdout = cli?.stdout ?? ((s) => process.stdout.write(s + "\n"));
+  const stderr = cli?.stderr ?? ((s) => process.stderr.write(s + "\n"));
+  const exit = cli?.exit ?? ((code) => process.exit(code));
+  const promptMergeChoiceFn = cli?.promptMergeChoice ?? promptMergeChoice;
+  const openInEditorFn = cli?.openInEditor ?? openInEditor;
+  const stdin = cli?.stdin;
+  let pkgManifest;
+  try {
+    pkgManifest = loadPackageManifest({ packageRoot: cli?.packageRoot });
+  } catch (err) {
+    stderr(`[upgrade] ${err.message}`);
+    exit(1);
+    return;
+  }
+  const installSnapshot = await loadInstallSnapshot(cwd);
+  const snapshotByPath = /* @__PURE__ */ new Map();
+  for (const entry of installSnapshot?.files ?? []) {
+    snapshotByPath.set(entry.path, entry.sha256);
+  }
+  const onlyTier = flags.only;
+  const filteredFiles = onlyTier ? pkgManifest.files.filter((e) => e.tier === onlyTier) : pkgManifest.files;
+  const workItems = [];
+  await Promise.all(
+    filteredFiles.map(async (entry) => {
+      if (entry.tier === "user-artifact") {
+        return;
+      }
+      const currentSha = await computeCurrentSha(entry, cwd);
+      const installSha = snapshotByPath.get(entry.path) ?? null;
+      let action;
+      switch (entry.overwrite_policy) {
+        case "always":
+          action = "overwrite";
+          break;
+        case "skip":
+        case "preserve":
+          action = "skip";
+          break;
+        case "merge-3way":
+        default:
+          action = "merge-3way";
+          break;
+      }
+      workItems.push({ entry, currentSha, installSha, action });
+    })
+  );
+  workItems.sort((a, b) => a.entry.path.localeCompare(b.entry.path));
+  if (flags.dryRun) {
+    let count = 0;
+    for (const item of workItems) {
+      const state = classify(item.entry.sha256, item.installSha, item.currentSha, item.entry.tier);
+      stdout(`[dry-run] ${item.entry.path}  action=${item.action}  state=${state}`);
+      count++;
+    }
+    stdout(`[dry-run] ${count} files planned. No changes made.`);
+    return;
+  }
+  const packageRoot = cli?.packageRoot ?? cwd;
+  const driftMap = {};
+  for (const item of workItems) {
+    const { entry, currentSha, installSha, action } = item;
+    switch (action) {
+      case "skip": {
+        stdout(`[skip] ${entry.path}  policy=${entry.overwrite_policy}`);
+        break;
+      }
+      case "overwrite": {
+        await applyAlwaysOverwrite(entry, cwd, packageRoot, stdout);
+        break;
+      }
+      case "merge-3way": {
+        await applyMerge3Way(
+          entry,
+          cwd,
+          packageRoot,
+          installSha,
+          currentSha,
+          { yes: flags.yes, dryRun: false },
+          { stdout, stderr, promptMergeChoiceFn, openInEditorFn, stdin }
+        );
+        break;
+      }
+    }
+    const postSha = await computeCurrentSha(entry, cwd);
+    driftMap[entry.path] = {
+      state: classify(entry.sha256, installSha, postSha, entry.tier),
+      entry,
+      install_sha: installSha,
+      current_sha: postSha,
+      package_sha: entry.sha256
+    };
+  }
+  await writeDriftState(cwd, driftMap, { lastRefreshed: now.toISOString() });
+  stdout("[upgrade] complete.");
+}
+
+// src/commands/uninstall.ts
+import * as fs23 from "fs";
+import * as fsp2 from "fs/promises";
+import * as path24 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"];
+function parseTierList(raw) {
+  const result = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    for (const t of item.split(",")) {
+      const tier = t.trim();
+      if (tier === "all") {
+        for (const f of FRAMEWORK_TIERS) result.add(f);
+        for (const u of USER_ARTIFACT_TIERS) result.add(u);
+      } else {
+        result.add(tier);
+      }
+    }
+  }
+  return result;
+}
+function shouldPreserve(entry, preserveSet, removeSet) {
+  if (removeSet.has(entry.tier)) return false;
+  if (preserveSet.has(entry.tier)) return true;
+  if (USER_ARTIFACT_TIERS.includes(entry.tier)) return true;
+  return false;
+}
+function resolveProjectName(target) {
+  const pkgPath = path24.join(target, "package.json");
+  if (fs23.existsSync(pkgPath)) {
+    try {
+      const raw = fs23.readFileSync(pkgPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed.name && typeof parsed.name === "string") {
+        return parsed.name;
+      }
+    } catch {
+    }
+  }
+  return path24.basename(target);
+}
+function detectUncommittedChanges(target, manifestPaths, gitRunner) {
+  const run = gitRunner ?? ((args) => {
+    try {
+      const out = execSync2(["git", ...args].join(" "), {
+        cwd: target,
+        stdio: ["pipe", "pipe", "pipe"],
+        encoding: "utf-8"
+      });
+      return { stdout: out, code: 0 };
+    } catch (e) {
+      const err = e;
+      return { stdout: err.stdout ?? "", code: err.status ?? 1 };
+    }
+  });
+  const isGit = run(["-C", target, "rev-parse", "--is-inside-work-tree"]);
+  if (isGit.code !== 0) {
+    return [];
+  }
+  const result = run(["-C", target, "status", "--porcelain"]);
+  if (result.code !== 0) {
+    return [];
+  }
+  const changedFiles = result.stdout.split("\n").filter(Boolean).map((line) => line.slice(3).trim());
+  const manifestSet = new Set(manifestPaths);
+  return changedFiles.filter((f) => manifestSet.has(f));
+}
+async function removeFromPackageJson(target, dryRun) {
+  const pkgPath = path24.join(target, "package.json");
+  if (!fs23.existsSync(pkgPath)) return false;
+  let raw;
+  try {
+    raw = await fsp2.readFile(pkgPath, "utf-8");
+  } catch {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+  let modified = false;
+  for (const key of ["dependencies", "devDependencies"]) {
+    const deps = parsed[key];
+    if (deps && typeof deps === "object" && "@cleargate/cli" in deps) {
+      const updated = { ...deps };
+      delete updated["@cleargate/cli"];
+      parsed[key] = updated;
+      modified = true;
+    }
+  }
+  if (modified && !dryRun) {
+    await fsp2.writeFile(pkgPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+  }
+  return modified;
+}
+async function writeAtomic3(filePath, content) {
+  const tmpPath = `${filePath}.tmp.${Date.now()}`;
+  await fsp2.writeFile(tmpPath, content, "utf-8");
+  await fsp2.rename(tmpPath, filePath);
+}
+async function removeFile(filePath) {
+  try {
+    await fsp2.unlink(filePath);
+  } catch {
+  }
+}
+async function removeDir(dirPath) {
+  try {
+    fs23.rmSync(dirPath, { recursive: true, force: true });
+  } catch {
+  }
+}
+async function uninstallHandler(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const stdout = opts.stdout ?? ((s) => process.stdout.write(s + "\n"));
+  const stderr = opts.stderr ?? ((s) => process.stderr.write(s + "\n"));
+  const exit = opts.exit ?? ((code) => process.exit(code));
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const dryRun = opts.dryRun ?? false;
+  const yes = opts.yes ?? false;
+  const force = opts.force ?? false;
+  const preserveSet = parseTierList(opts.preserve ?? []);
+  const removeSet = parseTierList(opts.remove ?? []);
+  const removeAll = (opts.remove ?? []).some((r) => r === "all");
+  if (removeAll) {
+    for (const t of FRAMEWORK_TIERS) removeSet.add(t);
+    for (const u of USER_ARTIFACT_TIERS) removeSet.add(u);
+  }
+  const target = opts.path ? path24.resolve(opts.path) : cwd;
+  const cleargateDir = path24.join(target, ".cleargate");
+  const manifestPath = path24.join(cleargateDir, ".install-manifest.json");
+  const uninstalledPath = path24.join(cleargateDir, ".uninstalled");
+  if (!fs23.existsSync(manifestPath)) {
+    if (fs23.existsSync(uninstalledPath)) {
+      stdout("already uninstalled");
+      exit(0);
+      return;
+    }
+    stdout(`no ClearGate install detected at ${target}`);
+    exit(0);
+    return;
+  }
+  if (fs23.existsSync(uninstalledPath) && !fs23.existsSync(manifestPath)) {
+    stdout("already uninstalled");
+    exit(0);
+    return;
+  }
+  const snapshot = await loadInstallSnapshot(target);
+  if (!snapshot) {
+    stdout(`no ClearGate install detected at ${target}`);
+    exit(0);
+    return;
+  }
+  if (!force) {
+    const manifestPaths = snapshot.files.map((e) => e.path);
+    const uncommitted = detectUncommittedChanges(target, manifestPaths, opts.git);
+    if (uncommitted.length > 0) {
+      stderr(
+        `Uncommitted changes to tracked files: ${uncommitted.slice(0, 5).join(", ")}${uncommitted.length > 5 ? ` and ${uncommitted.length - 5} more` : ""}. Commit, stash, or pass --force.`
+      );
+      exit(1);
+      return;
+    }
+  }
+  const claudeMdPath = path24.join(target, "CLAUDE.md");
+  let claudeMdContent = null;
+  if (fs23.existsSync(claudeMdPath)) {
+    claudeMdContent = fs23.readFileSync(claudeMdPath, "utf-8");
+    if (!claudeMdContent.includes(CLEARGATE_START)) {
+      stderr("CLAUDE.md is missing <!-- CLEARGATE:START --> marker");
+      exit(1);
+      return;
+    }
+    if (!claudeMdContent.includes(CLEARGATE_END)) {
+      stderr("CLAUDE.md is missing <!-- CLEARGATE:END --> marker");
+      exit(1);
+      return;
+    }
+  }
+  const toRemove = [];
+  const toPreserve = [];
+  const toSkip = [];
+  for (const entry of snapshot.files) {
+    const filePath = path24.join(target, entry.path);
+    if (!fs23.existsSync(filePath)) {
+      toSkip.push(entry);
+      continue;
+    }
+    if (shouldPreserve(entry, preserveSet, removeSet)) {
+      toPreserve.push(entry);
+    } else {
+      toRemove.push(entry);
+    }
+  }
+  stdout(`Will remove ${toRemove.length} files, keep ${toPreserve.length} files, update CLAUDE.md to strip CLEARGATE block, remove @cleargate/cli from package.json.`);
+  if (dryRun) {
+    stdout("");
+    stdout("[dry-run] Planned removals:");
+    for (const e of toRemove) {
+      stdout(`  [remove] ${e.path}`);
+    }
+    stdout("");
+    stdout("[dry-run] Planned preservations:");
+    for (const e of toPreserve) {
+      stdout(`  [keep]   ${e.path}`);
+    }
+    if (toSkip.length > 0) {
+      stdout("");
+      stdout("[dry-run] Untracked (already missing on disk):");
+      for (const e of toSkip) {
+        stdout(`  [skip]   ${e.path}`);
+      }
+    }
+    stdout("");
+    stdout("[dry-run] No files changed.");
+    exit(0);
+    return;
+  }
+  if (!yes) {
+    const projectName = resolveProjectName(target);
+    const promptNameFn = opts.promptName ?? (() => {
+      return new Promise((resolve13) => {
+        process.stdout.write(`Type the project name "${projectName}" to confirm uninstall: `);
+        let buf = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.once("data", (chunk) => {
+          buf = chunk.toString().trim();
+          resolve13(buf);
+        });
+      });
+    });
+    const typed = await promptNameFn();
+    if (typed !== projectName) {
+      stdout("name mismatch \u2014 aborting");
+      exit(1);
+      return;
+    }
+  }
+  const removedPaths = [];
+  const preservedPaths = [];
+  for (const entry of toRemove) {
+    const filePath = path24.join(target, entry.path);
+    await removeFile(filePath);
+    removedPaths.push(entry.path);
+  }
+  for (const entry of toPreserve) {
+    preservedPaths.push(entry.path);
+  }
+  if (claudeMdContent !== null) {
+    try {
+      const stripped = removeBlock(claudeMdContent);
+      await writeAtomic3(claudeMdPath, stripped);
+      removedPaths.push("CLAUDE.md (CLEARGATE block)");
+    } catch (err) {
+      stderr(`Warning: could not strip CLAUDE.md block: ${err.message}`);
+    }
+  }
+  const settingsPath = path24.join(target, ".claude", "settings.json");
+  if (fs23.existsSync(settingsPath)) {
+    try {
+      const raw = fs23.readFileSync(settingsPath, "utf-8");
+      const settings = JSON.parse(raw);
+      const cleaned = removeClearGateHooks(settings);
+      await writeAtomic3(settingsPath, JSON.stringify(cleaned, null, 2) + "\n");
+      removedPaths.push(".claude/settings.json (ClearGate hooks)");
+    } catch (err) {
+      stderr(`Warning: could not update settings.json: ${err.message}`);
+    }
+  }
+  const pkgModified = await removeFromPackageJson(target, false);
+  if (pkgModified) {
+    removedPaths.push("package.json (@cleargate/cli dep)");
+    stdout("Removed @cleargate/cli from package.json. Run `npm install` to update package-lock.json.");
+  }
+  await removeFile(manifestPath);
+  await removeFile(path24.join(cleargateDir, ".drift-state.json"));
+  const marker = {
+    uninstalled_at: now().toISOString(),
+    prior_version: snapshot.cleargate_version,
+    preserved: preservedPaths,
+    removed: removedPaths
+  };
+  await fsp2.mkdir(cleargateDir, { recursive: true });
+  await writeAtomic3(uninstalledPath, JSON.stringify(marker, null, 2) + "\n");
+  if (removeAll) {
+    const hasPreservedInsideCleargate = preservedPaths.some(
+      (p) => p.startsWith(".cleargate/")
+    );
+    if (!hasPreservedInsideCleargate) {
+      await removeDir(cleargateDir);
+    }
+  }
+  if (preservedPaths.length > 0) {
+    stdout(`Preserved ${preservedPaths.length} items. Run cleargate init in this directory to restore.`);
+  }
+}
+
 // src/cli.ts
 var program = new Command();
 program.name("cleargate").description("ClearGate CLI \u2014 connects AI agent teams to the ClearGate MCP server").version(package_default.version, "-V, --version").option("--profile <name>", "configuration profile to use", "default").option("--mcp-url <url>", "MCP server URL (overrides config file and env)").showHelpAfterError("(use `cleargate --help`)");
@@ -272,9 +4539,105 @@ program.command("join <invite-url>").description("join a ClearGate workspace usi
     mcpUrlFlag: globals.mcpUrl
   });
 });
+program.command("init").description("initialise a repo with ClearGate scaffold (CLAUDE.md block, hook config, agents, templates)").option("--force", "overwrite existing files that differ from the bundled payload").action(async (opts) => {
+  await initHandler({ force: opts.force ?? false });
+});
 program.command("whoami").description("print the currently authenticated agent identity").action(stubHandler("whoami"));
-program.command("stamp").description("stamp a delivery artifact into the MCP server").action(stubHandler("stamp"));
-program.command("wiki").description("query or update the workspace wiki").action(stubHandler("wiki"));
+program.command("stamp <file>").description("stamp ClearGate metadata fields into a file's frontmatter").option("--dry-run", "print planned changes without writing").action(async (file, opts) => {
+  await stampHandler(file, { dryRun: opts.dryRun });
+});
+var wiki = program.command("wiki").description("query or update the workspace wiki");
+wiki.command("build").description("full rebuild of .cleargate/wiki/ from raw delivery items").action(async () => {
+  await wikiBuildHandler();
+});
+wiki.command("ingest <file>").description("ingest a single raw delivery file into the wiki").action(async (file) => {
+  await wikiIngestHandler({ rawPath: file });
+});
+wiki.command("lint").description("check wiki pages for drift vs raw sources").option("--suggest", "advisory mode \u2014 exit 0, emit suggestions only").helpOption("--help", [
+  "Usage: cleargate wiki lint [--suggest]",
+  "",
+  "Enforcement mode (default): exits 1 on any finding.",
+  "Suggest mode (--suggest): exits 0, prefixes findings with [advisory],",
+  "  and emits Karpathy cross-ref discovery candidates."
+].join("\n")).action(async (_opts, command) => {
+  const cmdOpts = command.opts();
+  await wikiLintHandler({
+    mode: cmdOpts.suggest ? "suggest" : "enforce"
+  });
+});
+wiki.command("query <terms...>").description("search the wiki index for matching work items").option("--persist", "write result as a topic page under wiki/topics/").addHelpText("after", [
+  "",
+  "NOTE: CLI synthesis is grep-and-list. For NL synthesis with the",
+  "cleargate-wiki-query subagent, invoke from a Claude Code session.",
+  "This diverges from PROPOSAL-002 \xA72.2 intentionally for testability",
+  "and offline/scripted use."
+].join("\n")).action(async (terms, opts) => {
+  await wikiQueryHandler({
+    query: terms.join(" "),
+    persist: opts.persist ?? false
+  });
+});
+var gate = program.command("gate").description("evaluate readiness gates for a ClearGate work-item file");
+gate.command("check <file>").description("evaluate readiness criteria and write result to frontmatter").option("-v, --verbose", "show full expected-vs-actual detail per criterion").option("--transition <name>", "override auto-detected transition name").action(async (file, opts) => {
+  await gateCheckHandler(file, { verbose: opts.verbose, transition: opts.transition });
+});
+gate.command("explain <file>").description("render cached gate result in \u226450 agent tokens (read-only)").action(async (file) => {
+  await gateExplainHandler(file);
+});
+program.command("stamp-tokens <file>").description("stamp draft_tokens from token-ledger into a work-item file (hook-invoked)").option("--dry-run", "print planned changes without writing").action(async (file, opts) => {
+  await stampTokensHandler(file, { dryRun: opts.dryRun });
+});
 program.command("admin").description("administrative operations (create-project, invite, issue-token, revoke-token)").action(stubHandler("admin"));
+program.command("doctor").description("diagnose scaffold drift, hook health, blocked items, and token cost").option("--check-scaffold", "check scaffold files for drift against install snapshot").option("--session-start-mode", "hidden: enables daily throttle (used by session-start hook)", false).option("--session-start", "emit blocked pending-sync items summary (used by SessionStart hook)").option("--pricing <file>", "compute USD cost estimate from a work item's draft_tokens").option("-v, --verbose", "show per-file drift detail").addHelpText("after", [
+  "",
+  "Modes (mutually exclusive):",
+  "  --check-scaffold    Compute drift for all tracked scaffold files.",
+  "                      Writes .cleargate/.drift-state.json.",
+  "  --session-start     List blocked pending-sync items (\u226410, \u2264100 tokens).",
+  "  --pricing <file>    Compute USD estimate from a work item's draft_tokens.",
+  "  (default)           Print a minimal hook-config health report."
+].join("\n")).action(async (opts) => {
+  await doctorHandler({
+    checkScaffold: opts.checkScaffold,
+    sessionStartMode: opts.sessionStartMode,
+    sessionStart: opts.sessionStart,
+    pricing: !!opts.pricing,
+    pricingFile: opts.pricing,
+    verbose: opts.verbose
+  });
+});
+program.command("upgrade").description("three-way merge scaffold files with upstream changes").option("--dry-run", "print plan without making any changes").option("--yes", 'auto-accept "take theirs" for all merge-3way files (non-interactive)').option("--only <tier>", "restrict to a specific scaffold tier (protocol/template/agent/hook/skill/cli-config)").addHelpText("after", [
+  "",
+  "Overwrite policies:",
+  "  always      \u2014 silent overwrite with package content",
+  "  never       \u2014 silent skip",
+  "  preserve    \u2014 silent skip",
+  "  merge-3way  \u2014 interactive: [k]eep mine / [t]ake theirs / [e]dit in $EDITOR",
+  "",
+  "--yes auto-accepts [t]ake theirs for all merge-3way files."
+].join("\n")).action(async (opts) => {
+  await upgradeHandler({ dryRun: opts.dryRun, yes: opts.yes, only: opts.only });
+});
+program.command("uninstall").description("remove ClearGate scaffold from a project (preservation-first)").option("--dry-run", "preview planned actions without making any changes (CI-safe)").option("--preserve <tiers>", "comma-separated tier ids to force-preserve (default: user-artifact)").option("--remove <tiers>", 'comma-separated tier ids to force-remove; use "all" to remove everything including user artifacts (DANGEROUS)').option("--yes", "skip typed project-name confirmation (dangerous \u2014 use in scripts/CI)").option("--path <dir>", "target directory (must contain .cleargate/.install-manifest.json); defaults to cwd").option("--force", "bypass uncommitted-changes safety check (not applicable for non-git targets)").addHelpText("after", [
+  "",
+  "Preservation defaults:",
+  "  user-artifact tier  \u2192 kept (FLASHCARD.md, archive, pending-sync, sprint REPORT.md)",
+  "  framework tiers     \u2192 removed (protocol, template, agent, hook, skill, cli-config)",
+  "",
+  "Always removed (no prompt): .claude/agents/*.md, ClearGate hooks,",
+  "  .claude/skills/flashcard/, CLAUDE.md CLEARGATE block,",
+  "  @cleargate/cli from package.json, .install-manifest.json, .drift-state.json.",
+  "",
+  "Non-git targets: uncommitted-changes check is skipped silently."
+].join("\n")).action(async (opts) => {
+  await uninstallHandler({
+    dryRun: opts.dryRun,
+    preserve: opts.preserve ? opts.preserve.split(",").map((s) => s.trim()) : void 0,
+    remove: opts.remove ? opts.remove.split(",").map((s) => s.trim()) : void 0,
+    yes: opts.yes,
+    path: opts.path,
+    force: opts.force
+  });
+});
 void program.parseAsync(process.argv);
 //# sourceMappingURL=cli.js.map