codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/criteria-service.js

@@ -0,0 +1,721 @@
+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 criteria_service_exports = {};
+__export(criteria_service_exports, {
+  CRITERION_KINDS: () => CRITERION_KINDS,
+  CRITERION_POLICIES: () => CRITERION_POLICIES,
+  CriterionError: () => CriterionError,
+  GATE_CRITERION_TEXT: () => GATE_CRITERION_TEXT,
+  addCriterionAsAgent: () => addCriterionAsAgent,
+  addCriterionAsHuman: () => addCriterionAsHuman,
+  addVerifiedSignoff: () => addVerifiedSignoff,
+  criteriaForExport: () => criteriaForExport,
+  criteriaForTemplate: () => criteriaForTemplate,
+  decideCriterion: () => decideCriterion,
+  defaultPolicy: () => defaultPolicy,
+  deleteCriterion: () => deleteCriterion,
+  deriveState: () => deriveState,
+  ensureCriteria: () => ensureCriteria,
+  getCriterion: () => getCriterion,
+  importCriteria: () => importCriteria,
+  listAwaitingPerson: () => listAwaitingPerson,
+  listCriteria: () => listCriteria,
+  listSignoffs: () => listSignoffs,
+  parseAcceptanceSection: () => parseAcceptanceSection,
+  seedTemplateCriteria: () => seedTemplateCriteria,
+  submitCriterion: () => submitCriterion,
+  unmetHumanCriteria: () => unmetHumanCriteria,
+  updateCriterion: () => updateCriterion
+});
+module.exports = __toCommonJS(criteria_service_exports);
+var import_agent_event_log = require("./agent-event-log");
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_plan_service = require("./plan-service");
+var import_trusted_roots = require("./trusted-roots");
+var import_signed_approvals = require("./signed-approvals");
+var import_persistence = require("./persistence");
+var import_human_decision = require("./human-decision");
+var import_artefact_service = require("./artefact-service");
+var _lazy___plan_file_service = __toESM(require("./plan-file-service"));
+const CRITERION_KINDS = ["manual", "artefact", "citation", "code", "test"];
+const CRITERION_POLICIES = ["agent", "propose", "human"];
+const GATE_CRITERION_TEXT = "Reviewed and approved";
+const STRICTNESS = { agent: 0, propose: 1, human: 2 };
+class CriterionError extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+  status;
+}
+let lastTick = 0;
+function tick() {
+  lastTick = Math.max(Date.now(), lastTick + 1);
+  return lastTick;
+}
+function defaultPolicy(kind) {
+  if (kind === "manual") return "human";
+  if (kind === "code") return "agent";
+  return "propose";
+}
+function normalisePolicy(kind, policy) {
+  return kind === "manual" ? "human" : policy;
+}
+function isKind(v) {
+  return typeof v === "string" && CRITERION_KINDS.includes(v);
+}
+function isPolicy(v) {
+  return typeof v === "string" && CRITERION_POLICIES.includes(v);
+}
+const CRITERION_COLS = "uid, item_uid, sort_order, text, kind, policy, source, author, author_type, created_at, updated_at, text_updated_at";
+function rows(sql, params = []) {
+  return (0, import_database.getDb)().exec(sql, params)[0]?.values ?? [];
+}
+function toEvidence(r) {
+  let locator = null;
+  if (typeof r[4] === "string") {
+    try {
+      locator = JSON.parse(r[4]);
+    } catch {
+      locator = r[4];
+    }
+  }
+  return {
+    uid: r[0],
+    submissionUid: r[2],
+    attachmentUid: r[3] ?? null,
+    locator,
+    note: r[5] ?? null,
+    sha256AtSubmit: r[6] ?? null,
+    submittedBy: r[7],
+    submittedByType: r[8],
+    submittedAt: r[9]
+  };
+}
+function toSignoff(r) {
+  let evidenceHashes = {};
+  if (typeof r[8] === "string") {
+    try {
+      evidenceHashes = JSON.parse(r[8]) ?? {};
+    } catch {
+      evidenceHashes = {};
+    }
+  }
+  return {
+    uid: r[0],
+    criterionUid: r[1],
+    decision: r[2],
+    actor: r[3],
+    actorType: r[4],
+    channel: r[5],
+    note: r[6] ?? null,
+    createdAt: r[7],
+    evidenceHashes,
+    anchor: typeof r[9] === "string" ? { attachmentUid: r[9], locator: parseJson(r[10]) } : null,
+    device: r[11] ?? null
+  };
+}
+function parseJson(v) {
+  if (typeof v !== "string") return null;
+  try {
+    return JSON.parse(v);
+  } catch {
+    return null;
+  }
+}
+function latestSubmissionOf(criterionUid) {
+  const last = rows(
+    `SELECT submission_uid FROM criterion_evidence WHERE criterion_uid = ?
+     ORDER BY submitted_at DESC LIMIT 1`,
+    [criterionUid]
+  )[0];
+  if (!last) return [];
+  return rows(
+    `SELECT uid, criterion_uid, submission_uid, attachment_uid, locator, note, sha256_at_submit,
+            submitted_by, submitted_by_type, submitted_at
+     FROM criterion_evidence WHERE submission_uid = ? ORDER BY rowid`,
+    [last[0]]
+  ).map(toEvidence);
+}
+function latestSignoffOf(criterionUid) {
+  const r = rows(
+    `SELECT uid, criterion_uid, decision, actor, actor_type, channel, note, created_at, evidence_hashes,
+            anchor_attachment_uid, anchor_locator, device
+     FROM criterion_signoffs WHERE criterion_uid = ? ORDER BY created_at DESC, rowid DESC LIMIT 1`,
+    [criterionUid]
+  )[0];
+  return r ? toSignoff(r) : null;
+}
+function deriveState(submission, signoff, since = null, evidenceChanged = false) {
+  if (since !== null) {
+    if (signoff && signoff.createdAt < since) signoff = null;
+    if (submission[0] && submission[0].submittedAt < since) submission = [];
+  }
+  const submittedAt = submission[0]?.submittedAt ?? null;
+  if (signoff && (submittedAt === null || signoff.createdAt >= submittedAt)) {
+    if (signoff.decision === "approved") return evidenceChanged ? "stale" : "met";
+    return "sent_back";
+  }
+  if (submittedAt !== null) return "submitted";
+  return "open";
+}
+function toCriterion(r) {
+  const uid = r[0];
+  const latestSubmission = latestSubmissionOf(uid);
+  const latestSignoff = latestSignoffOf(uid);
+  return {
+    uid,
+    itemUid: r[1],
+    sortOrder: r[2],
+    text: r[3],
+    kind: r[4],
+    policy: r[5],
+    source: r[6] ?? null,
+    author: r[7],
+    authorType: r[8],
+    createdAt: r[9],
+    updatedAt: r[10],
+    state: deriveState(
+      latestSubmission,
+      latestSignoff,
+      r[11] ?? null,
+      latestSignoff ? evidenceHasChanged(latestSignoff) : false
+    ),
+    latestSubmission,
+    latestSignoff
+  };
+}
+function evidenceHasChanged(signoff) {
+  const recorded = signoff.evidenceHashes ?? {};
+  const uids = Object.keys(recorded);
+  if (uids.length === 0) return false;
+  const now = (0, import_artefact_service.currentHashes)(uids);
+  return uids.some((uid) => recorded[uid] !== now[uid]);
+}
+function getCriterion(uid) {
+  const r = rows(`SELECT ${CRITERION_COLS} FROM item_criteria WHERE uid = ?`, [uid])[0];
+  return r ? toCriterion(r) : null;
+}
+function listCriteria(itemUid) {
+  ensureCriteria(itemUid);
+  return rows(
+    `SELECT ${CRITERION_COLS} FROM item_criteria WHERE item_uid = ? ORDER BY sort_order, created_at`,
+    [itemUid]
+  ).map(toCriterion);
+}
+function listAwaitingPerson(limit = 100) {
+  const candidates = rows(
+    `SELECT DISTINCT c.uid, i.title, p.uid, p.title
+       FROM item_criteria c
+       JOIN plan_items i ON i.uid = c.item_uid
+       JOIN plans p ON p.uid = i.plan_uid
+      WHERE EXISTS (SELECT 1 FROM criterion_evidence e WHERE e.criterion_uid = c.uid)`
+  );
+  const out = [];
+  for (const r of candidates) {
+    const criterion = getCriterion(r[0]);
+    if (!criterion || criterion.state !== "submitted" && criterion.state !== "stale") continue;
+    const at = criterion.state === "stale" ? criterion.latestSignoff?.createdAt ?? 0 : criterion.latestSubmission[0]?.submittedAt ?? 0;
+    out.push({
+      criterion,
+      itemTitle: r[1],
+      planUid: r[2],
+      planTitle: r[3],
+      at
+    });
+  }
+  return out.sort((a, b) => b.at - a.at).slice(0, limit).map(({ at: _at, ...rest }) => rest);
+}
+function listSignoffs(criterionUid) {
+  return rows(
+    `SELECT uid, criterion_uid, decision, actor, actor_type, channel, note, created_at, evidence_hashes,
+            anchor_attachment_uid, anchor_locator, device
+     FROM criterion_signoffs WHERE criterion_uid = ? ORDER BY created_at, rowid`,
+    [criterionUid]
+  ).map(toSignoff);
+}
+function unmetHumanCriteria(itemUid) {
+  return listCriteria(itemUid).filter((c) => c.policy === "human" && c.state !== "met");
+}
+function parseAcceptanceSection(body) {
+  const lines = body.split(/\r?\n/);
+  const start = lines.findIndex((l) => /^#{1,6}\s+acceptance criteria\s*$/i.test(l.trim()));
+  if (start === -1) return [];
+  const section = [];
+  for (const line of lines.slice(start + 1)) {
+    if (/^#{1,6}\s/.test(line.trim())) break;
+    section.push(line);
+  }
+  const listItem = /^\s*(?:[-*+]|\d+[.)])\s+(?:\[[ xX]\]\s+)?(.+?)\s*$/;
+  const listed = section.map((l) => l.match(listItem)?.[1]).filter((t) => !!t);
+  if (listed.length > 0) return listed;
+  const prose = section.join("\n").trim();
+  return prose ? [prose] : [];
+}
+function writeThroughFor(itemUid) {
+  try {
+    const r = rows(`SELECT plan_uid FROM plan_items WHERE uid = ?`, [itemUid])[0];
+    if (r) _lazy___plan_file_service.scheduleWriteThrough(r[0]);
+  } catch {
+  }
+}
+function itemRow(itemUid) {
+  const r = rows(`SELECT body, requires_approval FROM plan_items WHERE uid = ?`, [itemUid])[0];
+  return r ? { body: r[0] ?? "", requiresApproval: !!r[1] } : null;
+}
+function nextSortOrder(itemUid) {
+  const r = rows(`SELECT MAX(sort_order) FROM item_criteria WHERE item_uid = ?`, [itemUid])[0];
+  return typeof r?.[0] === "number" ? r[0] + 1 : 0;
+}
+function insertCriterion(input) {
+  const uid = input.uid ?? (0, import_node_crypto.randomUUID)();
+  const now = tick();
+  (0, import_database.getDb)().run(
+    `INSERT INTO item_criteria (${CRITERION_COLS}) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)`,
+    [
+      uid,
+      input.itemUid,
+      input.sortOrder ?? nextSortOrder(input.itemUid),
+      input.text,
+      input.kind,
+      normalisePolicy(input.kind, input.policy),
+      input.source,
+      input.author,
+      input.authorType,
+      input.createdAt ?? now,
+      now
+    ]
+  );
+  writeThroughFor(input.itemUid);
+  return uid;
+}
+function ensureCriteria(itemUid) {
+  const item = itemRow(itemUid);
+  if (!item) return;
+  const db = (0, import_database.getDb)();
+  let changed = false;
+  const migrated = rows(`SELECT 1 FROM item_criteria_migrated WHERE item_uid = ?`, [itemUid]).length > 0;
+  if (!migrated) {
+    for (const text of parseAcceptanceSection(item.body)) {
+      insertCriterion({
+        itemUid,
+        text,
+        kind: "manual",
+        policy: "propose",
+        source: "migrated",
+        author: "migration",
+        authorType: "system"
+      });
+    }
+    db.run(`INSERT OR IGNORE INTO item_criteria_migrated (item_uid, migrated_at) VALUES (?, ?)`, [itemUid, Date.now()]);
+    changed = true;
+  }
+  const gate = rows(`SELECT uid FROM item_criteria WHERE item_uid = ? AND source = 'gate'`, [itemUid])[0];
+  if (item.requiresApproval && !gate) {
+    insertCriterion({
+      itemUid,
+      text: GATE_CRITERION_TEXT,
+      kind: "manual",
+      policy: "human",
+      source: "gate",
+      author: "gate",
+      authorType: "system"
+    });
+    changed = true;
+  } else if (!item.requiresApproval && gate) {
+    db.run(`DELETE FROM item_criteria WHERE uid = ?`, [gate[0]]);
+    changed = true;
+  }
+  if (changed) (0, import_persistence.markDirty)();
+}
+function addCriterionAsHuman(itemUid, input, decision) {
+  assertHuman(decision);
+  requireItem(itemUid);
+  const kind = parseKind(input.kind);
+  const policy = input.policy === void 0 ? defaultPolicy(kind) : parsePolicy(input.policy);
+  const uid = insertCriterion({
+    itemUid,
+    text: requireText(input.text),
+    kind,
+    policy,
+    source: null,
+    author: decision.actor,
+    authorType: (0, import_human_decision.actorTypeOf)(decision)
+  });
+  (0, import_persistence.markDirty)();
+  return getCriterion(uid);
+}
+function addCriterionAsAgent(itemUid, input, actor) {
+  requireItem(itemUid);
+  const kind = parseKind(input.kind);
+  const uid = insertCriterion({
+    itemUid,
+    text: requireText(input.text),
+    kind,
+    policy: "propose",
+    source: null,
+    author: actor.author,
+    authorType: actor.authorType
+  });
+  (0, import_persistence.markDirty)();
+  return getCriterion(uid);
+}
+function updateCriterion(uid, changes, decision) {
+  assertHuman(decision);
+  const before = getCriterion(uid);
+  if (!before) throw new CriterionError("Criterion not found", 404);
+  const sets = [];
+  const params = [];
+  const now = tick();
+  if (changes.text !== void 0) {
+    const text = requireText(changes.text);
+    if (text !== before.text) {
+      sets.push("text = ?", "text_updated_at = ?");
+      params.push(text, now);
+    }
+  }
+  if (changes.policy !== void 0) {
+    sets.push("policy = ?");
+    params.push(normalisePolicy(before.kind, parsePolicy(changes.policy)));
+  }
+  if (changes.sortOrder !== void 0) {
+    if (typeof changes.sortOrder !== "number" || !Number.isInteger(changes.sortOrder)) {
+      throw new CriterionError("sortOrder must be an integer");
+    }
+    sets.push("sort_order = ?");
+    params.push(changes.sortOrder);
+  }
+  if (sets.length === 0) return before;
+  sets.push("updated_at = ?");
+  params.push(now);
+  (0, import_database.getDb)().run(`UPDATE item_criteria SET ${sets.join(", ")} WHERE uid = ?`, [...params, uid]);
+  writeThroughFor(before.itemUid);
+  (0, import_persistence.markDirty)();
+  return getCriterion(uid);
+}
+function deleteCriterion(uid, decision) {
+  assertHuman(decision);
+  const existing = getCriterion(uid);
+  if (!existing) return false;
+  (0, import_database.getDb)().run(`DELETE FROM item_criteria WHERE uid = ?`, [uid]);
+  writeThroughFor(existing.itemUid);
+  (0, import_persistence.markDirty)();
+  return true;
+}
+function submitCriterion(criterionUid, input, actor) {
+  const criterion = getCriterion(criterionUid);
+  if (!criterion) throw new CriterionError("Criterion not found", 404);
+  const evidence = input.evidence ?? [];
+  const note = typeof input.note === "string" && input.note.trim() ? input.note.trim() : null;
+  if (evidence.length === 0 && !note) {
+    throw new CriterionError("A submission needs evidence, a note, or both \u2014 say what shows this is met.");
+  }
+  for (const e of evidence) {
+    const owner = rows(
+      `SELECT target_type, target_uid FROM attachments WHERE uid = ?`,
+      [e.attachmentUid]
+    )[0];
+    if (!owner) throw new CriterionError(`Attachment ${e.attachmentUid} not found`, 404);
+    if (owner[1] !== criterion.itemUid) {
+      throw new CriterionError(`Attachment ${e.attachmentUid} belongs to another item; evidence must be attached to this one`);
+    }
+  }
+  const db = (0, import_database.getDb)();
+  const submissionUid = (0, import_node_crypto.randomUUID)();
+  const at = tick();
+  const pieces = evidence.length > 0 ? evidence : [null];
+  for (const e of pieces) {
+    db.run(
+      `INSERT INTO criterion_evidence
+         (uid, criterion_uid, submission_uid, attachment_uid, locator, note, sha256_at_submit,
+          submitted_by, submitted_by_type, submitted_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        (0, import_node_crypto.randomUUID)(),
+        criterionUid,
+        submissionUid,
+        e?.attachmentUid ?? null,
+        e?.locator === void 0 || e?.locator === null ? null : JSON.stringify(e.locator),
+        note,
+        e ? (0, import_artefact_service.currentHashes)([e.attachmentUid])[e.attachmentUid] : null,
+        actor.author,
+        actor.authorType,
+        at
+      ]
+    );
+  }
+  if (criterion.policy === "agent") {
+    appendSignoff(criterionUid, "approved", actor.author, actor.authorType, "mcp", note);
+  }
+  (0, import_persistence.markDirty)();
+  return getCriterion(criterionUid);
+}
+function decideCriterion(criterionUid, input, decision) {
+  assertHuman(decision);
+  const criterion = getCriterion(criterionUid);
+  if (!criterion) throw new CriterionError("Criterion not found", 404);
+  if (input.decision !== "approved" && input.decision !== "sent_back") {
+    throw new CriterionError("decision must be approved or sent_back");
+  }
+  const note = typeof input.note === "string" && input.note.trim() ? input.note.trim() : null;
+  if (input.decision === "sent_back" && !note) {
+    throw new CriterionError("Say what is wrong \u2014 a send-back note is what the agent reads next.");
+  }
+  const anchor = input.decision === "sent_back" ? parseAnchor(input.anchor, criterion.itemUid) : null;
+  const signed = appendSignoff(criterionUid, input.decision, decision.actor, (0, import_human_decision.actorTypeOf)(decision), decision.channel, note, anchor, decision.device ?? null);
+  (0, import_persistence.markDirty)();
+  if (input.decision === "approved" && (0, import_human_decision.isHumanDecision)(decision)) signPersonsApproval(criterion, signed);
+  return getCriterion(criterionUid);
+}
+function parseAnchor(raw, itemUid) {
+  if (raw === void 0 || raw === null) return null;
+  if (typeof raw !== "object" || Array.isArray(raw)) throw new CriterionError("anchor must be {attachmentUid, locator}");
+  const a = raw;
+  if (typeof a.attachmentUid !== "string") throw new CriterionError("anchor.attachmentUid is required");
+  const owner = rows(`SELECT target_uid FROM attachments WHERE uid = ?`, [a.attachmentUid])[0];
+  if (!owner) throw new CriterionError("The anchored file is not an attachment", 404);
+  if (owner[0] !== itemUid) throw new CriterionError("The anchored file belongs to another item");
+  const locator = a.locator ?? null;
+  if (locator !== null && (typeof locator !== "object" || Array.isArray(locator) || JSON.stringify(locator).length > 2e3)) {
+    throw new CriterionError('anchor.locator must be a small object such as {"lines": "4-6"}');
+  }
+  return { attachmentUid: a.attachmentUid, locator };
+}
+function appendSignoff(criterionUid, decision, actor, actorType, channel, note, anchor = null, device = null) {
+  let evidenceHashes = {};
+  if (decision === "approved") {
+    const uids = latestSubmissionOf(criterionUid).map((e) => e.attachmentUid).filter((u) => !!u);
+    evidenceHashes = (0, import_artefact_service.currentHashes)(uids);
+  }
+  const uid = (0, import_node_crypto.randomUUID)();
+  const at = tick();
+  (0, import_database.getDb)().run(
+    `INSERT INTO criterion_signoffs
+       (uid, criterion_uid, decision, actor, actor_type, channel, note, evidence_hashes, created_at,
+        anchor_attachment_uid, anchor_locator, device)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      uid,
+      criterionUid,
+      decision,
+      actor,
+      actorType,
+      channel,
+      note,
+      JSON.stringify(evidenceHashes),
+      at,
+      anchor?.attachmentUid ?? null,
+      anchor ? JSON.stringify(anchor.locator) : null,
+      device
+    ]
+  );
+  (0, import_agent_event_log.recordCriterionDecision)({ criterionUid, decision, actor, actorType, channel });
+  return { uid, evidenceHashes, at };
+}
+function addVerifiedSignoff(input) {
+  if (rows(`SELECT 1 FROM criterion_signoffs WHERE uid = ?`, [input.uid]).length) return false;
+  (0, import_database.getDb)().run(
+    `INSERT INTO criterion_signoffs (uid, criterion_uid, decision, actor, actor_type, channel, note, evidence_hashes, created_at)
+     VALUES (?, ?, 'approved', ?, 'human', 'file', NULL, ?, ?)`,
+    [input.uid, input.criterionUid, input.actor, JSON.stringify(input.evidence), input.at]
+  );
+  (0, import_persistence.markDirty)();
+  return true;
+}
+function criteriaForExport(itemUid) {
+  return listCriteria(itemUid).filter((c) => c.source !== "gate").map((c) => ({
+    uid: c.uid,
+    text: c.text,
+    kind: c.kind,
+    policy: c.policy,
+    sortOrder: c.sortOrder,
+    author: c.author,
+    authorType: c.authorType,
+    createdAt: new Date(c.createdAt).toISOString()
+  }));
+}
+function importCriteria(itemUid, raw) {
+  if (!Array.isArray(raw)) return 0;
+  const db = (0, import_database.getDb)();
+  let n = 0;
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const c = entry;
+    if (typeof c.uid !== "string" || typeof c.text !== "string" || !c.text.trim()) continue;
+    const kind = isKind(c.kind) ? c.kind : "manual";
+    let policy = isPolicy(c.policy) ? c.policy : defaultPolicy(kind);
+    const existing = getCriterion(c.uid);
+    if (existing) {
+      if (existing.itemUid !== itemUid) continue;
+      if (STRICTNESS[policy] < STRICTNESS[existing.policy]) policy = existing.policy;
+      const now = tick();
+      const reworded = c.text.trim() !== existing.text;
+      db.run(
+        `UPDATE item_criteria SET text = ?, policy = ?, sort_order = ?, updated_at = ?,
+           text_updated_at = CASE WHEN ? THEN ? ELSE text_updated_at END
+         WHERE uid = ?`,
+        [
+          c.text.trim(),
+          normalisePolicy(existing.kind, policy),
+          typeof c.sortOrder === "number" ? c.sortOrder : existing.sortOrder,
+          now,
+          reworded ? 1 : 0,
+          now,
+          c.uid
+        ]
+      );
+    } else {
+      if (policy === "agent" && kind !== "code") policy = "propose";
+      insertCriterion({
+        uid: c.uid,
+        itemUid,
+        text: c.text.trim(),
+        kind,
+        policy,
+        source: "import",
+        author: typeof c.author === "string" ? c.author : "file-import",
+        authorType: "file-import",
+        sortOrder: typeof c.sortOrder === "number" ? c.sortOrder : void 0,
+        createdAt: typeof c.createdAt === "string" ? Date.parse(c.createdAt) || void 0 : void 0
+      });
+    }
+    n++;
+  }
+  db.run(`INSERT OR IGNORE INTO item_criteria_migrated (item_uid, migrated_at) VALUES (?, ?)`, [itemUid, Date.now()]);
+  (0, import_persistence.markDirty)();
+  return n;
+}
+function seedTemplateCriteria(itemUid, raw, templateId) {
+  if (!Array.isArray(raw)) return 0;
+  let n = 0;
+  for (const entry of raw.slice(0, MAX_TEMPLATE_CRITERIA)) {
+    const c = typeof entry === "string" ? { text: entry } : entry;
+    if (!c || typeof c !== "object") continue;
+    const row = c;
+    if (typeof row.text !== "string" || !row.text.trim()) continue;
+    const kind = isKind(row.kind) ? row.kind : "manual";
+    let policy = isPolicy(row.policy) ? row.policy : defaultPolicy(kind);
+    if (policy === "agent" && kind !== "code") policy = "propose";
+    insertCriterion({
+      itemUid,
+      text: row.text.trim().slice(0, MAX_CRITERION_TEXT),
+      kind,
+      policy,
+      source: "template",
+      author: `template:${templateId}`,
+      authorType: "template"
+    });
+    n++;
+  }
+  if (n > 0) {
+    (0, import_database.getDb)().run(`INSERT OR IGNORE INTO item_criteria_migrated (item_uid, migrated_at) VALUES (?, ?)`, [itemUid, Date.now()]);
+    (0, import_persistence.markDirty)();
+  }
+  return n;
+}
+const MAX_TEMPLATE_CRITERIA = 50;
+const MAX_CRITERION_TEXT = 2e3;
+function criteriaForTemplate(itemUid) {
+  return listCriteria(itemUid).filter((c) => c.source !== "gate").map((c) => ({ text: c.text, kind: c.kind, policy: c.policy }));
+}
+function assertHuman(decision) {
+  if (!(0, import_human_decision.isHumanDecision)(decision) && !(0, import_human_decision.isUnverifiedDecision)(decision)) {
+    throw new CriterionError("Only a person can do this, from CodeTrellis or a paired phone.", 403);
+  }
+}
+function requireItem(itemUid) {
+  if (!itemRow(itemUid)) throw new CriterionError("Item not found", 404);
+}
+function requireText(text) {
+  if (typeof text !== "string" || !text.trim()) throw new CriterionError("text is required");
+  return text.trim();
+}
+function parseKind(kind) {
+  if (kind === void 0) return "manual";
+  if (!isKind(kind)) throw new CriterionError(`kind must be one of: ${CRITERION_KINDS.join(", ")}`);
+  return kind;
+}
+function parsePolicy(policy) {
+  if (!isPolicy(policy)) throw new CriterionError(`policy must be one of: ${CRITERION_POLICIES.join(", ")}`);
+  return policy;
+}
+function signPersonsApproval(criterion, signed) {
+  try {
+    const planRow = rows(`SELECT plan_uid FROM plan_items WHERE uid = ?`, [criterion.itemUid])[0];
+    if (!planRow) return;
+    const planUid = planRow[0];
+    const plan = (0, import_plan_service.getPlan)(planUid);
+    let repo = null;
+    try {
+      repo = plan?.projectPath ? (0, import_trusted_roots.resolveTrustedProjectRoot)(plan.projectPath, "signed approval") : null;
+    } catch {
+      repo = null;
+    }
+    const planDir = repo ? _lazy___plan_file_service.getLinkedPlanDir(planUid, repo) : null;
+    (0, import_signed_approvals.signApproval)({
+      signoffUid: signed.uid,
+      planUid,
+      itemUid: criterion.itemUid,
+      criterionUid: criterion.uid,
+      criterionText: criterion.text,
+      evidence: signed.evidenceHashes,
+      at: signed.at,
+      repo,
+      planDir
+    });
+  } catch {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CRITERION_KINDS,
+  CRITERION_POLICIES,
+  CriterionError,
+  GATE_CRITERION_TEXT,
+  addCriterionAsAgent,
+  addCriterionAsHuman,
+  addVerifiedSignoff,
+  criteriaForExport,
+  criteriaForTemplate,
+  decideCriterion,
+  defaultPolicy,
+  deleteCriterion,
+  deriveState,
+  ensureCriteria,
+  getCriterion,
+  importCriteria,
+  listAwaitingPerson,
+  listCriteria,
+  listSignoffs,
+  parseAcceptanceSection,
+  seedTemplateCriteria,
+  submitCriterion,
+  unmetHumanCriteria,
+  updateCriterion
+});