codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/spec-proposals-service.js

@@ -0,0 +1,470 @@
+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 spec_proposals_service_exports = {};
+__export(spec_proposals_service_exports, {
+  decideProposal: () => decideProposal,
+  decisionProblem: () => decisionProblem,
+  directEditNote: () => directEditNote,
+  getProposal: () => getProposal,
+  impactProblem: () => impactProblem,
+  listProposals: () => listProposals,
+  pageVersion: () => pageVersion,
+  proposalNoticeFor: () => proposalNoticeFor,
+  proposalProblem: () => proposalProblem,
+  proposalReads: () => proposalReads,
+  proposeSpecChange: () => proposeSpecChange,
+  replyToProposal: () => replyToProposal,
+  specChangedFor: () => specChangedFor
+});
+module.exports = __toCommonJS(spec_proposals_service_exports);
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_plan_item_service = require("./plan-item-service");
+var import_plan_event_service = require("./plan-event-service");
+var import_breakpoint_service = require("./breakpoint-service");
+var import_agent_event_log = require("./agent-event-log");
+var import_push_notification_service = require("./push-notification-service");
+var import_plan_service = require("./plan-service");
+var import_channel_event_service = require("./channel-event-service");
+var import_spec_links_service = require("./spec-links-service");
+var import_spec_sections = require("../../shared/lib/spec-sections");
+const rows = (sql, params = []) => (0, import_database.getDb)().exec(sql, params)[0]?.values ?? [];
+const parse = (s, fallback) => {
+  try {
+    return JSON.parse(String(s));
+  } catch {
+    return fallback;
+  }
+};
+function pageVersion(pageUid) {
+  return rows("SELECT COALESCE(MAX(version), 1) FROM plan_item_versions WHERE item_uid = ?", [pageUid])[0]?.[0] ?? 1;
+}
+function proposalProblem(input) {
+  const page = (0, import_plan_item_service.getItem)(input.page);
+  if (!page) return `No page ${input.page}.`;
+  if (page.kind !== "object") return `"${page.title}" is a task, not a page: only a spec page can be changed by proposal.`;
+  if (input.section && !(0, import_spec_sections.findSection)(page.body ?? "", input.section)) {
+    return `"${page.title}" has no heading "${input.section}". Sections are addressed by their heading's slug, such as "fields" for "## Fields".`;
+  }
+  if (!input.text.trim()) return "The proposal needs the new text.";
+  if (!input.why.trim()) return "The proposal needs a why: what is wrong with the spec as it is.";
+  const before = input.section ? (0, import_spec_sections.sectionText)(page.body ?? "", input.section) ?? "" : page.body ?? "";
+  if (before.trim() === input.text.trim()) return "The proposed text is the same as the page has now.";
+  return null;
+}
+const affectedWords = (affected) => {
+  const w = (0, import_spec_links_service.reliedOnWords)(affected);
+  return w ? w.replace(/^Relied on by /, "") + (affected.length === 1 ? " relies on this" : " rely on this") : null;
+};
+function fromRow(r) {
+  const pageUid = r[1];
+  const page = (0, import_plan_item_service.getItem)(pageUid);
+  const section = r[3];
+  const base = r[4];
+  const current = page ? pageVersion(pageUid) : base;
+  const affected = parse(r[9], []);
+  return {
+    uid: r[0],
+    pageUid,
+    pageTitle: page?.title ?? "",
+    planUid: r[2],
+    section,
+    sectionTitle: section && page ? (0, import_spec_sections.findSection)(page.body ?? "", section)?.title ?? null : null,
+    baseVersion: base,
+    currentVersion: current,
+    pageChangedSince: current !== base,
+    beforeText: r[5],
+    proposedText: r[6],
+    why: r[7],
+    evidence: parse(r[8], {}),
+    affected,
+    affectedWords: affectedWords(affected),
+    author: r[10],
+    authorType: r[11],
+    sessionId: r[12] ?? null,
+    status: r[13],
+    createdAt: r[14],
+    decidedAt: r[15] ?? null,
+    decidedBy: r[16] ?? null,
+    decidedByType: r[17] ?? null,
+    decisionNote: r[18] ?? null,
+    impacts: impactsOf(r[0]),
+    hitRef: r[19] ?? null,
+    decidedText: r[20] ?? null,
+    pageBreakpoint: guardOf(pageUid)
+  };
+}
+function guardOf(pageUid) {
+  const bp = (0, import_breakpoint_service.specBreakpointOn)(pageUid);
+  return bp ? { id: bp.id, note: bp.note } : null;
+}
+function impactsOf(proposalUid) {
+  return rows(
+    `SELECT id, impact, words, tasks, item_uid, plan_uid, author, author_type, session_id, created_at
+       FROM spec_proposal_impacts WHERE proposal_uid = ? ORDER BY created_at, id`,
+    [proposalUid]
+  ).map((r) => {
+    const itemUid = r[4] ?? null;
+    const planUid = r[5] ?? null;
+    return {
+      id: r[0],
+      impact: r[1],
+      words: r[2],
+      tasks: r[3] ?? null,
+      itemUid,
+      itemTitle: itemUid ? (0, import_plan_item_service.getItem)(itemUid)?.title ?? null : null,
+      planUid,
+      planTitle: planUid ? (0, import_plan_service.getPlan)(planUid)?.title ?? null : null,
+      author: r[6],
+      authorType: r[7],
+      sessionId: r[8] ?? null,
+      createdAt: r[9]
+    };
+  });
+}
+const COLUMNS = `uid, page_uid, plan_uid, section, base_version, before_text, proposed_text, why, evidence, affected,
+  author, author_type, session_id, status, created_at, decided_at, decided_by, decided_by_type, decision_note, hit_ref, decided_text`;
+function proposeSpecChange(input, by) {
+  const page = (0, import_plan_item_service.getItem)(input.page);
+  const section = input.section ?? "";
+  const before = section ? (0, import_spec_sections.sectionText)(page.body ?? "", section) ?? "" : page.body ?? "";
+  const affected = (0, import_spec_links_service.reliedOnBy)(page.uid, section || void 0);
+  const uid = (0, import_node_crypto.randomUUID)();
+  (0, import_database.getDb)().run(
+    `INSERT INTO spec_proposals (uid, page_uid, plan_uid, section, base_version, before_text, proposed_text, why, evidence,
+       affected, author, author_type, session_id, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'open', ?)`,
+    [
+      uid,
+      page.uid,
+      page.planUid,
+      section,
+      pageVersion(page.uid),
+      before,
+      input.text,
+      input.why.trim(),
+      JSON.stringify(input.evidence ?? {}),
+      JSON.stringify(affected),
+      by.author,
+      by.authorType,
+      by.sessionId ?? null,
+      Date.now()
+    ]
+  );
+  raiseHit(uid, page.planUid, page.uid, by);
+  (0, import_persistence.markDirty)();
+  return getProposal(uid);
+}
+function raiseHit(uid, planUid, pageUid, by, now = Date.now()) {
+  const bp = `bp_${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  (0, import_database.getDb)().run(
+    `INSERT INTO breakpoints (id, kind, target, plan_uid, note, created_at, created_by, created_by_type)
+     VALUES (?, 'proposal', ?, ?, NULL, ?, ?, ?)`,
+    [bp, uid, planUid, now, by.author, by.authorType]
+  );
+  const ref = `bp-${(0, import_node_crypto.randomBytes)(5).toString("hex")}`;
+  const workstream = by.sessionId ? rows("SELECT workstream_root FROM agent_sessions WHERE session_id = ?", [by.sessionId])[0]?.[0] ?? null : null;
+  (0, import_database.getDb)().run(
+    `INSERT INTO breakpoint_hits (ref, breakpoint_id, tool, action, item_uid, plan_uid, agent, session_id, workstream_root, hit_at)
+     VALUES (?, ?, 'propose_spec_change', 'propose', ?, ?, ?, ?, ?, ?)`,
+    [ref, bp, pageUid, planUid, by.author, by.sessionId ?? null, workstream, now]
+  );
+  (0, import_database.getDb)().run("UPDATE spec_proposals SET hit_ref = ? WHERE uid = ?", [ref, uid]);
+  const hit = (0, import_breakpoint_service.getHit)(ref);
+  (0, import_agent_event_log.recordBreakpointEvent)("breakpoint_hit", { ref, kind: "proposal", action: "propose", tool: hit.tool, itemUid: pageUid, itemTitle: hit.itemTitle, planUid, agent: by.author, breakpointId: bp, on: uid }, by.author);
+  void (0, import_push_notification_service.pushForBreakpoint)(hit).catch(() => {
+  });
+}
+function getProposal(uid) {
+  const r = rows(`SELECT ${COLUMNS} FROM spec_proposals WHERE uid = ?`, [uid])[0];
+  return r ? fromRow(r) : null;
+}
+function listProposals(filter = {}) {
+  const where2 = [];
+  const params = [];
+  if (filter.pageUid) {
+    where2.push("s.page_uid = ?");
+    params.push(filter.pageUid);
+  }
+  if (filter.status) {
+    where2.push("s.status = ?");
+    params.push(filter.status);
+  }
+  if (filter.projectPath) {
+    where2.push("s.plan_uid IN (SELECT uid FROM plans WHERE project_path = ? OR project_path = ?)");
+    params.push(filter.projectPath, filter.projectPath.replace(/[\\/]+$/, ""));
+  }
+  const cols = COLUMNS.split(",").map((c) => `s.${c.trim()}`).join(", ");
+  return rows(
+    `SELECT ${cols} FROM spec_proposals s ${where2.length ? `WHERE ${where2.join(" AND ")}` : ""} ORDER BY s.created_at DESC`,
+    params
+  ).map(fromRow);
+}
+function directEditNote(pageUid) {
+  const affected = (0, import_spec_links_service.reliedOnBy)(pageUid);
+  if (affected.length === 0) return null;
+  const names = affected.slice(0, 4).map((a) => `"${a.title}" (${a.planTitle})`).join(", ");
+  const more = affected.length > 4 ? ` and ${affected.length - 4} more` : "";
+  return `${(0, import_spec_links_service.reliedOnWords)(affected)}: ${names}${more}. The edit is saved; to change a spec others rely on, propose_spec_change lets their agents weigh in and a person decide first.`;
+}
+const where = (p) => `${p.section ? `\xA7 ${p.sectionTitle ?? p.section} of ` : ""}"${p.pageTitle}"`;
+function heldBy(sessionId, p) {
+  const relying = (0, import_spec_links_service.reliedOnBy)(p.pageUid, p.section || void 0);
+  if (relying.length === 0) return [];
+  const mine = new Set(rows(
+    `SELECT uid FROM plan_items WHERE assignee_session = ? AND uid IN (${relying.map(() => "?").join(",")})`,
+    [sessionId, ...relying.map((r) => r.itemUid)]
+  ).map((r) => r[0]));
+  return relying.filter((r) => mine.has(r.itemUid));
+}
+const quoted = (text, max = 20) => {
+  const lines = text.replace(/\n+$/, "").split("\n");
+  const shown = lines.slice(0, max).map((l) => `> ${l}`);
+  if (lines.length > max) shown.push(`> \u2026 ${lines.length - max} more lines (list_spec_proposals has it all)`);
+  return shown;
+};
+function noticeText(p, mine) {
+  const tasks = mine.map((t) => `"${t.title}" (${t.planTitle})`).join(", ");
+  const ev = [
+    p.evidence.tests?.length ? `tests ${p.evidence.tests.join(", ")}` : null,
+    p.evidence.files?.length ? `files ${p.evidence.files.join(", ")}` : null,
+    p.evidence.commits?.length ? `commits ${p.evidence.commits.join(", ")}` : null,
+    p.evidence.note ? p.evidence.note : null
+  ].filter(Boolean).join("; ");
+  return [
+    `${p.author} proposes a change to ${where(p)}. Your ${mine.length === 1 ? "task" : "tasks"} ${tasks} ${mine.length === 1 ? "relies" : "rely"} on it.`,
+    `Why: ${p.why}`,
+    ...ev ? [`Evidence: ${ev}`] : [],
+    "Now:",
+    ...quoted(p.beforeText || "(empty)"),
+    "Proposed:",
+    ...quoted(p.proposedText),
+    `Nothing changes until a person decides. Say what it would mean for your work: reply_to_spec_proposal("${p.uid}", impact: "none" | "changes", words).`
+  ].join("\n");
+}
+function proposalNoticeFor(sessionId, agentType, now = Date.now(), onTold) {
+  try {
+    const changed = specChangedNotice(sessionId, now);
+    if (changed && changed.items.length > 0) onTold?.(changed.items);
+    const later = [changed?.text ?? null, outcomeNotice(sessionId, now)].filter((x) => !!x);
+    const holds = rows("SELECT 1 FROM plan_items WHERE assignee_session = ? LIMIT 1", [sessionId]).length > 0;
+    const unread = !holds ? [] : rows(
+      `SELECT uid FROM spec_proposals s WHERE s.status = 'open' AND (s.session_id IS NULL OR s.session_id != ?)
+         AND NOT EXISTS (SELECT 1 FROM spec_proposal_reads d WHERE d.proposal_uid = s.uid AND d.session_id = ?)
+       ORDER BY s.created_at`,
+      [sessionId, sessionId]
+    ).map((r) => r[0]);
+    const told = [];
+    for (const uid of unread) {
+      const p = getProposal(uid);
+      if (!p) continue;
+      const mine = heldBy(sessionId, p);
+      if (mine.length === 0) continue;
+      told.push(noticeText(p, mine));
+      (0, import_database.getDb)().run(
+        "INSERT OR IGNORE INTO spec_proposal_reads (proposal_uid, session_id, agent_type, read_at) VALUES (?, ?, ?, ?)",
+        [uid, sessionId, agentType, now]
+      );
+    }
+    const notices = [...told.length ? [[`\u2500\u2500 CodeTrellis: spec change proposed \u2500\u2500`, told.join("\n\n")].join("\n")] : [], ...later];
+    if (notices.length === 0) return null;
+    (0, import_persistence.markDirty)();
+    return notices.join("\n\n");
+  } catch (err) {
+    console.warn("[Spec] proposal notice failed:", err instanceof Error ? err.message : err);
+    return null;
+  }
+}
+function proposalReads(uid) {
+  return rows("SELECT session_id, agent_type, read_at FROM spec_proposal_reads WHERE proposal_uid = ? ORDER BY read_at", [uid]).map((r) => ({ sessionId: r[0], agentType: r[1] ?? null, readAt: r[2] }));
+}
+function impactProblem(input) {
+  const p = getProposal(input.uid);
+  if (!p) return `No proposal ${input.uid}.`;
+  if (p.status !== "open") return `The proposal to change ${where(p)} was ${p.status}; there is nothing left to weigh in on.`;
+  if (input.impact === "changes" && !input.words?.trim()) return "Say in a sentence what it would change for your work.";
+  if (input.tasks !== void 0 && (!Number.isInteger(input.tasks) || input.tasks < 0)) return "tasks is how many of your tasks it would change: a whole number.";
+  return null;
+}
+function replyToProposal(input, by, now = Date.now()) {
+  const p = getProposal(input.uid);
+  const task = by.sessionId ? heldBy(by.sessionId, p)[0] ?? null : null;
+  const words = input.words?.trim() ?? "";
+  (0, import_database.getDb)().run(
+    `INSERT INTO spec_proposal_impacts (proposal_uid, impact, words, tasks, item_uid, plan_uid, author, author_type, session_id, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      p.uid,
+      input.impact,
+      words,
+      input.tasks ?? null,
+      task?.itemUid ?? null,
+      task?.planUid ?? null,
+      by.author,
+      by.authorType,
+      by.sessionId ?? null,
+      now
+    ]
+  );
+  (0, import_persistence.markDirty)();
+  const impact = impactsOf(p.uid).at(-1);
+  const proposerTask = p.sessionId ? rows("SELECT uid, plan_uid FROM plan_items WHERE assignee_session = ? ORDER BY updated_at DESC LIMIT 1", [p.sessionId])[0] : void 0;
+  const from = task ? `"${task.title}" (${task.planTitle})` : by.author;
+  const said = input.impact === "none" ? `no impact on ${from}.` : `${from} would change${input.tasks !== void 0 ? ` (${input.tasks} ${input.tasks === 1 ? "task" : "tasks"})` : ""}: ${words}`;
+  const event = (0, import_channel_event_service.postChannelEvent)({
+    planUid: proposerTask?.[1] ?? p.planUid,
+    itemUid: proposerTask?.[0] ?? null,
+    eventType: "weigh-in",
+    payload: {
+      message: `On the proposed change to ${where(p)}: ${said}`,
+      references: { items: [p.pageUid, ...task ? [task.itemUid] : []] }
+    },
+    author: by.author,
+    authorType: by.authorType
+  });
+  return { impact, event };
+}
+function pageWith(p, text) {
+  const page = (0, import_plan_item_service.getItem)(p.pageUid);
+  if (!page) return null;
+  return (0, import_spec_sections.withSectionText)(page.body ?? "", p.section || null, text) ?? null;
+}
+function decisionProblem(input) {
+  const p = getProposal(input.uid);
+  if (!p) return `No proposal ${input.uid}.`;
+  if (p.status !== "open") return `The proposal to change ${where(p)} was already ${p.status}.`;
+  if (!["accept", "amend", "reject"].includes(input.decision)) return "decision is accept, amend or reject.";
+  if (input.decision === "amend" && !input.text?.trim()) return "Amend needs the text as it should read.";
+  if (input.decision !== "reject") {
+    if (!(0, import_plan_item_service.getItem)(p.pageUid)) return "The page no longer exists.";
+    const text = input.decision === "amend" ? input.text : p.proposedText;
+    if (pageWith(p, text) === null) return `"${p.pageTitle}" no longer has the heading "${p.section}". Reject this and ask for a new proposal.`;
+  }
+  return null;
+}
+function decideProposal(input, by, now = Date.now()) {
+  const p = getProposal(input.uid);
+  const note = input.note?.trim() || null;
+  const accept = input.decision !== "reject";
+  const text = input.decision === "amend" ? input.text : p.proposedText;
+  let flagged = [];
+  if (accept) {
+    (0, import_plan_item_service.updateItem)(p.pageUid, {
+      body: pageWith(p, text),
+      changeSummary: `Accepted spec proposal ${p.uid.slice(0, 8)}${input.decision === "amend" ? ", amended" : ""}: ${p.why}`,
+      author: by.author,
+      authorType: by.authorType
+    });
+    flagged = (0, import_spec_links_service.reliedOnBy)(p.pageUid, p.section || void 0);
+    for (const t of flagged) {
+      (0, import_database.getDb)().run("INSERT OR IGNORE INTO spec_change_flags (item_uid, proposal_uid, created_at) VALUES (?, ?, ?)", [t.itemUid, p.uid, now]);
+      (0, import_plan_event_service.appendPlanEvent)({
+        planUid: t.planUid,
+        itemUid: t.itemUid,
+        eventType: "spec_changed",
+        afterState: { proposalUid: p.uid, pageUid: p.pageUid, section: p.section },
+        summary: `The spec "${t.title}" relies on changed: ${where(p)}`,
+        author: by.author,
+        authorType: by.authorType,
+        createdAt: now
+      });
+    }
+  }
+  (0, import_database.getDb)().run(
+    `UPDATE spec_proposals SET status = ?, decided_at = ?, decided_by = ?, decided_by_type = ?, decision_note = ?, decided_text = ?
+     WHERE uid = ? AND status = 'open'`,
+    [accept ? "accepted" : "rejected", now, by.author, by.authorType, note, input.decision === "amend" ? text : null, p.uid]
+  );
+  (0, import_agent_event_log.recordDecision)("spec_decided", {
+    proposalUid: p.uid,
+    planUid: p.planUid,
+    pageUid: p.pageUid,
+    section: p.section,
+    decision: input.decision,
+    ...note ? { note: note.slice(0, 200) } : {},
+    author: by.author,
+    authorType: by.authorType
+  }, by.authorType === "agent" ? by.author : by.authorType);
+  if (p.hitRef) {
+    (0, import_breakpoint_service.answerHit)({ ref: p.hitRef, decision: accept ? "continue" : "stop", note: note ?? (input.decision === "amend" ? "Accepted with changes." : null), by: by.author, byType: by.authorType, now });
+    (0, import_database.getDb)().run(`UPDATE breakpoints SET cleared_at = ?, cleared_by = ?, cleared_by_type = ? WHERE kind = 'proposal' AND target = ? AND cleared_at IS NULL`, [now, by.author, by.authorType, p.uid]);
+  }
+  (0, import_persistence.markDirty)();
+  return { proposal: getProposal(p.uid), flagged };
+}
+function specChangedFor(itemUid) {
+  return rows("SELECT proposal_uid, created_at, read_at FROM spec_change_flags WHERE item_uid = ? ORDER BY created_at DESC", [itemUid]).flatMap((r) => {
+    const p = getProposal(r[0]);
+    return p ? [{ proposalUid: p.uid, pageUid: p.pageUid, pageTitle: p.pageTitle, section: p.section, sectionTitle: p.sectionTitle, at: r[1], toldAt: r[2] ?? null }] : [];
+  });
+}
+function specChangedNotice(sessionId, now) {
+  const flags = rows(
+    `SELECT f.item_uid, f.proposal_uid, i.title FROM spec_change_flags f JOIN plan_items i ON i.uid = f.item_uid
+      WHERE f.read_at IS NULL AND i.assignee_session = ? ORDER BY f.created_at`,
+    [sessionId]
+  );
+  if (flags.length === 0) return null;
+  const items = [...new Set(flags.map((f) => f[0]))];
+  const parts = flags.map(([itemUid, proposalUid, title]) => {
+    (0, import_database.getDb)().run("UPDATE spec_change_flags SET read_at = ?, read_by_session = ? WHERE item_uid = ? AND proposal_uid = ?", [now, sessionId, itemUid, proposalUid]);
+    const p = getProposal(proposalUid);
+    if (!p) return null;
+    return [
+      `${where(p)} changed: a person accepted ${p.author}'s proposal${p.decidedText ? ", with changes" : ""}. Your task "${title}" relies on it.`,
+      ...p.decisionNote ? [`Their note: ${p.decisionNote}`] : [],
+      "It now reads:",
+      ...quoted(p.decidedText ?? p.proposedText),
+      "Work to the new text; get_spec_links shows the page."
+    ].join("\n");
+  }).filter((x) => !!x);
+  return parts.length ? { text: ["\u2500\u2500 CodeTrellis: spec changed \u2500\u2500", parts.join("\n\n")].join("\n"), items } : null;
+}
+function outcomeNotice(sessionId, now) {
+  const decided = rows(
+    `SELECT uid FROM spec_proposals s WHERE s.session_id = ? AND s.status IN ('accepted', 'rejected')
+       AND NOT EXISTS (SELECT 1 FROM spec_proposal_outcome_reads o WHERE o.proposal_uid = s.uid AND o.session_id = ?)
+     ORDER BY s.decided_at`,
+    [sessionId, sessionId]
+  ).map((r) => r[0]);
+  if (decided.length === 0) return null;
+  const parts = decided.map((uid) => {
+    (0, import_database.getDb)().run("INSERT OR IGNORE INTO spec_proposal_outcome_reads (proposal_uid, session_id, read_at) VALUES (?, ?, ?)", [uid, sessionId, now]);
+    const p = getProposal(uid);
+    const note = p.decisionNote ? ` Their note: ${p.decisionNote}` : "";
+    return p.status === "rejected" ? `Your proposal to change ${where(p)} was not accepted.${note} The page is as it was; carry on with the spec as it is.` : `Your proposal to change ${where(p)} was accepted${p.decidedText ? ", with changes" : ""}; the page has its new version.${note}`;
+  });
+  return ["\u2500\u2500 CodeTrellis: spec proposal decided \u2500\u2500", parts.join("\n")].join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decideProposal,
+  decisionProblem,
+  directEditNote,
+  getProposal,
+  impactProblem,
+  listProposals,
+  pageVersion,
+  proposalNoticeFor,
+  proposalProblem,
+  proposalReads,
+  proposeSpecChange,
+  replyToProposal,
+  specChangedFor
+});

package/src/backend/services/sql/embedded.js

@@ -0,0 +1,95 @@
+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 embedded_exports = {};
+__export(embedded_exports, {
+  extractEmbeddedSql: () => extractEmbeddedSql
+});
+module.exports = __toCommonJS(embedded_exports);
+var import_refs = require("./refs");
+var import_index = require("./index");
+function scanStringLiterals(content) {
+  const out = [];
+  const len = content.length;
+  let i = 0;
+  let line = 1;
+  const openers = [
+    { open: '"""', close: '"""', raw: true },
+    { open: "'''", close: "'''", raw: true },
+    { open: "`", close: "`", raw: true },
+    { open: '"', close: '"', raw: false },
+    { open: "'", close: "'", raw: false }
+  ];
+  while (i < len) {
+    if (content[i] === "\n") {
+      line++;
+      i++;
+      continue;
+    }
+    const opener = openers.find((o) => content.startsWith(o.open, i));
+    if (!opener) {
+      i++;
+      continue;
+    }
+    const startLine = line;
+    const bodyStart = i + opener.open.length;
+    let j = bodyStart;
+    let body = "";
+    while (j < len) {
+      if (!opener.raw && content[j] === "\\" && j + 1 < len) {
+        body += content[j + 1];
+        j += 2;
+        continue;
+      }
+      if (content.startsWith(opener.close, j)) break;
+      if (content[j] === "\n") {
+        line++;
+        if (!opener.raw) {
+          body = "";
+          break;
+        }
+      }
+      body += content[j];
+      j++;
+    }
+    if (body) out.push({ body, line: startLine });
+    i = j + opener.close.length;
+  }
+  return out;
+}
+function extractEmbeddedSql(content) {
+  const out = [];
+  for (const literal of scanStringLiterals(content)) {
+    if (!(0, import_refs.looksLikeSql)(literal.body)) continue;
+    const refs = (0, import_refs.extractTableRefs)(literal.body);
+    if (refs.length === 0) continue;
+    out.push(...(0, import_index.sqlRefsToCallsites)(refs, "embedded", literal.body, literal.line));
+  }
+  return dedupe(out);
+}
+function dedupe(callsites) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const cs of callsites) {
+    const key = `${cs.urlPattern}:${cs.method}`;
+    if (!seen.has(key)) seen.set(key, cs);
+  }
+  return [...seen.values()];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractEmbeddedSql
+});

package/src/backend/services/sql/index.js

@@ -0,0 +1,63 @@
+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 sql_exports = {};
+__export(sql_exports, {
+  applyMigrationFold: () => import_schema.applyMigrationFold,
+  extractSchemaStatements: () => import_schema.extractSchemaStatements,
+  extractSqlSymbols: () => import_schema.extractSqlSymbols,
+  extractTableRefs: () => import_refs.extractTableRefs,
+  foldMigrations: () => import_schema.foldMigrations,
+  isNameToken: () => import_tokenizer.isNameToken,
+  isWord: () => import_tokenizer.isWord,
+  looksLikeMigrationsDir: () => import_schema.looksLikeMigrationsDir,
+  looksLikeSql: () => import_refs.looksLikeSql,
+  sortMigrations: () => import_schema.sortMigrations,
+  sqlRefsToCallsites: () => sqlRefsToCallsites,
+  tokenize: () => import_tokenizer.tokenize
+});
+module.exports = __toCommonJS(sql_exports);
+var import_tokenizer = require("./tokenizer");
+var import_refs = require("./refs");
+var import_schema = require("./schema");
+const MAX_SQL_TEXT = 400;
+function sqlRefsToCallsites(refs, context, sqlText, line) {
+  return refs.map((ref) => ({
+    kind: "sql_query",
+    protocol: "sql",
+    line: line ?? ref.line,
+    method: ref.op.toUpperCase(),
+    urlPattern: ref.table,
+    sqlText: sqlText ? sqlText.slice(0, MAX_SQL_TEXT) : void 0,
+    context: `${context}:${ref.keyword}`
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyMigrationFold,
+  extractSchemaStatements,
+  extractSqlSymbols,
+  extractTableRefs,
+  foldMigrations,
+  isNameToken,
+  isWord,
+  looksLikeMigrationsDir,
+  looksLikeSql,
+  sortMigrations,
+  sqlRefsToCallsites,
+  tokenize
+});