codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/evidence.js

@@ -0,0 +1,363 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var evidence_exports = {};
+__export(evidence_exports, {
+  EVIDENCE_FORMAT: () => EVIDENCE_FORMAT,
+  EVIDENCE_VERSION: () => EVIDENCE_VERSION,
+  EvidenceError: () => EvidenceError,
+  MAX_EVIDENCE_ENTRIES: () => MAX_EVIDENCE_ENTRIES,
+  buildEvidence: () => buildEvidence,
+  decisionsBetween: () => decisionsBetween,
+  evidenceFromText: () => evidenceFromText,
+  renderEvidenceHtml: () => renderEvidenceHtml,
+  sealEvidence: () => sealEvidence,
+  verifyEvidence: () => verifyEvidence
+});
+module.exports = __toCommonJS(evidence_exports);
+var import_database = require("./database");
+var import_record_chain = require("./record-chain");
+var import_replay_frames = require("./replay-frames");
+var import_replay_state = require("./replay-state");
+var import_plan_service = require("./plan-service");
+var import_signoff_pack = require("./signoff-pack");
+var import_pack_seal = require("./pack-seal");
+var import_tool_phrasing = require("../../shared/lib/tool-phrasing");
+const EVIDENCE_FORMAT = "codetrellis-evidence";
+const EVIDENCE_VERSION = 1;
+const MAX_EVIDENCE_ENTRIES = 2e4;
+const MAX_FRAMES = 2e3;
+class EvidenceError extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+  status;
+}
+const HOW = 'digest = sha256(JSON.stringify([event.id, event.at, event.source, event.type, event.sessionId, event.agentType, event.payload])); hash = sha256(prev + "\\n" + seq + "\\n" + event.id + "\\n" + digest), hex, where prev is the hash before (record.before.hash for the first entry).';
+const DECISION_TYPES = /* @__PURE__ */ new Set(["breakpoint_hit", "breakpoint_answered", "criterion_decided", "signal_answered", "spec_decided", "rule_changed", "retention_changed"]);
+const day = (ms) => new Date(ms).toISOString().slice(0, 10);
+const minute = (ms) => new Date(ms).toISOString().replace("T", " ").slice(0, 16);
+function rowsOf(sql, params = []) {
+  const res = (0, import_database.getDb)().exec(sql, params);
+  if (!res.length) return [];
+  const { columns, values } = res[0];
+  return values.map((v) => Object.fromEntries(columns.map((c, i) => [c, v[i]])));
+}
+function linkBefore(at) {
+  const last = rowsOf("SELECT seq, hash FROM record_chain WHERE linked_at < ? ORDER BY seq DESC LIMIT 1", [at])[0];
+  if (last) return { seq: Number(last.seq), hash: last.hash };
+  const a = rowsOf("SELECT through_seq, hash FROM record_anchor WHERE id = 1")[0];
+  return a ? { seq: Number(a.through_seq), hash: a.hash } : { seq: 0, hash: import_record_chain.GENESIS };
+}
+function entriesIn(from, to) {
+  const n = Number(rowsOf("SELECT COUNT(*) AS n FROM record_chain WHERE linked_at >= ? AND linked_at <= ?", [from, to])[0]?.n ?? 0);
+  if (n > MAX_EVIDENCE_ENTRIES) {
+    throw new EvidenceError(`That window holds ${n.toLocaleString("en-GB")} record entries; one export carries at most ${MAX_EVIDENCE_ENTRIES.toLocaleString("en-GB")}. Choose a shorter window.`);
+  }
+  const rows = rowsOf(
+    `SELECT c.seq, c.linked_at, c.digest, c.prev, c.hash, e.id, e.at, e.source, e.type, e.session_id, e.agent_type, e.payload
+     FROM record_chain c LEFT JOIN agent_events e ON e.id = c.event_id
+     WHERE c.linked_at >= ? AND c.linked_at <= ? ORDER BY c.seq ASC`,
+    [from, to]
+  );
+  const before = rows.length ? { seq: Number(rows[0].seq) - 1, hash: rows[0].prev } : linkBefore(from);
+  const entries = rows.map((r) => ({
+    seq: Number(r.seq),
+    linkedAt: Number(r.linked_at),
+    digest: r.digest,
+    hash: r.hash,
+    event: r.id === null ? null : {
+      id: r.id,
+      at: Number(r.at),
+      source: String(r.source),
+      type: String(r.type),
+      sessionId: r.session_id ?? null,
+      agentType: r.agent_type ?? null,
+      payload: String(r.payload)
+    }
+  }));
+  return { before, entries };
+}
+function parsePayload(raw) {
+  try {
+    const v = JSON.parse(raw);
+    return v && typeof v === "object" ? v : {};
+  } catch {
+    return {};
+  }
+}
+function decisionsOf(entries) {
+  return entries.filter((e) => e.event && DECISION_TYPES.has(e.event.type)).map((e) => {
+    const ev = e.event;
+    const phrased = (0, import_tool_phrasing.phraseEvent)({ id: ev.id, timestamp: ev.at, source: ev.source, type: ev.type, payload: parsePayload(ev.payload) });
+    return { seq: e.seq, at: ev.at, type: ev.type, words: phrased.text };
+  });
+}
+function decisionsBetween(from, to, limit = 200) {
+  const types = [...DECISION_TYPES];
+  const rows = rowsOf(
+    `SELECT c.seq, c.linked_at, c.digest, c.prev, c.hash, e.id, e.at, e.source, e.type, e.session_id, e.agent_type, e.payload
+     FROM record_chain c JOIN agent_events e ON e.id = c.event_id
+     WHERE c.linked_at >= ? AND c.linked_at <= ? AND e.type IN (${types.map(() => "?").join(",")})
+     ORDER BY c.seq ASC LIMIT ?`,
+    [from, to, ...types, Math.min(Math.max(1, Math.floor(limit)), 1e3)]
+  );
+  return decisionsOf(rows.map((r) => ({
+    seq: Number(r.seq),
+    linkedAt: Number(r.linked_at),
+    digest: r.digest,
+    hash: r.hash,
+    event: { id: r.id, at: Number(r.at), source: String(r.source), type: String(r.type), sessionId: r.session_id ?? null, agentType: r.agent_type ?? null, payload: String(r.payload) }
+  })));
+}
+function moment(projectPath, at) {
+  const { sinceFrame: _diff, projectPath: _path, ...rest } = (0, import_replay_state.stateAt)(projectPath, at, false);
+  return rest;
+}
+function buildEvidence(req, now = Date.now()) {
+  let projectPath;
+  let from;
+  let to;
+  let plan = null;
+  let signoffPack = null;
+  if (req.planUid) {
+    const p = (0, import_plan_service.getPlan)(req.planUid);
+    if (!p) throw new EvidenceError(`Plan ${req.planUid} not found`, 404);
+    projectPath = p.projectPath;
+    from = p.createdAt;
+    to = p.status === "completed" || p.status === "archived" ? Math.max(p.updatedAt, p.createdAt) : now;
+    plan = { uid: p.uid, title: p.title };
+    signoffPack = (0, import_signoff_pack.buildSignoffPack)(p.uid, new Date(now));
+  } else {
+    if (!req.projectPath) throw new EvidenceError("Name a plan, or a project and a window (from, to)");
+    if (!Number.isFinite(req.from) || !Number.isFinite(req.to)) throw new EvidenceError("from and to must be times in milliseconds");
+    projectPath = req.projectPath;
+    from = req.from;
+    to = Math.min(req.to, now);
+    if (from > to) throw new EvidenceError("from must be before to");
+  }
+  const { before, entries } = entriesIn(from, to);
+  const last = entries[entries.length - 1];
+  const words = `${plan ? `The plan \u201C${plan.title}\u201D: ` : ""}${minute(from)} to ${minute(to)} UTC, ${entries.length.toLocaleString("en-GB")} record entr${entries.length === 1 ? "y" : "ies"}`;
+  return {
+    format: EVIDENCE_FORMAT,
+    version: EVIDENCE_VERSION,
+    generatedAt: new Date(now).toISOString(),
+    window: { from, to, projectPath, plan, words },
+    record: { how: HOW, before, through: last ? { seq: last.seq, hash: last.hash } : before, entries },
+    frames: (0, import_replay_frames.listFrames)(projectPath, { from, to, limit: MAX_FRAMES }),
+    start: moment(projectPath, from),
+    end: moment(projectPath, to),
+    decisions: decisionsOf(entries),
+    signoffPack
+  };
+}
+function sealEvidence(e) {
+  return (0, import_pack_seal.sealDocument)(import_pack_seal.EVIDENCE_NAMESPACE, e);
+}
+const MAX_PROBLEMS = 50;
+const label = (p) => `#${p.seq}${p.type ? ` (${p.type.replace(/_/g, " ")}${p.agentType ? ` by ${p.agentType}` : ""}${p.at ? `, ${day(p.at)}` : ""})` : ""}`;
+function str(v) {
+  return typeof v === "string" ? v : null;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function entriesOf(doc) {
+  const record = doc.record;
+  if (!record || !Array.isArray(record.entries)) return null;
+  const b = record.before;
+  const before = b && num(b.seq) !== null && str(b.hash) ? { seq: num(b.seq), hash: str(b.hash) } : null;
+  const entries = [];
+  for (const raw of record.entries.slice(0, MAX_EVIDENCE_ENTRIES)) {
+    const e = raw ?? {};
+    const ev = e.event;
+    entries.push({
+      seq: num(e.seq) ?? -1,
+      linkedAt: num(e.linkedAt) ?? 0,
+      digest: str(e.digest) ?? "",
+      hash: str(e.hash) ?? "",
+      event: ev && typeof ev === "object" ? {
+        id: str(ev.id) ?? "",
+        at: num(ev.at) ?? 0,
+        source: str(ev.source) ?? "",
+        type: str(ev.type) ?? "",
+        sessionId: str(ev.sessionId),
+        agentType: str(ev.agentType),
+        payload: str(ev.payload) ?? ""
+      } : null
+    });
+  }
+  return { before, entries };
+}
+function checkChain(before, entries) {
+  const problems = [];
+  const say = (p) => {
+    if (problems.length < MAX_PROBLEMS) problems.push(p);
+  };
+  let prev = before?.hash ?? "";
+  let expected = (before?.seq ?? -1) + 1;
+  for (const e of entries) {
+    const info = { type: e.event?.type ?? null, agentType: e.event?.agentType ?? null, at: e.event?.at ?? null };
+    if (!before || e.seq !== expected) say({ seq: e.seq, kind: "relinked", ...info });
+    else if ((0, import_record_chain.linkHash)(prev, e.seq, e.event?.id ?? "", e.digest) !== e.hash) say({ seq: e.seq, kind: "relinked", ...info });
+    if (!e.event) say({ seq: e.seq, kind: "missing", ...info });
+    else if ((0, import_record_chain.digestOf)({ id: e.event.id, at: e.event.at, source: e.event.source, type: e.event.type, session_id: e.event.sessionId, agent_type: e.event.agentType, payload: e.event.payload }) !== e.digest) {
+      say({ seq: e.seq, kind: "changed", ...info });
+    }
+    prev = e.hash;
+    expected = e.seq + 1;
+  }
+  const ok = problems.length === 0;
+  const span = entries.length ? ` (#${entries[0].seq} to #${entries[entries.length - 1].seq})` : "";
+  const n = `${entries.length.toLocaleString("en-GB")} record entr${entries.length === 1 ? "y" : "ies"}`;
+  const WORDS = {
+    changed: "its event does not match its digest",
+    relinked: "its link does not follow from the one before",
+    missing: "its event was already gone when it was exported"
+  };
+  const words = ok ? entries.length ? `Its ${n}${span} recompute into one unbroken chain.` : "It carries no record entries." : `Its record entries do not recompute: ${problems.slice(0, 3).map((p) => `${label(p)}: ${WORDS[p.kind]}`).join("; ")}.`;
+  return { ok, entries: entries.length, problems, words };
+}
+function checkHere(entries) {
+  const db = (0, import_database.getDb)();
+  const anchorSeq = Number(db.exec("SELECT through_seq FROM record_anchor WHERE id = 1")[0]?.values[0]?.[0] ?? 0);
+  const problems = [];
+  let trimmed = 0;
+  for (const e of entries) {
+    if (problems.length >= MAX_PROBLEMS) break;
+    const info = { type: e.event?.type ?? null, agentType: e.event?.agentType ?? null, at: e.event?.at ?? null };
+    const link = rowsOf("SELECT hash, event_id FROM record_chain WHERE seq = ?", [e.seq])[0];
+    if (!link) {
+      if (e.seq <= anchorSeq) trimmed++;
+      else problems.push({ seq: e.seq, kind: "removed", ...info });
+      continue;
+    }
+    if (link.hash !== e.hash) {
+      problems.push({ seq: e.seq, kind: "relinked", ...info });
+      continue;
+    }
+    const ev = rowsOf(
+      "SELECT id, at, source, type, session_id, agent_type, payload FROM agent_events WHERE id = ?",
+      [link.event_id]
+    )[0];
+    if (!ev) {
+      if (e.event) problems.push({ seq: e.seq, kind: "removed", ...info });
+      continue;
+    }
+    if ((0, import_record_chain.digestOf)(ev) !== e.digest) problems.push({ seq: e.seq, kind: "changed", ...info });
+  }
+  const WORDS = {
+    changed: "its content was changed in this computer's record since",
+    removed: "it was removed from this computer's record since",
+    relinked: "its link in this computer's record was changed since"
+  };
+  if (problems.length) {
+    return { state: "differs", problems, words: `Since it was exported: ${problems.slice(0, 3).map((p) => `${label(p)}: ${WORDS[p.kind]}`).join("; ")}.` };
+  }
+  if (trimmed) {
+    return { state: "trimmed", problems, words: `This computer's record still matches it, except ${trimmed.toLocaleString("en-GB")} entr${trimmed === 1 ? "y" : "ies"} retention has removed since.` };
+  }
+  return { state: "matches", problems, words: entries.length ? "This computer's record still holds every entry in it, unchanged." : "This computer's record has nothing to compare." };
+}
+function verifyEvidence(doc) {
+  const d = doc && typeof doc === "object" ? doc : {};
+  if (d.format !== EVIDENCE_FORMAT) throw new EvidenceError("That file is not a CodeTrellis evidence export");
+  const seal = (0, import_pack_seal.checkDocumentSeal)(import_pack_seal.EVIDENCE_NAMESPACE, "export", d);
+  const read = entriesOf(d);
+  const chain = read ? checkChain(read.before, read.entries) : { ok: false, entries: 0, problems: [], words: "It carries no record entries that can be read." };
+  const here = seal.state === "this-computer" && read ? checkHere(read.entries) : {
+    state: "not-here",
+    problems: [],
+    words: seal.state === "changed" || seal.state === "unsigned" ? "Its signature does not hold, so who made it is not known and this computer's record was not compared." : "It was made on another computer, so this one has no record of it to compare."
+  };
+  const ok = (seal.state === "this-computer" || seal.state === "teammate") && chain.ok && here.state !== "differs";
+  return { ok, seal, chain, here, words: [seal.words, chain.words, here.words].filter(Boolean).join(" ") };
+}
+function evidenceFromText(text) {
+  const trimmed = text.trim();
+  try {
+    if (trimmed.startsWith("{")) return JSON.parse(trimmed);
+    const m = trimmed.match(/<script type="application\/json" id="codetrellis-evidence">([\s\S]*?)<\/script>/);
+    if (!m) throw new EvidenceError("No evidence data in that file");
+    return JSON.parse(m[1]);
+  } catch (err) {
+    if (err instanceof EvidenceError) throw err;
+    throw new EvidenceError("That file is not a readable evidence export");
+  }
+}
+function stackSection(title, m) {
+  const plans = m.stack.plans.map((p) => `<li><b>${(0, import_signoff_pack.esc)(p.title)}</b> <span class="muted">${(0, import_signoff_pack.esc)(p.status)}</span><ul>${p.tasks.map((t) => `<li>${(0, import_signoff_pack.esc)(t.title)} <span class="muted">${(0, import_signoff_pack.esc)(t.status ?? "")}${t.assignee ? ` \xB7 ${(0, import_signoff_pack.esc)(t.assignee)}` : ""}${t.workstream ? ` \xB7 ${(0, import_signoff_pack.esc)(t.workstream)}` : ""}</span></li>`).join("")}</ul></li>`).join("");
+  const signals = m.signals.map((s) => `<li>${(0, import_signoff_pack.esc)(s.summary)} <span class="muted">${(0, import_signoff_pack.esc)(s.severity)}</span></li>`).join("");
+  return `<h2>${(0, import_signoff_pack.esc)(title)} <span class="muted">${(0, import_signoff_pack.esc)(minute(m.at))} UTC</span></h2>
+<h3>The stack</h3>${plans ? `<ul>${plans}</ul>` : '<p class="muted">Nothing under way.</p>'}
+<h3>Signals open</h3>${signals ? `<ul>${signals}</ul>` : '<p class="muted">None.</p>'}
+<p class="muted">${m.waiting.length === 0 ? "Nothing was waiting on a person." : `${m.waiting.length} call${m.waiting.length === 1 ? " was" : "s were"} waiting on a person.`}</p>`;
+}
+function renderEvidenceHtml(e) {
+  const title = e.window.plan ? `Evidence \u2014 ${e.window.plan.title}` : "Evidence";
+  const decisions = e.decisions.map((d) => `<tr><td>#${d.seq}</td><td>${(0, import_signoff_pack.esc)(minute(d.at))}</td><td>${(0, import_signoff_pack.esc)(d.words)}</td></tr>`).join("");
+  const frames = e.frames.map((f) => `<tr><td>${(0, import_signoff_pack.esc)(minute(f.at))}</td><td>${(0, import_signoff_pack.esc)(f.reasons.join(", "))}</td><td><code>${(0, import_signoff_pack.esc)((f.commitSha ?? "").slice(0, 10))}</code> ${(0, import_signoff_pack.esc)(f.branch ?? "")}</td><td>${(0, import_signoff_pack.esc)(f.agentType ?? "")}</td></tr>`).join("");
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'">
+<title>${(0, import_signoff_pack.esc)(title)}</title>
+<style>
+  body { font: 13px/1.5 -apple-system, "Segoe UI", Helvetica, Arial, sans-serif; color: #111; max-width: 860px; margin: 32px auto; padding: 0 24px; }
+  h1 { font-size: 22px; margin: 0 0 4px; }
+  h2 { font-size: 16px; margin: 28px 0 8px; border-bottom: 1px solid #ddd; padding-bottom: 4px; }
+  h3 { font-size: 13px; margin: 12px 0 4px; }
+  .muted { color: #666; font-weight: normal; font-size: 12px; }
+  code { font: 11px ui-monospace, Menlo, Consolas, monospace; color: #444; word-break: break-all; }
+  table { border-collapse: collapse; width: 100%; font-size: 12px; }
+  td, th { border-bottom: 1px solid #eee; padding: 4px 6px; text-align: left; vertical-align: top; }
+</style>
+</head>
+<body>
+<h1>${(0, import_signoff_pack.esc)(title)}</h1>
+<p class="muted">${(0, import_signoff_pack.esc)(e.window.words)} \xB7 ${(0, import_signoff_pack.esc)(e.window.projectPath)} \xB7 generated ${(0, import_signoff_pack.esc)(e.generatedAt.replace("T", " ").slice(0, 16))} UTC by CodeTrellis</p>
+${e.seal ? `<p class="muted" id="seal">Signed by the computer with key <code>${(0, import_signoff_pack.esc)(e.seal.key)}</code>, with its record at entry #${(0, import_signoff_pack.esc)(String(e.sealedRecord?.seq ?? 0))}. Verify it in CodeTrellis: a changed byte, a broken chain, or a record changed since, shows.</p>` : ""}
+<h2>Breakpoints and decisions</h2>
+${decisions ? `<table><thead><tr><th>Entry</th><th>When (UTC)</th><th>What</th></tr></thead><tbody>${decisions}</tbody></table>` : '<p class="muted">None in this window.</p>'}
+${stackSection("At the start", e.start)}
+${stackSection("At the end", e.end)}
+<h2>Recorded moments</h2>
+${frames ? `<table><thead><tr><th>When (UTC)</th><th>Why</th><th>Commit</th><th>Agent</th></tr></thead><tbody>${frames}</tbody></table>` : '<p class="muted">None in this window.</p>'}
+<h2>The record</h2>
+<p class="muted">${e.record.entries.length.toLocaleString("en-GB")} entries, from the link after #${e.record.before.seq} (<code>${(0, import_signoff_pack.esc)(e.record.before.hash.slice(0, 16))}\u2026</code>) through #${e.record.through.seq} (<code>${(0, import_signoff_pack.esc)(e.record.through.hash.slice(0, 16))}\u2026</code>). Each recomputes from the data in this file: ${(0, import_signoff_pack.esc)(e.record.how)}</p>
+${e.signoffPack ? `<h2>Sign-off pack</h2><p class="muted">${e.signoffPack.rows.filter((r) => r.state === "met").length} of ${e.signoffPack.rows.length} criteria met; ${e.signoffPack.files.length} file${e.signoffPack.files.length === 1 ? "" : "s"} with hashes. The pack is in this file's data.</p>` : ""}
+<script type="application/json" id="codetrellis-evidence">${(0, import_signoff_pack.scriptJson)(e)}</script>
+</body>
+</html>
+`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EVIDENCE_FORMAT,
+  EVIDENCE_VERSION,
+  EvidenceError,
+  MAX_EVIDENCE_ENTRIES,
+  buildEvidence,
+  decisionsBetween,
+  evidenceFromText,
+  renderEvidenceHtml,
+  sealEvidence,
+  verifyEvidence
+});

package/src/backend/services/external-intake-service.js

@@ -0,0 +1,269 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var external_intake_service_exports = {};
+__export(external_intake_service_exports, {
+  MAX_INTAKE_DEPTH: () => MAX_INTAKE_DEPTH,
+  acceptanceSection: () => acceptanceSection,
+  findPlanByExternalKey: () => findPlanByExternalKey,
+  flattenIntake: () => flattenIntake,
+  getPlanExternalRefs: () => getPlanExternalRefs,
+  getSyncState: () => getSyncState,
+  intakeBody: () => intakeBody,
+  intakeKind: () => intakeKind,
+  keyFromUrl: () => keyFromUrl,
+  markSynced: () => markSynced,
+  sameUrl: () => sameUrl,
+  setPlanExternalRef: () => setPlanExternalRef
+});
+module.exports = __toCommonJS(external_intake_service_exports);
+var _lazy___plan_file_service = __toESM(require("./plan-file-service"));
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_external_refs_service = require("./external-refs-service");
+const MAX_INTAKE_DEPTH = 3;
+function getPlanExternalRefs(planUid) {
+  try {
+    const res = (0, import_database.getDb)().exec(
+      `SELECT uid, plan_uid, kind, url, title, external_key, author, author_type, created_at
+       FROM plan_external_refs WHERE plan_uid = ? ORDER BY created_at ASC`,
+      [planUid]
+    );
+    return (res[0]?.values ?? []).map((r) => ({
+      uid: r[0],
+      planUid: r[1],
+      kind: r[2],
+      url: r[3],
+      title: r[4],
+      externalKey: r[5] ?? null,
+      author: r[6],
+      authorType: r[7],
+      createdAt: r[8]
+    }));
+  } catch {
+    return [];
+  }
+}
+function sameUrl(a, b) {
+  const norm = (u) => {
+    try {
+      const p = new URL(u);
+      return `${p.protocol.toLowerCase()}//${p.host.toLowerCase()}${p.pathname.replace(/\/+$/, "")}${p.search}`;
+    } catch {
+      return u.trim().replace(/\/+$/, "");
+    }
+  };
+  return norm(a) === norm(b);
+}
+function findPlanByExternalKey(key) {
+  if (!key) return null;
+  try {
+    const res = (0, import_database.getDb)().exec(
+      `SELECT r.plan_uid
+         FROM plan_external_refs r
+         JOIN plans p ON p.uid = r.plan_uid
+        WHERE r.external_key = ? AND p.status != 'archived'
+        ORDER BY r.created_at ASC LIMIT 1`,
+      [key]
+    );
+    return res[0]?.values?.[0]?.[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function writePlanThrough(planUid) {
+  try {
+    _lazy___plan_file_service.scheduleWriteThrough(planUid);
+  } catch {
+  }
+}
+function setPlanExternalRef(input) {
+  const db = (0, import_database.getDb)();
+  const kind = input.kind ?? (0, import_external_refs_service.inferKind)(input.url);
+  const key = input.key ?? keyFromUrl(input.url, kind);
+  const title = input.title?.trim() || key || input.url;
+  const now = Date.now();
+  const refs = getPlanExternalRefs(input.planUid);
+  const existing = key ? refs.find((r) => r.externalKey === key) : refs.find((r) => r.externalKey === null && sameUrl(r.url, input.url));
+  if (existing) {
+    db.run(`UPDATE plan_external_refs SET url = ?, title = ?, kind = ? WHERE uid = ?`, [
+      input.url,
+      title,
+      kind,
+      existing.uid
+    ]);
+    (0, import_persistence.markDirty)();
+    writePlanThrough(input.planUid);
+    return { ...existing, url: input.url, title, kind };
+  }
+  const uid = (0, import_node_crypto.randomUUID)();
+  const author = input.author ?? "human";
+  const authorType = input.authorType ?? "human";
+  db.run(
+    `INSERT INTO plan_external_refs (uid, plan_uid, kind, url, title, external_key, author, author_type, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [uid, input.planUid, kind, input.url, title, key, author, authorType, now]
+  );
+  (0, import_persistence.markDirty)();
+  writePlanThrough(input.planUid);
+  return {
+    uid,
+    planUid: input.planUid,
+    kind,
+    url: input.url,
+    title,
+    externalKey: key,
+    author,
+    authorType,
+    createdAt: now
+  };
+}
+function keyFromUrl(url, kind) {
+  const k = kind ?? (0, import_external_refs_service.inferKind)(url);
+  const patterns = {
+    jira: /\/browse\/([A-Z][A-Z0-9_]+-\d+)/i,
+    linear: /\/issue\/([A-Z][A-Z0-9_]+-\d+)/i,
+    github_issue: /github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/i,
+    github_pr: /github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/i
+  };
+  const re = patterns[k];
+  if (!re) return null;
+  const m = re.exec(url);
+  if (!m) return null;
+  return m.length > 2 ? `${m[1]}#${m[2]}` : m[1].toUpperCase();
+}
+function acceptanceSection(criteria) {
+  const clean = criteria.map((c) => c.trim()).filter(Boolean);
+  if (clean.length === 0) return "";
+  return ["", "## Acceptance criteria", ...clean.map((c) => `- [ ] ${c}`), ""].join("\n");
+}
+function suggestTransition(status) {
+  switch (status) {
+    case "in_progress":
+      return "In Progress";
+    case "done":
+      return "Done";
+    case "blocked":
+      return "Blocked";
+    case "pending":
+    case "assigned":
+      return "To Do";
+    default:
+      return null;
+  }
+}
+function getSyncState(planUid) {
+  const db = (0, import_database.getDb)();
+  let lastSyncedAt = null;
+  try {
+    const res = db.exec(`SELECT last_synced_at FROM external_sync_state WHERE plan_uid = ?`, [planUid]);
+    const row = res[0]?.values[0];
+    if (row) lastSyncedAt = row[0];
+  } catch {
+  }
+  const changed = [];
+  try {
+    const res = db.exec(
+      `SELECT i.uid, i.title, i.status, i.updated_at, r.external_key, r.url
+       FROM plan_items i
+       JOIN external_refs r ON r.item_uid = i.uid
+       WHERE i.plan_uid = ?
+         AND r.external_key IS NOT NULL
+         AND (? IS NULL OR i.updated_at > ?)
+       ORDER BY i.updated_at ASC`,
+      [planUid, lastSyncedAt, lastSyncedAt]
+    );
+    for (const row of res[0]?.values ?? []) {
+      const status = row[2] ?? null;
+      changed.push({
+        itemUid: row[0],
+        title: row[1],
+        status,
+        updatedAt: row[3],
+        externalKey: row[4],
+        url: row[5],
+        suggestedTransition: suggestTransition(status)
+      });
+    }
+  } catch {
+  }
+  return { planUid, lastSyncedAt, changed, planRefs: getPlanExternalRefs(planUid) };
+}
+function markSynced(planUid, syncedBy, note) {
+  const now = Date.now();
+  (0, import_database.getDb)().run(
+    `INSERT INTO external_sync_state (plan_uid, last_synced_at, synced_by, note)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(plan_uid) DO UPDATE SET
+       last_synced_at = excluded.last_synced_at,
+       synced_by = excluded.synced_by,
+       note = excluded.note`,
+    [planUid, now, syncedBy ?? null, note ?? null]
+  );
+  (0, import_persistence.markDirty)();
+  return { lastSyncedAt: now };
+}
+function flattenIntake(roots, maxDepth = MAX_INTAKE_DEPTH) {
+  const out = [];
+  const walk = (node, depth, parentIndex) => {
+    const index = out.length;
+    out.push({ node, depth, parentIndex });
+    const canNest = depth + 1 <= maxDepth - 1;
+    const childDepth = canNest ? depth + 1 : depth;
+    const childParent = canNest ? index : parentIndex;
+    for (const child of node.children ?? []) {
+      walk(child, childDepth, childParent);
+    }
+  };
+  for (const root of roots) walk(root, 0, null);
+  return out;
+}
+function intakeBody(node) {
+  const body = (node.body ?? "").trim();
+  const acceptance = acceptanceSection(node.acceptance ?? []);
+  return [body, acceptance].filter(Boolean).join("\n");
+}
+function intakeKind(node, depth) {
+  if (node.kind) return node.kind;
+  return depth === 0 && (node.children?.length ?? 0) > 0 ? "object" : "action";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_INTAKE_DEPTH,
+  acceptanceSection,
+  findPlanByExternalKey,
+  flattenIntake,
+  getPlanExternalRefs,
+  getSyncState,
+  intakeBody,
+  intakeKind,
+  keyFromUrl,
+  markSynced,
+  sameUrl,
+  setPlanExternalRef
+});