codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/signed-approvals.js

@@ -0,0 +1,244 @@
+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 signed_approvals_exports = {};
+__export(signed_approvals_exports, {
+  importApprovals: () => importApprovals,
+  listSignedApprovals: () => listSignedApprovals,
+  signApproval: () => signApproval,
+  signingSetup: () => signingSetup,
+  verifyRecord: () => verifyRecord
+});
+module.exports = __toCommonJS(signed_approvals_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_confined_fs = require("./confined-fs");
+var import_self_write_tracker = require("./self-write-tracker");
+var import_signed_approval_record = require("./signed-approval-record");
+const MAX_RECORDS = 500;
+const SSH_KEYGEN = "ssh-keygen";
+function gitConfig(repo, key) {
+  try {
+    const v = (0, import_node_child_process.execFileSync)("git", ["-C", repo, "config", "--get", key], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim();
+    return v || null;
+  } catch {
+    return null;
+  }
+}
+const expandHome = (p) => p.startsWith("~/") ? import_node_path.default.join(import_node_os.default.homedir(), p.slice(2)) : p;
+function signingSetup(repo) {
+  const signer = gitConfig(repo, "user.email");
+  const format = gitConfig(repo, "gpg.format");
+  const key = gitConfig(repo, "user.signingkey");
+  const allowed = gitConfig(repo, "gpg.ssh.allowedSignersFile");
+  const allowedSigners = allowed ? import_node_path.default.resolve(repo, expandHome(allowed)) : null;
+  const no = (why) => ({ canSign: false, why, signer, keyFile: null, allowedSigners });
+  if (format !== "ssh") return no("git signing is not set up with an SSH key (gpg.format ssh)");
+  if (!key) return no("git has no signing key (user.signingkey)");
+  if (!signer) return no("git has no user.email to sign as");
+  let keyFile;
+  if (key.startsWith("key::")) {
+    keyFile = import_node_path.default.join(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "codetrellis-signing-")), "key.pub");
+    import_node_fs.default.writeFileSync(keyFile, `${key.slice(5).trim()}
+`, { mode: 384, flag: "wx" });
+  } else {
+    keyFile = import_node_path.default.resolve(repo, expandHome(key));
+    if (!import_node_fs.default.existsSync(keyFile)) return no(`the signing key ${key} is not on this machine`);
+  }
+  return { canSign: true, why: null, signer, keyFile, allowedSigners };
+}
+function insertRow(r) {
+  (0, import_database.getDb)().run(
+    `INSERT OR REPLACE INTO signed_approvals (uid, plan_uid, item_uid, criterion_uid, signer, origin, state, reason, file, at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [r.uid, r.planUid, r.itemUid, r.criterionUid, r.signer, r.origin, r.state, r.reason, r.file ?? null, r.at]
+  );
+  (0, import_persistence.markDirty)();
+}
+function rowToApproval(r) {
+  return {
+    uid: r[0],
+    planUid: r[1],
+    itemUid: r[2],
+    criterionUid: r[3],
+    signer: r[4] ?? null,
+    origin: r[5],
+    state: r[6],
+    reason: r[7] ?? null,
+    at: r[8]
+  };
+}
+function listSignedApprovals(itemUid) {
+  const res = (0, import_database.getDb)().exec(
+    `SELECT uid, plan_uid, item_uid, criterion_uid, signer, origin, state, reason, at FROM signed_approvals WHERE item_uid = ? ORDER BY at DESC`,
+    [itemUid]
+  );
+  return (res[0]?.values ?? []).map(rowToApproval);
+}
+function signApproval(input) {
+  const base = { uid: input.signoffUid, planUid: input.planUid, itemUid: input.itemUid, criterionUid: input.criterionUid, origin: "here", at: input.at };
+  const local = (why, signer = null) => {
+    const row2 = { ...base, signer, state: "local", reason: why };
+    insertRow(row2);
+    return row2;
+  };
+  if (!input.repo || !input.planDir) return local("the plan is not shared through a folder, so the approval stays on this machine");
+  if (process.env.CODETRELLIS_SIGN_APPROVALS === "0") return local("signing approvals is turned off on this machine, so the approval stays on it");
+  const setup = signingSetup(input.repo);
+  if (!setup.canSign) return local(`${setup.why}, so the approval stays on this machine`, setup.signer);
+  const statement = {
+    uid: input.signoffUid,
+    planUid: input.planUid,
+    itemUid: input.itemUid,
+    criterionUid: input.criterionUid,
+    criterionSha256: (0, import_signed_approval_record.sha256)(input.criterionText),
+    decision: "approved",
+    evidence: input.evidence,
+    signer: setup.signer,
+    at: new Date(input.at).toISOString()
+  };
+  let signature;
+  try {
+    signature = (0, import_node_child_process.execFileSync)(SSH_KEYGEN, ["-Y", "sign", "-f", setup.keyFile, "-n", import_signed_approval_record.NAMESPACE], {
+      input: (0, import_signed_approval_record.canonicalStatement)(statement),
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 15e3
+    });
+  } catch (err) {
+    const why = err.stderr?.toString().trim().split("\n").pop() || err.message;
+    return local(`git's SSH key could not sign it (${why.slice(0, 160)}), so the approval stays on this machine`, setup.signer);
+  }
+  const rel = import_node_path.default.join("approvals", `${input.signoffUid}.yaml`);
+  try {
+    const written = (0, import_confined_fs.writeFileWithin)(input.planDir, rel, (0, import_signed_approval_record.recordYaml)(statement, signature), "approval record");
+    (0, import_self_write_tracker.stampSelfWrite)(written);
+  } catch (err) {
+    return local(`the record could not be written (${err.message}), so the approval stays on this machine`, setup.signer);
+  }
+  const row = { ...base, signer: setup.signer, state: "signed", reason: null };
+  insertRow({ ...row, file: rel });
+  return row;
+}
+function verifyRecord(text, signature, signer, allowedSigners, namespace = import_signed_approval_record.NAMESPACE) {
+  if (!allowedSigners) return { ok: false, reason: "git has no allowed signers to check it against (gpg.ssh.allowedSignersFile)" };
+  if (!import_node_fs.default.existsSync(allowedSigners)) return { ok: false, reason: `the allowed signers file ${allowedSigners} is not on this machine` };
+  const dir = import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "codetrellis-verify-"));
+  try {
+    const sig = import_node_path.default.join(dir, "approval.sig");
+    import_node_fs.default.writeFileSync(sig, signature, { mode: 384 });
+    (0, import_node_child_process.execFileSync)(SSH_KEYGEN, ["-Y", "verify", "-f", allowedSigners, "-I", signer, "-n", namespace, "-s", sig], {
+      input: text,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 15e3
+    });
+    return { ok: true };
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") return { ok: false, reason: "ssh-keygen is not installed, so the signature cannot be checked" };
+    const said = e.stderr?.toString().trim().split("\n").pop() ?? "";
+    return { ok: false, reason: `the signature does not verify for ${signer}${said ? ` (${said.slice(0, 160)})` : ""}` };
+  } finally {
+    import_node_fs.default.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function importApprovals(planDir, planUid, repo, lookup) {
+  const dir = import_node_path.default.join(planDir, "approvals");
+  let names;
+  try {
+    names = import_node_fs.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".yaml")).map((e) => e.name).slice(0, MAX_RECORDS);
+  } catch {
+    return { verified: 0, unverified: 0 };
+  }
+  const known = new Set(((0, import_database.getDb)().exec(
+    `SELECT uid FROM signed_approvals WHERE plan_uid = ? AND (origin = 'here' OR state = 'verified')`,
+    [planUid]
+  )[0]?.values ?? []).map((r) => r[0]));
+  const allowed = signingSetup(repo).allowedSigners;
+  let verified = 0;
+  let unverified = 0;
+  for (const name of names) {
+    const rel = import_node_path.default.join("approvals", name);
+    let content;
+    try {
+      content = (0, import_confined_fs.readTextWithin)(planDir, rel, "approval record");
+    } catch {
+      continue;
+    }
+    const parsed = (0, import_signed_approval_record.parseRecord)(content);
+    const uidFromName = name.slice(0, -".yaml".length);
+    if (known.has(uidFromName)) continue;
+    const at = parsed.ok ? Date.parse(parsed.statement.at) : Date.now();
+    const unverifiable = (reason, item, criterion, signer) => {
+      insertRow({ uid: uidFromName, planUid, itemUid: item, criterionUid: criterion, signer, origin: "file", state: "unverified", reason, at, file: rel });
+      unverified++;
+    };
+    if (!parsed.ok) {
+      unverifiable(parsed.reason, "", "", null);
+      continue;
+    }
+    const s = parsed.statement;
+    if (s.uid !== uidFromName) {
+      unverifiable("the file is named for another approval", s.itemUid, s.criterionUid, s.signer);
+      continue;
+    }
+    if (s.planUid !== planUid) {
+      unverifiable("the record is for another plan", s.itemUid, s.criterionUid, s.signer);
+      continue;
+    }
+    const c = lookup.criterion(s.criterionUid);
+    if (!c || c.itemUid !== s.itemUid || c.planUid !== planUid) {
+      unverifiable("the criterion it approves is not in this plan", s.itemUid, s.criterionUid, s.signer);
+      continue;
+    }
+    if ((0, import_signed_approval_record.sha256)(c.text) !== s.criterionSha256) {
+      unverifiable("the criterion has been reworded since it was approved", s.itemUid, s.criterionUid, s.signer);
+      continue;
+    }
+    const check = verifyRecord(parsed.text, parsed.signature, s.signer, allowed);
+    if (!check.ok) {
+      unverifiable(check.reason, s.itemUid, s.criterionUid, s.signer);
+      continue;
+    }
+    lookup.addSignoff({ uid: s.uid, criterionUid: s.criterionUid, actor: s.signer, evidence: s.evidence, at });
+    insertRow({ uid: s.uid, planUid, itemUid: s.itemUid, criterionUid: s.criterionUid, signer: s.signer, origin: "file", state: "verified", reason: null, at, file: rel });
+    verified++;
+  }
+  return { verified, unverified };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  importApprovals,
+  listSignedApprovals,
+  signApproval,
+  signingSetup,
+  verifyRecord
+});

package/src/backend/services/signoff-pack.js

@@ -0,0 +1,328 @@
+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 signoff_pack_exports = {};
+__export(signoff_pack_exports, {
+  PACK_FORMAT: () => PACK_FORMAT,
+  PACK_VERSION: () => PACK_VERSION,
+  PackError: () => PackError,
+  buildSignoffPack: () => buildSignoffPack,
+  esc: () => esc,
+  packFilesOf: () => packFilesOf,
+  packFromText: () => packFromText,
+  packSignals: () => packSignals,
+  packSkills: () => packSkills,
+  renderPackHtml: () => renderPackHtml,
+  scriptJson: () => scriptJson,
+  verifyPack: () => verifyPack
+});
+module.exports = __toCommonJS(signoff_pack_exports);
+var import_plan_service = require("./plan-service");
+var import_trusted_roots = require("./trusted-roots");
+var import_sha256_file = require("../lib/sha256-file");
+var import_signoff_rows = require("./signoff-rows");
+var import_plan_item_service = require("./plan-item-service");
+var import_skill_use_service = require("./skill-use-service");
+var import_signoff = require("../../shared/lib/signoff");
+var import_awareness_service = require("./awareness-service");
+var import_task_workstreams = require("./task-workstreams");
+var import_other_work = require("../../shared/lib/other-work");
+var import_signal_words = require("../../shared/lib/signal-words");
+var import_material_place = require("./material-place");
+const PACK_FORMAT = "codetrellis-signoff-pack";
+const PACK_VERSION = 1;
+function packSignals(planUid, projectPath) {
+  if (!projectPath) return [];
+  let signals;
+  try {
+    signals = (0, import_awareness_service.loadSignals)(projectPath).filter((s) => s.subject.material);
+  } catch {
+    return [];
+  }
+  if (signals.length === 0) return [];
+  const out = [];
+  for (const item of (0, import_plan_item_service.listAllItems)(planUid)) {
+    if (item.kind !== "action") continue;
+    const root = (0, import_task_workstreams.taskWorkstreamId)(item.uid);
+    const touched = signals.filter((s) => s.workstreams.includes(root));
+    if (touched.length === 0) continue;
+    const byId = new Map(touched.map((s) => [s.id, s]));
+    const label = (r) => touched.find((s) => s.subject.labels?.[r])?.subject.labels?.[r] ?? r;
+    for (const e of (0, import_other_work.otherWorkInFlight)({ root, name: item.title }, touched, label).entries) {
+      out.push({
+        itemUid: item.uid,
+        itemTitle: item.title,
+        signalId: e.signalId,
+        severity: e.severity,
+        heading: e.heading,
+        says: (0, import_signal_words.briefLine)(byId.get(e.signalId), root),
+        outcome: e.outcome,
+        outcomeWords: e.outcomeWords,
+        notes: e.notes
+      });
+    }
+  }
+  return out;
+}
+function packSkills(planUid) {
+  const out = [];
+  for (const item of (0, import_plan_item_service.listAllItems)(planUid)) {
+    if (item.kind !== "action") continue;
+    const wanted = (0, import_plan_item_service.resolveSkills)(item).filter((s) => s.required || s.use === "recommended");
+    if (wanted.length === 0) continue;
+    const proof = (0, import_skill_use_service.skillProof)(item, wanted);
+    const sources = (0, import_skill_use_service.skillUseSources)(item.uid);
+    for (const s of wanted) {
+      const p = proof?.get(s.name) ?? null;
+      out.push({
+        itemUid: item.uid,
+        itemTitle: item.title,
+        name: s.name,
+        use: s.required ? "required" : "recommended",
+        proof: p,
+        proofSource: p === "used" ? (0, import_skill_use_service.sourceOf)(sources, s.name) : null
+      });
+    }
+  }
+  return out;
+}
+function buildSignoffPack(planUid, now = /* @__PURE__ */ new Date()) {
+  const plan = (0, import_plan_service.getPlan)(planUid);
+  if (!plan) throw new Error(`Plan ${planUid} not found`);
+  const rows = (0, import_signoff_rows.signoffRows)(planUid);
+  const files = /* @__PURE__ */ new Map();
+  const claim = (path, sha256, takenAt) => {
+    if (!path || !sha256) return;
+    const key = `${path}\0${sha256}`;
+    if (!files.has(key)) files.set(key, { path, sha256, takenAt });
+  };
+  for (const r of rows) {
+    const approved = r.decision?.decision === "approved";
+    for (const e of r.evidence) {
+      const atApproval = approved && e.attachmentUid ? r.decision.evidenceHashes[e.attachmentUid] : void 0;
+      if (atApproval) claim(e.path, atApproval, "approval");
+      else claim(e.path, e.sha256AtSubmit, "submission");
+    }
+  }
+  return {
+    format: PACK_FORMAT,
+    version: PACK_VERSION,
+    plan: { uid: plan.uid, title: plan.title },
+    generatedAt: now.toISOString(),
+    rows,
+    files: [...files.values()].sort((a, b) => a.path.localeCompare(b.path)),
+    skills: packSkills(planUid),
+    signals: packSignals(planUid, plan.projectPath ?? null)
+  };
+}
+class PackError extends Error {
+}
+const SHA256 = /^[a-f0-9]{64}$/;
+const MAX_PACK_FILES = 5e3;
+function packFilesOf(raw) {
+  if (!raw || typeof raw !== "object") throw new PackError("That is not a sign-off pack");
+  const p = raw;
+  if (p.format !== PACK_FORMAT) throw new PackError("That is not a CodeTrellis sign-off pack");
+  if (p.version !== PACK_VERSION) throw new PackError(`This pack is version ${String(p.version)}; this app reads version ${PACK_VERSION}`);
+  if (!Array.isArray(p.files)) throw new PackError("The pack names no files");
+  if (p.files.length > MAX_PACK_FILES) throw new PackError(`The pack names more than ${MAX_PACK_FILES} files`);
+  return p.files.flatMap((f) => {
+    if (!f || typeof f !== "object") return [];
+    const { path, sha256, takenAt } = f;
+    if (typeof path !== "string" || !path || path.length > 1024 || typeof sha256 !== "string" || !SHA256.test(sha256)) return [];
+    return [{ path, sha256, takenAt: takenAt === "approval" ? "approval" : "submission" }];
+  });
+}
+async function verifyPack(planUid, raw, now = /* @__PURE__ */ new Date()) {
+  const files = packFilesOf(raw);
+  const packPlan = raw.plan?.uid;
+  if (packPlan !== planUid) throw new PackError("This pack is for a different plan \u2014 open that plan to verify it");
+  const plan = (0, import_plan_service.getPlan)(planUid);
+  if (!plan?.projectPath) throw new PackError("This plan is not associated with a project");
+  const root = (0, import_trusted_roots.resolveTrustedProjectRoot)(plan.projectPath, "plan.projectPath");
+  const results = [];
+  for (const f of files) {
+    let current = null;
+    try {
+      const at = (0, import_material_place.locateStored)(f.path, root);
+      if (!at) throw new Error("not placed on this device");
+      current = (await (0, import_sha256_file.sha256FileWithin)(at.root, at.rel)).sha256;
+    } catch {
+      current = null;
+    }
+    results.push({
+      path: f.path,
+      sha256: f.sha256,
+      now: current,
+      verdict: current === null ? "missing" : current === f.sha256 ? "matches" : "changed"
+    });
+  }
+  return {
+    planUid,
+    checkedAt: now.toISOString(),
+    files: results,
+    matches: results.filter((r) => r.verdict === "matches").length,
+    changed: results.filter((r) => r.verdict === "changed").length,
+    missing: results.filter((r) => r.verdict === "missing").length
+  };
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function scriptJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+const GLYPH = {
+  met: "\u2713",
+  submitted: "\u25D0",
+  sent_back: "\u21A9",
+  stale: "\u26A0",
+  open: "\u25CB"
+};
+function rowHtml(r) {
+  const evidence = r.evidence.length === 0 ? '<p class="muted">No evidence was offered.</p>' : `<ul class="evidence">${r.evidence.map((e) => `<li><span class="path">${esc(e.path ?? "note")}</span>${e.where ? ` \u2014 ${esc(e.where)}` : ""}${e.sha256AtSubmit ? `<br><code>sha256 ${esc(e.sha256AtSubmit)}</code>` : ""}</li>`).join("")}</ul>`;
+  const notes = [
+    r.submissionNote ? `<p><strong>${esc(r.submittedBy ?? "The agent")} said:</strong> ${esc(r.submissionNote)}</p>` : "",
+    r.decision?.note ? `<p><strong>Decision note:</strong> ${esc(r.decision.note)}</p>` : "",
+    r.changedFiles.length ? `<p class="warn">Changed since it was approved: ${esc(r.changedFiles.join(", "))}</p>` : ""
+  ].join("");
+  return `<section class="criterion">
+  <h3><span class="glyph">${GLYPH[r.state]}</span> ${esc(r.text)}</h3>
+  <p class="state">${esc((0, import_signoff.stateWords)(r))} \xB7 ${esc(r.kind)} \xB7 ${esc(r.policy === "agent" ? "the agent may approve" : r.policy === "propose" ? "the agent proposes, a person decides" : "a person decides")}</p>
+  <p class="decision">${esc((0, import_signoff.decisionWords)(r))}</p>
+  ${evidence}${notes}
+</section>`;
+}
+function groupByItem(rows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const g = groups.get(r.itemUid) ?? { title: r.itemTitle, ref: r.itemRef, rows: [] };
+    g.rows.push(r);
+    groups.set(r.itemUid, g);
+  }
+  return [...groups.values()];
+}
+function summaryApart(self, unverified) {
+  const parts = [
+    self ? `${self} of them by the agent's own checks` : "",
+    unverified ? `${unverified}${self ? "" : " of them"} unverified (local API)` : ""
+  ].filter(Boolean);
+  return parts.length ? ` \u2014 ${parts.join(" and ")}, listed separately` : "";
+}
+function renderPackHtml(pack) {
+  const unverifiedApproval = (r) => r.unverified && r.decision?.decision === "approved";
+  const byPerson = pack.rows.filter((r) => !r.selfApproved && !unverifiedApproval(r));
+  const selfApproved = pack.rows.filter((r) => r.selfApproved);
+  const unverified = pack.rows.filter(unverifiedApproval);
+  const met = pack.rows.filter((r) => r.state === "met").length;
+  const title = `Sign-off pack \u2014 ${pack.plan.title}`;
+  const sections = groupByItem(byPerson).map((g) => `<h2>${esc(g.title)} <span class="ref">${esc(g.ref)}</span></h2>
+${g.rows.map(rowHtml).join("\n")}`).join("\n");
+  const self = selfApproved.length === 0 ? "" : `
+<h2 class="self">Approved by the agent's own checks</h2>
+<p class="muted">These criteria were left to the agent (agent policy), and it approved them itself when it submitted. No person signed them.</p>
+${groupByItem(selfApproved).map((g) => `<h3 class="item">${esc(g.title)} <span class="ref">${esc(g.ref)}</span></h3>
+${g.rows.map(rowHtml).join("\n")}`).join("\n")}`;
+  const unverifiedSection = unverified.length === 0 ? "" : `
+<h2 class="self">Approved through the local API (unverified)</h2>
+<p class="muted">These approvals came over the local HTTP API with this machine's token, not from the CodeTrellis app or a paired phone. A person in a browser or a script holding the token could have made them; nothing records which.</p>
+${groupByItem(unverified).map((g) => `<h3 class="item">${esc(g.title)} <span class="ref">${esc(g.ref)}</span></h3>
+${g.rows.map(rowHtml).join("\n")}`).join("\n")}`;
+  const fileRows = pack.files.map((f) => `<tr><td class="path">${esc(f.path)}</td><td><code>${esc(f.sha256)}</code></td><td>${f.takenAt === "approval" ? "at approval" : "when offered"}</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>${esc(title)}</title>
+<style>
+  body { font: 13px/1.5 -apple-system, "Segoe UI", Helvetica, Arial, sans-serif; color: #111; max-width: 820px; 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; }
+  h2.self { color: #7a4d00; }
+  h3 { font-size: 14px; margin: 0 0 2px; }
+  h3.item { margin-top: 16px; }
+  .ref, .muted, .state { color: #666; font-weight: normal; font-size: 12px; }
+  .criterion { border: 1px solid #e3e3e3; border-radius: 6px; padding: 10px 12px; margin: 8px 0; break-inside: avoid; }
+  .decision { margin: 2px 0 6px; }
+  .glyph { display: inline-block; width: 1.2em; }
+  .evidence { margin: 4px 0; padding-left: 18px; }
+  .path { font-family: ui-monospace, Menlo, Consolas, monospace; }
+  code { font: 11px ui-monospace, Menlo, Consolas, monospace; color: #444; word-break: break-all; }
+  .warn { color: #8a5a00; }
+  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; }
+  .summary { margin: 8px 0 0; color: #333; }
+</style>
+</head>
+<body>
+<h1>${esc(title)}</h1>
+<p class="muted">Generated ${esc(pack.generatedAt.replace("T", " ").slice(0, 16))} UTC by CodeTrellis \xB7 plan ${esc(pack.plan.uid)}</p>
+${pack.seal ? `<p class="muted" id="seal">Signed by the computer with key <code>${esc(pack.seal.key)}</code>, with its record at entry #${esc(String(pack.sealedRecord?.seq ?? 0))} (<code>${esc((pack.sealedRecord?.hash ?? "").slice(0, 16))}\u2026</code>). Verify it in CodeTrellis: a changed byte, or a changed record, shows.</p>` : ""}
+<p class="summary">${met} of ${pack.rows.length} criteria met${summaryApart(selfApproved.length, unverified.length)}.</p>
+${sections || (pack.rows.length ? "" : '<p class="muted">This plan has no acceptance criteria.</p>')}
+${unverifiedSection}
+${self}
+${skillsSection(pack.skills ?? [])}
+${signalsSection(pack.signals ?? [])}
+<h2>Files and hashes</h2>
+<p class="muted">Every file this pack vouches for, with the sha256 it had when it was judged. "Verify a pack" in CodeTrellis re-hashes each one and says which still match.</p>
+<table><thead><tr><th>File</th><th>sha256</th><th>Taken</th></tr></thead><tbody>${fileRows || '<tr><td colspan="3" class="muted">No files.</td></tr>'}</tbody></table>
+<script type="application/json" id="codetrellis-signoff-pack">${scriptJson(pack)}</script>
+</body>
+</html>
+`;
+}
+function signalsSection(signals) {
+  if (signals.length === 0) return "";
+  const rows = signals.map((s) => `<tr><td>${esc(s.itemTitle)}</td><td><b>${esc(s.heading)}</b> <span class="muted">${esc(s.severity)}</span><br>${esc(s.says)}${s.notes.map((n) => `<br><span class="muted">${esc(n)}</span>`).join("")}</td><td>${esc(s.outcomeWords)}</td></tr>`).join("");
+  return `
+<h2>Other work that touched these tasks</h2>
+<p class="muted">Files these tasks shared with other tasks that changed, versions they disagreed on, or outputs two tasks wrote, and how each ended.</p>
+<table><thead><tr><th>Task</th><th>What happened</th><th>How it ended</th></tr></thead><tbody>${rows}</tbody></table>`;
+}
+function skillsSection(skills) {
+  if (skills.length === 0) return "";
+  const words = (p, src) => p === "used" ? `\u2713 used${src === "mcp" ? " (read through CodeTrellis)" : src === "session_log" ? " (Claude Code session log)" : ""}` : p === "not_used" ? "\u25CB not used" : p === "unknown" ? "unknown (nothing seen: the agent may have read the file itself)" : "not started";
+  const rows = skills.map((s) => `<tr><td>${esc(s.itemTitle)}</td><td>${esc(s.name)}</td><td>${s.use}</td><td>${esc(words(s.proof, s.proofSource))}</td></tr>`).join("");
+  return `
+<h2>Skills</h2>
+<p class="muted">The skills each task asked the agent to use, and whether the agent loaded them: from Claude Code's session log, or from the agent reading it through CodeTrellis (any client). Unknown means nothing was seen.</p>
+<table><thead><tr><th>Task</th><th>Skill</th><th>Asked as</th><th>Used</th></tr></thead><tbody>${rows}</tbody></table>`;
+}
+function packFromText(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{")) return JSON.parse(trimmed);
+  const m = trimmed.match(/<script type="application\/json" id="codetrellis-signoff-pack">([\s\S]*?)<\/script>/);
+  if (!m) throw new PackError("No sign-off pack data in that file");
+  return JSON.parse(m[1]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PACK_FORMAT,
+  PACK_VERSION,
+  PackError,
+  buildSignoffPack,
+  esc,
+  packFilesOf,
+  packFromText,
+  packSignals,
+  packSkills,
+  renderPackHtml,
+  scriptJson,
+  verifyPack
+});