@saasontools/strauss-kb 0.1.2 → 0.1.4

package/dist/cli-main.cjs

@@ -24,10 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var import_node_path3 = require("path");
+var import_node_path7 = require("path");
 
-// src/commands.ts
-var import_zod6 = require("zod");
+// src/decision-record.ts
+var import_zod3 = require("zod");
 
 // src/compose.ts
 var import_zod2 = require("zod");
@@ -198,12 +198,22 @@ var composeInputSchema = import_zod2.z.object({
   sources: import_zod2.z.array(kbSourceSchema).optional(),
   /** No source exists, as a claim rather than a sentinel in `sources`. */
   assumption: import_zod2.z.boolean().optional(),
+  /**
+   * OKF `stale_after`: the absolute date this record stops being trusted.
+   * Anything the outside world can change — pricing, quotas, versions,
+   * reception counts — should carry one.
+   */
+  stale_after: import_zod2.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, {
+    message: "stale_after must be YYYY-MM-DD"
+  }).refine((date) => !Number.isNaN(Date.parse(date)), {
+    message: "stale_after must be a real date"
+  }).optional(),
   verify: import_zod2.z.array(import_zod2.z.string().min(1)).optional(),
   tags: import_zod2.z.array(import_zod2.z.string().min(1)).optional(),
   /** Concept ids this record relates to; rendered as body links. */
   relatedConceptIds: import_zod2.z.array(kbConceptIdSchema).optional(),
   /** Concept ids this record replaces. The store settles the backlinks. */
-  supersedes: import_zod2.z.array(kbConceptIdSchema).optional(),
+  supersedes: import_zod2.z.array(kbConceptIdSchema).max(32).optional(),
   materiality: import_zod2.z.enum(KB_MATERIALITIES).optional(),
   confidence: import_zod2.z.enum(KB_CONFIDENCES).optional(),
   owner: import_zod2.z.string().min(1).optional()
@@ -230,6 +240,7 @@ function composeRecord(type, input, writtenBy, writtenAt) {
     verified: [],
     strauss_status: spec.initialStatus
   };
+  if (parsed.stale_after) frontmatter.stale_after = parsed.stale_after;
   if (parsed.anchors?.length) frontmatter.strauss_anchors = parsed.anchors;
   if (parsed.verify?.length) frontmatter.strauss_verify = parsed.verify;
   if (parsed.tags?.length) frontmatter.tags = parsed.tags;
@@ -266,7 +277,6 @@ ${text}`);
 }
 
 // src/decision-record.ts
-var import_zod3 = require("zod");
 var DECISION_TYPE = "decision";
 var NO_DECISION_SLUG = "none";
 var decisionInputSchema = composeInputSchema.omit({ sections: true }).extend({
@@ -304,19 +314,952 @@ function composeNoDecisionRecord(reason, writtenBy, writtenAt) {
   );
 }
 
+// src/commands/answer.ts
+var import_zod6 = require("zod");
+
+// src/kb-pins/budgets.ts
+function asBudgets(value) {
+  if (value === null || typeof value !== "object") return {};
+  const table = value;
+  const pick = (key, min) => {
+    const raw = table[key];
+    return typeof raw === "number" && Number.isInteger(raw) && raw >= min ? raw : void 0;
+  };
+  const budgetTokens = pick("budgetTokens", 1);
+  const fullUnderTokens = pick("fullUnderTokens", 0);
+  return {
+    ...budgetTokens ? { budgetTokens } : {},
+    ...fullUnderTokens !== void 0 ? { fullUnderTokens } : {}
+  };
+}
+function contextProfileBudgets(manifest, profile) {
+  const table = manifest.context;
+  if (table === null || typeof table !== "object") return {};
+  const entries = table;
+  return {
+    ...asBudgets(entries["default"]),
+    ...profile ? asBudgets(entries[profile]) : {}
+  };
+}
+function mergedContextBudgets(merged, profile) {
+  const layered = ["user", "local", "project"].map((layer) => {
+    const manifest = merged.manifests[layer];
+    return manifest ? contextProfileBudgets(manifest, profile) : {};
+  });
+  return { ...layered[0], ...layered[1], ...layered[2] };
+}
+
+// src/kb-pins/errors.ts
+var KbPinsMalformedError = class extends Error {
+  constructor(file, cause) {
+    super(`pin manifest ${file} is not readable (${cause}) \u2014 fix or remove it`);
+    this.name = "KbPinsMalformedError";
+  }
+};
+var KbBaseFrozenError = class extends Error {
+  constructor(bundlePath2, layer) {
+    super(
+      `${bundlePath2} is frozen (read-only) by this workspace's ${layer} pin manifest \u2014 re-pin with --unfreeze, or unpin, to change it`
+    );
+    this.name = "KbBaseFrozenError";
+  }
+};
+
+// src/kb-pins/frozen.ts
+var import_node_path3 = require("path");
+
+// src/kb-pins/layers.ts
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path2 = require("path");
+
+// src/kb-pins/model.ts
+var import_node_path = require("path");
+var import_zod4 = require("zod");
+var PINS_FILE = (0, import_node_path.join)(".strauss", "kb-pins.json");
+var PINS_LOCAL_FILE = (0, import_node_path.join)(".strauss", "kb-pins.local.json");
+var PIN_LAYERS = ["project", "local", "user"];
+var pinSchema = import_zod4.z.object({
+  /** Relative to the manifest's root, so the file is committable. */
+  path: import_zod4.z.string().min(1),
+  pinnedAt: import_zod4.z.string().min(1).optional(),
+  /**
+   * How `context` renders this base. `full` preloads the whole base into
+   * the block regardless of the full-under threshold — for a base whose
+   * contents should simply be present, the way an ADR base should be —
+   * still answering to the block budget, with an index fallback that says
+   * so when it cannot fit. `index` never upgrades, whatever the threshold.
+   * Absent: the profile's full-under threshold decides. Invalid values
+   * degrade to absent rather than failing the manifest.
+   */
+  mode: import_zod4.z.enum(["full", "index"]).optional().catch(void 0),
+  /**
+   * Context profiles this pin surfaces in (e.g. only at session-start,
+   * not per turn). Absent: every profile. A run without a profile sees
+   * every pin. A base that only matters to one skill is better loaded by
+   * that skill at point of use than pinned at all — pins are what every
+   * session should see.
+   */
+  profiles: import_zod4.z.array(import_zod4.z.string()).optional().catch(void 0),
+  /**
+   * The base is concluded — a finished piece of research, a frozen ADR
+   * set. Write commands against it refuse while this workspace holds the
+   * pin, and `context` labels it read-only. Workspace policy, not base
+   * state: the base itself stays copyable and writable elsewhere.
+   */
+  frozen: import_zod4.z.boolean().optional().catch(void 0)
+}).passthrough();
+var pinsManifestSchema = import_zod4.z.object({
+  pins: import_zod4.z.array(pinSchema).default([]),
+  /**
+   * Per-repo budgets for the `context` command, keyed by profile —
+   * `"session-start"`, `"compact"`, `"turn"`, or `"default"` for all of
+   * them. Deliberately untyped here: a typo'd budget must degrade to the
+   * built-in default, not make the whole manifest unreadable and silence
+   * the index at every session start. `contextProfileBudgets` does the
+   * tolerant read.
+   */
+  context: import_zod4.z.unknown().optional()
+}).passthrough();
+
+// src/kb-pins/layers.ts
+function userRoot() {
+  return process.env.STRAUSS_KB_USER_ROOT || (0, import_node_os.homedir)();
+}
+function layerRoot(workspaceDir, layer) {
+  return layer === "user" ? userRoot() : (0, import_node_path2.resolve)(workspaceDir);
+}
+function layerFile(workspaceDir, layer) {
+  return (0, import_node_path2.join)(
+    layerRoot(workspaceDir, layer),
+    layer === "local" ? PINS_LOCAL_FILE : PINS_FILE
+  );
+}
+async function readPinsLayer(workspaceDir, layer) {
+  const file = layerFile(workspaceDir, layer);
+  let raw;
+  try {
+    raw = await (0, import_promises.readFile)(file, "utf8");
+  } catch {
+    return { pins: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new KbPinsMalformedError(
+      file,
+      error instanceof Error ? error.message : "invalid JSON"
+    );
+  }
+  const manifest = pinsManifestSchema.safeParse(parsed);
+  if (!manifest.success) {
+    throw new KbPinsMalformedError(
+      file,
+      manifest.error.issues[0]?.message ?? "invalid shape"
+    );
+  }
+  return manifest.data;
+}
+async function writePinsLayer(workspaceDir, layer, manifest) {
+  const file = layerFile(workspaceDir, layer);
+  await (0, import_promises.mkdir)((0, import_node_path2.dirname)(file), { recursive: true });
+  await (0, import_promises.writeFile)(file, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function resolvePinPath(rootDir, path) {
+  return (0, import_node_path2.isAbsolute)(path) ? (0, import_node_path2.resolve)(path) : (0, import_node_path2.resolve)(rootDir, path.split("/").join(import_node_path2.sep));
+}
+function storablePath(rootDir, bundlePath2) {
+  const rel = (0, import_node_path2.relative)((0, import_node_path2.resolve)(rootDir), (0, import_node_path2.resolve)(bundlePath2));
+  return (rel === "" ? "." : rel).split(import_node_path2.sep).join("/");
+}
+async function readMergedPins(workspaceDir) {
+  const manifests = {};
+  const pins = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const layer of PIN_LAYERS) {
+    let manifest;
+    try {
+      manifest = await readPinsLayer(workspaceDir, layer);
+    } catch {
+      continue;
+    }
+    manifests[layer] = manifest;
+    const root = layerRoot(workspaceDir, layer);
+    for (const entry of manifest.pins) {
+      const absolutePath = resolvePinPath(root, entry.path);
+      if (seen.has(absolutePath)) continue;
+      seen.add(absolutePath);
+      pins.push({ ...entry, layer, absolutePath });
+    }
+  }
+  return { pins, manifests };
+}
+
+// src/kb-pins/frozen.ts
+async function assertBaseNotFrozen(workspaceDir, bundlePath2) {
+  const merged = await readMergedPins(workspaceDir);
+  const absolute = (0, import_node_path3.resolve)(bundlePath2);
+  const pin = merged.pins.find((entry) => entry.absolutePath === absolute);
+  if (pin?.frozen === true) {
+    throw new KbBaseFrozenError(pin.path, pin.layer);
+  }
+}
+
+// src/kb-pins/list.ts
+async function listPins(store, workspaceDir) {
+  const merged = await readMergedPins(workspaceDir);
+  return Promise.all(
+    merged.pins.map(async (entry) => {
+      const records = await store.list(entry.absolutePath);
+      return {
+        path: entry.path,
+        layer: entry.layer,
+        pinnedAt: entry.pinnedAt ?? null,
+        absolutePath: entry.absolutePath,
+        valid: records.length > 0,
+        recordCount: records.length,
+        mode: entry.mode ?? null,
+        profiles: entry.profiles ?? null,
+        frozen: entry.frozen === true
+      };
+    })
+  );
+}
+
+// src/kb-pins/pin.ts
+async function pinBase(store, workspaceDir, bundlePath2, at, options = {}) {
+  const layer = options.layer ?? "project";
+  const root = layerRoot(workspaceDir, layer);
+  const manifest = await readPinsLayer(workspaceDir, layer);
+  const absolute = resolvePinPath(root, storablePath(root, bundlePath2));
+  const existing = manifest.pins.find(
+    (entry2) => resolvePinPath(root, entry2.path) === absolute
+  );
+  const records = await store.list(absolute);
+  const warning = records.length === 0 ? `no records found at ${absolute} \u2014 pinned anyway; bases are routinely pinned before they are populated` : void 0;
+  const fields = {
+    ...options.mode ? { mode: options.mode } : {},
+    ...options.profiles?.length ? { profiles: options.profiles } : {},
+    ...options.frozen !== void 0 ? { frozen: options.frozen } : {}
+  };
+  if (existing) {
+    const updated = { ...existing, ...fields };
+    if (Object.keys(fields).length) {
+      await writePinsLayer(workspaceDir, layer, {
+        ...manifest,
+        pins: manifest.pins.map(
+          (entry2) => entry2 === existing ? updated : entry2
+        )
+      });
+    }
+    return {
+      path: existing.path,
+      layer,
+      pinnedAt: existing.pinnedAt ?? at,
+      alreadyPinned: true,
+      ...updated.mode ? { mode: updated.mode } : {},
+      ...updated.profiles ? { profiles: updated.profiles } : {},
+      ...updated.frozen !== void 0 ? { frozen: updated.frozen } : {},
+      ...warning ? { warning } : {}
+    };
+  }
+  const entry = {
+    path: storablePath(root, bundlePath2),
+    pinnedAt: at,
+    ...fields
+  };
+  await writePinsLayer(workspaceDir, layer, {
+    ...manifest,
+    pins: [...manifest.pins, entry]
+  });
+  return {
+    path: entry.path,
+    layer,
+    pinnedAt: at,
+    alreadyPinned: false,
+    ...fields,
+    ...warning ? { warning } : {}
+  };
+}
+
+// src/kb-pins/unpin.ts
+var import_node_path4 = require("path");
+async function unpinBase(workspaceDir, bundlePath2) {
+  const layers = [];
+  for (const layer of PIN_LAYERS) {
+    const root = layerRoot(workspaceDir, layer);
+    let manifest;
+    try {
+      manifest = await readPinsLayer(workspaceDir, layer);
+    } catch {
+      continue;
+    }
+    const absolute = resolvePinPath(root, storablePath(root, bundlePath2));
+    const kept = manifest.pins.filter(
+      (entry) => resolvePinPath(root, entry.path) !== absolute
+    );
+    if (kept.length !== manifest.pins.length) {
+      await writePinsLayer(workspaceDir, layer, { ...manifest, pins: kept });
+      layers.push(layer);
+    }
+  }
+  return {
+    path: storablePath((0, import_node_path4.resolve)(workspaceDir), bundlePath2),
+    removed: layers.length > 0,
+    layers
+  };
+}
+
+// src/commands/model.ts
+var import_zod5 = require("zod");
+var bundlePath = import_zod5.z.string().min(1).describe("Absolute path to the knowledge base directory.");
+var conceptId = import_zod5.z.string().min(1).describe("e.g. decision.cursor-v2");
+function define(command) {
+  return command;
+}
+function argvFlag(argv, name) {
+  const at = argv.indexOf(name);
+  return at !== -1 ? argv[at + 1] : void 0;
+}
+
+// src/commands/answer.ts
+var answerCommand = define({
+  name: "answer",
+  tool: "kb_answer",
+  usage: "answer <concept-id> <answer...>",
+  description: "Resolve an open question: sets the status, stamps who answered and when, and appends an Answer section. If the answer overturns an assumption or a decision, that is a supersession \u2014 do it explicitly.",
+  input: import_zod6.z.object({ bundlePath, conceptId, answer: import_zod6.z.string().min(1) }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    conceptId: argv[1],
+    answer: argv.slice(2).join(" ").trim()
+  }),
+  run: async ({ store, actor }, { bundlePath: path, conceptId: id, answer }) => {
+    await assertBaseNotFrozen(process.cwd(), path);
+    const record = await store.answer(path, id, answer, actor);
+    return { conceptId: record.conceptId };
+  }
+});
+
+// src/commands/context.ts
+var import_zod7 = require("zod");
+
+// src/kb-context.ts
+var import_promises2 = require("fs/promises");
+
+// src/adjudicate.ts
+var STANDING = {
+  accepted: "current",
+  resolved: "current",
+  draft: "unsettled",
+  proposed: "unsettled",
+  open: "open",
+  rejected: "rejected",
+  superseded: "superseded"
+};
+function adjudicate(hits, bundle, now = /* @__PURE__ */ new Date()) {
+  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
+  return hits.map((record) => {
+    const status = record.frontmatter.strauss_status;
+    const warnings = [];
+    let heads = [];
+    if (status === "superseded") {
+      const resolved = resolveHeads(record, byId);
+      heads = resolved.heads;
+      warnings.push(...resolved.warnings);
+      if (heads.length) {
+        warnings.push({
+          kind: "superseded",
+          by: heads.map((head) => head.conceptId)
+        });
+      }
+    } else if (status === "rejected") {
+      warnings.push({ kind: "rejected" });
+    } else if (status === "draft" || status === "proposed") {
+      warnings.push({ kind: "unsettled", status });
+    } else if (status === "open") {
+      warnings.push({ kind: "unresolved-question" });
+    }
+    const staleAfter = record.frontmatter.stale_after;
+    if (staleAfter && Date.parse(staleAfter) < now.getTime()) {
+      warnings.push({ kind: "stale", staleAfter });
+    }
+    if (!record.frontmatter.verified?.length) {
+      warnings.push({ kind: "unverified" });
+    }
+    return { record, standing: STANDING[status], heads, warnings };
+  });
+}
+function resolveHeads(from, byId) {
+  const warnings = [];
+  const heads = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set([from.conceptId]);
+  const queue = [from];
+  while (queue.length) {
+    const current = queue.shift();
+    const next = successors(current, byId);
+    for (const missing of next.missing) {
+      warnings.push({ kind: "broken-chain", missing });
+    }
+    if (!next.records.length) {
+      if (current.conceptId !== from.conceptId)
+        heads.set(current.conceptId, current);
+      continue;
+    }
+    for (const record of next.records) {
+      if (seen.has(record.conceptId)) {
+        warnings.push({ kind: "chain-cycle", through: [...seen] });
+        continue;
+      }
+      seen.add(record.conceptId);
+      queue.push(record);
+    }
+  }
+  if (heads.size > 1) {
+    warnings.push({ kind: "forked-chain", heads: [...heads.keys()] });
+  }
+  return { heads: [...heads.values()], warnings };
+}
+function successors(record, byId) {
+  const ids = /* @__PURE__ */ new Set();
+  const forward = record.frontmatter.strauss_superseded_by;
+  if (forward) ids.add(forward);
+  for (const [id, candidate] of byId) {
+    if (candidate.frontmatter.strauss_supersedes?.includes(record.conceptId)) {
+      ids.add(id);
+    }
+  }
+  const records = [];
+  const missing = [];
+  for (const id of ids) {
+    const found = byId.get(id);
+    if (found) records.push(found);
+    else missing.push(id);
+  }
+  return { records, missing };
+}
+
+// src/kb-index.ts
+var INDEX_FILE = "INDEX.md";
+var HEADING = "# KB Index";
+function renderIndex(records) {
+  const lines = [...records].sort((left, right) => left.conceptId.localeCompare(right.conceptId)).map(renderIndexLine);
+  return `${HEADING}
+
+${lines.join("\n")}
+`;
+}
+function renderIndexLine(record) {
+  const { frontmatter: fm } = record;
+  const parts = [fm.type, fm.strauss_status];
+  if (fm.tags?.length) parts.push(`tags: ${fm.tags.join(", ")}`);
+  if (fm.description) parts.push(fm.description);
+  return `- [${fm.title ?? record.conceptId}](${record.conceptId}.md) \u2014 ${parts.join(" \xB7 ")}`;
+}
+function indexIsStale(stored, expected) {
+  return stored !== expected;
+}
+
+// src/kb-context.ts
+var HEADING2 = "## Knowledge bases (pinned)";
+var DEFAULT_CONTEXT_BUDGET = 4e3;
+var CONTEXT_PROFILES = {
+  "session-start": { fullUnderTokens: 1500 },
+  compact: { budgetTokens: 2500 },
+  turn: { budgetTokens: 2500 }
+};
+function approxTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function preamble() {
+  return [
+    HEADING2,
+    "",
+    "What follows is an index of this workspace's pinned knowledge bases \u2014",
+    "concept ids, titles and standing only. The record bodies are NOT in this",
+    "context.",
+    "",
+    "Consult records only through the strauss-kb MCP tools: `kb_load` (the",
+    "preferred first call), `kb_query`, and `kb_trace`, passing the",
+    "`bundlePath` listed with each base. Do not read record files directly:",
+    "a raw file read bypasses supersession resolution, and a superseded or",
+    "rejected record file reads exactly like a current one \u2014 only the store",
+    "resolves chains and standing.",
+    "",
+    "KB content loaded earlier in a long session may have been compacted",
+    "away. Before answering a question one of these bases governs, load it",
+    "again at the point of use \u2014 reloading a small base costs a few thousand",
+    "tokens."
+  ].join("\n");
+}
+async function renderBase(store, path, absolutePath, fullUnderTokens, pinMode, budgetTokens) {
+  const bundle = await store.list(absolutePath);
+  if (bundle.length === 0) {
+    return {
+      path,
+      absolutePath,
+      mode: "empty",
+      body: "No readable records yet \u2014 pinned ahead of being populated."
+    };
+  }
+  const fullCap = pinMode === "full" ? budgetTokens : pinMode === "index" ? 0 : fullUnderTokens;
+  let degradedFrom;
+  if (fullCap > 0) {
+    const full = await store.load(absolutePath, {
+      budgetTokens: fullCap
+    });
+    if (!full.loaded && pinMode === "full") {
+      degradedFrom = { approxTokens: full.approxTokens };
+    }
+    if (full.loaded) {
+      const records = full.records.map(
+        (hit) => [
+          `#### ${hit.record.conceptId} \u2014 ${hit.record.frontmatter.title ?? "(untitled)"} (${hit.standing})`,
+          "",
+          hit.record.body.trim()
+        ].join("\n")
+      );
+      const superseded2 = full.superseded.map(
+        (entry) => `- \`${entry.conceptId}\` \u2192 superseded by ${entry.supersededBy.map((id) => `\`${id}\``).join(", ") || "(missing replacement)"}`
+      );
+      return {
+        path,
+        absolutePath,
+        mode: "full",
+        body: [
+          ...records,
+          ...superseded2.length ? [
+            "#### Superseded (bodies withheld \u2014 kb_trace reaches them)",
+            ...superseded2
+          ] : []
+        ].join("\n\n")
+      };
+    }
+  }
+  const adjudicated = adjudicate(bundle, bundle);
+  const lines = adjudicated.filter((hit) => hit.standing !== "superseded").map((hit) => renderIndexLine(hit.record));
+  const superseded = adjudicated.filter((hit) => hit.standing === "superseded").map(
+    (hit) => `- \`${hit.record.conceptId}\` \u2192 superseded by ${hit.heads.map((head) => `\`${head.conceptId}\``).join(", ") || "(missing replacement)"}`
+  );
+  return {
+    path,
+    absolutePath,
+    mode: "index",
+    body: [...lines, ...superseded].join("\n"),
+    ...degradedFrom ? { degradedFrom } : {}
+  };
+}
+async function buildContext(store, workspaceDir, options = {}) {
+  const builtin = options.profile ? CONTEXT_PROFILES[options.profile] ?? {} : {};
+  let budgetTokens = options.budgetTokens ?? builtin.budgetTokens ?? DEFAULT_CONTEXT_BUDGET;
+  let fullUnderTokens = options.fullUnderTokens ?? builtin.fullUnderTokens ?? 0;
+  const merged = await readMergedPins(workspaceDir);
+  const fromManifest = mergedContextBudgets(merged, options.profile);
+  budgetTokens = options.budgetTokens ?? fromManifest.budgetTokens ?? builtin.budgetTokens ?? DEFAULT_CONTEXT_BUDGET;
+  fullUnderTokens = options.fullUnderTokens ?? fromManifest.fullUnderTokens ?? builtin.fullUnderTokens ?? 0;
+  const pins = merged.pins.filter(
+    (pin) => !pin.profiles?.length || !options.profile || pin.profiles.includes(options.profile)
+  );
+  if (pins.length === 0) {
+    return {
+      block: "",
+      refused: false,
+      approxTokens: 0,
+      budgetTokens,
+      bases: []
+    };
+  }
+  const sections = await Promise.all(
+    pins.map(async (pin) => ({
+      section: await renderBase(
+        store,
+        pin.path,
+        pin.absolutePath,
+        fullUnderTokens,
+        pin.mode,
+        budgetTokens
+      ),
+      frozen: pin.frozen === true
+    }))
+  );
+  const modeLabel = {
+    index: "index only \u2014 record bodies are not here",
+    full: "full records \u2014 this base arrives whole",
+    empty: "empty"
+  };
+  for (const { section } of sections) {
+    if (section.degradedFrom) {
+      options.warn?.({
+        operation: "kb.context.full-pin-degraded",
+        path: section.path,
+        approxTokens: section.degradedFrom.approxTokens,
+        budgetTokens
+      });
+    }
+  }
+  const rendered = sections.map(({ section, frozen }) => {
+    const label = section.degradedFrom ? `index only \u2014 pinned \`mode: full\`, but its ~${section.degradedFrom.approxTokens} tokens exceed this block's ${budgetTokens}-token budget; kb_load it directly (load's budget is separate), or raise this profile's budget` : modeLabel[section.mode];
+    return [
+      `### ${section.path} (${label}${frozen ? " \xB7 frozen, read-only" : ""})`,
+      "",
+      `bundlePath: \`${section.absolutePath}\``,
+      "",
+      section.body
+    ].join("\n");
+  });
+  const block = [preamble(), "", rendered.join("\n\n"), ""].join("\n");
+  const bases = sections.map(({ section }) => ({
+    path: section.path,
+    absolutePath: section.absolutePath,
+    approxTokens: approxTokens(section.body)
+  }));
+  const total = approxTokens(block);
+  if (total > budgetTokens) {
+    options.warn?.({
+      operation: "kb.context.refused",
+      approxTokens: total,
+      budgetTokens,
+      bases: bases.map((base) => base.path)
+    });
+    const refusal = [
+      HEADING2,
+      "",
+      `The pinned index runs to ~${total} tokens, past the ${budgetTokens}-token`,
+      "budget, and was not emitted \u2014 a truncated index is indistinguishable",
+      "from a complete one. The pinned bases:",
+      "",
+      ...bases.map(
+        (base) => `- ${base.path} \u2014 ~${base.approxTokens} tokens (bundlePath: \`${base.absolutePath}\`)`
+      ),
+      "",
+      "For the question at hand, read what you need now \u2014 `kb_load` a base",
+      "(its own budget is separate), or `kb_index` for one base's shape.",
+      "",
+      "To bring this block back under budget, in order of preference:",
+      "- supersede or resolve stale records \u2014 the base shrinks, the knowledge keeps",
+      "- force a large base to index lines: `strauss-kb pin <path> --mode index`",
+      "- scope a pin to the profiles that need it: `strauss-kb pin <path> --profiles session-start`",
+      "- raise this profile's budget under `context` in .strauss/kb-pins.json",
+      "- unpin what no session actually needs",
+      ""
+    ].join("\n");
+    return {
+      block: refusal,
+      refused: true,
+      approxTokens: total,
+      budgetTokens,
+      bases
+    };
+  }
+  return { block, refused: false, approxTokens: total, budgetTokens, bases };
+}
+function toHookJson(block, event) {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: event,
+      additionalContext: block
+    }
+  });
+}
+var CONTEXT_BEGIN = "<!-- strauss-kb:begin -->";
+var CONTEXT_END = "<!-- strauss-kb:end -->";
+async function syncInstructions(file, block) {
+  const existing = await (0, import_promises2.readFile)(file, "utf8").catch(() => null);
+  const region = block ? `${CONTEXT_BEGIN}
+${block.trim()}
+${CONTEXT_END}` : null;
+  if (existing === null) {
+    if (!region) return { file, action: "unchanged" };
+    await (0, import_promises2.writeFile)(file, `${region}
+`, "utf8");
+    return { file, action: "created" };
+  }
+  const begin = existing.indexOf(CONTEXT_BEGIN);
+  const end = existing.indexOf(CONTEXT_END);
+  if (begin !== -1 && end !== -1 && end >= begin) {
+    const before = existing.slice(0, begin);
+    const after = existing.slice(end + CONTEXT_END.length);
+    const next = region ? `${before}${region}${after}` : `${before.replace(/\n+$/, "\n")}${after.replace(/^\n+/, "\n")}`;
+    if (next === existing) return { file, action: "unchanged" };
+    await (0, import_promises2.writeFile)(file, next, "utf8");
+    return { file, action: region ? "replaced" : "removed" };
+  }
+  if (!region) return { file, action: "unchanged" };
+  await (0, import_promises2.writeFile)(
+    file,
+    `${existing.replace(/\n*$/, "\n\n")}${region}
+`,
+    "utf8"
+  );
+  return { file, action: "appended" };
+}
+
+// src/commands/context.ts
+var contextCommand = define({
+  name: "context",
+  tool: "kb_context",
+  usage: "context [--profile NAME] [--budget N] [--full-under N] [--format json] [--event NAME]",
+  description: "The pinned-base index block, for injection at every context birth \u2014 startup, clear, resume, and after compaction. An index, not the content: concept ids, titles and standing, with the bodies left behind kb_load at the point of use. Emits nothing when nothing is pinned. Refuses with the list of bases and their sizes rather than truncating past its budget. Budgets resolve most-specific-first: explicit flags, then the workspace manifests' `context` tables (per profile, over their `default`), then the built-in profile (session-start, compact, turn), then package defaults \u2014 so a repo tunes its own numbers in .strauss/kb-pins.json without touching hook commands. Like kb_schema and kb_types this takes no bundlePath \u2014 it reads the workspace pin manifests, because which bases a session should see is workspace state, not a property of one base.",
+  input: import_zod7.z.object({
+    budgetTokens: import_zod7.z.number().int().positive().optional().describe(
+      "Ceiling on the whole emitted block; past it the command refuses with a list of bases rather than truncating. Defaults to 4000."
+    ),
+    fullUnderTokens: import_zod7.z.number().int().positive().optional().describe(
+      "Per-base rendering threshold, applied before the budget: a base whose complete load fits under this arrives as full records instead of index lines, and the whole block still answers to budgetTokens. Off by default \u2014 index-only is the safe default at a context birth, because injected bodies outlive the qualifiers on them; the session-start profile opts tiny bases in at 1500."
+    ),
+    profile: import_zod7.z.string().optional().describe(
+      "Named budget set: built-ins are session-start (full-under 1500), compact and turn (budget 2500); the manifests' `context` tables override per repo. Unknown names fall through to defaults rather than failing."
+    ),
+    format: import_zod7.z.enum(["markdown", "json"]).optional().describe(
+      "CLI envelope for hook protocols that require strict JSON on stdout. MCP callers omit this \u2014 the block itself is identical."
+    ),
+    event: import_zod7.z.string().optional().describe(
+      "hookEventName stamped into the JSON envelope. Only meaningful with format=json."
+    )
+  }),
+  fromArgv: (argv) => {
+    const budget = argvFlag(argv, "--budget");
+    const fullUnder = argvFlag(argv, "--full-under");
+    const profile = argvFlag(argv, "--profile");
+    const format = argvFlag(argv, "--format");
+    const event = argvFlag(argv, "--event");
+    return {
+      ...budget ? { budgetTokens: Number(budget) } : {},
+      ...fullUnder ? { fullUnderTokens: Number(fullUnder) } : {},
+      ...profile ? { profile } : {},
+      ...format ? { format } : {},
+      ...event ? { event } : {}
+    };
+  },
+  run: async ({ store }, { budgetTokens, fullUnderTokens, profile, format, event }) => {
+    const result = await buildContext(store, process.cwd(), {
+      ...budgetTokens ? { budgetTokens } : {},
+      ...fullUnderTokens ? { fullUnderTokens } : {},
+      ...profile ? { profile } : {},
+      // Degradations — a full pin that could not fit, a refused block — go
+      // to stderr as well as into the block itself: stderr is diagnostics on
+      // both surfaces (hooks discard it, MCP logs it), so an operator can
+      // see budget pressure without reading injected context.
+      warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}
+`)
+    });
+    if (!result.block) return "";
+    return format === "json" ? toHookJson(result.block, event ?? "SessionStart") : result.block;
+  }
+});
+
+// src/commands/list.ts
+var import_zod8 = require("zod");
+var listCommand = define({
+  name: "list",
+  tool: "kb_list",
+  usage: "list [type]",
+  description: "Every record, optionally narrowed to one type. Use kb_query when you have a question; this is for enumerating.",
+  input: import_zod8.z.object({ bundlePath, type: import_zod8.z.enum(KB_RECORD_TYPES).optional() }),
+  fromArgv: (argv, path) => ({ bundlePath: path, type: argv[1] }),
+  run: async ({ store }, { bundlePath: path, type }) => (await store.list(path, type)).map((record) => ({
+    conceptId: record.conceptId,
+    title: record.frontmatter.title ?? null,
+    description: record.frontmatter.description ?? null,
+    status: record.frontmatter.strauss_status,
+    anchors: record.frontmatter.strauss_anchors ?? []
+  }))
+});
+
+// src/commands/load.ts
+var import_zod9 = require("zod");
+var loadCommand = define({
+  name: "load",
+  tool: "kb_load",
+  usage: "load [type] [--budget N]",
+  description: "Load the whole knowledge base at once, each record with its standing. Prefer this over searching: these bases run to a few thousand tokens, and a reader holding all of it has perfect recall and knows why it is asking, which no ranker does. Superseded records arrive under `superseded` as name, replacement and date only \u2014 their bodies no longer hold, and reading one later in a long session is the mistake this prevents; pass the id to kb_trace when you need the history. Rejected and unresolved records arrive whole: what was turned down, and what is still open, is the part a diff cannot show you. Refuses with a count rather than truncating when the base is too large \u2014 a truncated base is indistinguishable from a complete one, and would have you conclude something was never decided from a slice you did not know was a slice. Call at the point of use, not once per session: a base loaded early is summarised away by compaction, so if the visible context holds no records from this base and the question at hand is one it might govern, load before answering \u2014 never conclude nothing was decided from a context with no KB content in it. This tool (with kb_query and kb_trace) is the only supported way to read a base; a raw file read bypasses supersession resolution and returns replaced records as if current.",
+  input: import_zod9.z.object({
+    bundlePath,
+    type: import_zod9.z.enum(KB_RECORD_TYPES).optional(),
+    budgetTokens: import_zod9.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000.")
+  }),
+  fromArgv: (argv, path) => {
+    const budget = argvFlag(argv, "--budget");
+    return {
+      bundlePath: path,
+      ...argv[1] && argv[1] !== "--budget" ? { type: argv[1] } : {},
+      ...budget ? { budgetTokens: Number(budget) } : {}
+    };
+  },
+  run: async ({ store }, { bundlePath: path, type, budgetTokens }) => {
+    const result = await store.load(path, {
+      ...type ? { type } : {},
+      ...budgetTokens ? { budgetTokens } : {}
+    });
+    if (!result.loaded) return result;
+    return {
+      ...result,
+      records: result.records.map((hit) => ({
+        conceptId: hit.record.conceptId,
+        title: hit.record.frontmatter.title ?? null,
+        standing: hit.standing,
+        supersededBy: hit.heads.map((head) => head.conceptId),
+        warnings: hit.warnings,
+        anchors: hit.record.frontmatter.strauss_anchors ?? [],
+        body: hit.record.body
+      }))
+    };
+  }
+});
+
+// src/commands/log.ts
+var import_zod10 = require("zod");
+var logCommand = define({
+  name: "log",
+  tool: "kb_log",
+  usage: "log",
+  description: "What touched what, and when. The only artifact here that cannot be reconstructed from the records, so malformed lines are reported rather than repaired.",
+  input: import_zod10.z.object({ bundlePath }),
+  fromArgv: (_argv, path) => ({ bundlePath: path }),
+  run: ({ store }, { bundlePath: path }) => store.readLog(path)
+});
+
+// src/commands/no-decision.ts
+var import_zod11 = require("zod");
+var noDecisionCommand = define({
+  name: "no-decision",
+  tool: "kb_no_decision",
+  usage: "no-decision <reason...>",
+  description: 'Claim in one sentence that there was nothing to decide. Gating on "did you write a decision?" rewards writing a junk one; gating on "did you answer?" does not, so silence has to be expressible. Idempotent \u2014 restating it is not a collision.',
+  input: import_zod11.z.object({ bundlePath, reason: import_zod11.z.string().min(1) }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    reason: argv.slice(1).join(" ").trim()
+  }),
+  run: async ({ store, actor, now }, { bundlePath: path, reason }) => {
+    await assertBaseNotFrozen(process.cwd(), path);
+    const record = await store.write(
+      path,
+      { ...composeNoDecisionRecord(reason, actor, now()), overwrite: true },
+      actor
+    );
+    return { conceptId: record.conceptId };
+  }
+});
+
+// src/commands/pin.ts
+var import_zod12 = require("zod");
+var pinCommand = define({
+  name: "pin",
+  tool: "kb_pin",
+  usage: "pin [bundle-path] [--mode full|index] [--profiles a,b] [--local|--user] [--frozen|--unfreeze]",
+  description: "Pin a base into a workspace pin manifest, so `context` surfaces it at every context birth. Three layers, nearest wins: the committed project manifest (.strauss/kb-pins.json, the default), `--local` (.strauss/kb-pins.local.json, personal and gitignored), and `--user` (~/.strauss/kb-pins.json, every workspace). Idempotent \u2014 re-pinning changes nothing unless --mode, --profiles, or --frozen/--unfreeze are given, which update just those fields. `--mode full` preloads the whole base into the block regardless of the full-under threshold; `--mode index` never upgrades. `--profiles` scopes the pin to named context profiles. `--frozen` marks the base concluded: write commands against it refuse and `context` labels it read-only. A path with no records yet succeeds with a warning; bases are routinely pinned before they are populated. Pins are workspace state: the pinned base itself is never touched.",
+  input: import_zod12.z.object({
+    bundlePath,
+    mode: import_zod12.z.enum(["full", "index"]).optional().describe(
+      "full: always emit this base's records whole (still under the block budget); index: never upgrade. Absent: the profile's full-under threshold decides."
+    ),
+    profiles: import_zod12.z.array(import_zod12.z.string()).optional().describe("Context profiles this pin surfaces in. Absent: all of them."),
+    layer: import_zod12.z.enum(["project", "local", "user"]).optional().describe(
+      "Which manifest to write: project (committed, default), local (personal, gitignored), user (~/.strauss, every workspace)."
+    ),
+    frozen: import_zod12.z.boolean().optional().describe(
+      "true: the base is concluded \u2014 writes against it refuse while pinned. false: lift a freeze."
+    )
+  }),
+  fromArgv: (argv, path) => {
+    const positional = argv[1] && !argv[1].startsWith("--") ? argv[1] : path;
+    const mode = argvFlag(argv, "--mode");
+    const profiles = argvFlag(argv, "--profiles");
+    const layer = argv.includes("--user") ? "user" : argv.includes("--local") ? "local" : void 0;
+    const frozen = argv.includes("--frozen") ? true : argv.includes("--unfreeze") ? false : void 0;
+    return {
+      bundlePath: positional,
+      ...mode ? { mode } : {},
+      ...profiles ? {
+        profiles: profiles.split(",").map((p) => p.trim()).filter(Boolean)
+      } : {},
+      ...layer ? { layer } : {},
+      ...frozen !== void 0 ? { frozen } : {}
+    };
+  },
+  run: ({ store, now }, { bundlePath: path, mode, profiles, layer, frozen }) => pinBase(store, process.cwd(), path, now(), {
+    ...mode ? { mode } : {},
+    ...profiles ? { profiles } : {},
+    ...layer ? { layer } : {},
+    ...frozen !== void 0 ? { frozen } : {}
+  })
+});
+
+// src/commands/pins.ts
+var import_zod13 = require("zod");
+var pinsCommand = define({
+  name: "pins",
+  tool: "kb_pins",
+  usage: "pins",
+  description: "Every pinned base across the manifest layers, each with its layer and whether it currently resolves to readable records. Reads the workspace manifests rather than any one base, like kb_context.",
+  input: import_zod13.z.object({}),
+  fromArgv: () => ({}),
+  run: ({ store }) => listPins(store, process.cwd())
+});
+
+// src/commands/query.ts
+var import_zod14 = require("zod");
+var queryCommand = define({
+  name: "query",
+  tool: "kb_query",
+  usage: "query <text...>",
+  description: "Search and return each match with its standing. Results are flagged, never filtered: a superseded record comes back alongside whatever replaced it, and a rejected one is marked as something explicitly not adopted. Prefer kb_load when the base fits its budget: on this package's measurements, a reader holding the whole base answered eight of nine questions whose wording appears in no record, where embedding search answered four. Never read record files directly \u2014 this tool (with kb_load and kb_trace) is the only supported way to read a base; a file read bypasses supersession resolution and returns replaced records as if current.",
+  input: import_zod14.z.object({
+    bundlePath,
+    text: import_zod14.z.string().optional(),
+    type: import_zod14.z.enum(KB_RECORD_TYPES).optional(),
+    includeNonCurrent: import_zod14.z.boolean().optional()
+  }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    text: argv.slice(1).join(" ").trim(),
+    includeNonCurrent: true
+  }),
+  run: async ({ store }, { bundlePath: path, text, type, includeNonCurrent }) => (await store.query(path, text ?? "", {
+    ...type ? { type } : {},
+    includeNonCurrent: includeNonCurrent === true
+  })).map((hit) => ({
+    conceptId: hit.record.conceptId,
+    title: hit.record.frontmatter.title ?? null,
+    description: hit.record.frontmatter.description ?? null,
+    standing: hit.standing,
+    supersededBy: hit.heads.map((head) => head.conceptId),
+    warnings: hit.warnings,
+    body: hit.record.body
+  }))
+});
+
+// src/commands/read-index.ts
+var import_zod15 = require("zod");
+var readIndexCommand = define({
+  name: "index",
+  tool: "kb_index",
+  usage: "index",
+  description: "The index, rebuilt if it disagrees with the records. One call gives the whole shape of the base: title, type, status, and description per record. The cheap re-orientation call after compaction or deep in a long session \u2014 a few hundred tokens; call it (or kb_context, when bases are pinned) first, then kb_load or fetch by concept id.",
+  input: import_zod15.z.object({ bundlePath }),
+  fromArgv: (_argv, path) => ({ bundlePath: path }),
+  run: ({ store }, { bundlePath: path }) => store.readIndex(path)
+});
+
+// src/commands/schema.ts
+var import_zod18 = require("zod");
+
 // src/json-schema.ts
-var import_zod5 = require("zod");
+var import_zod17 = require("zod");
 
 // src/kb-log.ts
-var import_zod4 = require("zod");
+var import_zod16 = require("zod");
 var LOG_FILE = "log.jsonl";
-var kbLogEntrySchema = import_zod4.z.object({
-  at: import_zod4.z.string().min(1),
-  by: import_zod4.z.string().min(1),
-  operation: import_zod4.z.string().min(1),
-  conceptId: import_zod4.z.string().min(1),
+var kbLogEntrySchema = import_zod16.z.object({
+  at: import_zod16.z.string().min(1),
+  by: import_zod16.z.string().min(1),
+  operation: import_zod16.z.string().min(1),
+  conceptId: import_zod16.z.string().min(1),
   /** Second concept id, where the operation relates two — supersession. */
-  target: import_zod4.z.string().min(1).optional()
+  target: import_zod16.z.string().min(1).optional()
 }).strict();
 function renderLogEntry(entry) {
   return `${JSON.stringify(kbLogEntrySchema.parse(entry))}
@@ -347,14 +1290,107 @@ function parseLog(raw) {
 // src/json-schema.ts
 function kbJsonSchemas() {
   return {
-    recordFrontmatter: import_zod5.z.toJSONSchema(kbRecordFrontmatterSchema, {
+    recordFrontmatter: import_zod17.z.toJSONSchema(kbRecordFrontmatterSchema, {
       io: "input"
     }),
-    composeInput: import_zod5.z.toJSONSchema(composeInputSchema, { io: "input" }),
-    logEntry: import_zod5.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
+    composeInput: import_zod17.z.toJSONSchema(composeInputSchema, { io: "input" }),
+    logEntry: import_zod17.z.toJSONSchema(kbLogEntrySchema, { io: "input" })
   };
 }
 
+// src/commands/schema.ts
+var schemaCommand = define({
+  name: "schema",
+  tool: "kb_schema",
+  usage: "schema",
+  description: "JSON Schema for the frontmatter, the write input, and log entries \u2014 generated from the code that enforces them, so it cannot drift from what a write will accept.",
+  input: import_zod18.z.object({}),
+  fromArgv: () => ({}),
+  run: () => Promise.resolve(kbJsonSchemas())
+});
+
+// src/commands/status.ts
+var import_zod19 = require("zod");
+var statusCommand = define({
+  name: "status",
+  tool: "kb_status",
+  usage: "status <concept-id> <status>",
+  description: "Move a record's status, leaving everything else alone. Uses a compare-and-swap, so a concurrent change fails loudly rather than being overwritten.",
+  input: import_zod19.z.object({
+    bundlePath,
+    conceptId,
+    status: import_zod19.z.enum(KB_RECORD_STATUSES)
+  }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    conceptId: argv[1],
+    status: argv[2]
+  }),
+  run: async ({ store, actor }, { bundlePath: path, conceptId: id, status }) => {
+    await assertBaseNotFrozen(process.cwd(), path);
+    const record = await store.setStatus(path, id, status, actor);
+    return { conceptId: record.conceptId, status };
+  }
+});
+
+// src/commands/supersede.ts
+var import_zod20 = require("zod");
+var supersedeCommand = define({
+  name: "supersede",
+  tool: "kb_supersede",
+  usage: "supersede <concept-id> <replacement-id>",
+  description: "Mark a record superseded by another, linking both directions. Use this rather than editing a record whose meaning changed \u2014 a record that quietly becomes something else invalidates every reference to it, and the earlier understanding is what a later trace needs.",
+  input: import_zod20.z.object({ bundlePath, conceptId, replacementId: conceptId }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    conceptId: argv[1],
+    replacementId: argv[2]
+  }),
+  run: async ({ store, actor }, { bundlePath: path, conceptId: id, replacementId }) => {
+    await assertBaseNotFrozen(process.cwd(), path);
+    await store.supersede(path, id, replacementId, actor);
+    return { superseded: id, replacedBy: replacementId };
+  }
+});
+
+// src/commands/sync-instructions.ts
+var import_zod21 = require("zod");
+var syncInstructionsCommand = define({
+  name: "sync-instructions",
+  usage: "sync-instructions <file> [--profile NAME] [--budget N] [--full-under N]",
+  description: "Idempotently plant the `context` block between sentinel comments in an instruction file (AGENTS.md, CLAUDE.md), creating the block when absent and leaving everything outside the sentinels alone. CLI-only: this is file plumbing for runtimes whose instruction files are re-read where their conversations are not, not an agent capability \u2014 the capability is kb_context.",
+  input: import_zod21.z.object({
+    file: import_zod21.z.string().min(1).describe("The instruction file to edit in place."),
+    budgetTokens: import_zod21.z.number().int().positive().optional(),
+    fullUnderTokens: import_zod21.z.number().int().positive().optional(),
+    profile: import_zod21.z.string().optional()
+  }),
+  fromArgv: (argv) => {
+    const budget = argvFlag(argv, "--budget");
+    const fullUnder = argvFlag(argv, "--full-under");
+    const profile = argvFlag(argv, "--profile");
+    return {
+      file: argv[1],
+      ...budget ? { budgetTokens: Number(budget) } : {},
+      ...fullUnder ? { fullUnderTokens: Number(fullUnder) } : {},
+      ...profile ? { profile } : {}
+    };
+  },
+  run: async ({ store }, { file, budgetTokens, fullUnderTokens, profile }) => {
+    const result = await buildContext(store, process.cwd(), {
+      ...budgetTokens ? { budgetTokens } : {},
+      ...fullUnderTokens ? { fullUnderTokens } : {},
+      ...profile ? { profile } : {},
+      warn: (entry) => process.stderr.write(`${JSON.stringify(entry)}
+`)
+    });
+    return syncInstructions(file, result.block);
+  }
+});
+
+// src/commands/trace.ts
+var import_zod22 = require("zod");
+
 // src/trace.ts
 var TRACE_EDGES = ["supersession", "anchor", "source"];
 function trace(seedId, bundle, options = {}) {
@@ -428,6 +1464,64 @@ function byGeneratedAt(left, right) {
   return at(left).localeCompare(at(right)) || left.depth - right.depth;
 }
 
+// src/commands/trace.ts
+var traceCommand = define({
+  name: "trace",
+  tool: "kb_trace",
+  usage: "trace <concept-id> [edges...]",
+  description: 'How a position was arrived at, as a timeline ordered by when each record was written. Deliberately includes rejected, draft, and superseded records \u2014 in a history those are the content, not noise. Follows supersession, shared code anchors, and shared sources. Use when the question is "why is this the way it is" rather than "what do we hold now". This tool (with kb_load and kb_query) is the only supported way to read a base; a raw file read bypasses supersession resolution and returns replaced records as if current.',
+  input: import_zod22.z.object({
+    bundlePath,
+    conceptId,
+    edges: import_zod22.z.array(import_zod22.z.enum(TRACE_EDGES)).optional(),
+    depth: import_zod22.z.number().int().positive().optional()
+  }),
+  fromArgv: (argv, path) => ({
+    bundlePath: path,
+    conceptId: argv[1],
+    edges: argv.slice(2).filter((edge) => TRACE_EDGES.includes(edge))
+  }),
+  run: async ({ store }, { bundlePath: path, conceptId: id, edges, depth }) => (await store.trace(path, id, {
+    ...edges?.length ? { edges } : {},
+    ...depth ? { depth } : {}
+  })).map((step) => ({
+    conceptId: step.record.conceptId,
+    at: step.record.frontmatter.generated?.at ?? null,
+    status: step.record.frontmatter.strauss_status,
+    title: step.record.frontmatter.title ?? null,
+    depth: step.depth,
+    via: step.via,
+    body: step.record.body
+  }))
+});
+
+// src/commands/types.ts
+var import_zod23 = require("zod");
+var typesCommand = define({
+  name: "types",
+  tool: "kb_types",
+  usage: "types",
+  description: "The twelve record types with their purpose, body sections, and starting status. Read this before writing rather than guessing headings \u2014 a section the type does not define is rejected.",
+  input: import_zod23.z.object({}),
+  fromArgv: () => ({}),
+  run: () => Promise.resolve(RECORD_TYPES)
+});
+
+// src/commands/unpin.ts
+var import_zod24 = require("zod");
+var unpinCommand = define({
+  name: "unpin",
+  tool: "kb_unpin",
+  usage: "unpin [bundle-path]",
+  description: "Remove a base from every pin manifest layer that holds it \u2014 project, local, and user \u2014 because unpinned means gone, not still injected from another file. Reports which layers were touched.",
+  input: import_zod24.z.object({ bundlePath }),
+  fromArgv: (argv, path) => ({ bundlePath: argv[1] ?? path }),
+  run: (_ctx, { bundlePath: path }) => unpinBase(process.cwd(), path)
+});
+
+// src/commands/validate.ts
+var import_zod25 = require("zod");
+
 // src/validate.ts
 function validateBundle(records) {
   const byId = new Map(records.map((record) => [record.conceptId, record]));
@@ -463,299 +1557,114 @@ function validateBundle(records) {
   return problems;
 }
 
-// src/commands.ts
-var bundlePath = import_zod6.z.string().min(1).describe("Absolute path to the knowledge base directory.");
-var conceptId = import_zod6.z.string().min(1).describe("e.g. decision.cursor-v2");
-function define(command) {
-  return command;
-}
-var KB_COMMANDS = [
-  define({
-    name: "write",
-    tool: "kb_write",
-    usage: "write <type> < record.json",
-    description: [
-      "Write one record. Search first \u2014 the same knowledge filed twice under different slugs is how a base rots, and a duplicate concept id is rejected rather than overwritten. Call kb_types for the sections each type accepts.",
-      "",
-      "Judgment the tool cannot enforce for you:",
-      "- An unsourced claim is an `assumption` record with assumption: true, never a `fact` with a vague source. The distinction is what lets a later reader separate what was established from what was guessed.",
-      "- When two records conflict, say so in a `risk`, an `open-question`, or a superseding `decision`. Quietly picking a winner destroys the disagreement, which is usually the useful part.",
-      "- Prefer a new record over overloading an existing one, and keep each short. A record nobody finishes reading is not durable memory.",
-      "- Records are never deleted; supersede instead, so the earlier reasoning stays inspectable."
-    ].join("\n"),
-    input: import_zod6.z.object({
-      bundlePath,
-      type: import_zod6.z.enum(KB_RECORD_TYPES),
-      input: composeInputSchema
-    }),
-    fromArgv: async (argv, path, stdin) => ({
-      bundlePath: path,
-      type: argv[1],
-      input: JSON.parse(await stdin())
-    }),
-    run: async ({ store, actor, now }, { bundlePath: path, type, input }) => {
-      const record = await store.write(
-        path,
-        composeRecord(type, input, actor, now()),
-        actor
-      );
-      return { conceptId: record.conceptId };
-    }
-  }),
-  define({
-    name: "write-decision",
-    tool: "kb_write_decision",
-    usage: "write-decision < decision.json",
-    description: [
-      "Write a decision. Takes `alternative` and `impact` as fields rather than free sections, because what was rejected is the part a later reader cannot reconstruct from the code \u2014 a heading is too easy to leave empty.",
-      "",
-      "What belongs in one:",
-      '- Record a decision when a later reader would otherwise "simplify" the constraint away. If the diff already answers the question, there is nothing here to write.',
-      "- `alternative` is what you turned down and why, not a list of everything considered.",
-      "- A reference to material you read goes in `sources`; a reference to code goes in `anchors`; a reference to another record goes in `relatedConceptIds`."
-    ].join("\n"),
-    input: import_zod6.z.object({ bundlePath, input: decisionInputSchema }),
-    fromArgv: async (_argv, path, stdin) => ({
-      bundlePath: path,
-      input: JSON.parse(await stdin())
-    }),
-    run: async ({ store, actor, now }, { bundlePath: path, input }) => {
-      const record = await store.write(
-        path,
-        composeDecisionRecord(input, actor, now()),
-        actor
-      );
-      return { conceptId: record.conceptId };
-    }
-  }),
-  define({
-    name: "no-decision",
-    tool: "kb_no_decision",
-    usage: "no-decision <reason...>",
-    description: 'Claim in one sentence that there was nothing to decide. Gating on "did you write a decision?" rewards writing a junk one; gating on "did you answer?" does not, so silence has to be expressible. Idempotent \u2014 restating it is not a collision.',
-    input: import_zod6.z.object({ bundlePath, reason: import_zod6.z.string().min(1) }),
-    fromArgv: (argv, path) => ({
-      bundlePath: path,
-      reason: argv.slice(1).join(" ").trim()
-    }),
-    run: async ({ store, actor, now }, { bundlePath: path, reason }) => {
-      const record = await store.write(
-        path,
-        { ...composeNoDecisionRecord(reason, actor, now()), overwrite: true },
-        actor
-      );
-      return { conceptId: record.conceptId };
-    }
-  }),
-  define({
-    name: "status",
-    tool: "kb_status",
-    usage: "status <concept-id> <status>",
-    description: "Move a record's status, leaving everything else alone. Uses a compare-and-swap, so a concurrent change fails loudly rather than being overwritten.",
-    input: import_zod6.z.object({
-      bundlePath,
-      conceptId,
-      status: import_zod6.z.enum(KB_RECORD_STATUSES)
-    }),
-    fromArgv: (argv, path) => ({
-      bundlePath: path,
-      conceptId: argv[1],
-      status: argv[2]
-    }),
-    run: async ({ store, actor }, { bundlePath: path, conceptId: id, status }) => {
-      const record = await store.setStatus(path, id, status, actor);
-      return { conceptId: record.conceptId, status };
-    }
-  }),
-  define({
-    name: "supersede",
-    tool: "kb_supersede",
-    usage: "supersede <concept-id> <replacement-id>",
-    description: "Mark a record superseded by another, linking both directions. Use this rather than editing a record whose meaning changed \u2014 a record that quietly becomes something else invalidates every reference to it, and the earlier understanding is what a later trace needs.",
-    input: import_zod6.z.object({ bundlePath, conceptId, replacementId: conceptId }),
-    fromArgv: (argv, path) => ({
-      bundlePath: path,
-      conceptId: argv[1],
-      replacementId: argv[2]
-    }),
-    run: async ({ store, actor }, { bundlePath: path, conceptId: id, replacementId }) => {
-      await store.supersede(path, id, replacementId, actor);
-      return { superseded: id, replacedBy: replacementId };
-    }
-  }),
-  define({
-    name: "answer",
-    tool: "kb_answer",
-    usage: "answer <concept-id> <answer...>",
-    description: "Resolve an open question: sets the status, stamps who answered and when, and appends an Answer section. If the answer overturns an assumption or a decision, that is a supersession \u2014 do it explicitly.",
-    input: import_zod6.z.object({ bundlePath, conceptId, answer: import_zod6.z.string().min(1) }),
-    fromArgv: (argv, path) => ({
-      bundlePath: path,
-      conceptId: argv[1],
-      answer: argv.slice(2).join(" ").trim()
-    }),
-    run: async ({ store, actor }, { bundlePath: path, conceptId: id, answer }) => {
-      const record = await store.answer(path, id, answer, actor);
-      return { conceptId: record.conceptId };
-    }
-  }),
-  define({
-    name: "load",
-    tool: "kb_load",
-    usage: "load [type] [--budget N]",
-    description: "Load the whole knowledge base at once, each record with its standing. Prefer this over searching: these bases run to a few thousand tokens, and a reader holding all of it has perfect recall and knows why it is asking, which no ranker does. Superseded records arrive under `superseded` as name, replacement and date only \u2014 their bodies no longer hold, and reading one later in a long session is the mistake this prevents; pass the id to kb_trace when you need the history. Rejected and unresolved records arrive whole: what was turned down, and what is still open, is the part a diff cannot show you. Refuses with a count rather than truncating when the base is too large \u2014 a truncated base is indistinguishable from a complete one, and would have you conclude something was never decided from a slice you did not know was a slice.",
-    input: import_zod6.z.object({
-      bundlePath,
-      type: import_zod6.z.enum(KB_RECORD_TYPES).optional(),
-      budgetTokens: import_zod6.z.number().int().positive().optional().describe("Approximate token ceiling. Defaults to 25000.")
-    }),
-    fromArgv: (argv, path) => {
-      const at = argv.indexOf("--budget");
-      return {
-        bundlePath: path,
-        ...argv[1] && argv[1] !== "--budget" ? { type: argv[1] } : {},
-        ...at !== -1 && argv[at + 1] ? { budgetTokens: Number(argv[at + 1]) } : {}
-      };
-    },
-    run: async ({ store }, { bundlePath: path, type, budgetTokens }) => {
-      const result = await store.load(path, {
-        ...type ? { type } : {},
-        ...budgetTokens ? { budgetTokens } : {}
-      });
-      if (!result.loaded) return result;
-      return {
-        ...result,
-        records: result.records.map((hit) => ({
-          conceptId: hit.record.conceptId,
-          title: hit.record.frontmatter.title ?? null,
-          standing: hit.standing,
-          supersededBy: hit.heads.map((head) => head.conceptId),
-          warnings: hit.warnings,
-          anchors: hit.record.frontmatter.strauss_anchors ?? [],
-          body: hit.record.body
-        }))
-      };
-    }
-  }),
-  define({
-    name: "query",
-    tool: "kb_query",
-    usage: "query <text...>",
-    description: "Search and return each match with its standing. Results are flagged, never filtered: a superseded record comes back alongside whatever replaced it, and a rejected one is marked as something explicitly not adopted. Prefer this over reading record files directly \u2014 relevance and standing are different questions, and a bare match answers only the first.",
-    input: import_zod6.z.object({
-      bundlePath,
-      text: import_zod6.z.string().optional(),
-      type: import_zod6.z.enum(KB_RECORD_TYPES).optional(),
-      includeNonCurrent: import_zod6.z.boolean().optional()
-    }),
-    fromArgv: (argv, path) => ({
-      bundlePath: path,
-      text: argv.slice(1).join(" ").trim(),
-      includeNonCurrent: true
-    }),
-    run: async ({ store }, { bundlePath: path, text, type, includeNonCurrent }) => (await store.query(path, text ?? "", {
-      ...type ? { type } : {},
-      includeNonCurrent: includeNonCurrent === true
-    })).map((hit) => ({
-      conceptId: hit.record.conceptId,
-      title: hit.record.frontmatter.title ?? null,
-      description: hit.record.frontmatter.description ?? null,
-      standing: hit.standing,
-      supersededBy: hit.heads.map((head) => head.conceptId),
-      warnings: hit.warnings,
-      body: hit.record.body
-    }))
+// src/commands/validate.ts
+var validateCommand = define({
+  name: "validate",
+  tool: "kb_validate",
+  usage: "validate",
+  description: "Check pointers no single record can see: supersession links that disagree between the two records, and assumptions that cite sources. Per-record shape is enforced on every read, so a problem here means someone edited a file by hand.",
+  input: import_zod25.z.object({ bundlePath }),
+  fromArgv: (_argv, path) => ({ bundlePath: path }),
+  run: async ({ store }, { bundlePath: path }) => validateBundle(await store.list(path)),
+  failsWhen: (result) => Array.isArray(result) && result.length > 0
+});
+
+// src/commands/write.ts
+var import_zod26 = require("zod");
+var writeCommand = define({
+  name: "write",
+  tool: "kb_write",
+  usage: "write <type> < record.json",
+  description: [
+    "Write one record. Search first \u2014 the same knowledge filed twice under different slugs is how a base rots, and a duplicate concept id is rejected rather than overwritten. Call kb_types for the sections each type accepts.",
+    "",
+    "Judgment the tool cannot enforce for you:",
+    "- An unsourced claim is an `assumption` record with assumption: true, never a `fact` with a vague source. The distinction is what lets a later reader separate what was established from what was guessed.",
+    "- When two records conflict, say so in a `risk`, an `open-question`, or a superseding `decision`. Quietly picking a winner destroys the disagreement, which is usually the useful part.",
+    "- Prefer a new record over overloading an existing one, and keep each short. A record nobody finishes reading is not durable memory.",
+    "- Records are never deleted; supersede instead, so the earlier reasoning stays inspectable."
+  ].join("\n"),
+  input: import_zod26.z.object({
+    bundlePath,
+    type: import_zod26.z.enum(KB_RECORD_TYPES),
+    input: composeInputSchema
   }),
-  define({
-    name: "trace",
-    tool: "kb_trace",
-    usage: "trace <concept-id> [edges...]",
-    description: 'How a position was arrived at, as a timeline ordered by when each record was written. Deliberately includes rejected, draft, and superseded records \u2014 in a history those are the content, not noise. Follows supersession, shared code anchors, and shared sources. Use when the question is "why is this the way it is" rather than "what do we hold now".',
-    input: import_zod6.z.object({
-      bundlePath,
-      conceptId,
-      edges: import_zod6.z.array(import_zod6.z.enum(TRACE_EDGES)).optional(),
-      depth: import_zod6.z.number().int().positive().optional()
-    }),
-    fromArgv: (argv, path) => ({
-      bundlePath: path,
-      conceptId: argv[1],
-      edges: argv.slice(2).filter((edge) => TRACE_EDGES.includes(edge))
-    }),
-    run: async ({ store }, { bundlePath: path, conceptId: id, edges, depth }) => (await store.trace(path, id, {
-      ...edges?.length ? { edges } : {},
-      ...depth ? { depth } : {}
-    })).map((step) => ({
-      conceptId: step.record.conceptId,
-      at: step.record.frontmatter.generated?.at ?? null,
-      status: step.record.frontmatter.strauss_status,
-      title: step.record.frontmatter.title ?? null,
-      depth: step.depth,
-      via: step.via,
-      body: step.record.body
-    }))
+  fromArgv: async (argv, path, stdin) => ({
+    bundlePath: path,
+    type: argv[1],
+    input: JSON.parse(await stdin())
   }),
-  define({
-    name: "list",
-    tool: "kb_list",
-    usage: "list [type]",
-    description: "Every record, optionally narrowed to one type. Use kb_query when you have a question; this is for enumerating.",
-    input: import_zod6.z.object({ bundlePath, type: import_zod6.z.enum(KB_RECORD_TYPES).optional() }),
-    fromArgv: (argv, path) => ({ bundlePath: path, type: argv[1] }),
-    run: async ({ store }, { bundlePath: path, type }) => (await store.list(path, type)).map((record) => ({
+  run: async ({ store, actor, now }, { bundlePath: path, type, input }) => {
+    await assertBaseNotFrozen(process.cwd(), path);
+    const record = await store.write(
+      path,
+      composeRecord(type, input, actor, now()),
+      actor
+    );
+    return {
       conceptId: record.conceptId,
-      title: record.frontmatter.title ?? null,
-      description: record.frontmatter.description ?? null,
-      status: record.frontmatter.strauss_status,
-      anchors: record.frontmatter.strauss_anchors ?? []
-    }))
-  }),
-  define({
-    name: "index",
-    tool: "kb_index",
-    usage: "index",
-    description: "The index, rebuilt if it disagrees with the records. One call gives the whole shape of the base: title, type, status, and description per record.",
-    input: import_zod6.z.object({ bundlePath }),
-    fromArgv: (_argv, path) => ({ bundlePath: path }),
-    run: ({ store }, { bundlePath: path }) => store.readIndex(path)
-  }),
-  define({
-    name: "log",
-    tool: "kb_log",
-    usage: "log",
-    description: "What touched what, and when. The only artifact here that cannot be reconstructed from the records, so malformed lines are reported rather than repaired.",
-    input: import_zod6.z.object({ bundlePath }),
-    fromArgv: (_argv, path) => ({ bundlePath: path }),
-    run: ({ store }, { bundlePath: path }) => store.readLog(path)
-  }),
-  define({
-    name: "validate",
-    tool: "kb_validate",
-    usage: "validate",
-    description: "Check pointers no single record can see: supersession links that disagree between the two records, and assumptions that cite sources. Per-record shape is enforced on every read, so a problem here means someone edited a file by hand.",
-    input: import_zod6.z.object({ bundlePath }),
-    fromArgv: (_argv, path) => ({ bundlePath: path }),
-    run: async ({ store }, { bundlePath: path }) => validateBundle(await store.list(path)),
-    failsWhen: (result) => Array.isArray(result) && result.length > 0
-  }),
-  define({
-    name: "schema",
-    tool: "kb_schema",
-    usage: "schema",
-    description: "JSON Schema for the frontmatter, the write input, and log entries \u2014 generated from the code that enforces them, so it cannot drift from what a write will accept.",
-    input: import_zod6.z.object({}),
-    fromArgv: () => ({}),
-    run: () => Promise.resolve(kbJsonSchemas())
+      action: record.action,
+      supersededIds: record.supersededIds
+    };
+  }
+});
+
+// src/commands/write-decision.ts
+var import_zod27 = require("zod");
+var writeDecisionCommand = define({
+  name: "write-decision",
+  tool: "kb_write_decision",
+  usage: "write-decision < decision.json",
+  description: [
+    "Write a decision. Takes `alternative` and `impact` as fields rather than free sections, because what was rejected is the part a later reader cannot reconstruct from the code \u2014 a heading is too easy to leave empty.",
+    "",
+    "What belongs in one:",
+    '- Record a decision when a later reader would otherwise "simplify" the constraint away. If the diff already answers the question, there is nothing here to write.',
+    "- `alternative` is what you turned down and why, not a list of everything considered.",
+    "- A reference to material you read goes in `sources`; a reference to code goes in `anchors`; a reference to another record goes in `relatedConceptIds`."
+  ].join("\n"),
+  input: import_zod27.z.object({ bundlePath, input: decisionInputSchema }),
+  fromArgv: async (_argv, path, stdin) => ({
+    bundlePath: path,
+    input: JSON.parse(await stdin())
   }),
-  define({
-    name: "types",
-    tool: "kb_types",
-    usage: "types",
-    description: "The twelve record types with their purpose, body sections, and starting status. Read this before writing rather than guessing headings \u2014 a section the type does not define is rejected.",
-    input: import_zod6.z.object({}),
-    fromArgv: () => ({}),
-    run: () => Promise.resolve(RECORD_TYPES)
-  })
+  run: async ({ store, actor, now }, { bundlePath: path, input }) => {
+    await assertBaseNotFrozen(process.cwd(), path);
+    const record = await store.write(
+      path,
+      composeDecisionRecord(input, actor, now()),
+      actor
+    );
+    return {
+      conceptId: record.conceptId,
+      action: record.action,
+      supersededIds: record.supersededIds
+    };
+  }
+});
+
+// src/commands/index.ts
+var KB_COMMANDS = [
+  writeCommand,
+  writeDecisionCommand,
+  noDecisionCommand,
+  statusCommand,
+  supersedeCommand,
+  answerCommand,
+  loadCommand,
+  queryCommand,
+  traceCommand,
+  listCommand,
+  readIndexCommand,
+  logCommand,
+  validateCommand,
+  schemaCommand,
+  pinCommand,
+  unpinCommand,
+  pinsCommand,
+  contextCommand,
+  syncInstructionsCommand,
+  typesCommand
 ];
 var KB_COMMANDS_BY_NAME = new Map(
   KB_COMMANDS.map((command) => [command.name, command])
@@ -763,8 +1672,8 @@ var KB_COMMANDS_BY_NAME = new Map(
 
 // src/kb-store.ts
 var import_node_crypto = require("crypto");
-var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
+var import_promises4 = require("fs/promises");
+var import_node_path6 = require("path");
 
 // src/markdown.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
@@ -821,7 +1730,7 @@ var KbRecordAlreadyExistsError = class extends BaseError {
       fault: "User" /* User */,
       retriable: false,
       reportToUser: true,
-      details: { conceptId: conceptId2 }
+      details: { conceptId: conceptId2, action: "refused" }
     });
     this.conceptId = conceptId2;
   }
@@ -871,121 +1780,9 @@ var KbInvalidConceptIdError = class extends BaseError {
   }
 };
 
-// src/kb-index.ts
-var INDEX_FILE = "INDEX.md";
-var HEADING = "# KB Index";
-function renderIndex(records) {
-  const lines = [...records].sort((left, right) => left.conceptId.localeCompare(right.conceptId)).map((record) => {
-    const { frontmatter: fm } = record;
-    const parts = [fm.type, fm.strauss_status];
-    if (fm.tags?.length) parts.push(`tags: ${fm.tags.join(", ")}`);
-    if (fm.description) parts.push(fm.description);
-    return `- [${fm.title ?? record.conceptId}](${record.conceptId}.md) \u2014 ${parts.join(" \xB7 ")}`;
-  });
-  return `${HEADING}
-
-${lines.join("\n")}
-`;
-}
-function indexIsStale(stored, expected) {
-  return stored !== expected;
-}
-
-// src/adjudicate.ts
-var STANDING = {
-  accepted: "current",
-  resolved: "current",
-  draft: "unsettled",
-  proposed: "unsettled",
-  open: "open",
-  rejected: "rejected",
-  superseded: "superseded"
-};
-function adjudicate(hits, bundle, now = /* @__PURE__ */ new Date()) {
-  const byId = new Map(bundle.map((record) => [record.conceptId, record]));
-  return hits.map((record) => {
-    const status = record.frontmatter.strauss_status;
-    const warnings = [];
-    let heads = [];
-    if (status === "superseded") {
-      const resolved = resolveHeads(record, byId);
-      heads = resolved.heads;
-      warnings.push(...resolved.warnings);
-      if (heads.length) {
-        warnings.push({
-          kind: "superseded",
-          by: heads.map((head) => head.conceptId)
-        });
-      }
-    } else if (status === "rejected") {
-      warnings.push({ kind: "rejected" });
-    } else if (status === "draft" || status === "proposed") {
-      warnings.push({ kind: "unsettled", status });
-    } else if (status === "open") {
-      warnings.push({ kind: "unresolved-question" });
-    }
-    const staleAfter = record.frontmatter.stale_after;
-    if (staleAfter && Date.parse(staleAfter) < now.getTime()) {
-      warnings.push({ kind: "stale", staleAfter });
-    }
-    if (!record.frontmatter.verified?.length) {
-      warnings.push({ kind: "unverified" });
-    }
-    return { record, standing: STANDING[status], heads, warnings };
-  });
-}
-function resolveHeads(from, byId) {
-  const warnings = [];
-  const heads = /* @__PURE__ */ new Map();
-  const seen = /* @__PURE__ */ new Set([from.conceptId]);
-  const queue = [from];
-  while (queue.length) {
-    const current = queue.shift();
-    const next = successors(current, byId);
-    for (const missing of next.missing) {
-      warnings.push({ kind: "broken-chain", missing });
-    }
-    if (!next.records.length) {
-      if (current.conceptId !== from.conceptId)
-        heads.set(current.conceptId, current);
-      continue;
-    }
-    for (const record of next.records) {
-      if (seen.has(record.conceptId)) {
-        warnings.push({ kind: "chain-cycle", through: [...seen] });
-        continue;
-      }
-      seen.add(record.conceptId);
-      queue.push(record);
-    }
-  }
-  if (heads.size > 1) {
-    warnings.push({ kind: "forked-chain", heads: [...heads.keys()] });
-  }
-  return { heads: [...heads.values()], warnings };
-}
-function successors(record, byId) {
-  const ids = /* @__PURE__ */ new Set();
-  const forward = record.frontmatter.strauss_superseded_by;
-  if (forward) ids.add(forward);
-  for (const [id, candidate] of byId) {
-    if (candidate.frontmatter.strauss_supersedes?.includes(record.conceptId)) {
-      ids.add(id);
-    }
-  }
-  const records = [];
-  const missing = [];
-  for (const id of ids) {
-    const found = byId.get(id);
-    if (found) records.push(found);
-    else missing.push(id);
-  }
-  return { records, missing };
-}
-
 // src/search-index.ts
-var import_promises = require("fs/promises");
-var import_node_path = require("path");
+var import_promises3 = require("fs/promises");
+var import_node_path5 = require("path");
 var SEARCH_INDEX_FILE = ".index.sqlite";
 var COLLECTION = "kb";
 async function searchBase(bundlePath2, query, options = {}) {
@@ -994,7 +1791,7 @@ async function searchBase(bundlePath2, query, options = {}) {
   let store = null;
   try {
     store = await qmd.createStore({
-      dbPath: (0, import_node_path.join)(bundlePath2, SEARCH_INDEX_FILE),
+      dbPath: (0, import_node_path5.join)(bundlePath2, SEARCH_INDEX_FILE),
       config: {
         collections: {
           [COLLECTION]: {
@@ -1029,13 +1826,13 @@ async function searchBase(bundlePath2, query, options = {}) {
   }
 }
 async function isStale(bundlePath2) {
-  const indexAt = await (0, import_promises.stat)((0, import_node_path.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
+  const indexAt = await (0, import_promises3.stat)((0, import_node_path5.join)(bundlePath2, SEARCH_INDEX_FILE)).then((s) => s.mtimeMs).catch(() => 0);
   if (!indexAt) return true;
   const { readdir: readdir2 } = await import("fs/promises");
   const names = await readdir2(bundlePath2).catch(() => []);
   for (const name of names) {
     if (!name.endsWith(".md") || name === INDEX_FILE) continue;
-    const at = await (0, import_promises.stat)((0, import_node_path.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
+    const at = await (0, import_promises3.stat)((0, import_node_path5.join)(bundlePath2, name)).then((s) => s.mtimeMs).catch(() => 0);
     if (at > indexAt) return true;
   }
   return false;
@@ -1070,7 +1867,7 @@ async function loadQmd(logger) {
 }
 
 // src/kb-store.ts
-var KB_DIR = (0, import_node_path2.join)(".strauss", "kb");
+var KB_DIR = (0, import_node_path6.join)(".strauss", "kb");
 var STORE_OWNED = /* @__PURE__ */ new Set([INDEX_FILE, LOG_FILE, SEARCH_INDEX_FILE]);
 var DEFAULT_LOAD_BUDGET = 25e3;
 var KbStore = class {
@@ -1101,7 +1898,7 @@ var KbStore = class {
     const conceptId2 = `${input.type}.${input.slug}`;
     const root = this.root(bundlePath2);
     const target = this.recordPath(bundlePath2, conceptId2);
-    await (0, import_promises2.mkdir)(root, { recursive: true });
+    await (0, import_promises4.mkdir)(root, { recursive: true });
     await this.publish(
       target,
       stringifyMarkdownWithFrontmatter(input.body, frontmatter),
@@ -1113,20 +1910,34 @@ var KbStore = class {
       conceptId: conceptId2,
       by: actor
     });
+    const targets = new Set(frontmatter.strauss_supersedes ?? []);
+    targets.delete(conceptId2);
+    const supersededIds = [];
+    for (const old of targets) {
+      if (await this.markSupersededRetrying(bundlePath2, old, conceptId2, actor)) {
+        supersededIds.push(old);
+      }
+    }
     this.logger.info?.({
       operation: "kb.write",
       bundlePath: root,
       conceptId: conceptId2,
       anchors: frontmatter.strauss_anchors?.length ?? 0
     });
-    return { conceptId: conceptId2, frontmatter, body: input.body };
+    return {
+      conceptId: conceptId2,
+      frontmatter,
+      body: input.body,
+      action: supersededIds.length ? "superseded-prior" : "created",
+      supersededIds
+    };
   }
   /** One record by concept id, or null when it does not exist. */
   async read(bundlePath2, conceptId2) {
     const target = this.recordPath(bundlePath2, conceptId2);
     let raw;
     try {
-      raw = await (0, import_promises2.readFile)(target, "utf8");
+      raw = await (0, import_promises4.readFile)(target, "utf8");
     } catch {
       return null;
     }
@@ -1143,14 +1954,14 @@ var KbStore = class {
     const root = this.root(bundlePath2);
     let names;
     try {
-      names = await (0, import_promises2.readdir)(root);
+      names = await (0, import_promises4.readdir)(root);
     } catch {
       return [];
     }
     const wanted = names.sort().filter((name) => name.endsWith(".md") && !STORE_OWNED.has(name)).map((name) => ({ name, conceptId: name.slice(0, -".md".length) })).filter(({ conceptId: conceptId2 }) => !type || conceptId2.startsWith(`${type}.`));
     const records = await Promise.all(
       wanted.map(
-        async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises2.readFile)((0, import_node_path2.join)(root, name), "utf8"))
+        async ({ name, conceptId: conceptId2 }) => this.parse(conceptId2, await (0, import_promises4.readFile)((0, import_node_path6.join)(root, name), "utf8"))
       )
     );
     return records.filter((record) => record !== null);
@@ -1183,15 +1994,11 @@ var KbStore = class {
   async supersede(bundlePath2, conceptId2, replacementId, actor = "unknown") {
     const replacement = await this.read(bundlePath2, replacementId);
     if (!replacement) throw new KbRecordNotFoundError(replacementId);
-    const superseded = await this.mutate(
+    const superseded = await this.markSuperseded(
       bundlePath2,
       conceptId2,
-      (frontmatter) => ({
-        ...frontmatter,
-        strauss_status: "superseded",
-        strauss_superseded_by: replacementId
-      }),
-      { operation: "supersede", by: actor, target: replacementId }
+      replacementId,
+      actor
     );
     await this.mutate(
       bundlePath2,
@@ -1288,19 +2095,19 @@ ${answer}
     const adjudicated = adjudicate(wanted, bundle);
     const records = adjudicated.filter((hit) => hit.standing !== "superseded");
     const superseded = adjudicated.filter((hit) => hit.standing === "superseded").map(stub);
-    const approxTokens = records.reduce((total, hit) => total + estimateTokens(hit.record), 0) + superseded.reduce((total, entry) => total + estimateStubTokens(entry), 0);
-    if (approxTokens > budgetTokens) {
+    const approxTokens2 = records.reduce((total, hit) => total + estimateTokens(hit.record), 0) + superseded.reduce((total, entry) => total + estimateStubTokens(entry), 0);
+    if (approxTokens2 > budgetTokens) {
       return {
         loaded: false,
         recordCount: wanted.length,
-        approxTokens,
+        approxTokens: approxTokens2,
         budgetTokens
       };
     }
     return {
       loaded: true,
       recordCount: wanted.length,
-      approxTokens,
+      approxTokens: approxTokens2,
       budgetTokens,
       records,
       superseded
@@ -1320,11 +2127,11 @@ ${answer}
   async readIndex(bundlePath2) {
     const root = this.root(bundlePath2);
     const expected = renderIndex(await this.list(bundlePath2));
-    const stored = await (0, import_promises2.readFile)((0, import_node_path2.join)(root, INDEX_FILE), "utf8").catch(
+    const stored = await (0, import_promises4.readFile)((0, import_node_path6.join)(root, INDEX_FILE), "utf8").catch(
       () => null
     );
     if (indexIsStale(stored, expected)) {
-      await this.publish((0, import_node_path2.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
+      await this.publish((0, import_node_path6.join)(root, INDEX_FILE), expected, true, INDEX_FILE);
       this.logger.info?.({
         operation: "kb.index.repair",
         bundlePath: root,
@@ -1341,8 +2148,8 @@ ${answer}
    * knows which agent touched what. So a bad line is surfaced and left alone.
    */
   async readLog(bundlePath2) {
-    const raw = await (0, import_promises2.readFile)(
-      (0, import_node_path2.join)(this.root(bundlePath2), LOG_FILE),
+    const raw = await (0, import_promises4.readFile)(
+      (0, import_node_path6.join)(this.root(bundlePath2), LOG_FILE),
       "utf8"
     ).catch(() => "");
     const result = parseLog(raw);
@@ -1355,16 +2162,52 @@ ${answer}
     }
     return result;
   }
+  /**
+   * `markSuperseded`, tolerant of the two ways it legitimately doesn't land:
+   * a missing target (a broken link, legal per compose.ts) or a CAS conflict
+   * from a concurrent writer touching the same target. A conflict is retried
+   * a bounded number of times — each attempt re-reads the target fresh — and
+   * on the last, `false` reports "not marked" rather than throwing: the
+   * caller's own record is already published, so failing here would leave
+   * that publish unreported instead of undone. kb_validate's existing
+   * "not marked superseded" check is what surfaces the residue.
+   */
+  async markSupersededRetrying(bundlePath2, conceptId2, replacementId, actor, retries = 3) {
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        await this.markSuperseded(bundlePath2, conceptId2, replacementId, actor);
+        return true;
+      } catch (error) {
+        if (error instanceof KbRecordNotFoundError) return false;
+        if (!(error instanceof KbWriteConflictError)) throw error;
+        if (attempt === retries) return false;
+      }
+    }
+    return false;
+  }
+  /** The one-directional half of `supersede`: marks `conceptId` superseded. */
+  async markSuperseded(bundlePath2, conceptId2, replacementId, actor) {
+    return this.mutate(
+      bundlePath2,
+      conceptId2,
+      (frontmatter) => ({
+        ...frontmatter,
+        strauss_status: "superseded",
+        strauss_superseded_by: replacementId
+      }),
+      { operation: "supersede", by: actor, target: replacementId }
+    );
+  }
   async mutate(bundlePath2, conceptId2, change, entry, changeBody = (body) => body) {
     const target = this.recordPath(bundlePath2, conceptId2);
-    const before = await (0, import_promises2.readFile)(target, "utf8").catch(() => null);
+    const before = await (0, import_promises4.readFile)(target, "utf8").catch(() => null);
     if (before === null) throw new KbRecordNotFoundError(conceptId2);
     const parsed = this.parse(conceptId2, before);
     if (!parsed) throw new KbRecordNotFoundError(conceptId2);
     const frontmatter = change(parsed.frontmatter);
     const body = changeBody(parsed.body);
     const contents = stringifyMarkdownWithFrontmatter(body, frontmatter);
-    const witness = await (0, import_promises2.readFile)(target, "utf8").catch(() => null);
+    const witness = await (0, import_promises4.readFile)(target, "utf8").catch(() => null);
     if (witness === null || digest(witness) !== digest(before)) {
       throw new KbWriteConflictError(conceptId2);
     }
@@ -1390,26 +2233,26 @@ ${answer}
    */
   async publish(target, contents, overwrite, conceptId2) {
     const staging = `${target}.${process.pid}.tmp`;
-    await (0, import_promises2.writeFile)(staging, contents, "utf8");
+    await (0, import_promises4.writeFile)(staging, contents, "utf8");
     try {
       if (overwrite) {
-        await (0, import_promises2.rename)(staging, target);
+        await (0, import_promises4.rename)(staging, target);
         return;
       }
-      await (0, import_promises2.link)(staging, target);
+      await (0, import_promises4.link)(staging, target);
     } catch (error) {
       if (error.code === "EEXIST") {
         throw new KbRecordAlreadyExistsError(conceptId2);
       }
       throw error;
     } finally {
-      await (0, import_promises2.unlink)(staging).catch(() => void 0);
+      await (0, import_promises4.unlink)(staging).catch(() => void 0);
     }
   }
   /** Appends one log line. Failing to log must not fail the mutation. */
   async record(root, entry) {
     const line = renderLogEntry({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
-    await (0, import_promises2.appendFile)((0, import_node_path2.join)(root, LOG_FILE), line, "utf8").catch((error) => {
+    await (0, import_promises4.appendFile)((0, import_node_path6.join)(root, LOG_FILE), line, "utf8").catch((error) => {
       this.logger.warn?.({
         operation: "kb.log.append",
         outcome: "failed",
@@ -1435,18 +2278,18 @@ ${answer}
     };
   }
   root(bundlePath2) {
-    return (0, import_node_path2.resolve)(bundlePath2);
+    return (0, import_node_path6.resolve)(bundlePath2);
   }
   // Concept ids are `<type>.<slug>` and map to a single file directly under the
   // bundle root; anything carrying a separator would escape it.
   recordPath(bundlePath2, conceptId2) {
-    if (conceptId2.includes(import_node_path2.sep) || conceptId2.includes("/")) {
+    if (conceptId2.includes(import_node_path6.sep) || conceptId2.includes("/")) {
       throw new KbInvalidConceptIdError(
         "concept id must not contain a path separator",
         { conceptId: conceptId2 }
       );
     }
-    return (0, import_node_path2.join)(this.root(bundlePath2), `${conceptId2}.md`);
+    return (0, import_node_path6.join)(this.root(bundlePath2), `${conceptId2}.md`);
   }
 };
 function estimateTokens(record) {
@@ -1505,6 +2348,7 @@ async function runKbCli(argv) {
     parsed.data
   );
   if (command.failsWhen?.(result)) process.exitCode = 1;
+  if (result === "") return;
   process.stdout.write(
     typeof result === "string" ? result.endsWith("\n") ? result : `${result}
 ` : `${JSON.stringify(result, null, 2)}
@@ -1514,18 +2358,18 @@ async function runKbCli(argv) {
 function takeBundle(argv) {
   const at = argv.indexOf("--bundle");
   if (at === -1) {
-    return { bundle: (0, import_node_path3.join)(process.cwd(), KB_DIR), rest: argv };
+    return { bundle: (0, import_node_path7.join)(process.cwd(), KB_DIR), rest: argv };
   }
   const bundle = argv[at + 1];
   if (!bundle) die("--bundle requires a path");
   return { bundle, rest: [...argv.slice(0, at), ...argv.slice(at + 2)] };
 }
 function readStdin() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve5, reject) => {
     let text = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => text += chunk);
-    process.stdin.on("end", () => resolve2(text));
+    process.stdin.on("end", () => resolve5(text));
     process.stdin.on("error", reject);
   });
 }