@zettelgeist/cli 0.1.0

package/dist/bin.js

@@ -0,0 +1,2211 @@
+#!/usr/bin/env node
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/output.ts
+function okEnvelope(data) {
+  return { ok: true, data };
+}
+function errorEnvelope(message, detail) {
+  if (detail === void 0) return { ok: false, error: { message } };
+  return { ok: false, error: { message, detail } };
+}
+function emit(ctx, env, humanRender) {
+  if (ctx.json) {
+    ctx.writeStdout(JSON.stringify(env) + "\n");
+    return;
+  }
+  if (env.ok) {
+    ctx.writeStdout(humanRender() + "\n");
+  } else {
+    ctx.writeStderr(`error: ${env.error.message}
+`);
+  }
+}
+var realEmitContext;
+var init_output = __esm({
+  "src/output.ts"() {
+    "use strict";
+    realEmitContext = (json) => ({
+      json,
+      writeStdout: (s) => process.stdout.write(s),
+      writeStderr: (s) => process.stderr.write(s)
+    });
+  }
+});
+
+// ../core/src/types.js
+var init_types = __esm({
+  "../core/src/types.js"() {
+    "use strict";
+  }
+});
+
+// ../core/src/frontmatter.js
+import matter from "gray-matter";
+function parseFrontmatter(text) {
+  try {
+    const parsed = matter(text, {});
+    return {
+      data: parsed.data ?? {},
+      body: parsed.content,
+      error: null
+    };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      data: {},
+      body: text,
+      error: { code: "E_INVALID_FRONTMATTER", detail }
+    };
+  }
+}
+var init_frontmatter = __esm({
+  "../core/src/frontmatter.js"() {
+    "use strict";
+  }
+});
+
+// ../core/src/tasks.js
+function parseTasks(body) {
+  const tasks = [];
+  const lines = body.split("\n");
+  let index = 0;
+  for (const line of lines) {
+    const m = line.match(TASK_LINE);
+    if (!m)
+      continue;
+    index += 1;
+    const checked = m[1] !== " ";
+    let text = (m[2] ?? "").trim();
+    text = text.replace(NUMERIC_PREFIX, "");
+    const tags = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const word of text.split(/\s+/)) {
+      if (KNOWN_TAGS.has(word) && !seen.has(word)) {
+        tags.push(word);
+        seen.add(word);
+      }
+    }
+    const cleanedWords = text.split(/\s+/).filter((w) => !KNOWN_TAGS.has(w));
+    text = cleanedWords.join(" ").trim();
+    tasks.push({ index, checked, text, tags });
+  }
+  return tasks;
+}
+var TASK_LINE, NUMERIC_PREFIX, KNOWN_TAGS;
+var init_tasks = __esm({
+  "../core/src/tasks.js"() {
+    "use strict";
+    TASK_LINE = /^[\s>]*[-*+]\s+\[([ xX])\]\s+(.*)$/;
+    NUMERIC_PREFIX = /^\d+\.\s+/;
+    KNOWN_TAGS = /* @__PURE__ */ new Set(["#human-only", "#agent-only", "#skip"]);
+  }
+});
+
+// ../core/src/loader.js
+async function folderContainsMarkdown(fs11, dir) {
+  const entries = await fs11.readDir(dir);
+  for (const e of entries) {
+    if (e.isDir) {
+      if (await folderContainsMarkdown(fs11, `${dir}/${e.name}`))
+        return true;
+    } else if (e.name.endsWith(".md")) {
+      return true;
+    }
+  }
+  return false;
+}
+async function loadAllSpecs(fs11, specsDir = "specs") {
+  if (!await fs11.exists(specsDir))
+    return [];
+  const entries = await fs11.readDir(specsDir);
+  const specs = [];
+  for (const entry of entries) {
+    if (!entry.isDir)
+      continue;
+    if (!SPEC_NAME.test(entry.name))
+      continue;
+    const dir = `${specsDir}/${entry.name}`;
+    if (!await folderContainsMarkdown(fs11, dir))
+      continue;
+    const spec = await loadSpec(fs11, entry.name, specsDir);
+    specs.push(spec);
+  }
+  specs.sort((a, b) => a.name.localeCompare(b.name));
+  return specs;
+}
+async function loadSpec(fs11, name, specsDir = "specs") {
+  const root = `${specsDir}/${name}`;
+  const requirementsPath = `${root}/requirements.md`;
+  const tasksPath = `${root}/tasks.md`;
+  const handoffPath = `${root}/handoff.md`;
+  const lensesDir = `${root}/lenses`;
+  let frontmatter = {};
+  let requirements = null;
+  if (await fs11.exists(requirementsPath)) {
+    const raw = await fs11.readFile(requirementsPath);
+    const parsed = parseFrontmatter(raw);
+    frontmatter = parsed.data;
+    requirements = parsed.body;
+  }
+  let tasks = [];
+  if (await fs11.exists(tasksPath)) {
+    const raw = await fs11.readFile(tasksPath);
+    const parsed = parseFrontmatter(raw);
+    tasks = parseTasks(parsed.body);
+  }
+  let handoff = null;
+  if (await fs11.exists(handoffPath)) {
+    handoff = await fs11.readFile(handoffPath);
+  }
+  const lenses = /* @__PURE__ */ new Map();
+  if (await fs11.exists(lensesDir)) {
+    const lensEntries = await fs11.readDir(lensesDir);
+    for (const e of lensEntries) {
+      if (e.isDir)
+        continue;
+      if (!e.name.endsWith(".md"))
+        continue;
+      const key = e.name.replace(/\.md$/, "");
+      lenses.set(key, await fs11.readFile(`${lensesDir}/${e.name}`));
+    }
+  }
+  return { name, frontmatter, requirements, tasks, handoff, lenses };
+}
+var SPEC_NAME;
+var init_loader = __esm({
+  "../core/src/loader.js"() {
+    "use strict";
+    init_frontmatter();
+    init_tasks();
+    SPEC_NAME = /^[a-z0-9-]+$/;
+  }
+});
+
+// ../core/src/status.js
+function isCounted(task) {
+  return !task.tags.includes("#skip");
+}
+function deriveStatus(spec, repo) {
+  const fm = spec.frontmatter.status;
+  if (typeof fm === "string" && VALID_STATUSES.has(fm)) {
+    return fm;
+  }
+  const counted = spec.tasks.filter(isCounted);
+  const claimed = repo.claimedSpecs.has(spec.name);
+  const merged = repo.mergedSpecs.has(spec.name);
+  if (counted.length === 0) {
+    return claimed ? "in-progress" : "draft";
+  }
+  const allChecked = counted.every((t) => t.checked);
+  const anyChecked = counted.some((t) => t.checked);
+  if (allChecked)
+    return merged ? "done" : "in-review";
+  if (anyChecked || claimed)
+    return "in-progress";
+  return "planned";
+}
+var VALID_STATUSES;
+var init_status = __esm({
+  "../core/src/status.js"() {
+    "use strict";
+    VALID_STATUSES = /* @__PURE__ */ new Set([
+      "draft",
+      "planned",
+      "in-progress",
+      "in-review",
+      "done",
+      "blocked",
+      "cancelled"
+    ]);
+  }
+});
+
+// ../core/src/graph.js
+function buildGraph(specs) {
+  const nameSet = new Set(specs.map((s) => s.name));
+  const nodes = specs.map((s) => ({
+    name: s.name,
+    partOf: typeof s.frontmatter.part_of === "string" ? s.frontmatter.part_of : null
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  const edges = [];
+  for (const s of specs) {
+    const deps = s.frontmatter.depends_on;
+    if (!Array.isArray(deps))
+      continue;
+    const seen = /* @__PURE__ */ new Set();
+    for (const d of deps) {
+      if (typeof d !== "string")
+        continue;
+      if (!nameSet.has(d))
+        continue;
+      if (seen.has(d))
+        continue;
+      seen.add(d);
+      edges.push({ from: s.name, to: d });
+    }
+  }
+  edges.sort((a, b) => a.from === b.from ? a.to.localeCompare(b.to) : a.from.localeCompare(b.from));
+  const blocks = edges.map((e) => ({ from: e.to, to: e.from })).sort((a, b) => a.from === b.from ? a.to.localeCompare(b.to) : a.from.localeCompare(b.from));
+  const cycles = detectCycles(specs.map((s) => s.name).sort(), edges);
+  return { nodes, edges, blocks, cycles };
+}
+function detectCycles(orderedNames, edges) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const n of orderedNames)
+    adj.set(n, []);
+  for (const e of edges)
+    adj.get(e.from)?.push(e.to);
+  for (const list of adj.values())
+    list.sort();
+  const cycles = [];
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function dfs(node) {
+    visited.add(node);
+    stack.push(node);
+    onStack.add(node);
+    for (const next of adj.get(node) ?? []) {
+      if (onStack.has(next)) {
+        const startIdx = stack.indexOf(next);
+        const raw = stack.slice(startIdx);
+        const canonical = canonicalize(raw);
+        const key = canonical.join("|");
+        if (!seen.has(key)) {
+          seen.add(key);
+          cycles.push(canonical);
+        }
+      } else if (!visited.has(next)) {
+        dfs(next);
+      }
+    }
+    stack.pop();
+    onStack.delete(node);
+  }
+  for (const n of orderedNames) {
+    if (!visited.has(n))
+      dfs(n);
+  }
+  cycles.sort((a, b) => a.join("|").localeCompare(b.join("|")));
+  return cycles;
+}
+function canonicalize(cycle) {
+  let minIdx = 0;
+  for (let i = 1; i < cycle.length; i += 1) {
+    if (cycle[i] < cycle[minIdx])
+      minIdx = i;
+  }
+  return cycle.slice(minIdx).concat(cycle.slice(0, minIdx));
+}
+var init_graph = __esm({
+  "../core/src/graph.js"() {
+    "use strict";
+  }
+});
+
+// ../core/src/validate.js
+async function validateRepo(fs11, specsDir = "specs") {
+  const errors = [];
+  if (!await fs11.exists(specsDir)) {
+    return { errors };
+  }
+  const entries = await fs11.readDir(specsDir);
+  for (const e of entries) {
+    if (!e.isDir)
+      continue;
+    const hasMarkdown = await folderContainsMarkdown(fs11, `${specsDir}/${e.name}`);
+    if (!hasMarkdown) {
+      errors.push({ code: "E_EMPTY_SPEC", path: `${specsDir}/${e.name}` });
+    }
+  }
+  for (const e of entries) {
+    if (!e.isDir)
+      continue;
+    const reqPath = `${specsDir}/${e.name}/requirements.md`;
+    if (!await fs11.exists(reqPath))
+      continue;
+    const raw = await fs11.readFile(reqPath);
+    const parsed = parseFrontmatter(raw);
+    if (parsed.error) {
+      errors.push({ code: "E_INVALID_FRONTMATTER", path: reqPath, detail: parsed.error.detail });
+    }
+  }
+  const specs = await loadAllSpecs(fs11, specsDir);
+  const graph = buildGraph(specs);
+  for (const cycle of graph.cycles) {
+    errors.push({ code: "E_CYCLE", path: cycle });
+  }
+  errors.sort(compareErrors);
+  return { errors };
+}
+function compareErrors(a, b) {
+  if (a.code !== b.code)
+    return a.code.localeCompare(b.code);
+  const aPath = Array.isArray(a.path) ? a.path.join("|") : a.path;
+  const bPath = Array.isArray(b.path) ? b.path.join("|") : b.path;
+  return aPath.localeCompare(bPath);
+}
+var init_validate = __esm({
+  "../core/src/validate.js"() {
+    "use strict";
+    init_graph();
+    init_frontmatter();
+    init_loader();
+  }
+});
+
+// ../core/src/regen.js
+function regenerateIndex(specs, repoState, existingIndex) {
+  const human = extractHumanRegion(existingIndex);
+  const auto = renderAutoRegion(specs, repoState);
+  if (human === "")
+    return `${MARKER}
+
+${auto}`;
+  return `${human}
+
+${MARKER}
+
+${auto}`;
+}
+function extractHumanRegion(existing) {
+  if (existing === null || existing === "")
+    return "";
+  const idx = existing.indexOf(MARKER);
+  if (idx === -1)
+    return existing.replace(/\n+$/, "");
+  return existing.slice(0, idx).replace(/\n+$/, "");
+}
+function renderAutoRegion(specs, repoState) {
+  if (specs.length === 0) {
+    return "## State\n\n_No specs._\n\n## Graph\n\n_No specs._\n";
+  }
+  return `${renderStateTable(specs, repoState)}
+${renderGraphBlock(specs)}`;
+}
+function renderStateTable(specs, repoState) {
+  const sorted = [...specs].sort((a, b) => a.name.localeCompare(b.name));
+  const rows = sorted.map((s) => {
+    const status = deriveStatus(s, repoState);
+    const progress = renderProgress(s);
+    const blockedBy = renderBlockedBy(s);
+    return `| ${s.name} | ${status} | ${progress} | ${blockedBy} |`;
+  });
+  return [
+    "## State",
+    "",
+    "| Spec | Status | Progress | Blocked by |",
+    "|------|--------|----------|------------|",
+    ...rows,
+    ""
+  ].join("\n");
+}
+function renderProgress(spec) {
+  const counted = spec.tasks.filter((t) => !t.tags.includes("#skip"));
+  const checked = counted.filter((t) => t.checked).length;
+  return `${checked}/${counted.length}`;
+}
+function renderBlockedBy(spec) {
+  const v = spec.frontmatter.blocked_by;
+  if (typeof v === "string" && v.trim() !== "")
+    return v.trim();
+  return "\u2014";
+}
+function renderGraphBlock(specs) {
+  const graph = buildGraph(specs);
+  const lines = ["## Graph", "", "```mermaid", "graph TD"];
+  for (const node of graph.nodes)
+    lines.push(`  ${node.name}`);
+  for (const edge of graph.edges)
+    lines.push(`  ${edge.from} --> ${edge.to}`);
+  lines.push("```");
+  lines.push("");
+  return lines.join("\n");
+}
+var MARKER;
+var init_regen = __esm({
+  "../core/src/regen.js"() {
+    "use strict";
+    init_graph();
+    init_status();
+    MARKER = "<!-- ZETTELGEIST:AUTO-GENERATED BELOW \u2014 do not edit -->";
+  }
+});
+
+// ../core/src/config.js
+import yaml from "js-yaml";
+async function loadConfig(fs11) {
+  const errors = [];
+  const defaults = { formatVersion: null, specsDir: "specs" };
+  const raw = await fs11.readFile(CONFIG_PATH);
+  let parsed;
+  try {
+    parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    errors.push({ code: "E_INVALID_FRONTMATTER", path: CONFIG_PATH, detail });
+    return { config: defaults, errors };
+  }
+  const obj = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  const fv = obj["format_version"];
+  let formatVersion = null;
+  if (typeof fv === "string") {
+    formatVersion = fv;
+  } else {
+    errors.push({
+      code: "E_INVALID_FRONTMATTER",
+      path: CONFIG_PATH,
+      detail: "format_version must be a string"
+    });
+  }
+  let specsDir = "specs";
+  if ("specs_dir" in obj) {
+    const sd = obj["specs_dir"];
+    if (typeof sd === "string") {
+      specsDir = sd;
+    } else {
+      errors.push({
+        code: "E_INVALID_FRONTMATTER",
+        path: CONFIG_PATH,
+        detail: "specs_dir must be a string"
+      });
+    }
+  }
+  return { config: { formatVersion, specsDir }, errors };
+}
+var CONFIG_PATH;
+var init_config = __esm({
+  "../core/src/config.js"() {
+    "use strict";
+    CONFIG_PATH = ".zettelgeist.yaml";
+  }
+});
+
+// ../core/src/index.ts
+async function runConformance(fs11) {
+  if (!await fs11.exists(".zettelgeist.yaml")) {
+    throw new Error("not a zettelgeist repo (missing .zettelgeist.yaml)");
+  }
+  const cfg = await loadConfig(fs11);
+  const specsDir = cfg.config.specsDir;
+  const specs = await loadAllSpecs(fs11, specsDir);
+  const repoState = { claimedSpecs: /* @__PURE__ */ new Set(), mergedSpecs: /* @__PURE__ */ new Set() };
+  const validation = await validateRepo(fs11, specsDir);
+  const graph = buildGraph(specs);
+  const statuses = {};
+  for (const s of specs) statuses[s.name] = deriveStatus(s, repoState);
+  const indexPath = `${specsDir}/INDEX.md`;
+  let existingIndex = null;
+  if (await fs11.exists(indexPath)) {
+    existingIndex = await fs11.readFile(indexPath);
+  }
+  const index = regenerateIndex(specs, repoState, existingIndex);
+  const errors = [...cfg.errors, ...validation.errors].sort(compareErrors);
+  return {
+    statuses: { specs: statuses },
+    graph: { nodes: graph.nodes, edges: graph.edges, cycles: graph.cycles },
+    validation: { errors },
+    index
+  };
+}
+var init_src = __esm({
+  "../core/src/index.ts"() {
+    "use strict";
+    init_types();
+    init_frontmatter();
+    init_tasks();
+    init_loader();
+    init_status();
+    init_graph();
+    init_validate();
+    init_regen();
+    init_config();
+    init_loader();
+    init_status();
+    init_graph();
+    init_validate();
+    init_regen();
+    init_config();
+  }
+});
+
+// ../fs-adapters/src/mem.ts
+var init_mem = __esm({
+  "../fs-adapters/src/mem.ts"() {
+    "use strict";
+  }
+});
+
+// ../fs-adapters/src/disk.ts
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+function makeDiskFsReader(rootDir) {
+  const resolve6 = (p) => path.join(rootDir, p);
+  return {
+    async readDir(p) {
+      const entries = await fs.readdir(resolve6(p), { withFileTypes: true });
+      return entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+    },
+    async readFile(p) {
+      return fs.readFile(resolve6(p), "utf8");
+    },
+    async exists(p) {
+      try {
+        await fs.stat(resolve6(p));
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+var init_disk = __esm({
+  "../fs-adapters/src/disk.ts"() {
+    "use strict";
+  }
+});
+
+// ../fs-adapters/src/index.ts
+var init_src2 = __esm({
+  "../fs-adapters/src/index.ts"() {
+    "use strict";
+    init_mem();
+    init_disk();
+  }
+});
+
+// src/commands/regen.ts
+var regen_exports = {};
+__export(regen_exports, {
+  HELP: () => HELP,
+  regenCommand: () => regenCommand
+});
+import { promises as fs2 } from "node:fs";
+import * as path2 from "node:path";
+async function getSpecsTreeSha(repoPath, specsDir) {
+  try {
+    const hash = await hashWorkingTree(repoPath, specsDir);
+    return hash;
+  } catch {
+    return null;
+  }
+}
+async function hashWorkingTree(repoPath, specsDir) {
+  const root = path2.join(repoPath, specsDir);
+  const entries = [];
+  const { createHash } = await import("node:crypto");
+  await walk2(root, "");
+  entries.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+  const h = createHash("sha1");
+  for (const e of entries) h.update(`${e.rel}\0${e.sha}
+`);
+  return h.digest("hex");
+  async function walk2(absDir, relDir) {
+    let names;
+    try {
+      names = await fs2.readdir(absDir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      if (name === ".git" || name === "node_modules" || name === ".claim") continue;
+      if (relDir === "" && name === "INDEX.md") continue;
+      const abs = path2.join(absDir, name);
+      const rel = relDir ? `${relDir}/${name}` : name;
+      let stat;
+      try {
+        stat = await fs2.stat(abs);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        await walk2(abs, rel);
+      } else if (stat.isFile()) {
+        const content = await fs2.readFile(abs);
+        const sha = createHash("sha1").update(content).digest("hex");
+        entries.push({ rel, sha });
+      }
+    }
+  }
+}
+async function readCache(repoPath) {
+  try {
+    const raw = await fs2.readFile(path2.join(repoPath, ".zettelgeist", "regen-cache.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.tree_sha !== "string" || typeof parsed.generated_index !== "string") return null;
+    return { tree_sha: parsed.tree_sha, generated_index: parsed.generated_index };
+  } catch {
+    return null;
+  }
+}
+async function writeCache(repoPath, entry) {
+  const dir = path2.join(repoPath, ".zettelgeist");
+  await fs2.mkdir(dir, { recursive: true });
+  const tmp = path2.join(dir, "regen-cache.json.tmp");
+  await fs2.writeFile(tmp, JSON.stringify(entry, null, 2) + "\n", "utf8");
+  await fs2.rename(tmp, path2.join(dir, "regen-cache.json"));
+}
+async function regenCommand(input) {
+  const reader = makeDiskFsReader(input.path);
+  if (!await reader.exists(".zettelgeist.yaml")) {
+    return errorEnvelope(`not a zettelgeist repo: ${input.path}`);
+  }
+  const cfg = await loadConfig(reader);
+  const specsDir = cfg.config.specsDir;
+  const indexAbsPath = path2.join(input.path, specsDir, "INDEX.md");
+  const indexRelPath = path2.posix.join(specsDir, "INDEX.md");
+  const treeSha = await getSpecsTreeSha(input.path, specsDir);
+  let generated = null;
+  let cacheHit = false;
+  if (treeSha) {
+    const cache = await readCache(input.path);
+    if (cache && cache.tree_sha === treeSha) {
+      generated = cache.generated_index;
+      cacheHit = true;
+    }
+  }
+  if (generated === null) {
+    let result;
+    try {
+      result = await runConformance(reader);
+    } catch (err) {
+      return errorEnvelope(err instanceof Error ? err.message : String(err));
+    }
+    generated = result.index;
+    if (treeSha) {
+      await writeCache(input.path, { tree_sha: treeSha, generated_index: generated });
+    }
+  }
+  let onDisk = null;
+  try {
+    onDisk = await fs2.readFile(indexAbsPath, "utf8");
+  } catch {
+  }
+  if (onDisk === generated) {
+    return okEnvelope({ changed: false, path: indexRelPath, cacheHit });
+  }
+  if (input.check) {
+    return errorEnvelope(onDisk === null ? `${indexRelPath} is missing` : `${indexRelPath} is stale`);
+  }
+  await fs2.mkdir(path2.dirname(indexAbsPath), { recursive: true });
+  const tmpPath = `${indexAbsPath}.tmp`;
+  await fs2.writeFile(tmpPath, generated, "utf8");
+  await fs2.rename(tmpPath, indexAbsPath);
+  return okEnvelope({ changed: true, path: indexRelPath, cacheHit });
+}
+var HELP;
+var init_regen2 = __esm({
+  "src/commands/regen.ts"() {
+    "use strict";
+    init_src();
+    init_src2();
+    init_output();
+    HELP = `zettelgeist regen [--check] [--json]
+
+  Regenerate <specs_dir>/INDEX.md from the spec content in the current repo.
+
+  Flags:
+    --check        Exit 1 if INDEX.md is stale or missing instead of writing.
+    --json         Emit a machine-readable JSON envelope.
+
+  Caches generated INDEX content keyed by the git tree SHA at
+  .zettelgeist/regen-cache.json so repeat runs are fast.
+`;
+  }
+});
+
+// src/commands/validate.ts
+var validate_exports = {};
+__export(validate_exports, {
+  HELP: () => HELP2,
+  validateCommand: () => validateCommand
+});
+async function validateCommand(input) {
+  const reader = makeDiskFsReader(input.path);
+  if (!await reader.exists(".zettelgeist.yaml")) {
+    return errorEnvelope(`not a zettelgeist repo: ${input.path}`);
+  }
+  const cfg = await loadConfig(reader);
+  const validation = await validateRepo(reader, cfg.config.specsDir);
+  const allErrors = [...cfg.errors, ...validation.errors];
+  if (allErrors.length === 0) return okEnvelope({ errors: [] });
+  const count = allErrors.length;
+  return errorEnvelope(
+    `${count} validation error${count === 1 ? "" : "s"}`,
+    { errors: allErrors }
+  );
+}
+var HELP2;
+var init_validate2 = __esm({
+  "src/commands/validate.ts"() {
+    "use strict";
+    init_src();
+    init_src2();
+    init_output();
+    HELP2 = `zettelgeist validate [--json]
+
+  Validate the current repo against the Zettelgeist format spec.
+
+  Reports a non-zero exit code if any validation errors are found.
+
+  Flags:
+    --json         Emit a machine-readable JSON envelope (with the full
+                   error list under .data.errors).
+`;
+  }
+});
+
+// ../git-hook/src/install-hook.ts
+import { promises as fs3 } from "node:fs";
+import * as path3 from "node:path";
+function mergeHookContent(existing) {
+  if (existing === null || existing === "") return HOOK_BLOCK + "\n";
+  const beginIdx = existing.indexOf(HOOK_MARKER_BEGIN);
+  const endIdx = existing.indexOf(HOOK_MARKER_END);
+  if (beginIdx !== -1 && endIdx !== -1 && endIdx > beginIdx) {
+    const before = existing.slice(0, beginIdx);
+    const after = existing.slice(endIdx + HOOK_MARKER_END.length);
+    return before + HOOK_BLOCK + after;
+  }
+  const shebangMatch = existing.match(SHEBANG_RE);
+  const stripped = shebangMatch ? existing.slice(shebangMatch[0].length).trim() : existing.trim();
+  if (stripped === "") {
+    return existing + HOOK_BLOCK + "\n";
+  }
+  throw new Error(
+    "pre-commit hook contains non-marker content; refuse to overwrite. Use --force to back it up to pre-commit.before-zettelgeist and replace, or merge the marker block manually."
+  );
+}
+async function installPreCommitHook(repoRoot, options = {}) {
+  const hookDir = path3.join(repoRoot, ".git", "hooks");
+  const hookPath = path3.join(hookDir, "pre-commit");
+  await fs3.mkdir(hookDir, { recursive: true });
+  let existing = null;
+  try {
+    existing = await fs3.readFile(hookPath, "utf8");
+  } catch {
+  }
+  let next;
+  let backup;
+  try {
+    next = mergeHookContent(existing);
+  } catch (err) {
+    if (!options.force) throw err;
+    backup = `${hookPath}.before-zettelgeist`;
+    if (existing !== null) await fs3.writeFile(backup, existing, "utf8");
+    next = HOOK_BLOCK + "\n";
+  }
+  await fs3.writeFile(hookPath, next, "utf8");
+  await fs3.chmod(hookPath, 493);
+  return backup ? { installed: true, backup } : { installed: true };
+}
+var HOOK_MARKER_BEGIN, HOOK_MARKER_END, HOOK_BLOCK, SHEBANG_RE;
+var init_install_hook = __esm({
+  "../git-hook/src/install-hook.ts"() {
+    "use strict";
+    HOOK_MARKER_BEGIN = "# >>> zettelgeist >>>";
+    HOOK_MARKER_END = "# <<< zettelgeist <<<";
+    HOOK_BLOCK = HOOK_MARKER_BEGIN + '\nif command -v zettelgeist >/dev/null 2>&1; then\n  zettelgeist regen --check\nelif [ -x ./node_modules/.bin/zettelgeist ]; then\n  ./node_modules/.bin/zettelgeist regen --check\nelse\n  echo "zettelgeist: not on PATH and not in ./node_modules/.bin \u2014 install it or remove this hook" >&2\n  exit 1\nfi\n' + HOOK_MARKER_END;
+    SHEBANG_RE = /^#!\s*\/[^\n]*\n/;
+  }
+});
+
+// ../git-hook/src/index.ts
+var init_src3 = __esm({
+  "../git-hook/src/index.ts"() {
+    "use strict";
+    init_install_hook();
+  }
+});
+
+// src/git.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+async function gitRepoRoot(cwd) {
+  const { stdout } = await execFileP("git", ["rev-parse", "--show-toplevel"], { cwd });
+  return stdout.trim();
+}
+var execFileP;
+var init_git = __esm({
+  "src/git.ts"() {
+    "use strict";
+    init_src3();
+    execFileP = promisify(execFile);
+  }
+});
+
+// src/commands/install-hook.ts
+var install_hook_exports = {};
+__export(install_hook_exports, {
+  HELP: () => HELP3,
+  installHookCommand: () => installHookCommand
+});
+async function installHookCommand(input) {
+  const reader = makeDiskFsReader(input.path);
+  if (!await reader.exists(".zettelgeist.yaml")) {
+    return errorEnvelope(`not a zettelgeist repo: ${input.path}`);
+  }
+  let repoRoot;
+  try {
+    repoRoot = await gitRepoRoot(input.path);
+  } catch {
+    return errorEnvelope(`${input.path} is not a git repo`);
+  }
+  try {
+    const result = await installPreCommitHook(repoRoot, { force: input.force });
+    return okEnvelope({ installed: true, ...result.backup ? { backup: result.backup } : {} });
+  } catch (err) {
+    return errorEnvelope(err instanceof Error ? err.message : String(err));
+  }
+}
+var HELP3;
+var init_install_hook2 = __esm({
+  "src/commands/install-hook.ts"() {
+    "use strict";
+    init_src2();
+    init_output();
+    init_git();
+    HELP3 = `zettelgeist install-hook [--force] [--json]
+
+  Install the Zettelgeist pre-commit hook into the current git repo.
+
+  The hook runs \`regen --check\` before each commit so INDEX.md never
+  drifts from the specs on disk. If a pre-existing hook is found it is
+  smart-merged or backed up.
+
+  Flags:
+    --force        Overwrite an existing hook (a backup is still written).
+    --json         Emit a machine-readable JSON envelope.
+`;
+  }
+});
+
+// src/commands/install-skill.ts
+var install_skill_exports = {};
+__export(install_skill_exports, {
+  HELP: () => HELP4,
+  installSkillCommand: () => installSkillCommand,
+  isScope: () => isScope,
+  stripFrontmatter: () => stripFrontmatter
+});
+import { promises as fs4 } from "node:fs";
+import * as os from "node:os";
+import * as path4 from "node:path";
+import { fileURLToPath } from "node:url";
+function isScope(s) {
+  return SCOPES.has(s);
+}
+async function locateBundledSkill() {
+  const here2 = path4.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path4.join(here2, "templates", "skill", "SKILL.md"),
+    path4.join(here2, "..", "templates", "skill", "SKILL.md"),
+    path4.join(here2, "..", "..", "templates", "skill", "SKILL.md")
+  ];
+  for (const c of candidates) {
+    try {
+      await fs4.access(c);
+      return c;
+    } catch {
+    }
+  }
+  throw new Error("bundled SKILL.md not found \u2014 reinstall @zettelgeist/cli");
+}
+function resolveDest(input) {
+  if (input.scope === "user") {
+    return path4.join(
+      input.homeDir ?? os.homedir(),
+      ".claude",
+      "skills",
+      "zettelgeist",
+      "SKILL.md"
+    );
+  }
+  if (input.scope === "project") {
+    return path4.join(input.cwd, ".claude", "skills", "zettelgeist", "SKILL.md");
+  }
+  return path4.join(input.cwd, "AGENTS.md");
+}
+function stripFrontmatter(skill) {
+  if (!skill.startsWith("---\n")) return skill;
+  const end = skill.indexOf("\n---\n", 4);
+  if (end === -1) return skill;
+  return skill.slice(end + 5).replace(/^\n+/, "");
+}
+function renderAgentsRegion(skillBody) {
+  return `${AGENTS_BEGIN}
+
+${skillBody.trimEnd()}
+
+${AGENTS_END}`;
+}
+function mergeAgentsMd(existing, skillBody, force) {
+  const begin = existing.indexOf(AGENTS_BEGIN);
+  const end = existing.indexOf(AGENTS_END);
+  if (begin === -1 && end === -1) {
+    const sep5 = existing.endsWith("\n") ? "\n" : "\n\n";
+    return { content: `${existing}${sep5}${renderAgentsRegion(skillBody)}
+`, merged: true };
+  }
+  if (begin === -1 || end === -1 || end < begin) {
+    if (!force) {
+      throw new Error(
+        "AGENTS.md has a malformed ZETTELGEIST marker pair \u2014 fix manually or re-run with --force to recover"
+      );
+    }
+    let stripped = existing.split("\n").filter((line) => !line.includes(AGENTS_BEGIN) && !line.includes(AGENTS_END)).join("\n").replace(/\n{3,}/g, "\n\n").replace(/\n+$/, "");
+    if (stripped.length === 0) stripped = "";
+    const sep5 = stripped.length === 0 ? "" : "\n\n";
+    return { content: `${stripped}${sep5}${renderAgentsRegion(skillBody)}
+`, merged: true };
+  }
+  const before = existing.slice(0, begin).replace(/\n+$/, "");
+  const after = existing.slice(end + AGENTS_END.length).replace(/^\n+/, "");
+  const middle = renderAgentsRegion(skillBody);
+  const joined = [before, middle, after].filter((s) => s.length > 0).join("\n\n");
+  return { content: `${joined}
+`, merged: true };
+}
+async function installSkillCommand(input) {
+  let source;
+  try {
+    source = await locateBundledSkill();
+  } catch (err) {
+    return errorEnvelope(err instanceof Error ? err.message : String(err));
+  }
+  let skill;
+  try {
+    skill = await fs4.readFile(source, "utf8");
+  } catch (err) {
+    return errorEnvelope(err instanceof Error ? err.message : String(err));
+  }
+  const dest = resolveDest(input);
+  if (input.scope === "agents-md") {
+    let existing = null;
+    try {
+      existing = await fs4.readFile(dest, "utf8");
+    } catch {
+    }
+    const body = stripFrontmatter(skill);
+    try {
+      if (existing === null) {
+        await fs4.writeFile(dest, `${renderAgentsRegion(body)}
+`, "utf8");
+        return okEnvelope({ installed: true, path: dest, scope: input.scope });
+      }
+      const merged = mergeAgentsMd(existing, body, input.force);
+      await fs4.writeFile(dest, merged.content, "utf8");
+      return okEnvelope({ installed: true, path: dest, scope: input.scope, merged: merged.merged });
+    } catch (err) {
+      return errorEnvelope(err instanceof Error ? err.message : String(err));
+    }
+  }
+  try {
+    await fs4.access(dest);
+    if (!input.force) {
+      return errorEnvelope(`${dest} already exists. Re-run with --force to overwrite.`);
+    }
+  } catch {
+  }
+  try {
+    await fs4.mkdir(path4.dirname(dest), { recursive: true });
+    await fs4.writeFile(dest, skill, "utf8");
+  } catch (err) {
+    return errorEnvelope(err instanceof Error ? err.message : String(err));
+  }
+  return okEnvelope({ installed: true, path: dest, scope: input.scope });
+}
+var HELP4, SCOPES, AGENTS_BEGIN, AGENTS_END;
+var init_install_skill = __esm({
+  "src/commands/install-skill.ts"() {
+    "use strict";
+    init_output();
+    HELP4 = `zettelgeist install-skill [--scope user|project|agents-md] [--force] [--json]
+
+  Install the Zettelgeist agent skill so coding agents pick it up
+  automatically when working in this repo.
+
+  Scopes:
+    user        ~/.claude/skills/zettelgeist/SKILL.md
+                Claude Code (CLI + VS Code), global. Default.
+    project     <cwd>/.claude/skills/zettelgeist/SKILL.md
+                Claude Code, per-repo. Commit this for the whole team.
+    agents-md   <cwd>/AGENTS.md
+                Cross-tool convention read by Codex, Copilot CLI, and
+                Claude Code as a fallback. Smart-merge: if AGENTS.md
+                exists, only the region between
+                  <!-- ZETTELGEIST:SKILL-BEGIN -->
+                  <!-- ZETTELGEIST:SKILL-END -->
+                is replaced; anything else is preserved.
+
+  Flags:
+    --scope SCOPE  Where to install. Defaults to "user".
+    --force        For user/project: overwrite an existing SKILL.md.
+                   For agents-md: recover from a malformed marker pair
+                   (strip the orphan markers and append a clean region).
+                   Normal smart-merges happen without --force.
+    --json         Emit a machine-readable JSON envelope.
+
+  The skill is a workflow guide: claim \u2192 read \u2192 mutate \u2192 handoff \u2192
+  release, plus the v0.1 format rules an agent will otherwise
+  rediscover by trial and error.
+`;
+    SCOPES = /* @__PURE__ */ new Set(["user", "project", "agents-md"]);
+    AGENTS_BEGIN = "<!-- ZETTELGEIST:SKILL-BEGIN \u2014 managed by `zettelgeist install-skill` -->";
+    AGENTS_END = "<!-- ZETTELGEIST:SKILL-END -->";
+  }
+});
+
+// src/handlers/util.ts
+import * as path5 from "node:path";
+function safeJoin(parentDir, ...segments) {
+  const resolved = path5.resolve(parentDir, ...segments);
+  const parent = path5.resolve(parentDir);
+  if (resolved !== parent && !resolved.startsWith(parent + path5.sep)) {
+    throw new PathTraversalError(`path escapes ${parent}: ${resolved}`);
+  }
+  return resolved;
+}
+function sendJson(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(body));
+}
+function sendText(res, status, body, contentType = "text/plain") {
+  res.writeHead(status, { "Content-Type": `${contentType}; charset=utf-8` });
+  res.end(body);
+}
+function sendNotFound(res) {
+  sendJson(res, 404, { ok: false, error: { message: "not found" } });
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+var PathTraversalError;
+var init_util = __esm({
+  "src/handlers/util.ts"() {
+    "use strict";
+    PathTraversalError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "PathTraversalError";
+      }
+    };
+  }
+});
+
+// src/handlers/specs.ts
+import { promises as fs5 } from "node:fs";
+import * as path6 from "node:path";
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import yaml2 from "js-yaml";
+import matter2 from "gray-matter";
+async function getContext(cwd) {
+  const reader = makeDiskFsReader(cwd);
+  const cfg = await loadConfig(reader);
+  return { cwd, specsDir: cfg.config.specsDir };
+}
+async function handleSpecsRoute(req, res, cwd, pathname) {
+  try {
+    return await dispatchSpecsRoute(req, res, cwd, pathname);
+  } catch (err) {
+    if (err instanceof PathTraversalError) {
+      sendJson(res, 403, { error: "forbidden" });
+      return;
+    }
+    throw err;
+  }
+}
+async function dispatchSpecsRoute(req, res, cwd, pathname) {
+  const ctx = await getContext(cwd);
+  if (pathname === "/api/specs" && req.method === "GET") {
+    return listSpecs(res, ctx);
+  }
+  const m = pathname.match(/^\/api\/specs\/([^/]+)(.*)$/);
+  if (!m) return sendNotFound(res);
+  const name = decodeURIComponent(m[1]);
+  const rest = m[2] ?? "";
+  const specsRoot = path6.resolve(ctx.cwd, ctx.specsDir);
+  safeJoin(specsRoot, name);
+  if (rest === "" && req.method === "GET") {
+    return readSpecDetail(res, ctx, name);
+  }
+  if (rest === "" && req.method === "DELETE") {
+    return deleteSpec(res, ctx, name);
+  }
+  const filesMatch = rest.match(/^\/files\/(.+)$/);
+  if (filesMatch) {
+    const relpath = decodeURIComponent(filesMatch[1]);
+    if (req.method === "GET") return readSpecFile(res, ctx, name, relpath);
+    if (req.method === "PUT") return writeSpecFile(req, res, ctx, name, relpath);
+    return sendNotFound(res);
+  }
+  const taskMatch = rest.match(/^\/tasks\/(\d+)\/(tick|untick)$/);
+  if (taskMatch && req.method === "POST") {
+    const n = parseInt(taskMatch[1], 10);
+    const op = taskMatch[2];
+    return tickTask(res, ctx, name, n, op === "tick");
+  }
+  if (rest === "/status" && req.method === "POST") {
+    return setStatus(req, res, ctx, name);
+  }
+  if (rest === "/frontmatter" && req.method === "PATCH") {
+    return patchFrontmatter(req, res, ctx, name);
+  }
+  if (rest === "/claim" && req.method === "POST") {
+    return claimSpec(req, res, ctx, name);
+  }
+  if (rest === "/release" && req.method === "POST") {
+    return releaseSpec(res, ctx, name);
+  }
+  if (rest === "/handoff" && req.method === "PUT") {
+    return writeHandoff(req, res, ctx, name);
+  }
+  return sendNotFound(res);
+}
+async function listSpecs(res, ctx) {
+  const reader = makeDiskFsReader(ctx.cwd);
+  const specs = await loadAllSpecs(reader, ctx.specsDir);
+  const repoState = { claimedSpecs: /* @__PURE__ */ new Set(), mergedSpecs: /* @__PURE__ */ new Set() };
+  const out = specs.map((s) => {
+    const counted = s.tasks.filter((t) => !t.tags.includes("#skip"));
+    const checked = counted.filter((t) => t.checked).length;
+    const blockedBy = stringOrNull(s.frontmatter.blocked_by);
+    return {
+      name: s.name,
+      status: deriveStatus(s, repoState),
+      progress: `${checked}/${counted.length}`,
+      blockedBy,
+      frontmatterStatus: statusOrNull(s.frontmatter.status),
+      pr: stringOrNull(s.frontmatter.pr),
+      branch: stringOrNull(s.frontmatter.branch),
+      worktree: stringOrNull(s.frontmatter.worktree)
+    };
+  });
+  sendJson(res, 200, out);
+}
+function stringOrNull(v) {
+  return typeof v === "string" && v.trim() !== "" ? v.trim() : null;
+}
+function statusOrNull(v) {
+  return typeof v === "string" && VALID_STATUSES2.has(v) ? v : null;
+}
+async function deleteSpec(res, ctx, name) {
+  const specDir = safeJoin(path6.resolve(ctx.cwd, ctx.specsDir), name);
+  const exists = await fs5.stat(specDir).then(() => true).catch(() => false);
+  if (!exists) {
+    sendJson(res, 404, { error: "spec not found" });
+    return;
+  }
+  try {
+    await fs5.rm(specDir, { recursive: true, force: true });
+  } catch (err) {
+    sendJson(res, 500, { error: err.message });
+    return;
+  }
+  const specRel = path6.relative(ctx.cwd, specDir).split(path6.sep).join("/");
+  const commit = await regenAndCommit(ctx, [specRel], `[zg] delete-spec: ${name}`);
+  sendJson(res, 200, { commit });
+}
+async function readSpecDetail(res, ctx, name) {
+  const reader = makeDiskFsReader(ctx.cwd);
+  try {
+    const spec = await loadSpec(reader, name, ctx.specsDir);
+    if (spec.requirements === null && spec.tasks.length === 0 && spec.handoff === null && spec.lenses.size === 0) {
+      sendJson(res, 404, { error: "spec not found" });
+      return;
+    }
+    sendJson(res, 200, {
+      name: spec.name,
+      frontmatter: spec.frontmatter,
+      requirements: spec.requirements,
+      tasks: spec.tasks.map((t) => ({ index: t.index, checked: t.checked, text: t.text, tags: [...t.tags] })),
+      handoff: spec.handoff,
+      lenses: Object.fromEntries(spec.lenses)
+    });
+  } catch (err) {
+    sendJson(res, 500, { error: err.message });
+  }
+}
+async function readSpecFile(res, ctx, name, relpath) {
+  const specDir = safeJoin(path6.resolve(ctx.cwd, ctx.specsDir), name);
+  const filepath = safeJoin(specDir, relpath);
+  try {
+    const content = await fs5.readFile(filepath, "utf8");
+    sendJson(res, 200, { content });
+  } catch (err) {
+    sendJson(res, 404, { error: err.message });
+  }
+}
+async function writeSpecFile(req, res, ctx, name, relpath) {
+  const body = await readBody(req);
+  if (!body || typeof body.content !== "string") {
+    sendJson(res, 400, { error: "body must be {content: string}" });
+    return;
+  }
+  const specDir = safeJoin(path6.resolve(ctx.cwd, ctx.specsDir), name);
+  const fileAbs = safeJoin(specDir, relpath);
+  const fileRel = path6.relative(ctx.cwd, fileAbs).split(path6.sep).join("/");
+  await fs5.mkdir(path6.dirname(fileAbs), { recursive: true });
+  const tmp = `${fileAbs}.tmp`;
+  await fs5.writeFile(tmp, body.content, "utf8");
+  await fs5.rename(tmp, fileAbs);
+  const commit = await regenAndCommit(ctx, [fileRel], `[zg] write: ${name}/${relpath}`);
+  sendJson(res, 200, { commit });
+}
+async function tickTask(res, ctx, name, n, checked) {
+  const specDir = safeJoin(path6.resolve(ctx.cwd, ctx.specsDir), name);
+  const tasksAbs = safeJoin(specDir, "tasks.md");
+  const tasksRel = path6.relative(ctx.cwd, tasksAbs).split(path6.sep).join("/");
+  let body;
+  try {
+    body = await fs5.readFile(tasksAbs, "utf8");
+  } catch {
+    sendJson(res, 404, { error: "spec or tasks.md not found" });
+    return;
+  }
+  const TASK_LINE2 = /^([\s>]*[-*+]\s+\[)([ xX])(\]\s+.*)$/;
+  const lines = body.split("\n");
+  let count = 0;
+  let mutated = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const m = lines[i]?.match(TASK_LINE2);
+    if (!m) continue;
+    count += 1;
+    if (count === n) {
+      lines[i] = m[1] + (checked ? "x" : " ") + m[3];
+      mutated = true;
+      break;
+    }
+  }
+  if (!mutated) {
+    sendJson(res, 400, { error: `no task at index ${n}` });
+    return;
+  }
+  const tmp = `${tasksAbs}.tmp`;
+  await fs5.writeFile(tmp, lines.join("\n"), "utf8");
+  await fs5.rename(tmp, tasksAbs);
+  const op = checked ? "tick" : "untick";
+  const commit = await regenAndCommit(ctx, [tasksRel], `[zg] ${op}: ${name}#${n}`);
+  sendJson(res, 200, { commit });
+}
+async function setStatus(req, res, ctx, name) {
+  const body = await readBody(req);
+  if (!body || body.status !== null && !ALLOWED_STATUSES.has(body.status)) {
+    sendJson(res, 400, {
+      error: "body.status must be one of draft, planned, in-progress, in-review, done, blocked, cancelled, or null"
+    });
+    return;
+  }
+  const specDir = safeJoin(path6.resolve(ctx.cwd, ctx.specsDir), name);
+  const reqAbs = safeJoin(specDir, "requirements.md");
+  const reqRel = path6.relative(ctx.cwd, reqAbs).split(path6.sep).join("/");
+  const raw = await fs5.readFile(reqAbs, "utf8").catch(() => "");
+  const parsed = matter2(raw, {});
+  const data = { ...parsed.data ?? {} };
+  if (body.status === null) {
+    delete data.status;
+    delete data.blocked_by;
+  } else {
+    data.status = body.status;
+    if (typeof body.reason === "string") data.blocked_by = body.reason;
+  }
+  const newFrontmatter = Object.keys(data).length > 0 ? `---
+${yaml2.dump(data)}---
+` : "";
+  const content = newFrontmatter + (parsed.content.startsWith("\n") ? parsed.content.slice(1) : parsed.content);
+  const tmp = `${reqAbs}.tmp`;
+  await fs5.mkdir(path6.dirname(reqAbs), { recursive: true });
+  await fs5.writeFile(tmp, content, "utf8");
+  await fs5.rename(tmp, reqAbs);
+  const commit = await regenAndCommit(ctx, [reqRel], `[zg] set-status: ${name}`);
+  sendJson(res, 200, { commit });
+}
+async function patchFrontmatter(req, res, ctx, name) {
+  const body = await readBody(req);
+  if (!body || typeof body.patch !== "object" || body.patch === null || Array.isArray(body.patch)) {
+    sendJson(res, 400, { error: "body must be {patch: {...}}" });
+    return;
+  }
+  for (const k of Object.keys(body.patch)) {
+    if (PATCH_FORBIDDEN_KEYS.has(k)) {
+      sendJson(res, 400, { error: `${k} cannot be set via frontmatter patch; use POST /status instead` });
+      return;
+    }
+  }
+  const specDir = safeJoin(path6.resolve(ctx.cwd, ctx.specsDir), name);
+  const reqAbs = safeJoin(specDir, "requirements.md");
+  const reqRel = path6.relative(ctx.cwd, reqAbs).split(path6.sep).join("/");
+  const raw = await fs5.readFile(reqAbs, "utf8").catch(() => "");
+  const parsed = matter2(raw, {});
+  const data = { ...parsed.data ?? {} };
+  for (const [k, v] of Object.entries(body.patch)) {
+    if (v === null) delete data[k];
+    else data[k] = v;
+  }
+  const newFrontmatter = Object.keys(data).length > 0 ? `---
+${yaml2.dump(data)}---
+` : "";
+  const content = newFrontmatter + (parsed.content.startsWith("\n") ? parsed.content.slice(1) : parsed.content);
+  await fs5.mkdir(path6.dirname(reqAbs), { recursive: true });
+  const tmp = `${reqAbs}.tmp`;
+  await fs5.writeFile(tmp, content, "utf8");
+  await fs5.rename(tmp, reqAbs);
+  const commit = await regenAndCommit(ctx, [reqRel], `[zg] patch-frontmatter: ${name}`);
+  sendJson(res, 200, { commit });
+}
+async function claimSpec(req, res, ctx, name) {
+  const body = await readBody(req);
+  const agentId = body?.agent_id ?? "agent";
+  const dir = safeJoin(path6.resolve(ctx.cwd, ctx.specsDir), name);
+  await fs5.mkdir(dir, { recursive: true });
+  await fs5.writeFile(safeJoin(dir, ".claim"), `${agentId}
+${(/* @__PURE__ */ new Date()).toISOString()}
+`, "utf8");
+  sendJson(res, 200, { acknowledged: true });
+}
+async function releaseSpec(res, ctx, name) {
+  const specDir = safeJoin(path6.resolve(ctx.cwd, ctx.specsDir), name);
+  const claimPath = safeJoin(specDir, ".claim");
+  await fs5.unlink(claimPath).catch((err) => {
+    if (err.code !== "ENOENT") throw err;
+  });
+  sendJson(res, 200, { acknowledged: true });
+}
+async function writeHandoff(req, res, ctx, name) {
+  const body = await readBody(req);
+  if (!body || typeof body.content !== "string") {
+    sendJson(res, 400, { error: "body must be {content: string}" });
+    return;
+  }
+  const specDir = safeJoin(path6.resolve(ctx.cwd, ctx.specsDir), name);
+  const handoffAbs = safeJoin(specDir, "handoff.md");
+  const handoffRel = path6.relative(ctx.cwd, handoffAbs).split(path6.sep).join("/");
+  await fs5.mkdir(path6.dirname(handoffAbs), { recursive: true });
+  const tmp = `${handoffAbs}.tmp`;
+  await fs5.writeFile(tmp, body.content, "utf8");
+  await fs5.rename(tmp, handoffAbs);
+  const commit = await regenAndCommit(ctx, [handoffRel], `[zg] handoff: ${name}`);
+  sendJson(res, 200, { commit });
+}
+async function regenAndCommit(ctx, files, message) {
+  const { regenCommand: regenCommand2 } = await Promise.resolve().then(() => (init_regen2(), regen_exports));
+  await regenCommand2({ path: ctx.cwd, check: false });
+  const indexRel = path6.posix.join(ctx.specsDir, "INDEX.md");
+  await execFileP2("git", ["add", ...files, indexRel], { cwd: ctx.cwd });
+  try {
+    await execFileP2("git", ["diff", "--cached", "--quiet"], { cwd: ctx.cwd });
+    const { stdout: stdout2 } = await execFileP2("git", ["rev-parse", "HEAD"], { cwd: ctx.cwd });
+    return stdout2.trim();
+  } catch {
+  }
+  await execFileP2("git", ["commit", "-m", message], { cwd: ctx.cwd });
+  const { stdout } = await execFileP2("git", ["rev-parse", "HEAD"], { cwd: ctx.cwd });
+  return stdout.trim();
+}
+var execFileP2, VALID_STATUSES2, ALLOWED_STATUSES, PATCH_FORBIDDEN_KEYS;
+var init_specs = __esm({
+  "src/handlers/specs.ts"() {
+    "use strict";
+    init_src();
+    init_src2();
+    init_util();
+    execFileP2 = promisify2(execFile2);
+    VALID_STATUSES2 = /* @__PURE__ */ new Set([
+      "draft",
+      "planned",
+      "in-progress",
+      "in-review",
+      "done",
+      "blocked",
+      "cancelled"
+    ]);
+    ALLOWED_STATUSES = /* @__PURE__ */ new Set([
+      "draft",
+      "planned",
+      "in-progress",
+      "in-review",
+      "done",
+      "blocked",
+      "cancelled"
+    ]);
+    PATCH_FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["status", "blocked_by"]);
+  }
+});
+
+// src/handlers/docs.ts
+import { promises as fs6 } from "node:fs";
+import * as path7 from "node:path";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+async function handleDocsRoute(req, res, cwd, pathname) {
+  if (pathname === "/api/docs" && req.method === "GET") {
+    return listDocs(res, cwd);
+  }
+  const renameMatch = pathname.match(/^\/api\/docs\/(.+)\/rename$/);
+  if (renameMatch && req.method === "POST") {
+    return renameDoc(req, res, cwd, decodeURIComponent(renameMatch[1]));
+  }
+  const m = pathname.match(/^\/api\/docs\/(.+)$/);
+  if (m) {
+    const relpath = decodeURIComponent(m[1]);
+    if (req.method === "GET") return readDoc(res, cwd, relpath);
+    if (req.method === "PUT") return writeDoc(req, res, cwd, relpath);
+  }
+  sendNotFound(res);
+}
+async function listDocs(res, cwd) {
+  const out = [];
+  for (const root of DOCS_ROOTS) {
+    const abs = path7.join(cwd, root);
+    const stat = await fs6.stat(abs).catch(() => null);
+    if (!stat) continue;
+    if (stat.isDirectory()) {
+      await walk(abs, cwd, out);
+    } else if (stat.isFile() && abs.endsWith(".md")) {
+      out.push({ path: root, title: await firstH1(abs) ?? root });
+    }
+  }
+  sendJson(res, 200, out);
+}
+async function walk(dir, cwd, out) {
+  const entries = await fs6.readdir(dir, { withFileTypes: true });
+  for (const e of entries) {
+    const full = path7.join(dir, e.name);
+    if (e.isDirectory()) {
+      await walk(full, cwd, out);
+    } else if (e.isFile() && e.name.endsWith(".md")) {
+      const rel = path7.relative(cwd, full).split(path7.sep).join("/");
+      out.push({ path: rel, title: await firstH1(full) ?? rel });
+    }
+  }
+}
+async function firstH1(file) {
+  try {
+    const content = await fs6.readFile(file, "utf8");
+    const m = content.match(/^#\s+(.+)$/m);
+    return m?.[1]?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+async function readDoc(res, cwd, relpath) {
+  const abs = guardPath(cwd, relpath);
+  if (!abs) {
+    sendJson(res, 403, { error: "forbidden" });
+    return;
+  }
+  try {
+    const content = await fs6.readFile(abs, "utf8");
+    sendJson(res, 200, {
+      source: content,
+      metadata: { title: await firstH1(abs) ?? relpath }
+    });
+  } catch (err) {
+    sendJson(res, 404, { error: err.message });
+  }
+}
+async function writeDoc(req, res, cwd, relpath) {
+  const body = await readBody(req);
+  if (!body || typeof body.content !== "string") {
+    sendJson(res, 400, { error: "body must be {content: string}" });
+    return;
+  }
+  const abs = guardPath(cwd, relpath);
+  if (!abs) {
+    sendJson(res, 403, { error: "forbidden" });
+    return;
+  }
+  await fs6.mkdir(path7.dirname(abs), { recursive: true });
+  const tmp = `${abs}.tmp`;
+  await fs6.writeFile(tmp, body.content, "utf8");
+  await fs6.rename(tmp, abs);
+  const rel = path7.relative(cwd, abs).split(path7.sep).join("/");
+  await execFileP3("git", ["add", rel], { cwd });
+  try {
+    await execFileP3("git", ["diff", "--cached", "--quiet"], { cwd });
+    const { stdout: stdout2 } = await execFileP3("git", ["rev-parse", "HEAD"], { cwd });
+    sendJson(res, 200, { commit: stdout2.trim() });
+    return;
+  } catch {
+  }
+  await execFileP3("git", ["commit", "-m", `[zg] write-doc: ${rel}`], { cwd });
+  const { stdout } = await execFileP3("git", ["rev-parse", "HEAD"], { cwd });
+  sendJson(res, 200, { commit: stdout.trim() });
+}
+async function renameDoc(req, res, cwd, oldRel) {
+  const body = await readBody(req);
+  if (!body || typeof body.newPath !== "string" || body.newPath.trim() === "") {
+    sendJson(res, 400, { error: "body must be {newPath: string}" });
+    return;
+  }
+  const oldAbs = guardPath(cwd, oldRel);
+  const newAbs = guardPath(cwd, body.newPath);
+  if (!oldAbs || !newAbs) {
+    sendJson(res, 403, { error: "forbidden" });
+    return;
+  }
+  const exists = await fs6.access(newAbs).then(() => true).catch(() => false);
+  if (exists) {
+    sendJson(res, 409, { error: "target exists" });
+    return;
+  }
+  try {
+    await fs6.mkdir(path7.dirname(newAbs), { recursive: true });
+    await fs6.rename(oldAbs, newAbs);
+  } catch (err) {
+    sendJson(res, 500, { error: err.message });
+    return;
+  }
+  const oldRelClean = path7.relative(cwd, oldAbs).split(path7.sep).join("/");
+  const newRelClean = path7.relative(cwd, newAbs).split(path7.sep).join("/");
+  await execFileP3("git", ["add", "-A", "--", oldRelClean, newRelClean], { cwd });
+  try {
+    await execFileP3("git", ["diff", "--cached", "--quiet"], { cwd });
+    const { stdout: stdout2 } = await execFileP3("git", ["rev-parse", "HEAD"], { cwd });
+    sendJson(res, 200, { commit: stdout2.trim(), newPath: newRelClean });
+    return;
+  } catch {
+  }
+  await execFileP3("git", ["commit", "-m", `[zg] rename-doc: ${oldRelClean} \u2192 ${newRelClean}`], { cwd });
+  const { stdout } = await execFileP3("git", ["rev-parse", "HEAD"], { cwd });
+  sendJson(res, 200, { commit: stdout.trim(), newPath: newRelClean });
+}
+function guardPath(cwd, relpath) {
+  const abs = path7.resolve(cwd, relpath);
+  const root = path7.resolve(cwd);
+  if (!abs.startsWith(root + path7.sep) && abs !== root) return null;
+  return abs;
+}
+var execFileP3, DOCS_ROOTS;
+var init_docs = __esm({
+  "src/handlers/docs.ts"() {
+    "use strict";
+    init_util();
+    execFileP3 = promisify3(execFile3);
+    DOCS_ROOTS = ["docs", "spec", "README.md"];
+  }
+});
+
+// src/handlers/static-assets.ts
+import { promises as fs7 } from "node:fs";
+import * as path8 from "node:path";
+async function handleStaticRoute(req, res, viewerBundle, pathname, _cwd) {
+  if (req.method !== "GET") {
+    sendNotFound(res);
+    return;
+  }
+  if (pathname === "/" || pathname === "/index.html") {
+    const indexPath = path8.join(viewerBundle, "index.html");
+    let html;
+    try {
+      html = await fs7.readFile(indexPath, "utf8");
+    } catch {
+      sendNotFound(res);
+      return;
+    }
+    const theme = "system";
+    const inject = `<script>window.zettelgeistConfig = { theme: ${JSON.stringify(theme)} };</script>
+<script>${REST_BACKEND_SHIM}</script>`;
+    html = html.replace(
+      /<script\s+type="module"\s+src="\.\/main\.js"/i,
+      `${inject}
+<script type="module" src="./main.js"`
+    );
+    res.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Cache-Control": "no-cache, no-store, must-revalidate",
+      "Pragma": "no-cache",
+      "Expires": "0"
+    });
+    res.end(html);
+    return;
+  }
+  const rel = pathname.replace(/^\/(static\/)?/, "");
+  const ext = path8.extname(rel).toLowerCase();
+  if (!MIME_TYPES[ext]) {
+    sendNotFound(res);
+    return;
+  }
+  const filePath = path8.join(viewerBundle, rel);
+  if (!filePath.startsWith(viewerBundle + path8.sep)) {
+    sendNotFound(res);
+    return;
+  }
+  try {
+    const content = await fs7.readFile(filePath);
+    res.writeHead(200, {
+      "Content-Type": `${MIME_TYPES[ext]}; charset=utf-8`,
+      "Cache-Control": "no-cache, no-store, must-revalidate"
+    });
+    res.end(content);
+  } catch {
+    sendNotFound(res);
+  }
+}
+var REST_BACKEND_SHIM, MIME_TYPES;
+var init_static_assets = __esm({
+  "src/handlers/static-assets.ts"() {
+    "use strict";
+    init_util();
+    REST_BACKEND_SHIM = `
+(() => {
+  const json = async (url, opts) => {
+    const r = await fetch(url, opts);
+    if (!r.ok) throw new Error(\`\${opts?.method || 'GET'} \${url} \u2192 \${r.status}\`);
+    return r.json();
+  };
+  const post = (url, body) => json(url, {
+    method: 'POST',
+    headers: body !== undefined ? { 'Content-Type': 'application/json' } : {},
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+  });
+  const put = (url, body) => json(url, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const patch = (url, body) => json(url, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const del = (url) => json(url, { method: 'DELETE' });
+  const enc = encodeURIComponent;
+  window.zettelgeistBackend = {
+    listSpecs: () => json('/api/specs'),
+    readSpec: (name) => json(\`/api/specs/\${enc(name)}\`),
+    readSpecFile: (name, rel) => json(\`/api/specs/\${enc(name)}/files/\${rel.split('/').map(enc).join('/')}\`),
+    validateRepo: () => json('/api/validation'),
+    listDocs: () => json('/api/docs'),
+    readDoc: (p) => json(\`/api/docs/\${p.split('/').map(enc).join('/')}\`),
+    writeDoc: (p, content) => put(\`/api/docs/\${p.split('/').map(enc).join('/')}\`, { content }),
+    renameDoc: (oldPath, newPath) => post(\`/api/docs/\${oldPath.split('/').map(enc).join('/')}/rename\`, { newPath }),
+    writeSpecFile: (name, rel, content) => put(\`/api/specs/\${enc(name)}/files/\${rel.split('/').map(enc).join('/')}\`, { content }),
+    tickTask: (name, n) => post(\`/api/specs/\${enc(name)}/tasks/\${n}/tick\`),
+    untickTask: (name, n) => post(\`/api/specs/\${enc(name)}/tasks/\${n}/untick\`),
+    setStatus: (name, status, reason) => post(\`/api/specs/\${enc(name)}/status\`, { status, reason }),
+    patchFrontmatter: (name, fmPatch) => patch(\`/api/specs/\${enc(name)}/frontmatter\`, { patch: fmPatch }),
+    writeHandoff: (name, content) => put(\`/api/specs/\${enc(name)}/handoff\`, { content }),
+    deleteSpec: (name) => del(\`/api/specs/\${enc(name)}\`),
+    regenerateIndex: () => post('/api/regenerate'),
+    claimSpec: (name, agentId) => post(\`/api/specs/\${enc(name)}/claim\`, { agent_id: agentId }),
+    releaseSpec: (name) => post(\`/api/specs/\${enc(name)}/release\`),
+  };
+})();
+`;
+    MIME_TYPES = {
+      ".html": "text/html",
+      ".js": "application/javascript",
+      ".css": "text/css",
+      ".map": "application/json",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".json": "application/json"
+    };
+  }
+});
+
+// src/server.ts
+import { createServer } from "node:http";
+import * as path9 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { promises as fs8 } from "node:fs";
+async function startServer(opts) {
+  const viewerBundle = opts.viewerBundlePath ?? DEFAULT_VIEWER_BUNDLE;
+  const server = createServer((req, res) => {
+    routeRequest(req, res, opts.cwd, viewerBundle).catch((err) => {
+      console.error("server error:", err);
+      try {
+        sendJson(res, 500, { ok: false, error: { message: err.message } });
+      } catch {
+      }
+    });
+  });
+  await new Promise((resolve6, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port, "127.0.0.1", () => resolve6());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : opts.port;
+  const url = `http://127.0.0.1:${port}`;
+  return {
+    port,
+    url,
+    async stop() {
+      await new Promise((resolve6, reject) => {
+        server.close((err) => err ? reject(err) : resolve6());
+      });
+    }
+  };
+}
+async function routeRequest(req, res, cwd, viewerBundle) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const pathname = url.pathname;
+  if (pathname.startsWith("/api/specs")) {
+    return handleSpecsRoute(req, res, cwd, pathname);
+  }
+  if (pathname === "/api/regenerate") {
+    return handleRegenerate(req, res, cwd);
+  }
+  if (pathname === "/api/validation") {
+    return handleValidation(req, res, cwd);
+  }
+  if (pathname.startsWith("/api/docs")) {
+    return handleDocsRoute(req, res, cwd, pathname);
+  }
+  if (pathname === "/static/user-overrides.css") {
+    return handleUserOverride(req, res, cwd);
+  }
+  return handleStaticRoute(req, res, viewerBundle, pathname, cwd);
+}
+async function handleRegenerate(_req, res, cwd) {
+  const { regenCommand: regenCommand2 } = await Promise.resolve().then(() => (init_regen2(), regen_exports));
+  const result = await regenCommand2({ path: cwd, check: false });
+  sendJson(res, result.ok ? 200 : 500, result);
+}
+async function handleValidation(_req, res, cwd) {
+  const { validateCommand: validateCommand2 } = await Promise.resolve().then(() => (init_validate2(), validate_exports));
+  const result = await validateCommand2({ path: cwd });
+  sendJson(res, 200, result);
+}
+async function handleUserOverride(_req, res, cwd) {
+  const userCss = path9.join(cwd, ".zettelgeist", "render-templates", "viewer.css");
+  try {
+    const content = await fs8.readFile(userCss, "utf8");
+    res.writeHead(200, { "Content-Type": "text/css; charset=utf-8" });
+    res.end(content);
+  } catch {
+    sendText(res, 404, "/* no user overrides */");
+  }
+}
+var here, DEFAULT_VIEWER_BUNDLE;
+var init_server = __esm({
+  "src/server.ts"() {
+    "use strict";
+    init_specs();
+    init_docs();
+    init_static_assets();
+    init_util();
+    here = path9.dirname(fileURLToPath2(import.meta.url));
+    DEFAULT_VIEWER_BUNDLE = path9.resolve(here, "viewer-bundle");
+  }
+});
+
+// src/commands/serve.ts
+var serve_exports = {};
+__export(serve_exports, {
+  HELP: () => HELP5,
+  serveCommand: () => serveCommand
+});
+import { promises as fs9 } from "node:fs";
+import * as path10 from "node:path";
+import { spawn } from "node:child_process";
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  try {
+    spawn(cmd, [url], { detached: true, stdio: "ignore" }).unref();
+  } catch {
+  }
+}
+async function serveCommand(input) {
+  const exists = await fs9.access(path10.join(input.path, ".zettelgeist.yaml")).then(() => true).catch(() => false);
+  if (!exists) return errorEnvelope(`not a zettelgeist repo: ${input.path}`);
+  let handle;
+  try {
+    handle = await startServer({ cwd: input.path, port: input.port });
+  } catch (err) {
+    return errorEnvelope(`failed to start server: ${err.message}`);
+  }
+  console.error(`zettelgeist serving at ${handle.url}`);
+  console.error("press Ctrl+C to stop.");
+  if (!input.noOpen) {
+    openBrowser(handle.url);
+  }
+  await new Promise((resolve6) => {
+    const stopAndExit = async () => {
+      console.error("\nshutting down\u2026");
+      await handle.stop();
+      resolve6();
+    };
+    process.once("SIGINT", stopAndExit);
+    process.once("SIGTERM", stopAndExit);
+  });
+  return okEnvelope({ url: handle.url, port: handle.port });
+}
+var HELP5;
+var init_serve = __esm({
+  "src/commands/serve.ts"() {
+    "use strict";
+    init_output();
+    init_server();
+    HELP5 = `zettelgeist serve [--port N] [--no-open] [--json]
+
+  Launch the local HTML viewer over HTTP. Defaults to
+  http://127.0.0.1:7681 and opens the URL in the system browser.
+
+  The server runs until you press Ctrl+C.
+
+  Flags:
+    --port N       Listen on port N instead of the default 7681.
+    --no-open      Do not open the browser; just print the URL.
+    --json         Emit a machine-readable JSON envelope on shutdown.
+`;
+  }
+});
+
+// src/render.ts
+import { marked } from "marked";
+function renderMarkdownBody(markdown) {
+  marked.setOptions({ gfm: true, breaks: false });
+  return marked.parse(markdown);
+}
+function renderTemplate(template, context) {
+  const placeholderRe = /\{\{([^{}]+)\}\}/g;
+  const seen = /* @__PURE__ */ new Set();
+  return template.replace(placeholderRe, (match, rawKey) => {
+    const key = rawKey.trim();
+    seen.add(key);
+    if (KNOWN_PLACEHOLDERS.includes(key)) {
+      const v = context[key];
+      if (typeof v === "string") return v;
+    }
+    if (key.startsWith(FRONTMATTER_PREFIX)) {
+      const fmKey = key.slice(FRONTMATTER_PREFIX.length);
+      const v = context.frontmatter[fmKey];
+      return v === void 0 ? "" : String(v);
+    }
+    throw new Error(
+      `unknown template placeholder "{{${key}}}". Valid placeholders: ${KNOWN_PLACEHOLDERS.join(", ")}, frontmatter.<key>`
+    );
+  });
+}
+function validateTemplate(template) {
+  const placeholderRe = /\{\{([^{}]+)\}\}/g;
+  const errors = [];
+  let match;
+  while ((match = placeholderRe.exec(template)) !== null) {
+    const key = match[1]?.trim() ?? "";
+    if (KNOWN_PLACEHOLDERS.includes(key)) continue;
+    if (key.startsWith(FRONTMATTER_PREFIX)) continue;
+    errors.push(`unknown placeholder: {{${key}}}`);
+  }
+  return errors;
+}
+var KNOWN_PLACEHOLDERS, FRONTMATTER_PREFIX;
+var init_render = __esm({
+  "src/render.ts"() {
+    "use strict";
+    KNOWN_PLACEHOLDERS = ["content", "title", "generated_at", "tool_version"];
+    FRONTMATTER_PREFIX = "frontmatter.";
+  }
+});
+
+// src/commands/export-doc.ts
+var export_doc_exports = {};
+__export(export_doc_exports, {
+  HELP: () => HELP6,
+  exportDocCommand: () => exportDocCommand
+});
+import { promises as fs10 } from "node:fs";
+import * as path11 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import matter3 from "gray-matter";
+async function loadDefaultTemplate() {
+  const here2 = path11.dirname(fileURLToPath3(import.meta.url));
+  const candidates = [
+    path11.join(here2, "templates", "export.html"),
+    // npm install: bin.js is at dist/, sibling templates/
+    path11.join(here2, "..", "templates", "export.html"),
+    // workspace dev: dist/bin.js, sibling templates/ at package root
+    path11.join(here2, "..", "..", "templates", "export.html")
+    // tests: src/commands/, templates/ two levels up
+  ];
+  for (const c of candidates) {
+    try {
+      return await fs10.readFile(c, "utf8");
+    } catch {
+    }
+  }
+  throw new Error("default export template not found");
+}
+async function exportDocCommand(input) {
+  const sourceAbs = path11.resolve(input.cwd, input.source);
+  let raw;
+  try {
+    raw = await fs10.readFile(sourceAbs, "utf8");
+  } catch (err) {
+    return errorEnvelope(`cannot read source: ${err.message}`);
+  }
+  const parsed = matter3(raw, {});
+  const frontmatter = parsed.data ?? {};
+  const body = parsed.content;
+  let title;
+  if (typeof frontmatter.title === "string") {
+    title = frontmatter.title;
+  } else {
+    const h1 = body.match(/^#\s+(.+)$/m);
+    title = h1?.[1]?.trim() ?? path11.basename(sourceAbs);
+  }
+  let template;
+  if (input.templatePath) {
+    try {
+      template = await fs10.readFile(path11.resolve(input.cwd, input.templatePath), "utf8");
+    } catch (err) {
+      return errorEnvelope(`cannot read template: ${err.message}`);
+    }
+  } else {
+    template = await loadDefaultTemplate();
+  }
+  const tmplErrors = validateTemplate(template);
+  if (tmplErrors.length > 0) {
+    return errorEnvelope(`template has ${tmplErrors.length} unknown placeholder(s)`, { errors: tmplErrors });
+  }
+  const context = {
+    content: renderMarkdownBody(body),
+    title,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    tool_version: TOOL_VERSION,
+    frontmatter
+  };
+  let html;
+  try {
+    html = renderTemplate(template, context);
+  } catch (err) {
+    return errorEnvelope(err.message);
+  }
+  const outDir = path11.join(input.cwd, ".zettelgeist", "exports");
+  await fs10.mkdir(outDir, { recursive: true });
+  const baseName = path11.basename(input.source, path11.extname(input.source)) + ".html";
+  const outPath = path11.join(outDir, baseName);
+  const tmp = `${outPath}.tmp`;
+  await fs10.writeFile(tmp, html, "utf8");
+  await fs10.rename(tmp, outPath);
+  return okEnvelope({ output: path11.relative(input.cwd, outPath) });
+}
+var HELP6, TOOL_VERSION;
+var init_export_doc = __esm({
+  "src/commands/export-doc.ts"() {
+    "use strict";
+    init_output();
+    init_render();
+    HELP6 = `zettelgeist export-doc <path> [--template T] [--json]
+
+  Render a markdown file to a standalone HTML document using the
+  bundled (or supplied) mustache template.
+
+  Args:
+    <path>         Markdown source path, relative to the current repo.
+
+  Flags:
+    --template T   Use template file T instead of the bundled default.
+    --json         Emit a machine-readable JSON envelope.
+
+  Output is written under .zettelgeist/exports/<basename>.html.
+`;
+    TOOL_VERSION = "0.1.0";
+  }
+});
+
+// src/router.ts
+import { parseArgs } from "node:util";
+var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
+  "regen",
+  "validate",
+  "install-hook",
+  "install-skill",
+  "serve",
+  "export-doc"
+]);
+var FLAG_OPTIONS = {
+  json: { type: "boolean" },
+  help: { type: "boolean", short: "h" },
+  check: { type: "boolean" },
+  force: { type: "boolean" },
+  port: { type: "string" },
+  "no-open": { type: "boolean" },
+  template: { type: "string" },
+  scope: { type: "string" }
+};
+function parseInvocation(argv) {
+  if (argv.length === 0) return { kind: "help", topic: null };
+  if (argv[0] === "--help" || argv[0] === "-h") return { kind: "help", topic: null };
+  const [first, ...rest] = argv;
+  if (!first) return { kind: "help", topic: null };
+  if (!KNOWN_COMMANDS.has(first)) return { kind: "unknown-command", name: first };
+  if (rest.includes("--help") || rest.includes("-h")) {
+    return { kind: "help", topic: first };
+  }
+  const { values, positionals } = parseArgs({
+    args: rest,
+    options: FLAG_OPTIONS,
+    allowPositionals: true
+  });
+  const flags = {
+    json: values.json ?? false,
+    help: values.help ?? false,
+    ...values.check !== void 0 ? { check: values.check } : {},
+    ...values.force !== void 0 ? { force: values.force } : {},
+    ...values.port !== void 0 ? { port: values.port } : {},
+    ...values["no-open"] !== void 0 ? { "no-open": values["no-open"] } : {},
+    ...values.template !== void 0 ? { template: values.template } : {},
+    ...values.scope !== void 0 ? { scope: values.scope } : {}
+  };
+  return { kind: "command", name: first, args: positionals, flags };
+}
+
+// src/bin.ts
+init_output();
+init_regen2();
+init_validate2();
+init_install_hook2();
+init_install_skill();
+init_serve();
+init_export_doc();
+var HELP7 = `zettelgeist v0.1
+
+Usage:
+  zettelgeist <command> [options]
+
+Commands:
+  regen [--check]                regenerate specs/INDEX.md
+  validate                       validate the repo against the spec
+  install-hook [--force]         install pre-commit hook
+  install-skill [--scope S]      install the agent skill (Claude Code etc.)
+  serve [--port N] [--no-open]   serve the viewer over HTTP
+  export-doc <path> [--template T]  render markdown to HTML
+
+Global flags:
+  --json     emit machine-readable JSON envelope
+  -h, --help show this help
+
+Run \`zettelgeist <command> --help\` for command-specific help.
+`;
+var COMMAND_HELP = {
+  regen: HELP,
+  validate: HELP2,
+  "install-hook": HELP3,
+  "install-skill": HELP4,
+  serve: HELP5,
+  "export-doc": HELP6
+};
+async function main() {
+  const inv = parseInvocation(process.argv.slice(2));
+  if (inv.kind === "help") {
+    const text = inv.topic && COMMAND_HELP[inv.topic] || HELP7;
+    process.stdout.write(text);
+    return 0;
+  }
+  if (inv.kind === "unknown-command") {
+    process.stderr.write(`unknown command: ${inv.name}
+${HELP7}`);
+    return 2;
+  }
+  const ctx = realEmitContext(inv.flags.json);
+  const cwd = process.cwd();
+  switch (inv.name) {
+    case "regen": {
+      const { regenCommand: regenCommand2 } = await Promise.resolve().then(() => (init_regen2(), regen_exports));
+      const env = await regenCommand2({ path: cwd, check: inv.flags.check ?? false });
+      emit(
+        ctx,
+        env,
+        () => env.ok ? env.data.changed ? `regen: wrote ${env.data.path}` : `regen: ${env.data.path} up to date${env.data.cacheHit ? " (cache hit)" : ""}` : ""
+      );
+      return env.ok ? 0 : 1;
+    }
+    case "validate": {
+      const { validateCommand: validateCommand2 } = await Promise.resolve().then(() => (init_validate2(), validate_exports));
+      const env = await validateCommand2({ path: cwd });
+      emit(ctx, env, () => "validate: ok");
+      return env.ok ? 0 : 1;
+    }
+    case "install-hook": {
+      const { installHookCommand: installHookCommand2 } = await Promise.resolve().then(() => (init_install_hook2(), install_hook_exports));
+      const env = await installHookCommand2({ path: cwd, force: inv.flags.force ?? false });
+      emit(
+        ctx,
+        env,
+        () => env.ok ? `install-hook: installed${env.data.backup ? ` (backup: ${env.data.backup})` : ""}` : ""
+      );
+      return env.ok ? 0 : 1;
+    }
+    case "install-skill": {
+      const { installSkillCommand: installSkillCommand2, isScope: isScope2 } = await Promise.resolve().then(() => (init_install_skill(), install_skill_exports));
+      const scopeRaw = inv.flags.scope ?? "user";
+      if (!isScope2(scopeRaw)) {
+        process.stderr.write(
+          `install-skill: --scope must be 'user', 'project', or 'agents-md' (got '${scopeRaw}')
+`
+        );
+        return 2;
+      }
+      const env = await installSkillCommand2({
+        cwd,
+        scope: scopeRaw,
+        force: inv.flags.force ?? false
+      });
+      emit(
+        ctx,
+        env,
+        () => env.ok ? `install-skill: ${env.data.merged ? "merged into" : "wrote"} ${env.data.path}` : ""
+      );
+      return env.ok ? 0 : 1;
+    }
+    case "serve": {
+      const { serveCommand: serveCommand2 } = await Promise.resolve().then(() => (init_serve(), serve_exports));
+      const port = inv.flags.port ? Number.parseInt(inv.flags.port, 10) : 7681;
+      const env = await serveCommand2({ path: cwd, port, noOpen: inv.flags["no-open"] ?? false });
+      emit(ctx, env, () => env.ok ? `serve: stopped` : "");
+      return env.ok ? 0 : 1;
+    }
+    case "export-doc": {
+      const { exportDocCommand: exportDocCommand2 } = await Promise.resolve().then(() => (init_export_doc(), export_doc_exports));
+      const source = inv.args[0];
+      if (!source) {
+        process.stderr.write("export-doc: missing source path\n");
+        return 2;
+      }
+      const env = await exportDocCommand2({
+        cwd,
+        source,
+        ...inv.flags.template ? { templatePath: inv.flags.template } : {}
+      });
+      emit(ctx, env, () => env.ok ? `export-doc: wrote ${env.data.output}` : "");
+      return env.ok ? 0 : 1;
+    }
+    default:
+      process.stderr.write(`unhandled command: ${inv.name}
+`);
+      return 2;
+  }
+}
+main().then(
+  (code) => process.exit(code),
+  (err) => {
+    process.stderr.write(`zettelgeist: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+);
+//# sourceMappingURL=bin.js.map