@mrciphersmith/keryx 0.3.64 → 0.3.66

package/dist/cli.js

@@ -20107,7 +20107,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@mrciphersmith/keryx",
-    version: "0.3.64",
+    version: "0.3.66",
     description: "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
     private: false,
     publishConfig: {
@@ -88435,6 +88435,58 @@ var MAX_TEXT_LENGTH = 300;
 function emptyTally() {
   return { answered: 0, matched: 0 };
 }
+function median(values) {
+  if (values.length === 0)
+    return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  const low = sorted[mid - 1] ?? 0;
+  const high = sorted[mid] ?? 0;
+  return sorted.length % 2 === 1 ? high : Math.round((low + high) / 2);
+}
+function buildBackfilled(history, firstAnswer, reasons) {
+  const out = {
+    total: history.length,
+    answered: 0,
+    withRecommendation: 0,
+    withoutRecommendation: 0,
+    matchTally: emptyTally(),
+    matchShare: null,
+    deviations: []
+  };
+  for (const open of history) {
+    if (open.recommendation === null)
+      out.withoutRecommendation += 1;
+    else
+      out.withRecommendation += 1;
+    const first = firstAnswer(open.id);
+    if (first === undefined)
+      continue;
+    out.answered += 1;
+    if (open.recommendation === null)
+      continue;
+    out.matchTally.answered += 1;
+    if (first.choice === open.recommendation.optionId) {
+      out.matchTally.matched += 1;
+      continue;
+    }
+    const reason = reasons.get(open.id)?.reason;
+    out.deviations.push({
+      id: open.id,
+      flow: open.flow,
+      stage: open.stage,
+      mode: open.mode,
+      question: open.question,
+      recommended: open.recommendation.optionId,
+      chose: first.choice,
+      changed: false,
+      ...open.source !== undefined ? { source: open.source } : {},
+      ...reason !== undefined ? { reason } : {}
+    });
+  }
+  out.matchShare = out.matchTally.answered === 0 ? null : out.matchTally.matched / out.matchTally.answered;
+  return out;
+}
 function buildReport2(records, skipped = 0) {
   const opens = [];
   const answers = new Map;
@@ -88454,8 +88506,11 @@ function buildReport2(records, skipped = 0) {
       reasons.set(record.id, record);
     }
   }
+  const live = opens.filter((open) => open.backfilled !== true);
+  const history = opens.filter((open) => open.backfilled === true);
+  const firstAnswer = (id) => [...answers.get(id) ?? []].sort((a, b) => a.seq - b.seq)[0];
   const report = {
-    total: opens.length,
+    total: live.length,
     answered: 0,
     unanswered: 0,
     withoutRecommendation: 0,
@@ -88463,9 +88518,11 @@ function buildReport2(records, skipped = 0) {
     byMode: { ordinary: emptyTally(), blind: emptyTally() },
     byStage: [],
     deviations: [],
-    irreversible: opens.filter((open) => open.irreversible).length,
-    blindRefused: opens.filter((open) => open.blindRefused === true).length,
-    inferredFlow: opens.filter((open) => open.flow !== null && open.flowSource === "inferred").length,
+    irreversible: live.filter((open) => open.irreversible).length,
+    blindRefused: live.filter((open) => open.blindRefused === true).length,
+    inferredFlow: live.filter((open) => open.flow !== null && open.flowSource === "inferred").length,
+    timing: { answered: 0, medianMs: null },
+    backfilled: buildBackfilled(history, firstAnswer, reasons),
     skipped
   };
   const stages = new Map;
@@ -88474,7 +88531,8 @@ function buildReport2(records, skipped = 0) {
     stages.set(name, found);
     return found;
   };
-  for (const open of opens) {
+  const times = [];
+  for (const open of live) {
     if (open.blindRefused === true)
       stageOf(open.stage).blindRefused += 1;
     const list = (answers.get(open.id) ?? []).sort((a, b) => a.seq - b.seq);
@@ -88484,6 +88542,7 @@ function buildReport2(records, skipped = 0) {
       continue;
     }
     report.answered += 1;
+    times.push(first.timeToAnswerMs);
     if (list.length > 1)
       report.changed += 1;
     if (open.recommendation === null) {
@@ -88513,6 +88572,7 @@ function buildReport2(records, skipped = 0) {
       });
     }
   }
+  report.timing = { answered: times.length, medianMs: median(times) };
   report.byStage = [...stages.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([stage, tallies]) => ({ stage, ...tallies }));
   return report;
 }
@@ -88521,14 +88581,45 @@ function share(tally) {
     return "n/a";
   return `${Math.round(tally.matched / tally.answered * 100)}% (${tally.matched}/${tally.answered})`;
 }
+function backfilledShare(report) {
+  if (report.matchTally.answered === 0)
+    return "n/a";
+  return `${Math.round(report.matchTally.matched / report.matchTally.answered * 100)}% (${report.matchTally.matched}/${report.matchTally.answered})`;
+}
+function renderBackfilled(report) {
+  const lines = [
+    "\u0414\u043E (\u0438\u0441\u0442\u043E\u0440\u0438\u0447\u0435\u0441\u043A\u043E\u0435, \u0434\u043E\u0437\u0430\u043F\u043E\u043B\u043D\u0435\u043D\u043E \u0437\u0430\u0434\u043D\u0438\u043C \u0447\u0438\u0441\u043B\u043E\u043C):",
+    `  \u0432\u0441\u0435\u0433\u043E: ${report.total}, \u0441 \u0440\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0430\u0446\u0438\u0435\u0439: ${report.withRecommendation}, \u0441\u043E\u0432\u043F\u0430\u0434\u0435\u043D\u0438\u0435: ${backfilledShare(report)}`,
+    `  \u043E\u0442\u043A\u043B\u043E\u043D\u0435\u043D\u0438\u0439: ${report.deviations.length}`
+  ];
+  for (const dev of report.deviations) {
+    const where = [dev.source === undefined ? undefined : oneLine2(dev.source), dev.flow === null ? "project" : `flow ${oneLine2(dev.flow)}`, oneLine2(dev.stage)].filter((part) => part !== undefined);
+    lines.push(`  ${oneLine2(dev.id)} [${where.join(", ")}]`);
+    lines.push(`    ${oneLine2(dev.question)}`);
+    lines.push(`    \u0440\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u043E\u0432\u0430\u043D\u043E ${oneLine2(dev.recommended)}, \u0432\u044B\u0431\u0440\u0430\u043D\u043E ${oneLine2(dev.chose)}`);
+    lines.push(`    \u043F\u0440\u0438\u0447\u0438\u043D\u0430: ${dev.reason === undefined ? "(\u043D\u0435 \u0443\u043A\u0430\u0437\u0430\u043D\u0430)" : oneLine2(dev.reason)}`);
+  }
+  return lines;
+}
+function seconds(ms) {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
 function renderReport(report) {
   const skippedLine = report.skipped > 0 ? `Skipped ${report.skipped} unreadable journal record${report.skipped === 1 ? "" : "s"}.` : undefined;
-  if (report.total === 0)
+  if (report.total === 0 && report.backfilled.total === 0)
     return skippedLine === undefined ? "No decisions recorded yet." : `No decisions recorded yet.
 ${skippedLine}`;
+  if (report.total === 0) {
+    const lines = ["No live decisions recorded yet.", "", ...renderBackfilled(report.backfilled)];
+    if (skippedLine !== undefined)
+      lines.push("", skippedLine);
+    return lines.join(`
+`);
+  }
   const lines = [
     `Decisions: ${report.total} recorded, ${report.answered} answered, ${report.unanswered} not answered yet`,
     `Changed after the reveal: ${report.changed}. Without a recommendation: ${report.withoutRecommendation}.`,
+    ...report.timing.medianMs === null ? [] : [`Median time to answer: ${seconds(report.timing.medianMs)} (${report.timing.answered} answered).`],
     "",
     "Match with the recommendation, by mode (first answer):",
     `  ordinary  ${share(report.byMode.ordinary)}`,
@@ -88555,15 +88646,27 @@ ${skippedLine}`;
   if (report.inferredFlow > 0) {
     lines.push("", `Flow attribution inferred (the one flow in progress, not named by KERYX_FLOW or the branch): ${report.inferredFlow} decision${report.inferredFlow === 1 ? "" : "s"}.`);
   }
+  if (report.backfilled.total > 0)
+    lines.push("", ...renderBackfilled(report.backfilled));
   if (skippedLine !== undefined)
     lines.push("", skippedLine);
   return lines.join(`
 `);
 }
+function percent(tally) {
+  if (tally.answered === 0)
+    return "\u043D\u0435\u0442 \u0434\u0430\u043D\u043D\u044B\u0445";
+  return `${Math.round(tally.matched / tally.answered * 100)}% (${tally.matched}/${tally.answered})`;
+}
+function renderReportLine(report) {
+  const all = report.total + report.backfilled.total;
+  return `\u0416\u0443\u0440\u043D\u0430\u043B \u0440\u0435\u0448\u0435\u043D\u0438\u0439: \u0432\u0441\u0435\u0433\u043E ${all} (\u0434\u043E: ${report.backfilled.total}, \u043F\u043E\u0441\u043B\u0435: ${report.total}). ` + `\u0421\u043E\u0432\u043F\u0430\u0434\u0435\u043D\u0438\u0435 \u0441 \u0440\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0430\u0446\u0438\u0435\u0439: \u0432\u0438\u0434\u0438\u043C\u0430\u044F ${percent(report.byMode.ordinary)}, \u0441\u043A\u0440\u044B\u0442\u0430\u044F ${percent(report.byMode.blind)}; ` + `\u0434\u043E: ${percent(report.backfilled.matchTally)}.`;
+}
 var init_report4 = () => {};
 
 // src/decisions/store.ts
-import { appendFile as appendFile11, mkdir as mkdir52, readFile as readFile102 } from "fs/promises";
+import { randomUUID as randomUUID23 } from "crypto";
+import { appendFile as appendFile11, mkdir as mkdir52, open as open9, readFile as readFile102, rename as rename10, rm as rm13, stat as stat24 } from "fs/promises";
 import path211 from "path";
 async function journalRoot(cwd) {
   const cached = rootCache.get(cwd);
@@ -88594,6 +88697,102 @@ async function appendRecord(cwd, record) {
   await appendFile11(journalFile(root), `${JSON.stringify(record)}
 `, { encoding: "utf8", mode: 384 });
 }
+async function endsWithoutNewline2(file) {
+  try {
+    const text = await readFile102(file, "utf8");
+    return text.length > 0 && !text.endsWith(`
+`);
+  } catch {
+    return false;
+  }
+}
+async function appendRecords(cwd, records) {
+  if (records.length === 0)
+    return;
+  const root = await journalRoot(cwd);
+  await mkdir52(decisionsDir(root), { recursive: true });
+  const file = journalFile(root);
+  const lead = await endsWithoutNewline2(file) ? `
+` : "";
+  await appendFile11(file, lead + records.map((record) => `${JSON.stringify(record)}
+`).join(""), { encoding: "utf8", mode: 384 });
+}
+function journalLockFile(root) {
+  return `${journalFile(root)}.lock`;
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function lockIsStale(file, staleMs) {
+  let mtimeMs;
+  try {
+    mtimeMs = (await stat24(file)).mtimeMs;
+  } catch {
+    return false;
+  }
+  if (Date.now() - mtimeMs > staleMs)
+    return true;
+  try {
+    const pid = JSON.parse(await readFile102(file, "utf8")).pid;
+    return typeof pid === "number" && !pidAlive(pid);
+  } catch {
+    return false;
+  }
+}
+async function ownsLock2(file, token) {
+  try {
+    return JSON.parse(await readFile102(file, "utf8")).token === token;
+  } catch {
+    return false;
+  }
+}
+async function withJournalLock(cwd, fn, options = {}) {
+  const staleMs = options.staleMs ?? JOURNAL_LOCK_STALE_MS;
+  const timeoutMs = options.timeoutMs ?? JOURNAL_LOCK_TIMEOUT_MS;
+  const pollMs = options.pollMs ?? 25;
+  const root = await journalRoot(cwd);
+  await mkdir52(decisionsDir(root), { recursive: true });
+  const file = journalLockFile(root);
+  const token = randomUUID23();
+  const deadline = Date.now() + timeoutMs;
+  for (;; ) {
+    try {
+      const handle = await open9(file, "wx", 384);
+      try {
+        await handle.writeFile(JSON.stringify({ pid: process.pid, at: new Date().toISOString(), token }));
+      } finally {
+        await handle.close();
+      }
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+    if (await lockIsStale(file, staleMs)) {
+      const aside = `${file}.stale-${process.pid}-${Date.now()}`;
+      try {
+        await rename10(file, aside);
+        await rm13(aside, { force: true });
+      } catch {}
+      continue;
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(`the decisions journal is locked by another run (${file}); try again, or delete that file if no import is running`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+  try {
+    return await fn();
+  } finally {
+    if (await ownsLock2(file, token))
+      await rm13(file, { force: true });
+  }
+}
 function isOption(value) {
   if (value === null || typeof value !== "object")
     return false;
@@ -88669,7 +88868,7 @@ async function readJournal(cwd) {
 async function readRecords(cwd) {
   return (await readJournal(cwd)).records;
 }
-var rootCache, isString2 = (value) => typeof value === "string";
+var rootCache, JOURNAL_LOCK_STALE_MS = 60000, JOURNAL_LOCK_TIMEOUT_MS = 15000, isString2 = (value) => typeof value === "string";
 var init_store6 = __esm(() => {
   init_git_worktrees();
   rootCache = new Map;
@@ -88935,6 +89134,8 @@ async function answerDecision(input) {
   const open = records.find((r) => r.kind === "open" && r.id === input.id);
   if (open === undefined)
     throw new Error(`no open decision with id ${input.id}`);
+  if (open.backfilled === true)
+    throw new Error(`decision ${open.id} is a backfilled historical record; its answer is not changed`);
   const other = input.other === true;
   const choice = other ? oneLine2(input.choice) : input.choice.trim();
   if (choice.length === 0)
@@ -88979,8 +89180,11 @@ async function answerDecision(input) {
 }
 async function recordReason(cwd, id, text, now = () => new Date, options = {}) {
   const records = await readRecords(cwd);
-  if (!records.some((r) => r.kind === "open" && r.id === id))
+  const open = records.find((r) => r.kind === "open" && r.id === id);
+  if (open === undefined)
     throw new Error(`no open decision with id ${id}`);
+  if (open.backfilled === true)
+    throw new Error(`decision ${id} is a backfilled historical record; its reason is not changed`);
   if (options.replace !== true && records.some((r) => r.kind === "reason" && r.id === id))
     return false;
   const reason = text === undefined ? "" : oneLine2(text);
@@ -89116,6 +89320,244 @@ var init_ask2 = __esm(() => {
   init_journal2();
 });
 
+// src/decisions/import.ts
+function parseEntry3(raw) {
+  if (!isObject(raw))
+    return "a decision must be a JSON object";
+  const id = raw["id"];
+  if (!isString3(id) || id.trim().length === 0)
+    return "needs a non-empty string id";
+  const at = raw["at"];
+  if (!isString3(at) || !Number.isFinite(Date.parse(at)))
+    return `${id}: "at" must be an ISO date`;
+  const flow = raw["flow"] === undefined ? null : raw["flow"];
+  if (flow !== null && !isString3(flow))
+    return `${id}: "flow" must be a string or null`;
+  const stageRaw = raw["stage"];
+  if (stageRaw !== undefined && !isString3(stageRaw))
+    return `${id}: "stage" must be a string`;
+  const question = raw["question"];
+  if (!isString3(question) || oneLine2(question).length === 0)
+    return `${id}: needs a question`;
+  const optionsRaw = raw["options"];
+  if (!Array.isArray(optionsRaw) || optionsRaw.length < 2)
+    return `${id}: needs at least two options`;
+  const options = [];
+  const ids = new Set;
+  for (const item of optionsRaw) {
+    if (!isObject(item) || !isString3(item["id"]) || item["id"].trim().length === 0)
+      return `${id}: every option needs an id`;
+    const optionId = item["id"];
+    if (ids.has(optionId))
+      return `${id}: duplicate option id: ${optionId}`;
+    ids.add(optionId);
+    const label = isString3(item["label"]) && item["label"].length > 0 ? item["label"] : optionId;
+    options.push({ id: optionId, label, ...isString3(item["description"]) && item["description"].length > 0 ? { description: item["description"] } : {} });
+  }
+  let recommendation = null;
+  const recRaw = raw["recommendation"];
+  if (recRaw !== undefined && recRaw !== null) {
+    if (!isObject(recRaw) || !isString3(recRaw["optionId"]))
+      return `${id}: "recommendation" needs an optionId`;
+    if (!ids.has(recRaw["optionId"]))
+      return `${id}: the recommended option "${recRaw["optionId"]}" is not one of the options`;
+    recommendation = { optionId: recRaw["optionId"], reason: isString3(recRaw["reason"]) ? oneLine2(recRaw["reason"]) : "" };
+  }
+  let answer = null;
+  const answerRaw = raw["answer"];
+  if (answerRaw !== undefined && answerRaw !== null) {
+    if (!isObject(answerRaw) || !isString3(answerRaw["choice"]) || answerRaw["choice"].trim().length === 0)
+      return `${id}: "answer" needs a choice`;
+    const other = answerRaw["other"] === true;
+    if (!other && !ids.has(answerRaw["choice"].trim())) {
+      return `${id}: the answer "${answerRaw["choice"]}" is not one of the options (use "other": true for the human's own words)`;
+    }
+    answer = { choice: other ? oneLine2(answerRaw["choice"]) : answerRaw["choice"].trim(), other };
+  }
+  const sourceRaw = raw["source"];
+  if (sourceRaw !== undefined && !isString3(sourceRaw))
+    return `${id}: "source" must be a string`;
+  const reasonRaw = raw["reason"];
+  if (reasonRaw !== undefined && reasonRaw !== null && !isString3(reasonRaw))
+    return `${id}: "reason" must be a string`;
+  const reason = isString3(reasonRaw) ? oneLine2(reasonRaw) : "";
+  const source = isString3(sourceRaw) ? oneLine2(sourceRaw) : "";
+  return {
+    id,
+    at,
+    flow,
+    stage: isString3(stageRaw) && stageRaw.trim().length > 0 ? oneLine2(stageRaw) : DEFAULT_STAGE,
+    question: oneLine2(question),
+    options,
+    recommendation,
+    ...source.length > 0 ? { source } : {},
+    answer,
+    ...reason.length > 0 ? { reason } : {}
+  };
+}
+function parseBackfill(text) {
+  const entries = [];
+  const errors = [];
+  text.split(`
+`).forEach((line, index) => {
+    if (line.trim().length === 0)
+      return;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      errors.push({ line: index + 1, message: "not valid JSON" });
+      return;
+    }
+    const entry = parseEntry3(parsed);
+    if (typeof entry === "string")
+      errors.push({ line: index + 1, message: entry });
+    else
+      entries.push(entry);
+  });
+  return { entries, errors };
+}
+function answerRecordOf(entry, at) {
+  if (entry.answer === null)
+    return;
+  return {
+    kind: "answer",
+    id: entry.id,
+    at,
+    seq: 1,
+    choice: entry.answer.choice,
+    timeToAnswerMs: 0,
+    changed: false,
+    ...entry.answer.other ? { other: true } : {}
+  };
+}
+function reasonRecordOf(entry, at) {
+  return entry.reason === undefined ? undefined : { kind: "reason", id: entry.id, at, reason: entry.reason };
+}
+function backfillRecords(entry) {
+  const open = {
+    kind: "open",
+    id: entry.id,
+    at: entry.at,
+    flow: entry.flow,
+    stage: entry.stage,
+    question: entry.question,
+    options: entry.options,
+    recommendation: entry.recommendation,
+    mode: "ordinary",
+    order: entry.options.map((option) => option.id),
+    showMark: entry.recommendation !== null,
+    irreversible: false,
+    backfilled: true,
+    ...entry.source !== undefined ? { source: entry.source } : {}
+  };
+  const records = [open];
+  const answer = answerRecordOf(entry, entry.at);
+  if (answer !== undefined)
+    records.push(answer);
+  const reason = reasonRecordOf(entry, entry.at);
+  if (reason !== undefined)
+    records.push(reason);
+  return records;
+}
+async function importBackfill(cwd, text, options = {}) {
+  if (options.dryRun === true)
+    return importUnlocked(cwd, text, options);
+  return withJournalLock(cwd, () => importUnlocked(cwd, text, options));
+}
+async function importUnlocked(cwd, text, options) {
+  const { entries, errors } = parseBackfill(text);
+  const records = await readRecords(cwd);
+  const known = new Map;
+  const answered = new Set;
+  const reasoned = new Set;
+  for (const record of records) {
+    if (record.kind === "open")
+      known.set(record.id, record);
+    else if (record.kind === "answer")
+      answered.add(record.id);
+    else
+      reasoned.add(record.id);
+  }
+  const result = {
+    dryRun: options.dryRun === true,
+    imported: 0,
+    skipped: 0,
+    withRecommendation: 0,
+    answered: 0,
+    deviations: 0,
+    skippedIds: [],
+    repaired: 0,
+    repairedIds: [],
+    malformed: errors
+  };
+  const toWrite = [];
+  for (const entry of entries) {
+    const existing = known.get(entry.id);
+    if (existing !== undefined) {
+      const answer = entry.answer;
+      const repairable = existing.backfilled === true && answer !== null && !answered.has(entry.id) && (answer.other || existing.options.some((option) => option.id === answer.choice));
+      if (!repairable || answer === null) {
+        result.skipped += 1;
+        result.skippedIds.push(entry.id);
+        continue;
+      }
+      const missing = [answerRecordOf(entry, existing.at), reasoned.has(entry.id) ? undefined : reasonRecordOf(entry, existing.at)].filter((record) => record !== undefined);
+      toWrite.push(...missing);
+      answered.add(entry.id);
+      result.repaired += 1;
+      result.repairedIds.push(entry.id);
+      result.answered += 1;
+      if (existing.recommendation !== null && answer.choice !== existing.recommendation.optionId)
+        result.deviations += 1;
+      continue;
+    }
+    known.set(entry.id, backfillRecords(entry)[0]);
+    answered.add(entry.id);
+    result.imported += 1;
+    if (entry.recommendation !== null)
+      result.withRecommendation += 1;
+    if (entry.answer !== null) {
+      result.answered += 1;
+      if (entry.recommendation !== null && entry.answer.choice !== entry.recommendation.optionId)
+        result.deviations += 1;
+    }
+    toWrite.push(...backfillRecords(entry));
+  }
+  if (!result.dryRun)
+    await appendRecords(cwd, toWrite);
+  return result;
+}
+function renderImportResult(result) {
+  const repaired = result.repaired > 0 ? `, repaired: ${result.repaired}` : "";
+  const malformed = result.malformed.length > 0 ? `, malformed: ${result.malformed.length}` : "";
+  const lines = [
+    `${result.dryRun ? "Dry run, nothing written. " : ""}Imported: ${result.imported}, skipped: ${result.skipped}, with recommendation: ${result.withRecommendation}, answered: ${result.answered}, deviations: ${result.deviations}${repaired}${malformed}`
+  ];
+  if (result.skippedIds.length > 0) {
+    const shown = result.skippedIds.slice(0, 20).map((id) => oneLine2(id, 80));
+    lines.push(`Skipped (already in the journal): ${shown.join(", ")}${result.skippedIds.length > shown.length ? `, ... and ${result.skippedIds.length - shown.length} more` : ""}`);
+  }
+  if (result.repairedIds.length > 0) {
+    const shown = result.repairedIds.slice(0, 20).map((id) => oneLine2(id, 80));
+    lines.push(`Repaired (the answer was missing from the journal and was added): ${shown.join(", ")}${result.repairedIds.length > shown.length ? `, ... and ${result.repairedIds.length - shown.length} more` : ""}`);
+  }
+  if (result.malformed.length > 0) {
+    lines.push("Malformed (skipped):");
+    for (const error of result.malformed.slice(0, 20))
+      lines.push(`  line ${error.line}: ${oneLine2(error.message, 200)}`);
+    if (result.malformed.length > 20)
+      lines.push(`  ... and ${result.malformed.length - 20} more`);
+  }
+  return lines.join(`
+`);
+}
+var isString3 = (value) => typeof value === "string", isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var init_import = __esm(() => {
+  init_journal2();
+  init_store6();
+});
+
 // src/decisions/context.ts
 async function currentBranch(cwd) {
   try {
@@ -89203,7 +89645,7 @@ async function latestAnsweredDecision(cwd, flow) {
   const answered = new Set(records.filter((r) => r.kind === "answer").map((r) => r.id));
   for (let i = records.length - 1;i >= 0; i -= 1) {
     const record = records[i];
-    if (record !== undefined && record.kind === "open" && answered.has(record.id) && (flow === undefined || record.flow === flow))
+    if (record !== undefined && record.kind === "open" && record.backfilled !== true && answered.has(record.id) && (flow === undefined || record.flow === flow))
       return record.id;
   }
   return;
@@ -89261,6 +89703,8 @@ function resolveOptionId(open, typed) {
 }
 async function changeAnswer(input) {
   const open = await resolveOpen(input.cwd, input.id, input.lastId, input.flow, input.session, "keryx decisions answer <id> --choice <option>");
+  if (open.backfilled === true)
+    throw new Error(`decision ${open.id} is a backfilled historical record; its answer is not changed`);
   const choice = resolveOptionId(open, input.choice);
   const answers = (await readRecords(input.cwd)).filter((r) => r.kind === "answer" && r.id === open.id);
   const first = [...answers].sort((x, y) => x.seq - y.seq)[0];
@@ -89280,9 +89724,15 @@ async function loadReport(cwd) {
 async function reportText(cwd) {
   return renderReport(await loadReport(cwd));
 }
+async function reportLine(cwd) {
+  return renderReportLine(await loadReport(cwd));
+}
 async function decisionCount(cwd) {
   return (await loadReport(cwd)).total;
 }
+async function backfilledCount(cwd) {
+  return (await loadReport(cwd)).backfilled.total;
+}
 var init_service13 = __esm(() => {
   init_report4();
   init_store6();
@@ -89290,13 +89740,14 @@ var init_service13 = __esm(() => {
   init_blind();
   init_journal2();
   init_report4();
+  init_import();
   init_store6();
   init_context2();
   init_followup();
 });
 
 // src/tui/ask-user-bridge.ts
-import { randomUUID as randomUUID23 } from "crypto";
+import { randomUUID as randomUUID24 } from "crypto";
 function setAskUserHost(fn) {
   host = fn;
 }
@@ -89331,7 +89782,7 @@ function journaledAskUser(cwd) {
 var host, notice, lastDecisionId, sessionId;
 var init_ask_user_bridge = __esm(() => {
   init_service13();
-  sessionId = `s-${randomUUID23()}`;
+  sessionId = `s-${randomUUID24()}`;
 });
 
 // src/harness/tool/metaproject-operations.ts
@@ -90872,7 +91323,7 @@ var init_project_tools = __esm(() => {
 });
 
 // src/commands/interactive-agent-tools.ts
-import { randomUUID as randomUUID24 } from "crypto";
+import { randomUUID as randomUUID25 } from "crypto";
 function denyInteractiveTools(tools, denied) {
   if (denied.length === 0)
     return [...tools];
@@ -90890,7 +91341,7 @@ function buildInteractiveAgentTools(input) {
   const getSessionDir = input.getSessionDir ?? (() => {
     return;
   });
-  const idSeq = input.idSeq ?? (() => randomUUID24());
+  const idSeq = input.idSeq ?? (() => randomUUID25());
   const clock = input.clock ?? (() => new Date().toISOString());
   const jobRegistry = input.jobRegistry;
   const project = buildProjectTools(input.cwd, input.metaprojectPort);
@@ -93393,9 +93844,9 @@ var init_registry3 = __esm(() => {
 });
 
 // src/harness/tool/builtin/spawn-subagent-tool.ts
-import { createHash as createHash60, randomUUID as randomUUID25 } from "crypto";
+import { createHash as createHash60, randomUUID as randomUUID26 } from "crypto";
 import { execFile as execFile7 } from "child_process";
-import { lstat as lstat14, mkdtemp as mkdtemp2, readFile as readFile104, realpath as realpath17, rm as rm13 } from "fs/promises";
+import { lstat as lstat14, mkdtemp as mkdtemp2, readFile as readFile104, realpath as realpath17, rm as rm14 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import path216 from "path";
 import { promisify as promisify5 } from "util";
@@ -93585,7 +94036,7 @@ async function verifyWorktreeCandidate(candidate, commonDir, worktreesDir) {
   }
 }
 function createSpawnSubagentTool(deps) {
-  const idSeq = deps.idSeq ?? (() => randomUUID25());
+  const idSeq = deps.idSeq ?? (() => randomUUID26());
   const clock = deps.clock ?? (() => new Date().toISOString());
   const parentRunId = deps.parentRunId ?? idSeq();
   const parentSessionId = deps.parentSessionId ?? idSeq();
@@ -93946,7 +94397,7 @@ function createSpawnSubagentTool(deps) {
         provider = deps.makeProvider(runModel.provider, runModel.model, parent.baseUrl);
       } catch (cause) {
         if (ephemeralDir !== undefined) {
-          await rm13(ephemeralDir, { recursive: true, force: true }).catch(() => {});
+          await rm14(ephemeralDir, { recursive: true, force: true }).catch(() => {});
         }
         await fireSubagentStop("Error").catch(() => {});
         ledger.release(spawned.reservation.reservationId, {
@@ -94072,7 +94523,7 @@ function createSpawnSubagentTool(deps) {
                 }
               }
             } finally {
-              await rm13(dirToClean, { recursive: true, force: true }).catch(() => {});
+              await rm14(dirToClean, { recursive: true, force: true }).catch(() => {});
             }
           });
         } catch (lockCause) {
@@ -94082,7 +94533,7 @@ function createSpawnSubagentTool(deps) {
             id: workerId,
             entry: { kind: "system", text: `slate cleanup lock failed (ignored): ${lockMsg}` }
           });
-          await rm13(dirToClean, { recursive: true, force: true }).catch(() => {});
+          await rm14(dirToClean, { recursive: true, force: true }).catch(() => {});
         }
       };
       try {
@@ -95887,7 +96338,7 @@ var init_dispatch2 = __esm(() => {
 
 // src/harness/external/acp-fs.ts
 import { constants as constants2, realpathSync as realpathSync15, statSync as statSync12 } from "fs";
-import { mkdir as mkdir53, open as open9, readFile as readFile105 } from "fs/promises";
+import { mkdir as mkdir53, open as open10, readFile as readFile105 } from "fs/promises";
 import path219 from "path";
 function refusedMethodError(method, reason) {
   return new AcpError(JSON_RPC_ERROR_CODES.methodNotFound, `${method} refused: ${reason}`, { reason });
@@ -95956,7 +96407,7 @@ async function writeTextFileInWorktree(worktree, target, content, requested, hoo
   const finalTarget = path219.join(parentReal, path219.basename(target));
   let handle;
   try {
-    handle = await open9(finalTarget, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_TRUNC | constants2.O_NOFOLLOW, 420);
+    handle = await open10(finalTarget, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_TRUNC | constants2.O_NOFOLLOW, 420);
   } catch (error) {
     const code = error.code;
     if (code === "ELOOP" || code === "EMLINK") {
@@ -96121,7 +96572,7 @@ function describeOutcome(outcome) {
     return outcome.reason;
   return "an unexpected result";
 }
-function isObject(value) {
+function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function short(value, max = 500) {
@@ -96131,7 +96582,7 @@ function short(value, max = 500) {
 function readOptions(raw) {
   if (!Array.isArray(raw))
     return [];
-  return raw.filter((option) => isObject(option) && typeof option["optionId"] === "string" && typeof option["kind"] === "string");
+  return raw.filter((option) => isObject2(option) && typeof option["optionId"] === "string" && typeof option["kind"] === "string");
 }
 async function superviseAcpRun(input, deps) {
   const clientCapabilities = acpClientCapabilities(input.write);
@@ -96203,7 +96654,7 @@ async function superviseAcpRun(input, deps) {
   let promptRequestId;
   let boundSessionId;
   const guardSession = (method, params) => {
-    const claimed = isObject(params) ? params["sessionId"] : undefined;
+    const claimed = isObject2(params) ? params["sessionId"] : undefined;
     let reason;
     if (phase !== "prompting") {
       reason = phase === "handshake" ? "no prompt is in progress yet; keryx answers only during this run's turn" : "this run's turn has ended; keryx no longer answers for it";
@@ -96234,9 +96685,9 @@ async function superviseAcpRun(input, deps) {
   });
   dispatcher.onRequest(ACP_CLIENT_METHODS.sessionRequestPermission, async (params, context) => {
     guardSession(ACP_CLIENT_METHODS.sessionRequestPermission, params);
-    const p = isObject(params) ? params : {};
+    const p = isObject2(params) ? params : {};
     const rawToolCall = p["toolCall"];
-    const toolCall = isObject(rawToolCall) && typeof rawToolCall["toolCallId"] === "string" ? rawToolCall : { toolCallId: "unidentified" };
+    const toolCall = isObject2(rawToolCall) && typeof rawToolCall["toolCallId"] === "string" ? rawToolCall : { toolCallId: "unidentified" };
     const { answer, decision } = await answerAcpPermission({ requestId: context.id, toolCall, options: readOptions(p["options"]) }, permissionContext);
     recordDecision(decision);
     return { outcome: answer.outcome };
@@ -96244,7 +96695,7 @@ async function superviseAcpRun(input, deps) {
   dispatcher.onRequest(ACP_CLIENT_METHODS.fsReadTextFile, async (params) => {
     const method = ACP_CLIENT_METHODS.fsReadTextFile;
     guardSession(method, params);
-    const p = isObject(params) ? params : {};
+    const p = isObject2(params) ? params : {};
     try {
       const { content } = await readTextFileInWorktree(input.cwd, p);
       recordFs({ method, path: String(p["path"]), outcome: "served", bytes: Buffer.byteLength(content, "utf8") });
@@ -96257,7 +96708,7 @@ async function superviseAcpRun(input, deps) {
   dispatcher.onRequest(ACP_CLIENT_METHODS.fsWriteTextFile, async (params, context) => {
     const method = ACP_CLIENT_METHODS.fsWriteTextFile;
     guardSession(method, params);
-    const p = isObject(params) ? params : {};
+    const p = isObject2(params) ? params : {};
     const requested = typeof p["path"] === "string" ? p["path"] : String(p["path"]);
     if (!input.write) {
       const reason = "keryx did not advertise fs.writeTextFile (a read-only run)";
@@ -96294,7 +96745,7 @@ async function superviseAcpRun(input, deps) {
   });
   for (const [method, reason] of ACP_REFUSED_CLIENT_METHODS) {
     dispatcher.onRequest(method, (params) => {
-      const p = isObject(params) ? params : {};
+      const p = isObject2(params) ? params : {};
       recordFs({
         method,
         ...typeof p["command"] === "string" ? { path: p["command"] } : {},
@@ -96308,7 +96759,7 @@ async function superviseAcpRun(input, deps) {
     return;
   });
   dispatcher.onNotification(ACP_CLIENT_METHODS.sessionUpdate, (params) => {
-    if (!isObject(params) || !isObject(params["update"]))
+    if (!isObject2(params) || !isObject2(params["update"]))
       return;
     if (boundSessionId === undefined || params["sessionId"] !== boundSessionId) {
       stderr.push(`[keryx] ignored a session/update for session ${JSON.stringify(params["sessionId"] ?? null)}`);
@@ -96368,7 +96819,7 @@ async function superviseAcpRun(input, deps) {
           usage = { used: update.used, size: update.size };
         }
         const reported = update.cost;
-        if (isObject(reported) && typeof reported["amount"] === "number" && typeof reported["currency"] === "string") {
+        if (isObject2(reported) && typeof reported["amount"] === "number" && typeof reported["currency"] === "string") {
           cost = { amount: reported["amount"], currency: reported["currency"] };
         }
         emit(cost !== undefined && cost.currency === "USD" ? { kind: "usage", costUnits: cost.amount } : { kind: "usage" });
@@ -96385,7 +96836,7 @@ async function superviseAcpRun(input, deps) {
     if (phase === "prompting" && promptRequestId !== undefined && line.includes(promptRequestId)) {
       try {
         const value = JSON.parse(line);
-        if (isObject(value) && !("method" in value) && value["id"] === promptRequestId)
+        if (isObject2(value) && !("method" in value) && value["id"] === promptRequestId)
           phase = "ended";
       } catch {}
     }
@@ -96465,16 +96916,16 @@ async function superviseAcpRun(input, deps) {
       failure = `the agent did not answer initialize within ${input.timeoutMs}ms`;
       return await finish();
     }
-    if (init.kind !== "result" || !isObject(init.result)) {
+    if (init.kind !== "result" || !isObject2(init.result)) {
       failure = `the agent did not answer initialize: ${describeOutcome(init)}`;
       return await finish();
     }
     const initResult = init.result;
     const version = initResult["protocolVersion"];
     protocolVersion = typeof version === "number" ? version : undefined;
-    if (isObject(initResult["agentInfo"]))
+    if (isObject2(initResult["agentInfo"]))
       agentInfo = initResult["agentInfo"];
-    if (isObject(initResult["agentCapabilities"]))
+    if (isObject2(initResult["agentCapabilities"]))
       agentCapabilities = initResult["agentCapabilities"];
     if (typeof version !== "number" || !ACP_SUPPORTED_PROTOCOL_VERSIONS.includes(version)) {
       failure = `unsupported ACP protocol version: the agent answered initialize with protocolVersion ${JSON.stringify(version)}; ` + `keryx speaks ${ACP_SUPPORTED_PROTOCOL_VERSIONS.join(", ")}`;
@@ -96486,7 +96937,7 @@ async function superviseAcpRun(input, deps) {
       failure = `the agent did not answer session/new within ${input.timeoutMs}ms`;
       return await finish();
     }
-    if (created.kind !== "result" || !isObject(created.result) || typeof created.result["sessionId"] !== "string") {
+    if (created.kind !== "result" || !isObject2(created.result) || typeof created.result["sessionId"] !== "string") {
       failure = `the agent refused session/new: ${created.kind === "result" ? "no sessionId in the answer" : describeOutcome(created)}`;
       return await finish();
     }
@@ -96526,12 +96977,12 @@ ${resource.text}` });
       const grace = afterMs(graceMs);
       const late = await Promise.race([turn, grace.promise]);
       grace.cancel();
-      if (late !== TIMEOUT && late.kind === "result" && isObject(late.result) && typeof late.result["stopReason"] === "string") {
+      if (late !== TIMEOUT && late.kind === "result" && isObject2(late.result) && typeof late.result["stopReason"] === "string") {
         stopReason = late.result["stopReason"];
       }
       return await finish();
     }
-    if (answered.kind !== "result" || !isObject(answered.result)) {
+    if (answered.kind !== "result" || !isObject2(answered.result)) {
       failure = `session/prompt did not complete: ${describeOutcome(answered)}`;
       return await finish();
     }
@@ -96610,7 +97061,7 @@ var init_acp_client = __esm(() => {
 // src/harness/external/acp-run.ts
 import { execFile as execFile9 } from "child_process";
 import { existsSync as existsSync38, readFileSync as readFileSync20, writeFileSync as writeFileSync4 } from "fs";
-import { mkdtemp as mkdtemp3, rm as rm14 } from "fs/promises";
+import { mkdtemp as mkdtemp3, rm as rm15 } from "fs/promises";
 import { tmpdir as tmpdir7 } from "os";
 import path220 from "path";
 import { promisify as promisify7 } from "util";
@@ -96687,7 +97138,7 @@ async function captureWorktreePatch(worktreePath) {
   } catch {
     return;
   } finally {
-    await rm14(dir, { recursive: true, force: true }).catch(() => {
+    await rm15(dir, { recursive: true, force: true }).catch(() => {
       return;
     });
   }
@@ -98048,7 +98499,7 @@ var init_codec2 = __esm(() => {
 });
 
 // src/harness/external/runtime.ts
-import { mkdtemp as mkdtemp4, rm as rm15, writeFile as writeFile34 } from "fs/promises";
+import { mkdtemp as mkdtemp4, rm as rm16, writeFile as writeFile34 } from "fs/promises";
 import { tmpdir as tmpdir8 } from "os";
 import path221 from "path";
 function refuse2(status, output) {
@@ -98065,7 +98516,7 @@ async function prepareResultSchema() {
     return { ok: true, schema, schemaText, schemaPath, schemaDir };
   } catch (error) {
     if (schemaDir !== undefined) {
-      await rm15(schemaDir, { recursive: true, force: true }).catch(() => {
+      await rm16(schemaDir, { recursive: true, force: true }).catch(() => {
         return;
       });
     }
@@ -98172,7 +98623,7 @@ async function runExternalChild(input, deps) {
     try {
       await writeFile34(resultSchemaPathForCodec, JSON.stringify(toStrictOutputSchema(bundledResultSchema)), "utf8");
     } catch (error) {
-      await rm15(schemaDir, { recursive: true, force: true }).catch(() => {
+      await rm16(schemaDir, { recursive: true, force: true }).catch(() => {
         return;
       });
       const message = error instanceof Error ? error.message : String(error);
@@ -98267,7 +98718,7 @@ async function runExternalChild(input, deps) {
       });
     }
   } finally {
-    await rm15(schemaDir, { recursive: true, force: true }).catch(() => {
+    await rm16(schemaDir, { recursive: true, force: true }).catch(() => {
       return;
     });
   }
@@ -98434,7 +98885,7 @@ var init_runtime2 = __esm(() => {
 });
 
 // src/harness/run-external-factory.ts
-import { randomUUID as randomUUID26 } from "crypto";
+import { randomUUID as randomUUID27 } from "crypto";
 import { execFile as execFile10 } from "child_process";
 import { mkdir as mkdir54 } from "fs/promises";
 import { tmpdir as tmpdir9 } from "os";
@@ -98495,7 +98946,7 @@ async function createRunExternal(options) {
     return;
   }
   const config = gate.config;
-  const idSeq = options.idSeq ?? (() => randomUUID26());
+  const idSeq = options.idSeq ?? (() => randomUUID27());
   const worktreesDir = options.worktreesDir ?? path222.join(tmpdir9(), "keryx-external-worktrees");
   const spawn = options.spawn ?? createBunSpawnPort();
   const worktree = options.worktree ?? ensuringParentDir(createGitWorktreePort({ repoRoot: options.cwd, worktreesDir }), worktreesDir);
@@ -99434,7 +99885,7 @@ var init_client2 = __esm(() => {
 
 // src/lib/file-lock.ts
 import { closeSync as closeSync3, mkdirSync as mkdirSync7, openSync as openSync3, readFileSync as readFileSync21, rmSync as rmSync3, statSync as statSync13, writeFileSync as writeFileSync6 } from "fs";
-import { randomUUID as randomUUID27 } from "crypto";
+import { randomUUID as randomUUID28 } from "crypto";
 import path225 from "path";
 function sleepSync(ms) {
   const bunSleep = globalThis.Bun?.sleepSync;
@@ -99451,7 +99902,7 @@ function withFileLock2(lockPath, fn, options = {}) {
   } catch {
     return null;
   }
-  const nonce = randomUUID27();
+  const nonce = randomUUID28();
   const started = Date.now();
   const deadline = started + LOCK_TIMEOUT_MS;
   let handle = null;
@@ -101709,7 +102160,7 @@ import {
   writeFileSync as writeFileSync7
 } from "fs";
 import path232 from "path";
-import { randomUUID as randomUUID28 } from "crypto";
+import { randomUUID as randomUUID29 } from "crypto";
 function projectRegistryPath(dir) {
   return path232.join(keryxConfigDir(dir), "projects.json");
 }
@@ -101824,7 +102275,7 @@ function quarantineDamagedRegistry(dir, onWarn) {
 }
 function saveProjectRegistry(registry, dir, onWarn) {
   const file = projectRegistryPath(dir);
-  const temp = `${file}.${randomUUID28()}.tmp`;
+  const temp = `${file}.${randomUUID29()}.tmp`;
   try {
     ensureKeryxConfigDir(dir);
     const sorted = {
@@ -101880,7 +102331,7 @@ function registerProject(projectPath, options = {}) {
       return { ok: true, entry: existing, created: false };
     }
     const entry = {
-      projectId: randomUUID28(),
+      projectId: randomUUID29(),
       path: absolute,
       displayName: options.displayName ?? path232.basename(absolute),
       state: "active",
@@ -109019,7 +109470,7 @@ function formatHygieneTags(hygiene) {
 }
 
 // src/sac/lifecycle-flag.ts
-import { randomUUID as randomUUID29 } from "crypto";
+import { randomUUID as randomUUID30 } from "crypto";
 function normalize3(raw) {
   return raw.replace(/^\.\//, "");
 }
@@ -109038,7 +109489,7 @@ async function computeLifecycleFlags(cwd, now = () => new Date) {
     authorizationServer: localWorkspaceAuthorizationServer(),
     strictGuard: { mode: "strict", availability: "available", decision: "pass", policyRevision: "local-offline-v1" }
   });
-  const workspaces = await workspaceService.list({ request: undefined, requestCorrelationId: randomUUID29(), includeArchived: true });
+  const workspaces = await workspaceService.list({ request: undefined, requestCorrelationId: randomUUID30(), includeArchived: true });
   for (const workspace of workspaces) {
     const component = workspace.resources.find((r) => r.kind === "component")?.uri;
     if (component !== undefined && !isStillPresent(component, valid)) {
@@ -109067,8 +109518,8 @@ var init_lifecycle_flag = __esm(() => {
 });
 
 // src/sac/catch-up.ts
-import { randomUUID as randomUUID30 } from "crypto";
-import { readdir as readdir36, stat as stat24 } from "fs/promises";
+import { randomUUID as randomUUID31 } from "crypto";
+import { readdir as readdir36, stat as stat25 } from "fs/promises";
 import path243 from "path";
 async function buildCatchUp(input) {
   const [proposals, sessionCategories, lifecycleFlagsAll, unreviewedPathsAll] = await Promise.all([
@@ -109083,7 +109534,7 @@ async function buildCatchUp(input) {
 }
 async function collectProposals(cwd, workspaceId) {
   const authorizationServer = localWorkspaceAuthorizationServer();
-  const actor = await authorizationServer.actorContextFor(undefined, randomUUID30());
+  const actor = await authorizationServer.actorContextFor(undefined, randomUUID31());
   if (!actor)
     throw new Error("trusted ActorContext is required for catch-up");
   const proposalService = createLocalProposalLifecycleService(cwd);
@@ -109286,7 +109737,7 @@ async function collectReceiptTargets(cwd, owner) {
 async function attributeToSession(absolutePath, sessionsNewestFirst) {
   let mtimeMs;
   try {
-    mtimeMs = (await stat24(absolutePath)).mtimeMs;
+    mtimeMs = (await stat25(absolutePath)).mtimeMs;
   } catch {
     return;
   }
@@ -109572,7 +110023,7 @@ var init_session = __esm(() => {
 });
 
 // src/tui/inspector-sources.ts
-import { randomUUID as randomUUID31 } from "crypto";
+import { randomUUID as randomUUID32 } from "crypto";
 function workspaceFromManifest(manifest) {
   return {
     id: manifest.id,
@@ -109651,7 +110102,7 @@ async function loadInspectorWorkspaces(cwd) {
       authorizationServer: localWorkspaceAuthorizationServer(),
       strictGuard: localSacGuard()
     });
-    const listed = await service.list({ request: undefined, requestCorrelationId: randomUUID31() });
+    const listed = await service.list({ request: undefined, requestCorrelationId: randomUUID32() });
     return listed.map(workspaceFromManifest);
   } catch {
     return [];
@@ -109664,7 +110115,7 @@ async function loadInspectorWorkspace(cwd, workspaceId) {
       authorizationServer: localWorkspaceAuthorizationServer(),
       strictGuard: localSacGuard()
     });
-    const manifest = await service.show({ request: undefined, requestCorrelationId: randomUUID31(), workspaceId });
+    const manifest = await service.show({ request: undefined, requestCorrelationId: randomUUID32(), workspaceId });
     return workspaceFromManifest(manifest);
   } catch {
     return;
@@ -111983,7 +112434,7 @@ var init_repair = __esm(() => {
 });
 
 // src/review/managed.ts
-import { mkdir as mkdir55, readFile as readFile117, readdir as readdir38, realpath as realpath18, rm as rm16, stat as stat25 } from "fs/promises";
+import { mkdir as mkdir55, readFile as readFile117, readdir as readdir38, realpath as realpath18, rm as rm17, stat as stat26 } from "fs/promises";
 import path246 from "path";
 function reviewsRoot(cwd) {
   return path246.join(cwd, ".metaproject", "reviews");
@@ -112210,7 +112661,7 @@ async function persistScreenRadius(packageDir, resolved) {
 `);
   }
   if (resolved.source === "handoff" && resolved.file !== undefined) {
-    await rm16(resolved.file, { force: true });
+    await rm17(resolved.file, { force: true });
   }
 }
 function concurrencyPlan(input, coverage) {
@@ -112489,7 +112940,7 @@ function readFromWorkingTree(input) {
       return null;
     }
     try {
-      const info = await stat25(real);
+      const info = await stat26(real);
       if (!info.isFile() || info.size > MAX_LOCATE_FILE_BYTES) {
         return null;
       }
@@ -114473,7 +114924,7 @@ var init_endpoint = __esm(() => {
 });
 
 // src/lib/serve-credential.ts
-import { createHash as createHash63, randomBytes as randomBytes11, randomUUID as randomUUID32 } from "crypto";
+import { createHash as createHash63, randomBytes as randomBytes11, randomUUID as randomUUID33 } from "crypto";
 import {
   chmodSync as chmodSync5,
   closeSync as closeSync5,
@@ -114557,7 +115008,7 @@ function readServeCredential(dir) {
 }
 function writeStore(store, dir) {
   const file = serveCredentialPath(dir);
-  const temp = `${file}.${randomUUID32()}.tmp`;
+  const temp = `${file}.${randomUUID33()}.tmp`;
   try {
     ensureKeryxConfigDir(dir);
     const handle = openSync5(temp, "wx", 384);
@@ -114597,7 +115048,7 @@ function mintRecord(now) {
   const salt = randomBytes11(32).toString("hex");
   return {
     token,
-    record: { id: randomUUID32(), algorithm: "sha256", salt, hash: hashToken(salt, token), createdAt: now }
+    record: { id: randomUUID33(), algorithm: "sha256", salt, hash: hashToken(salt, token), createdAt: now }
   };
 }
 function issueServeToken(dir, now = () => new Date().toISOString(), onWaiting) {
@@ -116193,7 +116644,7 @@ function fileExists(file) {
   const read = readConfigFile(file);
   return read.ok || read.reason !== "absent";
 }
-function isObject2(value) {
+function isObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function plural2(count, one, many) {
@@ -116220,7 +116671,7 @@ class ChannelsClient {
   status() {
     return this.call("channels-status", (body) => {
       const telegram = body.telegram;
-      return typeof body.machine === "string" && isObject2(telegram) && typeof telegram.state === "string" && typeof telegram.sessions === "number";
+      return typeof body.machine === "string" && isObject3(telegram) && typeof telegram.state === "string" && typeof telegram.sessions === "number";
     });
   }
   async startPairing(token) {
@@ -116389,12 +116840,12 @@ class ChannelsClient {
       parsed = undefined;
     }
     if (!response.ok) {
-      const error = isObject2(parsed) && isObject2(parsed.error) ? parsed.error : undefined;
+      const error = isObject3(parsed) && isObject3(parsed.error) ? parsed.error : undefined;
       const code = typeof error?.code === "string" ? error.code : `http-${response.status}`;
       const message = typeof error?.message === "string" ? error.message : `keryx serve refused the request (HTTP ${response.status})`;
       return { ok: false, code, reason: message };
     }
-    if (!isObject2(parsed) || !guard(parsed)) {
+    if (!isObject3(parsed) || !guard(parsed)) {
       return { ok: false, code: "unexpected-response", reason: "keryx serve sent an answer this shell does not understand; update keryx on both sides" };
     }
     return { ok: true, value: parsed };
@@ -116414,7 +116865,7 @@ class ChannelsClient {
 }
 function refusedConnection(error) {
   const seen = new Set;
-  for (let current = error;isObject2(current) || current instanceof Error; ) {
+  for (let current = error;isObject3(current) || current instanceof Error; ) {
     if (seen.has(current))
       break;
     seen.add(current);
@@ -120921,7 +121372,7 @@ var init_serve_turn_store = __esm(() => {
 });
 
 // src/lib/serve-approvals-store.ts
-import { randomUUID as randomUUID33 } from "crypto";
+import { randomUUID as randomUUID34 } from "crypto";
 import { existsSync as existsSync45, readdirSync as readdirSync10 } from "fs";
 import path261 from "path";
 function isApprovalId(value) {
@@ -121197,7 +121648,7 @@ function toPublicApproval(view) {
   };
 }
 function newApprovalId() {
-  return randomUUID33();
+  return randomUUID34();
 }
 var APPROVAL_SCHEMA_VERSION = "1.0.0", SUMMARY_MAX = 500, SCOPE_MAX = 300, CONSEQUENCE_MAX = 300, ID_PATTERN2;
 var init_serve_approvals_store = __esm(() => {
@@ -121718,10 +122169,12 @@ async function openDecisions(otui, chrome, options) {
   const text = await reportText(cwd).catch(() => UNREADABLE);
   return presentDecisions((hostOtui, hostChrome, input) => openModal(hostOtui, hostChrome, input), otui, chrome, { ...rest, text });
 }
-function projectDecisionsPanel(count, width) {
-  if (count <= 0)
+function projectDecisionsPanel(count, width, backfilled = 0) {
+  if (count <= 0 && backfilled <= 0)
     return { visible: false, text: "" };
-  const label = `${count} decision${count === 1 ? "" : "s"}`;
+  const live = count > 0 ? `${count} decision${count === 1 ? "" : "s"}` : "";
+  const before = backfilled > 0 ? `${count > 0 ? " + " : ""}${backfilled} before` : "";
+  const label = `${live}${before}`;
   const candidates = [`${label} \xB7 /decisions`, label];
   const text = candidates.find((candidate) => candidate.length <= width) ?? label.slice(0, Math.max(1, width));
   return { visible: true, text };
@@ -121744,6 +122197,7 @@ function mountDecisionsSidebar(options) {
   const { chrome } = options;
   const r = chrome.renderer;
   const count = options.count ?? (() => decisionCount(options.cwd));
+  const backfilledTotal = options.backfilled ?? (() => backfilledCount(options.cwd));
   const box = new core.BoxRenderable(r, { id: "sb-decisions", flexDirection: "column", flexShrink: 0 });
   options.parent.add(box);
   let modal;
@@ -121789,7 +122243,13 @@ function mountDecisionsSidebar(options) {
     } catch {
       n = 0;
     }
-    projected = projectDecisionsPanel(n, options.width);
+    let before;
+    try {
+      before = await backfilledTotal();
+    } catch {
+      before = 0;
+    }
+    projected = projectDecisionsPanel(n, options.width, before);
     paint();
   };
   const unsubscribeTheme = onThemeChange(guardedThemeRepaint("decisions-row", () => paint(true), () => disposed || isRenderableGone(box)));
@@ -121837,8 +122297,8 @@ var init_decisions_surface = __esm(() => {
 
 // src/harness/external/write-run.ts
 import { execFile as execFile11 } from "child_process";
-import { createHash as createHash66, randomUUID as randomUUID34 } from "crypto";
-import { mkdtemp as mkdtemp5, readlink, realpath as realpath19, rm as rm17 } from "fs/promises";
+import { createHash as createHash66, randomUUID as randomUUID35 } from "crypto";
+import { mkdtemp as mkdtemp5, readlink, realpath as realpath19, rm as rm18 } from "fs/promises";
 import { tmpdir as tmpdir11 } from "os";
 import path262 from "path";
 import { promisify as promisify9 } from "util";
@@ -121957,7 +122417,7 @@ async function captureWriteDiff(input) {
       refusedPaths
     };
   } finally {
-    await rm17(indexDir, { recursive: true, force: true }).catch(() => {
+    await rm18(indexDir, { recursive: true, force: true }).catch(() => {
       return;
     });
   }
@@ -122031,7 +122491,7 @@ async function runExternalWriteChild(input, deps) {
       });
     }
     if (ownedDir !== undefined)
-      await rm17(ownedDir, { recursive: true, force: true }).catch(() => {
+      await rm18(ownedDir, { recursive: true, force: true }).catch(() => {
         return;
       });
   }
@@ -122056,7 +122516,7 @@ async function runExternalWriteChild(input, deps) {
   }
 }
 function persistWriteRun(args) {
-  const runId = randomUUID34();
+  const runId = randomUUID35();
   const title = `External write ${args.agentId}: ${args.runStatus}`;
   const handle = createSession({
     cwd: args.projectRoot,
@@ -122172,7 +122632,7 @@ var init_write_run = __esm(() => {
 import { execFile as execFile12 } from "child_process";
 import { createHash as createHash67 } from "crypto";
 import { existsSync as existsSync46, rmSync as rmSync5 } from "fs";
-import { mkdtemp as mkdtemp6, rm as rm18 } from "fs/promises";
+import { mkdtemp as mkdtemp6, rm as rm19 } from "fs/promises";
 import { tmpdir as tmpdir12 } from "os";
 import path263 from "path";
 function errorMessage3(error) {
@@ -122292,11 +122752,11 @@ async function landWriteRun(input, deps = {}) {
       return;
     });
     if (ownedDir !== undefined)
-      await rm18(ownedDir, { recursive: true, force: true }).catch(() => {
+      await rm19(ownedDir, { recursive: true, force: true }).catch(() => {
         return;
       });
     else
-      await rm18(path263.join(worktreesDir, worktreeId), { recursive: true, force: true }).catch(() => {
+      await rm19(path263.join(worktreesDir, worktreeId), { recursive: true, force: true }).catch(() => {
         return;
       });
     await git(["worktree", "prune"], repo).catch(() => {
@@ -126285,7 +126745,7 @@ function recordTaskCost(store, record) {
   const next = existing.length >= MAX_SAMPLES_PER_KEY ? [...existing.slice(existing.length - MAX_SAMPLES_PER_KEY + 1), record] : [...existing, record];
   return { ...store, [key]: next };
 }
-function median(values) {
+function median2(values) {
   if (values.length === 0)
     return 0;
   const sorted = [...values].sort((a, b) => a - b);
@@ -126294,9 +126754,9 @@ function median(values) {
 }
 function statsForKey(records, providerId, modelId, category) {
   const n = records.length;
-  const medianTokens = median(records.map((r) => r.totalTokens));
+  const medianTokens = median2(records.map((r) => r.totalTokens));
   const knownCosts = records.map((r) => r.costUsd).filter((c) => c !== undefined);
-  const medianCostUsd = knownCosts.length > 0 ? median(knownCosts) : undefined;
+  const medianCostUsd = knownCosts.length > 0 ? median2(knownCosts) : undefined;
   const successRate = records.filter((r) => r.success).length / n;
   return { providerId, modelId, category, n, medianTokens, ...medianCostUsd !== undefined ? { medianCostUsd } : {}, successRate };
 }
@@ -128677,7 +129137,7 @@ var init_conform_report = __esm(() => {
 });
 
 // src/tui/conform-source.ts
-import { readFile as readFile127, readdir as readdir41, stat as stat26 } from "fs/promises";
+import { readFile as readFile127, readdir as readdir41, stat as stat27 } from "fs/promises";
 import path270 from "path";
 async function readRecentConformDocs(cwd) {
   try {
@@ -128720,7 +129180,7 @@ async function mostRecentReviewPackage(cwd) {
           continue;
         const dir = path270.join(reviewsDir, reviewEntry.name);
         try {
-          const info = await stat26(path270.join(dir, "report.md"));
+          const info = await stat27(path270.join(dir, "report.md"));
           if (best === undefined || info.mtimeMs > best.mtimeMs)
             best = { dir, mtimeMs: info.mtimeMs };
         } catch {}
@@ -129687,7 +130147,7 @@ var init_jev_rules = __esm(() => {
 });
 
 // src/commands/review-jev-rules.ts
-import { readFile as readFile130, readdir as readdir42, stat as stat27 } from "fs/promises";
+import { readFile as readFile130, readdir as readdir42, stat as stat28 } from "fs/promises";
 import { basename as basename3, dirname as dirname2, isAbsolute as isAbsolute3, join as join5, relative as relative3 } from "path";
 function rejectUnknownJevRulesFlags(args) {
   const unknown = args.filter((arg) => arg.startsWith("--") && !JEV_RULES_FLAGS.includes(arg.split("=")[0]));
@@ -129800,7 +130260,7 @@ async function discoverRuleSources(cwd, explicitPaths) {
   const explicitDirSources = [];
   for (const raw of explicitPaths) {
     const resolved = isAbsolute3(raw) ? raw : join5(cwd, raw);
-    const stats = await stat27(resolved).catch(() => {
+    const stats = await stat28(resolved).catch(() => {
       return;
     });
     if (stats === undefined) {
@@ -131677,7 +132137,7 @@ var init_jev_triage = __esm(() => {
 });
 
 // src/commands/review-jev-triage.ts
-import { readFile as readFile136, stat as stat28 } from "fs/promises";
+import { readFile as readFile136, stat as stat29 } from "fs/promises";
 import path276 from "path";
 function rejectUnknownJevTriageFlags(args) {
   const unknown = args.filter((arg) => arg.startsWith("--") && !JEV_TRIAGE_FLAGS.includes(arg.split("=")[0]));
@@ -131712,7 +132172,7 @@ function isMaxTokensExceededError2(error) {
 async function loadReportRaw(reportPath) {
   let filePath = reportPath;
   try {
-    const stats = await stat28(reportPath);
+    const stats = await stat29(reportPath);
     if (stats.isDirectory())
       filePath = path276.join(reportPath, "findings.json");
   } catch {}
@@ -131857,7 +132317,7 @@ var init_review_jev_triage = __esm(() => {
 });
 
 // src/tui/jev-triage-command.ts
-import { readdir as readdir43, readFile as readFile137, stat as stat29 } from "fs/promises";
+import { readdir as readdir43, readFile as readFile137, stat as stat30 } from "fs/promises";
 import path277 from "path";
 function isJevTriageCommand(name) {
   return name === JEV_TRIAGE_COMMAND;
@@ -131886,7 +132346,7 @@ async function resolveLatestReviewPackage(cwd) {
       const packageDir = path277.join(reviewsDir, reviewName);
       const findingsPath = path277.join(packageDir, "findings.json");
       try {
-        const stats = await stat29(findingsPath);
+        const stats = await stat30(findingsPath);
         candidates.push({ dir: packageDir, mtimeMs: stats.mtimeMs });
       } catch {
         continue;
@@ -139215,7 +139675,7 @@ function maxOverFiles(files, values) {
 }
 
 // src/wiki/deep-enrich.ts
-import { randomUUID as randomUUID35, createHash as createHash68 } from "crypto";
+import { randomUUID as randomUUID36, createHash as createHash68 } from "crypto";
 function errorMessage4(cause) {
   return cause instanceof Error ? cause.message : String(cause);
 }
@@ -139251,7 +139711,7 @@ function buildDeepUserPrompt(page, original, extra) {
 `);
 }
 async function enrichPageDeep(input) {
-  const idSeq = input.idSeq ?? (() => randomUUID35());
+  const idSeq = input.idSeq ?? (() => randomUUID36());
   const clock = input.clock ?? (() => new Date().toISOString());
   const toolCalls = [];
   if (input.signal?.aborted) {
@@ -144740,7 +145200,7 @@ var init_reflect = __esm(() => {
 });
 
 // src/commands/memory.ts
-import { randomUUID as randomUUID36 } from "crypto";
+import { randomUUID as randomUUID37 } from "crypto";
 import { readdir as readdir46 } from "fs/promises";
 import { join as join9 } from "path";
 function getService2() {
@@ -144928,7 +145388,7 @@ async function runSearch(args) {
   }
   if (args.includes("--json")) {
     const projection = renderMemorySearchReport({
-      runId: randomUUID36(),
+      runId: randomUUID37(),
       generatedAt: new Date,
       search: result,
       filters
@@ -145932,8 +146392,8 @@ var init_proxy = __esm(() => {
 
 // src/commands/trigger-agent-task.ts
 import { execFile as execFile13 } from "child_process";
-import { randomUUID as randomUUID37 } from "crypto";
-import { mkdtemp as mkdtemp7, mkdir as mkdir61, readdir as readdir47, rm as rm19, writeFile as writeFile38 } from "fs/promises";
+import { randomUUID as randomUUID38 } from "crypto";
+import { mkdtemp as mkdtemp7, mkdir as mkdir61, readdir as readdir47, rm as rm20, writeFile as writeFile38 } from "fs/promises";
 import { homedir as homedir12, tmpdir as tmpdir13 } from "os";
 import path290 from "path";
 function scrubGrantedOutput(text, env, secrets = []) {
@@ -146055,12 +146515,12 @@ function lastAssistantText(history) {
 async function pruneReports(dir, keep) {
   const names = (await readdir47(dir).catch(() => [])).filter((n) => n.endsWith(".md")).sort();
   for (const old of names.slice(0, Math.max(0, names.length - keep))) {
-    await rm19(path290.join(dir, old), { force: true }).catch(() => {});
+    await rm20(path290.join(dir, old), { force: true }).catch(() => {});
   }
 }
 async function runAgentTaskDispatch(projectRoot, entry, action, deps = {}) {
   const now = deps.now ?? (() => new Date);
-  const runId = deps.runId?.() ?? `sch-${now().toISOString().replace(/[-:.]/g, "").slice(0, 15)}-${randomUUID37().slice(0, 8)}`;
+  const runId = deps.runId?.() ?? `sch-${now().toISOString().replace(/[-:.]/g, "").slice(0, 15)}-${randomUUID38().slice(0, 8)}`;
   await ensureLocksDir(projectRoot);
   try {
     return await withFileLock(dispatchLockPath(projectRoot, `schedule-${entry.name}`), () => runLocked(projectRoot, entry, action, deps, runId, now), {
@@ -146100,7 +146560,7 @@ async function runLocked(projectRoot, entry, action, deps, runId, now) {
   await mkdir61(scratchHome, { recursive: true });
   await mkdir61(grantedCwd, { recursive: true, mode: 448 });
   const cleanup = async () => {
-    await rm19(scratch, { recursive: true, force: true }).catch(() => {});
+    await rm20(scratch, { recursive: true, force: true }).catch(() => {});
   };
   let closeProxy = async () => {};
   const networkDecisions = [];
@@ -146223,7 +146683,7 @@ async function runLocked(projectRoot, entry, action, deps, runId, now) {
           modelId: dispatch.model,
           toolNames: tools.map((t) => t.definition.name)
         }),
-        idSeq: () => randomUUID37(),
+        idSeq: () => randomUUID38(),
         unattended: true,
         hardDeny: unattendedRefusal,
         ...shellHooks !== undefined ? { hooks: shellHooks } : {}
@@ -146738,7 +147198,7 @@ var init_digest_limits = __esm(() => {
 });
 
 // src/scheduler/digest-summary.ts
-import { randomUUID as randomUUID38 } from "crypto";
+import { randomUUID as randomUUID39 } from "crypto";
 var SYSTEM, MAX_OUTPUT_TOKENS = 400, defaultSummarize = async (input) => {
   const { action, entry } = input;
   const dispatch = action.dispatch;
@@ -146768,7 +147228,7 @@ var SYSTEM, MAX_OUTPUT_TOKENS = 400, defaultSummarize = async (input) => {
     local.abort();
   });
   const provider = guardUsage(built, () => meter.markUsageMissing());
-  const requestId = `digest-${randomUUID38().slice(0, 8)}`;
+  const requestId = `digest-${randomUUID39().slice(0, 8)}`;
   const request = {
     providerId: dispatch.provider,
     modelId: dispatch.model,
@@ -146817,8 +147277,8 @@ var init_digest_summary = __esm(() => {
 });
 
 // src/scheduler/digest-run.ts
-import { randomUUID as randomUUID39 } from "crypto";
-import { mkdir as mkdir62, mkdtemp as mkdtemp8, rm as rm20, writeFile as writeFile39 } from "fs/promises";
+import { randomUUID as randomUUID40 } from "crypto";
+import { mkdir as mkdir62, mkdtemp as mkdtemp8, rm as rm21, writeFile as writeFile39 } from "fs/promises";
 import path292 from "path";
 function capForDelivery(text, reportPath) {
   if (text.length <= DELIVERY_TEXT_MAX)
@@ -146838,7 +147298,7 @@ async function announceRefusal(projectRoot, name, topic, runId, reason, result,
 }
 async function runDigestDispatch(projectRoot, entry, action, deps = {}) {
   const now = deps.now ?? (() => new Date);
-  const runId = deps.runId?.() ?? `dig-${now().toISOString().replace(/[-:.]/g, "").slice(0, 15)}-${randomUUID39().slice(0, 8)}`;
+  const runId = deps.runId?.() ?? `dig-${now().toISOString().replace(/[-:.]/g, "").slice(0, 15)}-${randomUUID40().slice(0, 8)}`;
   await ensureLocksDir(projectRoot);
   try {
     return await withFileLock(dispatchLockPath(projectRoot, `schedule-${entry.name}`), () => runLocked2(projectRoot, entry, action, deps, runId, now), {
@@ -146950,7 +147410,7 @@ async function runLocked2(projectRoot, entry, action, deps, runId, now) {
     crashed = error instanceof Error ? error.message : String(error);
   } finally {
     limits.dispose();
-    await rm20(scratch, { recursive: true, force: true }).catch(() => {});
+    await rm21(scratch, { recursive: true, force: true }).catch(() => {});
   }
   const tools = DIGEST_TOOL_IDS.filter((id) => action.grants.tools.includes(id));
   const attempted = tools.length * action.grants.repos.length;
@@ -155829,7 +156289,7 @@ var init_debug_watcher = __esm(() => {
 });
 
 // src/commands/shell.ts
-import { randomUUID as randomUUID40 } from "crypto";
+import { randomUUID as randomUUID41 } from "crypto";
 import { join as joinPath2 } from "path";
 import * as readline2 from "readline";
 function reportMcpProblems(runtime) {
@@ -158188,14 +158648,14 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
 `);
   }
   const surface = chooseShellSurface(flags, runtime.isTty ?? process.stdout.isTTY === true);
-  const shellHookSessionId = randomUUID40();
+  const shellHookSessionId = randomUUID41();
   let shellHooks;
   const getShellHooks = () => {
     if (shellHooks === undefined) {
       shellHooks = buildShellHookRuntime({
         projectRoot: resolveProjectRoot2(process.cwd()),
         sessionId: shellHookSessionId,
-        runId: randomUUID40(),
+        runId: randomUUID41(),
         interactive: true,
         profileId: "monitored-trusted-local",
         ...runtime.cacheDir === undefined ? {} : { configDir: runtime.cacheDir }
@@ -158300,7 +158760,7 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
           sessionOverride: reasoningSessionOverride,
           globalEffort: loadShellConfig(runtime.cacheDir).reasoningEffort
         }),
-        idSeq: () => randomUUID40(),
+        idSeq: () => randomUUID41(),
         askUser: invokeAskUserHost,
         sweepBackgroundJobs: () => jobRegistry.sweepAll(),
         jobRegistry,
@@ -158371,7 +158831,7 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
             return {
               makeProvider: chatFactory,
               clock: () => new Date().toISOString(),
-              idSeq: () => randomUUID40(),
+              idSeq: () => randomUUID41(),
               initial: Object.keys(resolvedModelParams).length > 0 ? { ...sel, modelParams: resolvedModelParams } : sel,
               session: {
                 cwd,
@@ -158499,7 +158959,7 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
     const deps = {
       makeProvider: baseFactory,
       clock: () => new Date().toISOString(),
-      idSeq: () => randomUUID40(),
+      idSeq: () => randomUUID41(),
       initial: {
         provider,
         model,
@@ -158580,7 +159040,7 @@ Example: keryx shell --provider ollama --model llama3.1:latest`);
           sessionOverride: reasoningSessionOverride,
           globalEffort: loadShellConfig(runtime.cacheDir).reasoningEffort
         }),
-        idSeq: () => randomUUID40(),
+        idSeq: () => randomUUID41(),
         askUser: invokeAskUserHost,
         mcpRuntime: () => mcpRuntime,
         sweepBackgroundJobs: () => jobRegistry.sweepAll(),
@@ -163090,8 +163550,8 @@ var init_sweep = __esm(() => {
 });
 
 // src/retention/auto-sweep.ts
-import { mkdir as mkdir63, readFile as readFile158, rm as rm21, stat as stat30, writeFile as writeFile40 } from "fs/promises";
-import { randomUUID as randomUUID41 } from "crypto";
+import { mkdir as mkdir63, readFile as readFile158, rm as rm22, stat as stat31, writeFile as writeFile40 } from "fs/promises";
+import { randomUUID as randomUUID42 } from "crypto";
 import path309 from "path";
 function autoSweepStampPath(cwd) {
   return path309.join(cwd, ".metaproject", "data", "retention", "last-auto-sweep.json");
@@ -163123,7 +163583,7 @@ async function readAutoSweepStamp(cwd) {
 }
 async function claimIsLive(cwd, staleMs) {
   const claimPath = autoSweepClaimPath(cwd);
-  const held = await stat30(claimPath).catch(() => null);
+  const held = await stat31(claimPath).catch(() => null);
   if (held === null || Date.now() - held.mtimeMs > staleMs) {
     return false;
   }
@@ -163140,7 +163600,7 @@ async function claimIsLive(cwd, staleMs) {
   }
 }
 async function acquireClaim(claimPath, staleMs) {
-  const nonce = `${process.pid}:${randomUUID41()}`;
+  const nonce = `${process.pid}:${randomUUID42()}`;
   for (let attempt = 0;attempt < 2; attempt += 1) {
     try {
       await writeFile40(claimPath, nonce, { flag: "wx", mode: 384 });
@@ -163148,7 +163608,7 @@ async function acquireClaim(claimPath, staleMs) {
         release: async () => {
           try {
             if (await readFile158(claimPath, "utf8") === nonce) {
-              await rm21(claimPath, { force: true });
+              await rm22(claimPath, { force: true });
             }
           } catch {}
         }
@@ -163158,9 +163618,9 @@ async function acquireClaim(claimPath, staleMs) {
       if (code !== "EEXIST") {
         return null;
       }
-      const held = await stat30(claimPath).catch(() => null);
+      const held = await stat31(claimPath).catch(() => null);
       if (held !== null && Date.now() - held.mtimeMs > staleMs) {
-        await rm21(claimPath, { force: true }).catch(() => {
+        await rm22(claimPath, { force: true }).catch(() => {
           return;
         });
         continue;
@@ -163229,7 +163689,7 @@ var init_auto_sweep = __esm(() => {
 
 // src/ctx/artifact-id.ts
 import { randomBytes as randomBytes13 } from "crypto";
-import { mkdir as mkdir64, readFile as readFile159, rm as rm22, writeFile as writeFile41 } from "fs/promises";
+import { mkdir as mkdir64, readFile as readFile159, rm as rm23, writeFile as writeFile41 } from "fs/promises";
 import path310 from "path";
 function pinnedClock() {
   const pin = process.env.KERYX_CTX_CLOCK_PIN_MS;
@@ -163278,7 +163738,7 @@ async function reserveArtifact(options) {
       continue;
     }
     if (!await claim(summaryPath)) {
-      await rm22(rawPath, { force: true });
+      await rm23(rawPath, { force: true });
       continue;
     }
     return { id, rawPath, summaryPath };
@@ -164754,7 +165214,7 @@ function readLiteral(source, start, quote) {
 }
 
 // src/wiki/freshness/queue.ts
-import { readFile as readFile161, rename as rename10, stat as stat31, unlink as unlink3, writeFile as writeFile43 } from "fs/promises";
+import { readFile as readFile161, rename as rename11, stat as stat32, unlink as unlink3, writeFile as writeFile43 } from "fs/promises";
 import path312 from "path";
 function queuePath(cwd) {
   return path312.join(cwd, ".metaproject", "data", "wiki", QUEUE_FILE);
@@ -164776,7 +165236,7 @@ async function drainQueue(cwd) {
       if (line.trim().length === 0) {
         continue;
       }
-      const entry = parseEntry3(line);
+      const entry = parseEntry4(line);
       if (entry === null) {
         corruptLines += 1;
         continue;
@@ -164798,7 +165258,7 @@ async function clearQueue(cwd) {
     }
   }
 }
-function parseEntry3(line) {
+function parseEntry4(line) {
   try {
     const value = JSON.parse(line);
     if (value.schemaVersion !== 1 || typeof value.rev !== "string" || !/^[0-9a-f]{40}$/.test(value.rev) || typeof value.recordedAt !== "string" || !Array.isArray(value.paths)) {
@@ -169551,7 +170011,7 @@ var init_sync2 = __esm(() => {
 });
 
 // src/gdskills/rule-references.ts
-import { stat as stat32 } from "fs/promises";
+import { stat as stat33 } from "fs/promises";
 import path328 from "path";
 function ruleReferences(content) {
   const refs = new Set;
@@ -169568,7 +170028,7 @@ function withKeryxDirSpelling(ref) {
 }
 async function isRegularFile(absolute) {
   try {
-    return (await stat32(absolute)).isFile();
+    return (await stat33(absolute)).isFile();
   } catch {
     return false;
   }
@@ -169789,7 +170249,7 @@ var init_project_reviewers = __esm(() => {
 });
 
 // src/gdskills/import-skills.ts
-import { readdir as readdir54, readFile as readFile170, stat as stat33 } from "fs/promises";
+import { readdir as readdir54, readFile as readFile170, stat as stat34 } from "fs/promises";
 import { homedir as homedir14 } from "os";
 import path330 from "path";
 function emptyOnlyError(label) {
@@ -169830,7 +170290,7 @@ async function importProjectSkills(options) {
   addFlagWarnings(imported, sources, existingFlags);
   const rules = [];
   for (const decision of ruleDecisions) {
-    rules.push("row" in decision ? decision.row : options.dryRun ? unwrittenRow(decision.placement, [decision.dryRunReason, ...gateNotes(decision.gate, true)].filter(isString3).join(" \u2014 ") || undefined, decision.gate.security) : await writePlacedRule(options, decision.placement, decision.gate));
+    rules.push("row" in decision ? decision.row : options.dryRun ? unwrittenRow(decision.placement, [decision.dryRunReason, ...gateNotes(decision.gate, true)].filter(isString4).join(" \u2014 ") || undefined, decision.gate.security) : await writePlacedRule(options, decision.placement, decision.gate));
   }
   return {
     from: options.from,
@@ -170150,7 +170610,7 @@ async function resolveImportSources(options) {
   if (!await pathExists(resolved)) {
     throw new Error(`keryx skills import: --from ${options.from} does not exist (resolved to ${resolved})`);
   }
-  const stats = await stat33(resolved);
+  const stats = await stat34(resolved);
   if (stats.isFile()) {
     return [await sourceFromFile(options, resolved)];
   }
@@ -170351,7 +170811,7 @@ function gateRowParts(gate, dryRun) {
   return security;
 }
 function gateNotes(gate, dryRun) {
-  return [gateRowParts(gate, dryRun).reason].filter(isString3);
+  return [gateRowParts(gate, dryRun).reason].filter(isString4);
 }
 function plannedSkillText(content, header) {
   const version = parseSkillFrontmatter(content).metadataVersion ?? "0.1.0";
@@ -170967,7 +171427,7 @@ Examples:
 var BUNDLED_NAMES, PATHS_NONE_WARNING = 'paths: none \u2014 dispatched on every round. Declare `metadata.paths: "<glob>, <glob>"` in its frontmatter to gate it on the diff.', DEFAULT_FETCHER = async (url) => {
   const response = await fetch(url);
   return { ok: response.ok, status: response.status, text: await response.text() };
-}, DEPRECATED_REASON = "deprecated", KNOWN_CATEGORIES, isString3 = (value) => value !== undefined, REFUSED_NOTE = "A refused file was not written.", ALLOW_FLAGGED_HINT = "A prompt-injection refusal can be overridden after you read the file: run the command again with --allow-flagged.", IMPORT_HEADER_LABELS, IMPORT_HEADER_LINE, BYTE_ORDER_MARK = 65279, ALLOW_FLAGGED_FLAG = "--allow-flagged", SECURITY_GATE_HELP = `Security gate: a SKILL.md or rule is written as the gate returns it, so a secret is
+}, DEPRECATED_REASON = "deprecated", KNOWN_CATEGORIES, isString4 = (value) => value !== undefined, REFUSED_NOTE = "A refused file was not written.", ALLOW_FLAGGED_HINT = "A prompt-injection refusal can be overridden after you read the file: run the command again with --allow-flagged.", IMPORT_HEADER_LABELS, IMPORT_HEADER_LINE, BYTE_ORDER_MARK = 65279, ALLOW_FLAGGED_FLAG = "--allow-flagged", SECURITY_GATE_HELP = `Security gate: a SKILL.md or rule is written as the gate returns it, so a secret is
 masked and the row says it was redacted, and any other finding is reported on the
 row. Text with a prompt-injection finding is refused in every security mode: the
 row is \`refused\` (\`would-refuse\` on a dry run) with the gate's own summary,
@@ -181155,12 +181615,29 @@ var init_command_registry = __esm(() => {
     {
       module: "decisions",
       command: "decisions report",
-      summary: "Match share between the human's choice and the agent's recommendation, by mode (ordinary, blind) and by stage, " + "with every deviation and its reason. Deterministic, no model.",
+      summary: "Match share between the human's choice and the agent's recommendation, by mode (ordinary, blind) and by stage, " + "with every deviation and its reason. Backfilled (imported, historical) decisions are reported in a block of their own and never counted in the live shares or the time to answer. Deterministic, no model.",
       intent: ["decisions report", "\u043E\u0442\u0447\u0451\u0442 \u043F\u043E \u0440\u0435\u043A\u043E\u043C\u0435\u043D\u0434\u0430\u0446\u0438\u044F\u043C", "how often does the human follow the recommendation", "blind mode results"],
-      args: [{ name: "json", type: "bool", required: false, desc: "print the report as JSON" }],
+      args: [
+        { name: "json", type: "bool", required: false, desc: "print the report as JSON (with a `backfilled` section)" },
+        { name: "line", type: "bool", required: false, desc: "print ONE line in Russian for the daily topic message: the total and the match share of the visible, hidden and historical decisions" }
+      ],
       json: true,
       read: true
     },
+    {
+      module: "decisions",
+      command: "decisions import",
+      summary: 'Import historical decisions from a JSON-lines file as backfilled records: the "before" arm of a comparison with the live journal. ' + "Each is marked backfilled, is never blind, keeps the time it was asked, and is reported apart from the live ones. " + "A line that is not a decision is skipped, named with its line number and counted as malformed, and the rest is imported; an id already in the journal is skipped, so a second import changes nothing (except that a backfilled decision missing its answer gets just that answer).",
+      intent: ["decisions import", "import historical decisions", "backfill the recommendation journal", "\u0438\u043C\u043F\u043E\u0440\u0442 \u0438\u0441\u0442\u043E\u0440\u0438\u0447\u0435\u0441\u043A\u0438\u0445 \u0440\u0435\u0448\u0435\u043D\u0438\u0439", "\u0434\u043E\u0437\u0430\u043F\u043E\u043B\u043D\u0438\u0442\u044C \u0436\u0443\u0440\u043D\u0430\u043B \u0440\u0435\u0448\u0435\u043D\u0438\u0439"],
+      args: [
+        { name: "<file>", type: "string", required: true, desc: "a JSON-lines file, one decision per line: id, at, flow, stage, question, options, recommendation, source, answer, reason" },
+        { name: "dry-run", type: "bool", required: false, desc: "check and count without writing" },
+        { name: "json", type: "bool", required: false, desc: 'print the counts as JSON (a failure is {"error": "..."})' }
+      ],
+      json: true,
+      read: false,
+      sideEffects: ["appends open, answer and reason records to .metaproject/data/decisions/journal.jsonl (nothing with --dry-run)"]
+    },
     {
       module: "product",
       command: "product index",
@@ -182014,7 +182491,7 @@ function isPassGate(gate) {
 
 // src/commands/security-audit-harness.ts
 import path347 from "path";
-import { stat as stat34 } from "fs/promises";
+import { stat as stat35 } from "fs/promises";
 function isSeverity(value) {
   return value !== undefined && SEVERITIES3.includes(value);
 }
@@ -182059,7 +182536,7 @@ async function handleAuditHarness(cwd, args = []) {
 }
 async function handleRun(cwd, args) {
   const root = resolveRoot(cwd, args);
-  const rootStat = await stat34(root).catch(() => {
+  const rootStat = await stat35(root).catch(() => {
     return;
   });
   if (!rootStat || !rootStat.isDirectory()) {
@@ -182146,7 +182623,7 @@ async function handleApply(cwd, args) {
     process.exitCode = 1;
     return;
   }
-  const rootStat = await stat34(root).catch(() => {
+  const rootStat = await stat35(root).catch(() => {
     return;
   });
   if (!rootStat || !rootStat.isDirectory()) {
@@ -184193,7 +184670,7 @@ var init_metaproject_tools2 = __esm(() => {
 // src/mcp/tools.ts
 import { readFile as readFile185, realpath as realpath22, writeFile as writeFile49 } from "fs/promises";
 import path351 from "path";
-import { randomUUID as randomUUID42 } from "crypto";
+import { randomUUID as randomUUID43 } from "crypto";
 function sacWorkspaceService(cwd) {
   return new WorkspaceService({
     workspaceRoot: cwd,
@@ -184279,7 +184756,7 @@ function buildToolRegistry() {
     { name: "sac.collaboration", module: "sac", description: "Read the collaboration references and activity for one Shared Agent Context workspace \u2014 who is participating and what has moved recently, redacted to what this actor may see. Local stdio only: over HTTP it returns `sac_transport_denied` without reading anything, because HTTP has no verified principal and must not inherit the local OS actor. Returns references and activity, not the items themselves \u2014 use sac.overview to enumerate items and sac.read to fetch one. Discover the workspaceId with sac.workspaceList.", inputSchema: OBJECT_SCHEMA({ workspaceId: { type: "string" } }, ["workspaceId"]), mutating: false, async invoke(cwd, params, context) {
       if (context?.transport === "http")
         return { code: "sac_transport_denied" };
-      return normalizeCollaborationResult(await createLocalCollaborationService(cwd).overview({ workspaceId: stringParam2(params, "workspaceId") ?? "", request: undefined, requestCorrelationId: randomUUID42() }));
+      return normalizeCollaborationResult(await createLocalCollaborationService(cwd).overview({ workspaceId: stringParam2(params, "workspaceId") ?? "", request: undefined, requestCorrelationId: randomUUID43() }));
     } },
     {
       name: "sac.overview",
@@ -184293,7 +184770,7 @@ function buildToolRegistry() {
         const workspaceId = stringParam2(params, "workspaceId") ?? "";
         const maxItems = typeof params.maxItems === "number" ? params.maxItems : 32;
         const maxTokens = typeof params.maxTokens === "number" ? params.maxTokens : 4096;
-        return normalizeFwkResult(await createLocalFwkReadService(cwd).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID42(), budget: { maxItems, maxTokens } }));
+        return normalizeFwkResult(await createLocalFwkReadService(cwd).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID43(), budget: { maxItems, maxTokens } }));
       }
     },
     {
@@ -184309,7 +184786,7 @@ function buildToolRegistry() {
         const itemId = stringParam2(params, "itemId") ?? "";
         const maxItems = typeof params.maxItems === "number" ? params.maxItems : 1;
         const maxTokens = typeof params.maxTokens === "number" ? params.maxTokens : 4096;
-        return normalizeFwkResult(await createLocalFwkReadService(cwd).read({ workspaceId, itemId, request: undefined, requestCorrelationId: randomUUID42(), budget: { maxItems, maxTokens } }));
+        return normalizeFwkResult(await createLocalFwkReadService(cwd).read({ workspaceId, itemId, request: undefined, requestCorrelationId: randomUUID43(), budget: { maxItems, maxTokens } }));
       }
     },
     {
@@ -184330,12 +184807,12 @@ function buildToolRegistry() {
         if (!session)
           throw new Error(`no session matching "${sessionRef}" in this project`);
         const { service, wrapUpAuthority, authorizationServer } = createHarnessProposalLifecycleService(cwd, { workspaceId, ...note ? { note } : {} });
-        const requestCorrelationId = randomUUID42();
+        const requestCorrelationId = randomUUID43();
         const actor = await authorizationServer.actorContextFor(undefined, requestCorrelationId);
         if (!actor)
           throw new Error("trusted ActorContext is required");
         const wrapUp = await wrapUpAuthority.issue({ actor, source: "session", sourceRef: sessionEvidenceRef(workspaceId, session.id) });
-        const proposal = await service.create({ request: undefined, requestCorrelationId, workspaceId, id: `proposal-${randomUUID42().replace(/-/g, "").slice(0, 16)}`, proposalRevision, kind, wrapUp });
+        const proposal = await service.create({ request: undefined, requestCorrelationId, workspaceId, id: `proposal-${randomUUID43().replace(/-/g, "").slice(0, 16)}`, proposalRevision, kind, wrapUp });
         if (note)
           await writeFile49(proposalNotePath(cwd, workspaceId, proposal.id), note, "utf8");
         return normalizeProposalLifecycleResult(proposal);
@@ -184354,9 +184831,9 @@ function buildToolRegistry() {
         const proposalId = stringParam2(params, "proposalId") ?? "";
         const decision = stringParam2(params, "decision");
         const reason = stringParam2(params, "reason");
-        const idempotencyKey = stringParam2(params, "idempotencyKey") ?? randomUUID42();
+        const idempotencyKey = stringParam2(params, "idempotencyKey") ?? randomUUID43();
         const confirmToken = stringParam2(params, "confirmToken");
-        const result = await createHarnessProposalLifecycleService(cwd, { workspaceId }).service.review({ request: undefined, requestCorrelationId: randomUUID42(), workspaceId, proposalId, decision, idempotencyKey, interactive: true, ...reason ? { reason } : {}, ...confirmToken ? { confirmToken } : {} });
+        const result = await createHarnessProposalLifecycleService(cwd, { workspaceId }).service.review({ request: undefined, requestCorrelationId: randomUUID43(), workspaceId, proposalId, decision, idempotencyKey, interactive: true, ...reason ? { reason } : {}, ...confirmToken ? { confirmToken } : {} });
         return normalizeProposalLifecycleResult(result);
       }
     },
@@ -184404,7 +184881,7 @@ function buildToolRegistry() {
           throw new Error("sac.workspaceCreate requires a non-empty 'title'");
         const rawComponent = stringParam2(params, "component");
         const component = rawComponent === undefined ? undefined : requireWorkspaceReference(rawComponent);
-        const workspace = await sacWorkspaceService(cwd).create({ request: undefined, requestCorrelationId: randomUUID42(), id: newWorkspaceId(), title, ...component ? { component: { kind: "component", uri: component } } : {} });
+        const workspace = await sacWorkspaceService(cwd).create({ request: undefined, requestCorrelationId: randomUUID43(), id: newWorkspaceId(), title, ...component ? { component: { kind: "component", uri: component } } : {} });
         return workspace;
       }
     },
@@ -184465,7 +184942,7 @@ function buildToolRegistry() {
         const text = redactSensitiveText(rawText);
         const ts = new Date().toISOString();
         const seed = {
-          id: `seed-${randomUUID42()}`,
+          id: `seed-${randomUUID43()}`,
           text,
           ts,
           ...kind ? { kind } : {},
@@ -184911,7 +185388,7 @@ var init_tools3 = __esm(() => {
 
 // src/mcp/resources.ts
 import path352 from "path";
-import { lstat as lstat19, readdir as readdir63, realpath as realpath23, stat as stat35 } from "fs/promises";
+import { lstat as lstat19, readdir as readdir63, realpath as realpath23, stat as stat36 } from "fs/promises";
 function mimeForPath(filePath) {
   if (filePath.endsWith(".json") || filePath.endsWith(".jsonl")) {
     return "application/json";
@@ -184954,7 +185431,7 @@ async function walkFiles(root, ownerRoot = root, ancestors = new Set) {
   }
   for (const entry of entries) {
     const full = path352.join(root, entry.name);
-    const info = await stat35(full).catch(() => null);
+    const info = await stat36(full).catch(() => null);
     if (!info || !isPathInside(ownerReal, await realpath23(full).catch(() => "")))
       continue;
     if (info.isDirectory()) {
@@ -185075,7 +185552,7 @@ async function readResource(cwd, roots, uri, harnessIdentity = null) {
       throw new Error(`Resource not found: ${uri}`);
     }
   }
-  const info = await stat35(resolved.absolute).catch(() => null);
+  const info = await stat36(resolved.absolute).catch(() => null);
   if (!info || !info.isFile()) {
     throw new Error(`Resource not found: ${uri}`);
   }
@@ -186593,7 +187070,7 @@ var init_service18 = __esm(() => {
 
 // src/commands/stack.ts
 import path356 from "path";
-import { stat as stat36 } from "fs/promises";
+import { stat as stat37 } from "fs/promises";
 async function stackCommand(args, cwd = process.cwd()) {
   const sub = args[0];
   if (sub === undefined || sub === "--help" || sub === "-h") {
@@ -186625,7 +187102,7 @@ async function handleDetect(args, cwd) {
   const write = !args.includes("--no-write");
   let rootStat;
   try {
-    rootStat = await stat36(root);
+    rootStat = await stat37(root);
   } catch {
     console.error(`--cwd directory does not exist: ${root}`);
     process.exitCode = 1;
@@ -188125,7 +188602,7 @@ function checkApproval(input) {
 // src/commands/harness.ts
 import { readFileSync as readFileSync28, writeFileSync as writeFileSync10 } from "fs";
 import path357 from "path";
-import { randomUUID as randomUUID43 } from "crypto";
+import { randomUUID as randomUUID44 } from "crypto";
 import { realpathSync as realpathSync18 } from "fs";
 import { homedir as homedir15, tmpdir as tmpdir14 } from "os";
 function canonicalPath2(p) {
@@ -188152,7 +188629,7 @@ function resolveRuntime(deps) {
   const env = deps?.env ?? process.env;
   const clock = deps?.clock ?? (() => new Date().toISOString());
   let idCounter = 0;
-  const idSeq = deps?.idSeq ?? (() => `${randomUUID43()}-${idCounter++}`);
+  const idSeq = deps?.idSeq ?? (() => `${randomUUID44()}-${idCounter++}`);
   return { env, clock, idSeq };
 }
 function shellAllowProfile() {
@@ -188256,7 +188733,7 @@ async function harnessCommand(args, deps) {
   const env = deps?.env ?? process.env;
   const clock = deps?.clock ?? (() => new Date().toISOString());
   let idCounter = 0;
-  const idSeq = deps?.idSeq ?? (() => `${randomUUID43()}-${idCounter++}`);
+  const idSeq = deps?.idSeq ?? (() => `${randomUUID44()}-${idCounter++}`);
   const fetchImpl = deps?.fetch ?? globalThis.fetch;
   if (provider === "anthropic") {
     const apiKey = env.ANTHROPIC_API_KEY;
@@ -188397,7 +188874,7 @@ function harnessReplay(args, deps) {
   }
   const clock = deps?.clock ?? (() => new Date().toISOString());
   let idCounter = 0;
-  const idSeq = deps?.idSeq ?? (() => `${randomUUID43()}-${idCounter++}`);
+  const idSeq = deps?.idSeq ?? (() => `${randomUUID44()}-${idCounter++}`);
   const fixture = (() => {
     if (parsed.fixture === undefined || parsed.fixture.length === 0) {
       return { ok: true, value: buildReplayFixture(run, { idSeq }), built: true };
@@ -189112,7 +189589,7 @@ var init_permission = __esm(() => {
 });
 
 // src/acp/agent-io.ts
-import { randomUUID as randomUUID44 } from "crypto";
+import { randomUUID as randomUUID45 } from "crypto";
 function toolKindFor(name) {
   return TOOL_KIND_BY_NAME[name] ?? "other";
 }
@@ -189127,7 +189604,7 @@ function createAcpAgentIo(sessionId, send, askPermission) {
   const pendingByName = new Map;
   const emit = (update) => send(sessionId, update);
   const openToolCall = (name, input, claimed) => {
-    const toolCallId = randomUUID44();
+    const toolCallId = randomUUID45();
     const queue = pendingByName.get(name) ?? [];
     queue.push({ toolCallId, input, claimed });
     pendingByName.set(name, queue);
@@ -189214,7 +189691,7 @@ function createAcpAgentIo(sessionId, send, askPermission) {
       const toolCallId = pending?.toolCallId;
       emit({
         sessionUpdate: "tool_call_update",
-        toolCallId: toolCallId ?? randomUUID44(),
+        toolCallId: toolCallId ?? randomUUID45(),
         status: result.isError ? "failed" : "completed",
         content: [{ type: "content", content: textBlock(result.output) }],
         rawOutput: result.output
@@ -189813,7 +190290,7 @@ var init_session_mcp = __esm(() => {
 });
 
 // src/acp/server.ts
-import { randomUUID as randomUUID45 } from "crypto";
+import { randomUUID as randomUUID46 } from "crypto";
 function finishReasonToStopReason(finishReason) {
   switch (finishReason) {
     case "budget":
@@ -189833,7 +190310,7 @@ function refuse5(error) {
 async function runAcpServer(options) {
   let initialized = false;
   let clientCapabilities;
-  const idSeq = options.idSeq ?? (() => randomUUID45());
+  const idSeq = options.idSeq ?? (() => randomUUID46());
   const registry = new AcpSessionRegistry({
     providerId: options.providerId,
     modelId: options.modelId,
@@ -190476,7 +190953,7 @@ Switch with /model <model>; it applies from the next turn.`;
         }
         continue;
       }
-      const toolCallId = message.toolCallId ?? randomUUID45();
+      const toolCallId = message.toolCallId ?? randomUUID46();
       sendUpdate(sessionId, {
         sessionUpdate: "tool_call_update",
         toolCallId,
@@ -190715,7 +191192,7 @@ var MODEL_PLACEHOLDER = "{{model}}";
 var init_fixture_provider = () => {};
 
 // src/commands/acp.ts
-import { randomUUID as randomUUID46 } from "crypto";
+import { randomUUID as randomUUID47 } from "crypto";
 function parseAcpArgs(args) {
   const parsed = {};
   for (let i = 0;i < args.length; i += 1) {
@@ -190969,7 +191446,7 @@ async function acpCommand(args) {
       } : { providerUnavailable: resolution.message, providerId: "", modelId: "" },
       agentInfo: { name: "keryx", version: package_default.version },
       ...parsed.dataDir !== undefined ? { dataDir: parsed.dataDir } : {},
-      idSeq: () => randomUUID46()
+      idSeq: () => randomUUID47()
     });
   } finally {
     process.off("SIGTERM", onSignal);
@@ -191036,7 +191513,7 @@ var init_acp = __esm(() => {
 });
 
 // src/bus/prune.ts
-import { randomUUID as randomUUID47 } from "crypto";
+import { randomUUID as randomUUID48 } from "crypto";
 async function expiryAlreadyLogged(root, leaseId) {
   const { events } = await readEvents(root, await cursorAtStart(root));
   return events.some((event) => event.kind === "lease-expired" && event.refs?.leaseId === leaseId);
@@ -191070,7 +191547,7 @@ async function pruneBus(root, options = {}) {
     const file = leasePath(root, lease.leaseId);
     try {
       await appendEvent(root, {
-        from: { instanceId: randomUUID47(), name: "system", origin: "system" },
+        from: { instanceId: randomUUID48(), name: "system", origin: "system" },
         to: ["*"],
         toLabel: "@all",
         kind: "lease-expired",
@@ -191123,7 +191600,7 @@ var init_prune3 = __esm(() => {
 });
 
 // src/commands/bus.ts
-import { randomUUID as randomUUID48 } from "crypto";
+import { randomUUID as randomUUID49 } from "crypto";
 async function busCommand(args) {
   const code = await runBusCommand(args);
   if (code !== 0)
@@ -191276,7 +191753,7 @@ ${PAUSE_USAGE3}`);
   if (toLabel === undefined || reason === undefined || reason.length === 0) {
     throw new BusRefusal("invalid-event", PAUSE_USAGE3);
   }
-  const holder = { instanceId: randomUUID48(), name: "cli", origin: "cli" };
+  const holder = { instanceId: randomUUID49(), name: "cli", origin: "cli" };
   const lease = await createPauseLease(busRoot, {
     holder,
     toLabel,
@@ -191298,7 +191775,7 @@ async function resume(args, busRoot, ctx) {
   if (leaseId === undefined) {
     throw new BusRefusal("invalid-event", "usage: keryx bus resume <leaseId> [--json]");
   }
-  await resumePauseLease(busRoot, { leaseId, by: { instanceId: randomUUID48(), name: "cli", origin: "cli" }, now: ctx.now });
+  await resumePauseLease(busRoot, { leaseId, by: { instanceId: randomUUID49(), name: "cli", origin: "cli" }, now: ctx.now });
   if (args.includes("--json")) {
     ctx.out(JSON.stringify({ schemaVersion: 1, leaseId }, null, 2));
   } else {
@@ -191602,7 +192079,7 @@ var init_modules = __esm(() => {
 });
 
 // src/lib/serve-approvals-broker.ts
-import { randomUUID as randomUUID49 } from "crypto";
+import { randomUUID as randomUUID50 } from "crypto";
 function describeAsk(ask) {
   const floors = ask.floors.length > 0 ? ` Needs a fresh answer every time (${ask.floors.join(", ")}).` : "";
   return {
@@ -191658,7 +192135,7 @@ function createApprovalBroker(options) {
           sessionId: ask.sessionId,
           ...text,
           expiresAt: new Date(createdAt.getTime() + options.expirySeconds * 1000),
-          correlationId: randomUUID49(),
+          correlationId: randomUUID50(),
           callFingerprint: ask.callFingerprint,
           floors: ask.floors
         }, options.dir, createdAt);
@@ -191800,7 +192277,7 @@ var init_serve_throttle = __esm(() => {
 });
 
 // src/lib/serve-turn.ts
-import { randomUUID as randomUUID50 } from "crypto";
+import { randomUUID as randomUUID51 } from "crypto";
 import path359 from "path";
 function validateTurnRequest(body) {
   const problem = (message) => ({
@@ -191975,7 +192452,7 @@ async function redactOut(security, text) {
 async function runRemoteTurn(input) {
   const scanRoot = input.scanRoot;
   const security = createSecurityService(scanRoot);
-  const newId = input.newId ?? (() => randomUUID50());
+  const newId = input.newId ?? (() => randomUUID51());
   const clock = input.clock ?? (() => new Date().toISOString());
   const turnId = input.turnId ?? newId();
   const sessionId = input.request.sessionId ?? newId();
@@ -192158,7 +192635,7 @@ function outcomeOf(status, gate, unresolvedBlockerIds) {
 }
 function createSubmitTurn(deps) {
   return async (request, project) => {
-    const turnId = (deps.newId ?? (() => randomUUID50()))();
+    const turnId = (deps.newId ?? (() => randomUUID51()))();
     const scanned = await scanPrompt(deps.dir, request.prompt);
     if (scanned.rejected) {
       return { kind: "rejected" };
@@ -192173,7 +192650,7 @@ function createSubmitTurn(deps) {
     }
     let effected = false;
     const detached = deps.approvals !== undefined && (deps.toolRegistry?.list().length ?? 0) > 0;
-    const sessionId = request.sessionId ?? (deps.newId ?? (() => randomUUID50()))();
+    const sessionId = request.sessionId ?? (deps.newId ?? (() => randomUUID51()))();
     let onStarted = () => {
       return;
     };
@@ -194059,7 +194536,7 @@ var init_durable_log = __esm(() => {
 import { createHash as createHash80 } from "crypto";
 import { unlinkSync as unlinkSync9 } from "fs";
 import path361 from "path";
-function parseEntry4(value) {
+function parseEntry5(value) {
   if (typeof value !== "object" || value === null) {
     return;
   }
@@ -194095,7 +194572,7 @@ class InboundQueues {
   log(bindingKey) {
     let log = this.logs.get(bindingKey);
     if (log === undefined) {
-      log = new DurableLog({ file: this.fileFor(bindingKey), parse: parseEntry4, maxEntries: MAX_INBOUND_PER_TOPIC });
+      log = new DurableLog({ file: this.fileFor(bindingKey), parse: parseEntry5, maxEntries: MAX_INBOUND_PER_TOPIC });
       log.load();
       this.logs.set(bindingKey, log);
     }
@@ -194736,9 +195213,9 @@ var init_rendering = __esm(() => {
 });
 
 // src/remote/outbound-queue.ts
-import { randomUUID as randomUUID51 } from "crypto";
+import { randomUUID as randomUUID52 } from "crypto";
 import path363 from "path";
-function parseEntry5(value) {
+function parseEntry6(value) {
   if (typeof value !== "object" || value === null) {
     return;
   }
@@ -194781,7 +195258,7 @@ class OutboundQueue {
     this.log = new DurableLog({
       file: path363.join(directory, OUTBOUND_FILE),
       maxEntries: options.maxEntries ?? OUTBOUND_MAX_ENTRIES,
-      parse: parseEntry5
+      parse: parseEntry6
     });
   }
   load() {
@@ -194798,7 +195275,7 @@ class OutboundQueue {
     const entries = [];
     parts.forEach((text, index) => {
       const entry = {
-        id: randomUUID51(),
+        id: randomUUID52(),
         chatId: message.chatId,
         ...message.threadId === undefined ? {} : { threadId: message.threadId },
         text,
@@ -197932,7 +198409,7 @@ var init_serve_digest = __esm(() => {
 });
 
 // src/commands/serve.ts
-import { randomUUID as randomUUID52 } from "crypto";
+import { randomUUID as randomUUID53 } from "crypto";
 function parseArgs5(args, valueFlags, booleanFlags) {
   const values = new Map;
   const flags = new Set;
@@ -198258,7 +198735,7 @@ function runConfig(args) {
       return;
     }
     const credential = readServeCredential();
-    const credentialId = credential.status === "ok" ? credential.record.id : randomUUID52();
+    const credentialId = credential.status === "ok" ? credential.record.id : randomUUID53();
     const config = defaultServeConfig(credentialId, {
       address: parsed.parsed.values.get("--bind") ?? DEFAULT_SERVE_BIND_ADDRESS,
       port: port ?? DEFAULT_SERVE_PORT,
@@ -199932,7 +200409,7 @@ ${settled.stderr}` };
 var PROBE_TIMEOUT_MS = 1e4;
 
 // src/commands/agents-external.ts
-import { randomUUID as randomUUID53 } from "crypto";
+import { randomUUID as randomUUID54 } from "crypto";
 import { mkdir as mkdir73 } from "fs/promises";
 import { tmpdir as tmpdir15 } from "os";
 import path369 from "path";
@@ -200219,7 +200696,7 @@ async function runCommand4(args, deps, log) {
     taskTitle: task.length > 80 ? `${task.slice(0, 77)}...` : task,
     taskDescription: task,
     acceptanceCriteria: [],
-    worktreeId: `acp-${randomUUID53()}`,
+    worktreeId: `acp-${randomUUID54()}`,
     maxPromptBytes: gate.config.maxPromptBytes,
     timeoutMs,
     parentEnv: env,
@@ -201865,7 +202342,7 @@ var init_metrics2 = __esm(() => {
 });
 
 // src/metrics/ablation-runner.ts
-function median2(values) {
+function median3(values) {
   if (values.length === 0)
     return null;
   const sorted = [...values].sort((a, b) => a - b);
@@ -201891,7 +202368,7 @@ function toolCallDistribution(samples) {
   }));
   return {
     samples: runSamples,
-    median: median2(values),
+    median: median3(values),
     spread: spread(values),
     reliability: ABLATION_RELIABILITY
   };
@@ -201901,7 +202378,7 @@ function tokenCost(samples, source) {
   if (known.length === 0)
     return;
   const note = `median of ${known.length}/${samples.length} seed samples with a reported token count`;
-  return { tokens: { raw: measured(median2(known), source, note) } };
+  return { tokens: { raw: measured(median3(known), source, note) } };
 }
 function successRate(samples) {
   const successes = samples.filter((s) => s.success).length;
@@ -203228,7 +203705,7 @@ function formatFwkExplain(result) {
 }
 
 // src/commands/workspace.ts
-import { randomUUID as randomUUID54 } from "crypto";
+import { randomUUID as randomUUID55 } from "crypto";
 import { writeFile as writeFile51 } from "fs/promises";
 function service8() {
   return new WorkspaceService({
@@ -203249,7 +203726,7 @@ async function workspaceCommand(args) {
       const component = rawComponent === undefined ? undefined : requireWorkspaceReference(rawComponent);
       if (!title)
         throw new Error("Usage: keryx workspace create --title <title> [--component <workspace-relative-ref>]");
-      const workspace = await service8().create({ request: undefined, requestCorrelationId: randomUUID54(), id: newWorkspaceId(), title, ...component ? { component: { kind: "component", uri: component } } : {} });
+      const workspace = await service8().create({ request: undefined, requestCorrelationId: randomUUID55(), id: newWorkspaceId(), title, ...component ? { component: { kind: "component", uri: component } } : {} });
       console.log(JSON.stringify(workspace, null, 2));
       return;
     }
@@ -203279,7 +203756,7 @@ async function workspaceCommand(args) {
       const revision = optionValue(args, "--revision");
       if (!workspaceId || !kind || !rawUri)
         throw new Error("Usage: keryx workspace add-resource <workspace-id> --kind <kind> --uri <workspace-relative-ref> [--revision <revision>]");
-      console.log(JSON.stringify(await service8().addResource({ request: undefined, requestCorrelationId: randomUUID54(), workspaceId, resource: { kind, uri: requireWorkspaceReference(rawUri), ...revision ? { revision } : {} } }), null, 2));
+      console.log(JSON.stringify(await service8().addResource({ request: undefined, requestCorrelationId: randomUUID55(), workspaceId, resource: { kind, uri: requireWorkspaceReference(rawUri), ...revision ? { revision } : {} } }), null, 2));
       return;
     }
     if (subcommand === "archive") {
@@ -203287,7 +203764,7 @@ async function workspaceCommand(args) {
       const workspaceId = args[1];
       if (!workspaceId)
         throw new Error("Usage: keryx workspace archive <workspace-id>");
-      console.log(JSON.stringify(await service8().archive({ request: undefined, requestCorrelationId: randomUUID54(), workspaceId }), null, 2));
+      console.log(JSON.stringify(await service8().archive({ request: undefined, requestCorrelationId: randomUUID55(), workspaceId }), null, 2));
       return;
     }
     if (subcommand === "remove-resource") {
@@ -203296,7 +203773,7 @@ async function workspaceCommand(args) {
       const uri = optionValue(args, "--uri");
       if (!workspaceId || !uri)
         throw new Error("Usage: keryx workspace remove-resource <workspace-id> --uri <workspace-relative-ref>");
-      console.log(JSON.stringify(await service8().removeResource({ request: undefined, requestCorrelationId: randomUUID54(), workspaceId, uri }), null, 2));
+      console.log(JSON.stringify(await service8().removeResource({ request: undefined, requestCorrelationId: randomUUID55(), workspaceId, uri }), null, 2));
       return;
     }
     if (subcommand === "rename") {
@@ -203305,7 +203782,7 @@ async function workspaceCommand(args) {
       const title = optionValue(args, "--title");
       if (!workspaceId || !title)
         throw new Error("Usage: keryx workspace rename <workspace-id> --title <title>");
-      console.log(JSON.stringify(await service8().rename({ request: undefined, requestCorrelationId: randomUUID54(), workspaceId, title }), null, 2));
+      console.log(JSON.stringify(await service8().rename({ request: undefined, requestCorrelationId: randomUUID55(), workspaceId, title }), null, 2));
       return;
     }
     if (subcommand === "overview") {
@@ -203317,7 +203794,7 @@ async function workspaceCommand(args) {
       const maxTokens = Number(optionValue(args, "--max-tokens") ?? "4096");
       if (!Number.isInteger(maxItems) || !Number.isInteger(maxTokens) || maxItems < 0 || maxTokens < 0)
         throw new Error("--max-items and --max-tokens must be non-negative integers");
-      const result = await createLocalFwkReadService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID54(), budget: { maxItems, maxTokens } });
+      const result = await createLocalFwkReadService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID55(), budget: { maxItems, maxTokens } });
       const normalized = normalizeFwkResult(result);
       console.log(JSON.stringify(normalized, null, 2));
       if (args.includes("--explain"))
@@ -203334,7 +203811,7 @@ async function workspaceCommand(args) {
       const maxTokens = Number(optionValue(args, "--max-tokens") ?? "4096");
       if (!Number.isInteger(maxItems) || !Number.isInteger(maxTokens) || maxItems < 0 || maxTokens < 0)
         throw new Error("--max-items and --max-tokens must be non-negative integers");
-      const result = await createLocalFwkReadService(process.cwd()).read({ workspaceId, itemId, request: undefined, requestCorrelationId: randomUUID54(), budget: { maxItems, maxTokens } });
+      const result = await createLocalFwkReadService(process.cwd()).read({ workspaceId, itemId, request: undefined, requestCorrelationId: randomUUID55(), budget: { maxItems, maxTokens } });
       const normalized = normalizeFwkResult(result);
       console.log(JSON.stringify(normalized, null, 2));
       if (args.includes("--explain"))
@@ -203356,14 +203833,14 @@ async function workspaceCommand(args) {
       const session = findSession(cwd, sessionRef);
       if (!session)
         throw new Error(`no session matching "${sessionRef}" in this project \u2014 use \`keryx sessions list\``);
-      const proposalId = `proposal-${randomUUID54().replace(/-/g, "").slice(0, 16)}`;
+      const proposalId = `proposal-${randomUUID55().replace(/-/g, "").slice(0, 16)}`;
       const notePath = proposalNotePath(cwd, workspaceId, proposalId);
       const materializedNote = note === undefined ? undefined : prepareOutputForPersistence(await guardOutput({ cwd, content: note, target: "task", source: "generated", path: notePath }), note);
       if (materializedNote !== undefined && !materializedNote.allowed)
         throw new Error(materializedNote.reason);
       const persistedNote = materializedNote?.allowed ? materializedNote.content : undefined;
       const { service, wrapUpAuthority, authorizationServer } = createHarnessProposalLifecycleService(cwd, { workspaceId, ...persistedNote ? { note: persistedNote } : {} });
-      const requestCorrelationId = randomUUID54();
+      const requestCorrelationId = randomUUID55();
       const actor = await authorizationServer.actorContextFor(undefined, requestCorrelationId);
       if (!actor)
         throw new Error("trusted ActorContext is required");
@@ -203404,13 +203881,13 @@ async function workspaceCommand(args) {
       const proposalId = args[2];
       const decision = optionValue(args, "--decision");
       const reason = optionValue(args, "--reason");
-      const idempotencyKey = optionValue(args, "--idempotency-key") ?? randomUUID54();
+      const idempotencyKey = optionValue(args, "--idempotency-key") ?? randomUUID55();
       const confirmToken = optionValue(args, "--confirm-token");
       if (!workspaceId || !proposalId || !decision)
         throw new Error("Usage: keryx workspace review <workspace-id> <proposal-id> --decision <accepted|rejected|dismissed> [--reason <reason>] [--idempotency-key <key>] [--confirm-token <token>]");
       if (decision === "accepted" && !confirmToken)
         throw new Error("--decision accepted requires --confirm-token \u2014 run `keryx workspace confirm-review " + workspaceId + " " + proposalId + "` first");
-      const result = await createHarnessProposalLifecycleService(process.cwd(), { workspaceId }).service.review({ request: undefined, requestCorrelationId: randomUUID54(), workspaceId, proposalId, decision, idempotencyKey, interactive: true, ...reason ? { reason } : {}, ...confirmToken ? { confirmToken } : {} });
+      const result = await createHarnessProposalLifecycleService(process.cwd(), { workspaceId }).service.review({ request: undefined, requestCorrelationId: randomUUID55(), workspaceId, proposalId, decision, idempotencyKey, interactive: true, ...reason ? { reason } : {}, ...confirmToken ? { confirmToken } : {} });
       console.log(JSON.stringify(normalizeProposalLifecycleResult(result), null, 2));
       return;
     }
@@ -203435,7 +203912,7 @@ async function workspaceCommand(args) {
       const artifactRef = optionValue(args, "--artifact");
       if (!workspaceId || !to || !artifactRef)
         throw new Error("Usage: keryx workspace handoff <workspace-id> --to <subject> --artifact <ref>");
-      const activity = await createLocalCollaborationService(process.cwd()).record({ request: undefined, requestCorrelationId: randomUUID54(), workspaceId, activity: { kind: "handoff-recorded", handoff: { to, artifactRef } } });
+      const activity = await createLocalCollaborationService(process.cwd()).record({ request: undefined, requestCorrelationId: randomUUID55(), workspaceId, activity: { kind: "handoff-recorded", handoff: { to, artifactRef } } });
       console.log(JSON.stringify(activity, null, 2));
       return;
     }
@@ -203444,7 +203921,7 @@ async function workspaceCommand(args) {
       const workspaceId = args[1];
       if (!workspaceId)
         throw new Error("Usage: keryx workspace collaboration <workspace-id>");
-      console.log(JSON.stringify(await createLocalCollaborationService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID54() }), null, 2));
+      console.log(JSON.stringify(await createLocalCollaborationService(process.cwd()).overview({ workspaceId, request: undefined, requestCorrelationId: randomUUID55() }), null, 2));
       return;
     }
     if (subcommand === "policy-readiness") {
@@ -203471,7 +203948,7 @@ async function workspaceCommand(args) {
       const workspaceId = args[1];
       const cwd = process.cwd();
       const authorizationServer = localWorkspaceAuthorizationServer();
-      const actor = await authorizationServer.actorContextFor(undefined, randomUUID54());
+      const actor = await authorizationServer.actorContextFor(undefined, randomUUID55());
       if (!actor)
         throw new Error("trusted ActorContext is required");
       if (workspaceId) {
@@ -204614,6 +205091,8 @@ var init_forgetting = __esm(() => {
 });
 
 // src/commands/decisions.ts
+import { readFile as readFile190 } from "fs/promises";
+import path373 from "path";
 function rejectUnknownFlags2(sub, args, accepted) {
   const unknown = args.filter((argument) => argument.startsWith("--")).map((argument) => argument.split("=")[0]).filter((name) => !accepted.includes(name));
   if (unknown.length > 0) {
@@ -204729,8 +205208,33 @@ async function runReason(args) {
   }
   console.log(recorded ? `decision ${id}: reason recorded` : `decision ${id}: the human was already asked once; nothing written`);
 }
+async function runImport(args) {
+  const file = positionalId(args);
+  if (file === undefined)
+    throw new Error("keryx decisions import needs the file: keryx decisions import <file.jsonl> [--dry-run] [--json]");
+  const rest = args.slice(1);
+  rejectUnknownFlags2("import", rest, IMPORT_FLAGS2);
+  let text;
+  try {
+    text = await readFile190(path373.resolve(process.cwd(), file), "utf8");
+  } catch {
+    throw new Error(`cannot read ${file}`);
+  }
+  const result = await importBackfill(process.cwd(), text, { dryRun: rest.includes("--dry-run") });
+  if (rest.includes("--json")) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(renderImportResult(result));
+}
 async function runReport3(args) {
   rejectUnknownFlags2("report", args, REPORT_FLAGS);
+  if (args.includes("--line") && args.includes("--json"))
+    throw new Error("keryx decisions report: --line and --json cannot be combined");
+  if (args.includes("--line")) {
+    console.log(await reportLine(process.cwd()));
+    return;
+  }
   if (args.includes("--json")) {
     console.log(JSON.stringify(await loadReport(process.cwd()), null, 2));
     return;
@@ -204752,8 +205256,14 @@ async function decisionsCommand(args = []) {
       return await runReason(args.slice(1));
     if (command === "report")
       return await runReport3(args.slice(1));
+    if (command === "import")
+      return await runImport(args.slice(1));
   } catch (cause) {
-    console.error(cause instanceof Error ? cause.message : String(cause));
+    const message = cause instanceof Error ? cause.message : String(cause);
+    if (command === "import" && args.includes("--json"))
+      console.log(JSON.stringify({ error: message }, null, 2));
+    else
+      console.error(message);
     process.exitCode = 1;
     return;
   }
@@ -204771,7 +205281,8 @@ Usage:
   keryx decisions open --question "<text>" --option <id>=<label> [--option ...] [--recommend <id> --reason "<why>"] [--stage <name>] [--flow <id>] [--action <tag>] [--json]
   keryx decisions answer <id> --choice <id> [--other] [--reason "<why>"] [--json]
   keryx decisions reason <id> --text "<why>" [--json]
-  keryx decisions report [--json]
+  keryx decisions report [--json | --line]
+  keryx decisions import <file.jsonl> [--dry-run] [--json]
 
 Every agent question with options leaves one record: what was asked, what the
 agent recommended and why, how it was shown, what the human chose and how long
@@ -204804,6 +205315,28 @@ it took. Call \`open\` BEFORE showing the question and \`answer\` after.
            its reason. It also counts the questions that looked irreversible
            and the ones where blind was refused because of it, per stage: a
            high number on ordinary questions means the list over-matches.
+           Backfilled decisions (see import) are reported in a separate block
+           "\u0434\u043E (\u0438\u0441\u0442\u043E\u0440\u0438\u0447\u0435\u0441\u043A\u043E\u0435, \u0434\u043E\u0437\u0430\u043F\u043E\u043B\u043D\u0435\u043D\u043E \u0437\u0430\u0434\u043D\u0438\u043C \u0447\u0438\u0441\u043B\u043E\u043C)" and never counted in
+           the live shares or in the time to answer. --line prints ONE line in
+           Russian for the daily topic message: the total (before, after) and the
+           match share of the visible, the hidden and the historical decisions.
+  import   loads historical decisions from a JSON-lines file, one per line:
+             {"id","at","flow","stage","question","options":[{"id","label"}],
+              "recommendation":{"optionId","reason"}|null,"source",
+              "answer":{"choice","other"?}|null,"reason"?}
+           Every one is marked backfilled (its recommendation was written down
+           after the fact), is never blind, and keeps the time it was asked in
+           "at"; its time to answer is unknown and never used. The file is
+           read line by line: a line that is not a decision is skipped, named
+           (line number and why) and counted, and the rest is imported. An id
+           already in the journal is skipped and reported, so the same file can
+           be imported twice; a backfilled decision whose answer is missing from
+           the journal (an interrupted write) gets just that answer on the next
+           import. --dry-run checks and counts without writing. It prints:
+           Imported: N, skipped: S, with recommendation: R, answered: A,
+           deviations: D, plus ", repaired: R" and ", malformed: M" when
+           there are any. With --json a failure is {"error": "..."}. A bare /decisions change never touches a backfilled
+           decision.
 
 The journal is one file per repository, .metaproject/data/decisions/journal.jsonl
 under the main checkout (every worktree shares it; it is git-ignored). Inside a
@@ -204813,14 +205346,15 @@ the answer also adds a line to that flow's journal.md, except for an inferred
 flow, which only stays in the project-wide journal. A failure here never
 stops the question.`);
 }
-var OPEN_FLAGS, ANSWER_FLAGS, REASON_FLAGS, REPORT_FLAGS;
+var OPEN_FLAGS, ANSWER_FLAGS, REASON_FLAGS, REPORT_FLAGS, IMPORT_FLAGS2;
 var init_decisions2 = __esm(() => {
   init_args();
   init_service13();
   OPEN_FLAGS = ["--question", "--option", "--options-json", "--recommend", "--reason", "--stage", "--flow", "--action", "--json"];
   ANSWER_FLAGS = ["--choice", "--other", "--reason", "--json"];
   REASON_FLAGS = ["--text", "--json"];
-  REPORT_FLAGS = ["--json"];
+  REPORT_FLAGS = ["--json", "--line"];
+  IMPORT_FLAGS2 = ["--dry-run", "--json"];
 });
 
 // src/commands/governance.ts
@@ -205034,7 +205568,7 @@ var init_product = __esm(() => {
 
 // src/commands/hooks.ts
 import { existsSync as existsSync58, readFileSync as readFileSync32 } from "fs";
-import path373 from "path";
+import path374 from "path";
 function resolveHomeDir(deps) {
   return resolveHooksHomeDir(process.env, deps.homeDir);
 }
@@ -205045,10 +205579,10 @@ function optConfigDir(deps) {
   return deps.configDir !== undefined ? { configDir: deps.configDir } : {};
 }
 function userHooksPath(homeDir) {
-  return path373.join(homeDir, ".keryx", "hooks.json");
+  return path374.join(homeDir, ".keryx", "hooks.json");
 }
 function projectHooksPath(projectRoot) {
-  return path373.join(projectRoot, ".metaproject", "hooks.json");
+  return path374.join(projectRoot, ".metaproject", "hooks.json");
 }
 function fail6(message) {
   console.error(message);
@@ -205166,10 +205700,10 @@ async function runList7(args, deps) {
 function argv0Resolves(argv0) {
   if (argv0 === "keryx")
     return true;
-  if (path373.isAbsolute(argv0))
+  if (path374.isAbsolute(argv0))
     return existsSync58(argv0);
   const pathEnv = process.env.PATH ?? "";
-  return pathEnv.split(path373.delimiter).filter((dir) => dir.length > 0).some((dir) => existsSync58(path373.join(dir, argv0)));
+  return pathEnv.split(path374.delimiter).filter((dir) => dir.length > 0).some((dir) => existsSync58(path374.join(dir, argv0)));
 }
 function checkArgvResolutions(registrations) {
   const seen = new Set;
@@ -205623,7 +206157,7 @@ async function writeDocAtomic(filePath, doc, scope, cwd, homeDir) {
     if (scope === "project") {
       await writeContained(cwd, PROJECT_HOOKS_REL, body);
     } else {
-      const userConfigDir = path373.join(homeDir, ".keryx");
+      const userConfigDir = path374.join(homeDir, ".keryx");
       if (!existsSync58(userConfigDir)) {
         await mkdirContained(homeDir, ".keryx");
       }
@@ -205938,13 +206472,13 @@ var init_types12 = __esm(() => {
 });
 
 // src/bundle/paths.ts
-import { lstat as lstat20, readFile as readFile190 } from "fs/promises";
-import path374 from "path";
+import { lstat as lstat20, readFile as readFile191 } from "fs/promises";
+import path375 from "path";
 function scopeRoot(scope, ctx) {
   if (scope === "user") {
     return userStoreRoot(ctx.env ?? process.env, ctx.homeDir);
   }
-  return path374.join(ctx.projectRoot, ".metaproject");
+  return path375.join(ctx.projectRoot, ".metaproject");
 }
 function isPortablePath(relPath) {
   return relPath.split("/").every((segment) => PORTABLE_SEGMENT_RE.test(segment));
@@ -206118,10 +206652,10 @@ async function targetFor(entry, targetScope, ctx) {
   return { ok: true, absolutePath: containment.absolutePath };
 }
 async function resolveContainedPathForWrite(root, relPath) {
-  const absolute = path374.resolve(root, relPath);
-  const rootResolved = path374.resolve(root);
-  const relative = path374.relative(rootResolved, absolute);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path374.sep}`) || path374.isAbsolute(relative)) {
+  const absolute = path375.resolve(root, relPath);
+  const rootResolved = path375.resolve(root);
+  const relative = path375.relative(rootResolved, absolute);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path375.sep}`) || path375.isAbsolute(relative)) {
     return {
       ok: false,
       refusal: { reason: BUNDLE_REFUSAL.pathEscape, path: relPath, message: `${relPath} resolves outside the scope root` }
@@ -206130,7 +206664,7 @@ async function resolveContainedPathForWrite(root, relPath) {
   return { ok: true, absolutePath: absolute };
 }
 async function refuseSymlinkChain(root, relPath) {
-  const rootResolved = path374.resolve(root);
+  const rootResolved = path375.resolve(root);
   try {
     const rootStat = await lstat20(rootResolved);
     if (rootStat.isSymbolicLink()) {
@@ -206143,7 +206677,7 @@ async function refuseSymlinkChain(root, relPath) {
   const segments = relPath.split("/");
   let current = rootResolved;
   for (const segment of segments) {
-    current = path374.join(current, segment);
+    current = path375.join(current, segment);
     try {
       const stat = await lstat20(current);
       if (stat.isSymbolicLink()) {
@@ -206158,7 +206692,7 @@ async function refuseSymlinkChain(root, relPath) {
 }
 async function readTargetFile(absolutePath) {
   try {
-    const bytes = await readFile190(absolutePath);
+    const bytes = await readFile191(absolutePath);
     return { ok: true, bytes };
   } catch (err) {
     const code = err.code;
@@ -206195,8 +206729,8 @@ var init_paths5 = __esm(() => {
 });
 
 // src/bundle/archive.ts
-import { readdir as readdir65, readFile as readFile191, lstat as lstat21 } from "fs/promises";
-import path375 from "path";
+import { readdir as readdir65, readFile as readFile192, lstat as lstat21 } from "fs/promises";
+import path376 from "path";
 import { gzipSync, gunzipSync } from "zlib";
 function resolveLimits(limits) {
   const maxTotalBytes = limits?.maxTotalBytes ?? DEFAULT_BUNDLE_LIMITS.maxTotalBytes;
@@ -206279,11 +206813,11 @@ function buildBundleArchive(files, manifestBytes) {
   const dirs = new Set;
   const sortedPaths = [...files.keys()].sort();
   for (const p of sortedPaths) {
-    let dir = path375.dirname(p);
+    let dir = path376.dirname(p);
     const segs = [];
     while (dir !== "." && dir !== "/" && dir !== "") {
       segs.unshift(dir);
-      dir = path375.dirname(dir);
+      dir = path376.dirname(dir);
     }
     for (const d of segs)
       dirs.add(d);
@@ -206351,7 +206885,7 @@ function parseUstar(tar, limits) {
     const name = prefix.length > 0 ? `${prefix}/${nameRaw}` : nameRaw;
     const typeflag = String.fromCharCode(header[156] ?? 0);
     const size = readOctal(header, 124, 12);
-    if (path375.isAbsolute(name) || name.split("/").includes("..") || name.length === 0) {
+    if (path376.isAbsolute(name) || name.split("/").includes("..") || name.length === 0) {
       return { ok: false, refusal: { reason: BUNDLE_REFUSAL.archiveInvalid, path: name, message: `unsafe entry name: ${name}` } };
     }
     const isDir = typeflag === "5";
@@ -206415,7 +206949,7 @@ async function openBundle(bundlePath, limits) {
     async function walk(dir, relPrefix) {
       const entries = await readdir65(dir, { withFileTypes: true });
       for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-        const abs = path375.join(dir, entry.name);
+        const abs = path376.join(dir, entry.name);
         const rel = relPrefix.length > 0 ? `${relPrefix}/${entry.name}` : entry.name;
         const entryStat = await lstat21(abs);
         if (entryStat.isSymbolicLink()) {
@@ -206434,7 +206968,7 @@ async function openBundle(bundlePath, limits) {
           if (entryStat.size > resolved.maxManifestBytes) {
             return { reason: BUNDLE_REFUSAL.archiveTooLarge, path: rel, message: `bundle.json is ${entryStat.size} bytes, over the ${resolved.maxManifestBytes}-byte manifest cap` };
           }
-          manifestBytes = await readFile191(abs);
+          manifestBytes = await readFile192(abs);
           continue;
         }
         entryCount += 1;
@@ -206445,7 +206979,7 @@ async function openBundle(bundlePath, limits) {
         if (totalBytes > resolved.maxTotalBytes) {
           return { reason: BUNDLE_REFUSAL.archiveTooLarge, message: `bundle directory exceeds ${resolved.maxTotalBytes} bytes total` };
         }
-        const bytes = await readFile191(abs);
+        const bytes = await readFile192(abs);
         files.set(rel, bytes);
       }
       return null;
@@ -206462,7 +206996,7 @@ async function openBundle(bundlePath, limits) {
     if (stat.size > resolved.maxCompressedBytes) {
       return { ok: false, refusal: { reason: BUNDLE_REFUSAL.archiveTooLarge, message: `${bundlePath} is ${stat.size} bytes, over the ${resolved.maxCompressedBytes}-byte compressed-size cap` } };
     }
-    const raw = await readFile191(bundlePath);
+    const raw = await readFile192(bundlePath);
     let tar;
     try {
       tar = gunzipSync(raw, { maxOutputLength: resolved.maxDecompressedBytes });
@@ -207292,9 +207826,9 @@ var init_learned_pattern_schema = __esm(() => {
 
 // src/bundle/export.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { mkdir as mkdir75, readdir as readdir66, readFile as readFile192, writeFile as writeFile52, lstat as lstat22 } from "fs/promises";
+import { mkdir as mkdir75, readdir as readdir66, readFile as readFile193, writeFile as writeFile52, lstat as lstat22 } from "fs/promises";
 import { existsSync as existsSync59 } from "fs";
-import path376 from "path";
+import path377 from "path";
 function globToRegExp5(glob) {
   let out = "";
   for (let i = 0;i < glob.length; i += 1) {
@@ -207377,7 +207911,7 @@ async function walkFiles2(dir, relPrefix, out, skipped) {
     return;
   }
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    const abs = path376.join(dir, entry.name);
+    const abs = path377.join(dir, entry.name);
     const rel = relPrefix.length > 0 ? `${relPrefix}/${entry.name}` : entry.name;
     const st = await lstat22(abs);
     if (st.isSymbolicLink()) {
@@ -207394,7 +207928,7 @@ async function walkFiles2(dir, relPrefix, out, skipped) {
 async function collectSkills(root, scope, skipped) {
   const candidates = [];
   for (const baseDirName of scope === "project" ? ["skills", "project-skills"] : ["skills"]) {
-    const base = path376.join(root, baseDirName);
+    const base = path377.join(root, baseDirName);
     if (!existsSync59(base))
       continue;
     const files = [];
@@ -207407,7 +207941,7 @@ async function collectSkills(root, scope, skipped) {
 async function collectRules(root, scope, skipped) {
   if (scope === "user")
     return [];
-  const base = path376.join(root, "rules");
+  const base = path377.join(root, "rules");
   if (!existsSync59(base))
     return [];
   const files = [];
@@ -207415,7 +207949,7 @@ async function collectRules(root, scope, skipped) {
   return files.filter((f) => /\.(md|mdc)$/.test(f.path)).map((f) => ({ bundlePath: f.path, kind: "rule", absolutePath: f.abs }));
 }
 async function collectAgents(root, skipped) {
-  const base = path376.join(root, "agents");
+  const base = path377.join(root, "agents");
   if (!existsSync59(base))
     return [];
   let entries;
@@ -207426,7 +207960,7 @@ async function collectAgents(root, skipped) {
   }
   const candidates = [];
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    const abs = path376.join(base, entry.name);
+    const abs = path377.join(base, entry.name);
     const st = await lstat22(abs);
     if (st.isSymbolicLink()) {
       skipped.push({ path: `agents/${entry.name}`, reason: "symlink" });
@@ -207441,7 +207975,7 @@ async function collectAgents(root, skipped) {
 async function collectMemory(root, skipped) {
   const candidates = [];
   for (const { folder } of MEMORY_TYPES) {
-    const base = path376.join(root, "memory", folder);
+    const base = path377.join(root, "memory", folder);
     if (!existsSync59(base))
       continue;
     let entries;
@@ -207451,7 +207985,7 @@ async function collectMemory(root, skipped) {
       continue;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const abs = path376.join(base, entry.name);
+      const abs = path377.join(base, entry.name);
       const st = await lstat22(abs);
       if (st.isSymbolicLink()) {
         skipped.push({ path: `memory/${folder}/${entry.name}`, reason: "symlink" });
@@ -207465,7 +207999,7 @@ async function collectMemory(root, skipped) {
   return candidates;
 }
 async function collectHookConfig(root) {
-  const abs = path376.join(root, "hooks.json");
+  const abs = path377.join(root, "hooks.json");
   if (!existsSync59(abs))
     return [];
   const st = await lstat22(abs);
@@ -207475,7 +208009,7 @@ async function collectHookConfig(root) {
 }
 async function collectLearnedPatterns(root, scope) {
   const relDir = scope === "user" ? "learning/patterns" : "data/learning/candidates";
-  const base = path376.join(root, ...relDir.split("/"));
+  const base = path377.join(root, ...relDir.split("/"));
   if (!existsSync59(base))
     return [];
   let entries;
@@ -207487,7 +208021,7 @@ async function collectLearnedPatterns(root, scope) {
   const candidates = [];
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
     if (entry.isFile() && entry.name.endsWith(".json")) {
-      candidates.push({ bundlePath: `${relDir}/${entry.name}`, kind: "learned-pattern", absolutePath: path376.join(base, entry.name) });
+      candidates.push({ bundlePath: `${relDir}/${entry.name}`, kind: "learned-pattern", absolutePath: path377.join(base, entry.name) });
     }
   }
   return candidates;
@@ -207528,10 +208062,10 @@ async function outDirIsEmpty(out) {
 }
 async function writeDirectoryBundle(out, manifestBytes, files) {
   await mkdir75(out, { recursive: true });
-  await writeFile52(path376.join(out, "bundle.json"), manifestBytes);
+  await writeFile52(path377.join(out, "bundle.json"), manifestBytes);
   for (const [rel, bytes] of files) {
-    const abs = path376.join(out, ...rel.split("/"));
-    await mkdir75(path376.dirname(abs), { recursive: true });
+    const abs = path377.join(out, ...rel.split("/"));
+    await mkdir75(path377.dirname(abs), { recursive: true });
     await writeFile52(abs, bytes);
   }
 }
@@ -207563,7 +208097,7 @@ async function exportBundle(opts) {
     } else {
       const rawDigestEntries = [];
       for (const candidate of filtered) {
-        const bytes = await readFile192(candidate.absolutePath);
+        const bytes = await readFile193(candidate.absolutePath);
         rawDigestEntries.push({ path: candidate.bundlePath, sha256: sha256Hex5(bytes) });
       }
       bundleId = contentDigestBundleId(opts.scope, rawDigestEntries);
@@ -207578,7 +208112,7 @@ async function exportBundle(opts) {
       skipped.push({ path: candidate.bundlePath, reason: `non-portable-name: ${portable.refusal.message}` });
       continue;
     }
-    let bytes = await readFile192(candidate.absolutePath);
+    let bytes = await readFile193(candidate.absolutePath);
     if (candidate.kind === "hook-config") {
       let parsed;
       try {
@@ -207665,7 +208199,7 @@ async function exportBundle(opts) {
     const archive = buildBundleArchive(files, manifestBytes);
     if (!archive.ok)
       return { ok: false, refusals: [archive.refusal] };
-    await mkdir75(path376.dirname(opts.out), { recursive: true });
+    await mkdir75(path377.dirname(opts.out), { recursive: true });
     await writeFile52(opts.out, archive.value);
   } else {
     if (existsSync59(opts.out) && !await outDirIsEmpty(opts.out)) {
@@ -207731,16 +208265,16 @@ var init_verify3 = __esm(() => {
 });
 
 // src/bundle/applied-state.ts
-import { readFile as readFile193 } from "fs/promises";
-import path377 from "path";
+import { readFile as readFile194 } from "fs/promises";
+import path378 from "path";
 function emptyState2() {
   return { schemaVersion: APPLIED_STATE_SCHEMA_VERSION, entries: {} };
 }
 function appliedStatePath(scope, ctx) {
   if (scope === "user") {
-    return path377.join(scopeRoot("user", ctx), "bundles", "applied-state.json");
+    return path378.join(scopeRoot("user", ctx), "bundles", "applied-state.json");
   }
-  return path377.join(scopeRoot(scope, ctx), "data", "bundles", "applied-state.json");
+  return path378.join(scopeRoot(scope, ctx), "data", "bundles", "applied-state.json");
 }
 function isPlainEntryShape(value) {
   if (typeof value !== "object" || value === null)
@@ -207799,7 +208333,7 @@ function migrateV1(v1) {
 async function readAppliedState(ledgerPath) {
   let raw;
   try {
-    raw = await readFile193(ledgerPath, "utf8");
+    raw = await readFile194(ledgerPath, "utf8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
@@ -207822,14 +208356,14 @@ async function readAppliedState(ledgerPath) {
   return { ok: false, reason: "corrupt-ledger", message: `applied-state ledger at ${ledgerPath} has an unrecognized shape` };
 }
 function containedRootAndRel(ledgerPath) {
-  const marker = `${path377.sep}.metaproject${path377.sep}`;
+  const marker = `${path378.sep}.metaproject${path378.sep}`;
   const idx = ledgerPath.indexOf(marker);
   if (idx >= 0) {
-    return { root: ledgerPath.slice(0, idx), rel: ledgerPath.slice(idx + path377.sep.length).split(path377.sep).join("/") };
+    return { root: ledgerPath.slice(0, idx), rel: ledgerPath.slice(idx + path378.sep.length).split(path378.sep).join("/") };
   }
-  const bundlesDir = path377.dirname(ledgerPath);
-  const root = path377.dirname(bundlesDir);
-  const rel = path377.join(path377.basename(bundlesDir), path377.basename(ledgerPath)).split(path377.sep).join("/");
+  const bundlesDir = path378.dirname(ledgerPath);
+  const root = path378.dirname(bundlesDir);
+  const rel = path378.join(path378.basename(bundlesDir), path378.basename(ledgerPath)).split(path378.sep).join("/");
   return { root, rel };
 }
 async function writeAppliedState(ledgerPath, state) {
@@ -207849,14 +208383,14 @@ var init_applied_state = __esm(() => {
 });
 
 // src/lib/private-dir.ts
-import { lstat as lstat23, mkdir as mkdir76, open as open10, readFile as readFile194 } from "fs/promises";
-import path378 from "path";
+import { lstat as lstat23, mkdir as mkdir76, open as open11, readFile as readFile195 } from "fs/promises";
+import path379 from "path";
 async function checkPrivateDirGitignore(dir, root) {
   if (root !== undefined) {
-    const rootResolved = path378.resolve(root);
-    const dirResolved = path378.resolve(dir);
-    const relative = path378.relative(rootResolved, dirResolved);
-    const relativePosix = relative.split(path378.sep).join("/");
+    const rootResolved = path379.resolve(root);
+    const dirResolved = path379.resolve(dir);
+    const relative = path379.relative(rootResolved, dirResolved);
+    const relativePosix = relative.split(path379.sep).join("/");
     const refusal = await refuseEscapingSymlink(rootResolved, relativePosix);
     if (refusal !== undefined) {
       return {
@@ -207886,7 +208420,7 @@ async function checkPrivateDirGitignore(dir, root) {
       message: `${dir} is a symlink; keryx will not manage a private directory reached through a symlink.`
     };
   }
-  const gitignorePath = path378.join(dir, ".gitignore");
+  const gitignorePath = path379.join(dir, ".gitignore");
   let stats;
   try {
     stats = await lstat23(gitignorePath);
@@ -207916,7 +208450,7 @@ async function checkPrivateDirGitignore(dir, root) {
   }
   let bytes;
   try {
-    bytes = await readFile194(gitignorePath);
+    bytes = await readFile195(gitignorePath);
   } catch (error) {
     return {
       ok: false,
@@ -207938,10 +208472,10 @@ async function ensurePrivateDirGitignore(dir, root) {
   if (!check.ok || check.action === "present") {
     return check;
   }
-  const gitignorePath = path378.join(dir, ".gitignore");
+  const gitignorePath = path379.join(dir, ".gitignore");
   await mkdir76(dir, { recursive: true });
   try {
-    const handle = await open10(gitignorePath, "wx");
+    const handle = await open11(gitignorePath, "wx");
     try {
       await handle.writeFile(PRIVATE_DIR_GITIGNORE, "utf8");
     } finally {
@@ -208354,9 +208888,9 @@ var init_plan2 = __esm(() => {
 });
 
 // src/bundle/audit.ts
-import { mkdtemp as mkdtemp9, mkdir as mkdir77, rm as rm23, writeFile as writeFile53 } from "fs/promises";
+import { mkdtemp as mkdtemp9, mkdir as mkdir77, rm as rm24, writeFile as writeFile53 } from "fs/promises";
 import { tmpdir as tmpdir16 } from "os";
-import path379 from "path";
+import path380 from "path";
 function entriesToStage(plan) {
   return plan.entries.filter((e) => e.bucket === "new" || e.bucket === "update" || e.bucket === "conflict" && e.forced);
 }
@@ -208366,12 +208900,12 @@ async function auditBundlePlan(plan, opts = {}) {
     return { ok: true, refusals: [], report: null };
   }
   const runAudit = opts.runAudit ?? runHarnessAudit;
-  const stagingDir = await mkdtemp9(path379.join(tmpdir16(), "keryx-bundle-audit-"));
+  const stagingDir = await mkdtemp9(path380.join(tmpdir16(), "keryx-bundle-audit-"));
   try {
     try {
       for (const entry of toStage) {
-        const abs = path379.join(stagingDir, ...entry.path.split("/"));
-        await mkdir77(path379.dirname(abs), { recursive: true });
+        const abs = path380.join(stagingDir, ...entry.path.split("/"));
+        await mkdir77(path380.dirname(abs), { recursive: true });
         await writeFile53(abs, entry.bytes);
       }
     } catch (err) {
@@ -208396,7 +208930,7 @@ async function auditBundlePlan(plan, opts = {}) {
     }
     return { ok: refusals.length === 0, refusals, report };
   } finally {
-    await rm23(stagingDir, { recursive: true, force: true });
+    await rm24(stagingDir, { recursive: true, force: true });
   }
 }
 var init_audit = __esm(() => {
@@ -208405,8 +208939,8 @@ var init_audit = __esm(() => {
 });
 
 // src/bundle/apply.ts
-import { mkdir as mkdir78, rmdir as rmdir2, stat as stat37 } from "fs/promises";
-import path380 from "path";
+import { mkdir as mkdir78, rmdir as rmdir2, stat as stat38 } from "fs/promises";
+import path381 from "path";
 function writableEntries(plan) {
   return plan.entries.filter((e) => e.bucket === "new" || e.bucket === "update" || e.bucket === "conflict" && e.forced);
 }
@@ -208477,7 +209011,7 @@ async function applyBundlePlan(plan, auditResult, opts = {}) {
         throw new ApplyAbort({ ...previousFile.refusal, path: entry.path });
       }
       const previousBytes = previousFile.bytes ?? null;
-      const createdDirs = await mkdirRecordingCreated(path380.dirname(entry.targetPath));
+      const createdDirs = await mkdirRecordingCreated(path381.dirname(entry.targetPath));
       for (const dir of [...createdDirs].reverse())
         rollback.push({ kind: "dir", absolutePath: dir });
       rollback.push({ kind: "file", root, rel: entry.targetRelative, previousBytes });
@@ -208560,14 +209094,14 @@ async function applyBundlePlan(plan, auditResult, opts = {}) {
 }
 async function mkdirRecordingCreated(dir) {
   const missing = [];
-  let current = path380.resolve(dir);
+  let current = path381.resolve(dir);
   for (;; ) {
     try {
-      await stat37(current);
+      await stat38(current);
       break;
     } catch {
       missing.push(current);
-      const parent = path380.dirname(current);
+      const parent = path381.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -208582,9 +209116,9 @@ function resolveLedgerPathForEntry(entry, opts) {
   if (entry.targetScope === "user") {
     return userStorePaths(opts.env ?? process.env, opts.homeDir).appliedState;
   }
-  const metaprojectIdx = entry.targetPath.indexOf(`${path380.sep}.metaproject${path380.sep}`);
-  const metaprojectRoot = metaprojectIdx === -1 ? path380.join(path380.dirname(entry.targetPath), ".metaproject") : entry.targetPath.slice(0, metaprojectIdx + `${path380.sep}.metaproject`.length);
-  return path380.join(metaprojectRoot, "data", "bundles", "applied-state.json");
+  const metaprojectIdx = entry.targetPath.indexOf(`${path381.sep}.metaproject${path381.sep}`);
+  const metaprojectRoot = metaprojectIdx === -1 ? path381.join(path381.dirname(entry.targetPath), ".metaproject") : entry.targetPath.slice(0, metaprojectIdx + `${path381.sep}.metaproject`.length);
+  return path381.join(metaprojectRoot, "data", "bundles", "applied-state.json");
 }
 var ApplyAbort;
 var init_apply4 = __esm(() => {
@@ -208660,26 +209194,26 @@ var init_inspect = __esm(() => {
 });
 
 // src/bundle/uninstall.ts
-import path381 from "path";
+import path382 from "path";
 function isContained(root, candidate) {
-  const rel = path381.relative(root, candidate);
-  return rel === "" || !rel.startsWith(`..${path381.sep}`) && rel !== ".." && !path381.isAbsolute(rel);
+  const rel = path382.relative(root, candidate);
+  return rel === "" || !rel.startsWith(`..${path382.sep}`) && rel !== ".." && !path382.isAbsolute(rel);
 }
 async function removeNowEmptyParents(root, relFilePath) {
-  let relDir = path381.posix.dirname(relFilePath);
+  let relDir = path382.posix.dirname(relFilePath);
   while (relDir !== "." && relDir !== "/" && relDir !== "") {
     if (PROTECTED_KIND_ROOTS.has(relDir))
       break;
     const removed = await rmdirIfEmptyContained(root, relDir).catch(() => false);
     if (!removed)
       break;
-    relDir = path381.posix.dirname(relDir);
+    relDir = path382.posix.dirname(relDir);
   }
 }
 async function uninstallBundle(opts) {
   const ctx = { projectRoot: opts.projectRoot, env: opts.env, homeDir: opts.homeDir };
   const root = scopeRoot(opts.targetScope, ctx);
-  const rootResolved = path381.resolve(root);
+  const rootResolved = path382.resolve(root);
   const ledgerPath = appliedStatePath(opts.targetScope, ctx);
   const ledgerRead = await readAppliedState(ledgerPath);
   if (!ledgerRead.ok) {
@@ -208719,7 +209253,7 @@ async function uninstallBundle(opts) {
     if (!kindCheck.ok) {
       return { ok: false, refusals: [{ reason: BUNDLE_REFUSAL.corruptLedger, path: relPath, message: `applied-state ledger record "${relPath}" does not match its recorded kind "${record.kind}": ${kindCheck.refusal.message}` }], removed: [], kept: [], missing: [] };
     }
-    const absolute = path381.resolve(rootResolved, normalized.path);
+    const absolute = path382.resolve(rootResolved, normalized.path);
     if (!isContained(rootResolved, absolute)) {
       return { ok: false, refusals: [{ reason: BUNDLE_REFUSAL.corruptLedger, path: relPath, message: `applied-state ledger record "${relPath}" resolves outside the scope root` }], removed: [], kept: [], missing: [] };
     }
@@ -208798,7 +209332,7 @@ var init_service20 = __esm(() => {
 });
 
 // src/commands/bundle.ts
-import path382 from "path";
+import path383 from "path";
 async function bundleCommand(args, cwd = process.cwd()) {
   const sub = args[0];
   if (sub === undefined || sub === "--help" || sub === "-h") {
@@ -208931,7 +209465,7 @@ async function handleExport(args, cwd) {
   const outcome = await exportBundle({
     projectRoot,
     scope: scopeArg,
-    out: path382.resolve(cwd, out),
+    out: path383.resolve(cwd, out),
     include: include.length > 0 ? include : undefined,
     kinds: kindsRaw.length > 0 ? kindsRaw : undefined,
     bundleId,
@@ -208976,7 +209510,7 @@ async function handleImport(args, cwd) {
   }
   const projectRoot = resolveBundleProjectRoot(cwd);
   if (external) {
-    await handleImportExternal(path382.resolve(cwd, target), projectRoot, { dryRun, json });
+    await handleImportExternal(path383.resolve(cwd, target), projectRoot, { dryRun, json });
     return;
   }
   const targetScopeArg = optionValue([...args], "--target-scope");
@@ -209003,7 +209537,7 @@ async function handleImport(args, cwd) {
       return;
     }
   }
-  const opened = await openBundle(path382.resolve(cwd, target));
+  const opened = await openBundle(path383.resolve(cwd, target));
   if (!opened.ok) {
     printRefusals([opened.refusal], json);
     process.exitCode = 1;
@@ -209181,7 +209715,7 @@ async function handleInspect(args, cwd) {
     return;
   }
   const projectRoot = resolveBundleProjectRoot(cwd);
-  const result = await inspectBundle(path382.resolve(cwd, bundlePath), {
+  const result = await inspectBundle(path383.resolve(cwd, bundlePath), {
     projectRoot,
     targetScope: targetScopeArg
   });
@@ -209225,7 +209759,7 @@ async function handleVerify(args, cwd) {
     failUsage("keryx bundle verify requires a <bundle> argument (or --external-imports)");
     return;
   }
-  const outcome = await verifyBundlePath(path382.resolve(cwd, bundlePath));
+  const outcome = await verifyBundlePath(path383.resolve(cwd, bundlePath));
   if (!outcome.ok) {
     printRefusals(outcome.refusals, json);
     process.exitCode = 1;
@@ -209368,23 +209902,23 @@ var init_bundle = __esm(() => {
 
 // src/commands/learn.ts
 import { existsSync as existsSync60 } from "fs";
-import { readFile as readFile195 } from "fs/promises";
+import { readFile as readFile196 } from "fs/promises";
 import { createInterface as createInterface4 } from "readline/promises";
-import path383 from "path";
+import path384 from "path";
 function resolveRoot2(deps) {
   return resolveProjectRoot2(deps.cwd ?? process.cwd());
 }
 function resolveLearnRoot(startDir, env) {
-  const hasMetaproject = (dir) => existsSync60(path383.join(dir, ".metaproject"));
+  const hasMetaproject = (dir) => existsSync60(path384.join(dir, ".metaproject"));
   const fromEnv = env.CLAUDE_PROJECT_DIR;
   if (typeof fromEnv === "string" && fromEnv.length > 0 && hasMetaproject(fromEnv)) {
     return fromEnv;
   }
-  let current = path383.resolve(startDir);
+  let current = path384.resolve(startDir);
   for (;; ) {
     if (hasMetaproject(current))
       return current;
-    const parent = path383.dirname(current);
+    const parent = path384.dirname(current);
     if (parent === current)
       return;
     current = parent;
@@ -209480,7 +210014,7 @@ async function runObserveHook(deps) {
 }
 async function countObservationLines(filePath) {
   try {
-    const raw = await readFile195(filePath, "utf8");
+    const raw = await readFile196(filePath, "utf8");
     return raw.split(`
 `).filter((line) => line.length > 0).length;
   } catch {
@@ -210217,7 +210751,7 @@ var init_group_subcommands = __esm(() => {
     ["trigger", ["run", "install", "uninstall", "list", "status", "schedule", "resolve"]],
     ["schedule", ["add", "list", "show", "pause", "resume", "run", "remove"]],
     ["governance", ["report", "show"]],
-    ["decisions", ["open", "answer", "reason", "report"]],
+    ["decisions", ["open", "answer", "reason", "report", "import"]],
     ["product", ["index", "open"]],
     ["hooks", ["list", "validate", "test", "enable", "disable", "trust", "untrust"]],
     ["bundle", ["export", "import", "inspect", "verify", "uninstall"]],
@@ -210521,9 +211055,11 @@ var VERSION3, CLI_ROUTES, MCP_KNOWN_SUBCOMMANDS, USAGE_BODY = `Usage:
                                                Spend, confirmations, signatures and gate outcomes,
                                                unified across flows; writes latest.md/latest.json
   keryx governance show [--json]                Reprint the most recently written governance report
-  keryx decisions open|answer|reason|report     Recommendation journal: record a question with options and its
+  keryx decisions open|answer|reason|report [--json|--line]|import <file.jsonl> [--dry-run] [--json]
+                                               Recommendation journal: record a question with options and its
                                                recommendation before showing it, the human's choice after;
-                                               report = match share by mode and stage, deviations (no model)
+                                               report = match share by mode and stage, deviations (no model);
+                                               import = earlier decisions from a JSON-lines file, kept apart
   keryx product index [--json]                  Read every flow and requirements package into a disposable intent index; reports entries with no stated intent
   keryx product open [--json]                   Intents closed in code with no recorded look back, each with its outcome criterion
   keryx hooks list [--json]                     Resolved keryx shell lifecycle hooks (built-in -> user -> project)