codetrellis 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,114 @@
+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_rows_exports = {};
+__export(signoff_rows_exports, {
+  criteriaWarnings: () => criteriaWarnings,
+  renderCriteriaTable: () => renderCriteriaTable,
+  rowsForCriterion: () => rowsForCriterion,
+  signoffRows: () => signoffRows
+});
+module.exports = __toCommonJS(signoff_rows_exports);
+var import_plan_item_service = require("./plan-item-service");
+var import_criteria_service = require("./criteria-service");
+var import_artefact_service = require("./artefact-service");
+var import_locator = require("../../shared/lib/locator");
+var import_references = require("../../shared/lib/references");
+var import_signoff = require("../../shared/lib/signoff");
+function refOf(item) {
+  return (0, import_references.formatReference)(item.kind === "object" ? "page" : "task", item.uid);
+}
+function rowsForCriterion(item, c) {
+  const evidence = c.latestSubmission.map((e) => {
+    const artefact = e.attachmentUid ? (0, import_artefact_service.getArtefact)(e.attachmentUid) : null;
+    return {
+      path: artefact?.path ?? null,
+      locator: e.locator,
+      where: (0, import_locator.describeLocator)(e.locator),
+      sha256AtSubmit: e.sha256AtSubmit,
+      sha256Now: artefact?.sha256 ?? null,
+      attachmentUid: e.attachmentUid
+    };
+  });
+  const s = c.latestSignoff;
+  const recorded = s?.evidenceHashes ?? {};
+  const changedFiles = c.state === "stale" ? Object.keys(recorded).filter((uid) => ((0, import_artefact_service.getArtefact)(uid)?.sha256 ?? null) !== recorded[uid]).map((uid) => (0, import_artefact_service.getArtefact)(uid)?.path ?? uid) : [];
+  return {
+    itemUid: item.uid,
+    itemTitle: item.title,
+    itemRef: refOf(item),
+    criterionUid: c.uid,
+    text: c.text,
+    kind: c.kind,
+    policy: c.policy,
+    state: c.state,
+    evidence,
+    submissionNote: c.latestSubmission.find((e) => e.note)?.note ?? null,
+    submittedBy: c.latestSubmission[0]?.submittedBy ?? null,
+    decision: s ? {
+      decision: s.decision,
+      actor: s.actor,
+      actorType: s.actorType,
+      channel: s.channel,
+      note: s.note,
+      at: s.createdAt,
+      evidenceHashes: recorded,
+      device: s.device ?? null
+    } : null,
+    selfApproved: !!s && s.decision === "approved" && s.actorType !== "human" && s.actorType !== "unverified",
+    unverified: !!s && s.actorType === "unverified",
+    changedFiles
+  };
+}
+function signoffRows(planUid) {
+  return (0, import_plan_item_service.listAllItems)(planUid).flatMap((item) => (0, import_criteria_service.listCriteria)(item.uid).map((c) => rowsForCriterion(item, c)));
+}
+function cell(text) {
+  return text.replace(/\r?\n+/g, " ").replace(/\|/g, "\\|").replace(/`/g, "'").trim() || "\u2014";
+}
+function renderCriteriaTable(rows) {
+  if (rows.length === 0) return "";
+  const lines = [
+    "## Acceptance criteria",
+    "",
+    "| Task | Criterion | State | Evidence | Signed |",
+    "|---|---|---|---|---|",
+    ...rows.map((r) => `| ${cell(r.itemTitle)} | ${cell(r.text)} | ${cell((0, import_signoff.stateWords)(r))} | ${cell((0, import_signoff.evidenceWords)(r))} | ${cell((0, import_signoff.decisionWords)(r))} |`)
+  ];
+  const self = rows.filter((r) => r.selfApproved);
+  if (self.length > 0) {
+    lines.push("", `_${self.length} of these ${self.length === 1 ? "was" : "were"} approved by the agent's own checks (agent policy), not by a person._`);
+  }
+  const unverified = rows.filter((r) => r.unverified && r.decision?.decision === "approved");
+  if (unverified.length > 0) {
+    lines.push("", `_${unverified.length} of these ${unverified.length === 1 ? "was" : "were"} approved through the local API, not from the CodeTrellis app or a paired phone, so it is not verified that a person approved ${unverified.length === 1 ? "it" : "them"}._`);
+  }
+  return lines.join("\n");
+}
+function criteriaWarnings(rows) {
+  return rows.filter((r) => r.state !== "met").map((r) => {
+    const why = r.state === "stale" && r.changedFiles.length ? `changed since approved (${r.changedFiles.join(", ")})` : (0, import_signoff.stateWords)(r);
+    return `"${r.text}" on ${r.itemTitle} is ${why}.`;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  criteriaWarnings,
+  renderCriteriaTable,
+  rowsForCriterion,
+  signoffRows
+});

package/src/backend/services/skill-arrival-service.js

@@ -0,0 +1,138 @@
+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 skill_arrival_service_exports = {};
+__export(skill_arrival_service_exports, {
+  acceptArrival: () => acceptArrival,
+  lastCommitOf: () => lastCommitOf,
+  noteArrivals: () => noteArrivals,
+  pendingArrivals: () => pendingArrivals,
+  planArrivals: () => planArrivals
+});
+module.exports = __toCommonJS(skill_arrival_service_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var import_database = require("./database");
+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]])));
+}
+const wanted = (s) => s.required || s.use === "recommended";
+function lastCommitOf(file) {
+  const run = (args) => (0, import_node_child_process.execFileSync)("git", ["-C", import_node_path.default.dirname(file), ...args], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 5e3
+  }).trim();
+  try {
+    const name = import_node_path.default.basename(file);
+    if (run(["status", "--porcelain", "--", name])) return { addedBy: null, commit: null };
+    const [addedBy, commit] = run(["log", "-1", "--format=%an%x1f%h", "--", name]).split("");
+    return commit ? { addedBy: addedBy || null, commit } : { addedBy: null, commit: null };
+  } catch {
+    return { addedBy: null, commit: null };
+  }
+}
+function noteArrivals(input) {
+  completeArrivals(input.itemUid, input.file);
+  const had = new Set(input.before.filter(wanted).map((s) => s.name));
+  const arrived = input.after.filter((s) => wanted(s) && !had.has(s.name)).map((s) => s.name);
+  if (arrived.length === 0) return [];
+  const pending = pendingArrivals(input.itemUid);
+  const fresh = arrived.filter((n) => !pending.has(n));
+  if (fresh.length === 0) return [];
+  const { addedBy, commit } = lastCommitOf(input.file);
+  const at = input.now ?? Date.now();
+  try {
+    for (const skill of fresh) {
+      (0, import_database.getDb)().run(
+        "INSERT INTO skill_arrivals (item_uid, skill, added_by, commit_sha, arrived_at) VALUES (?, ?, ?, ?, ?)",
+        [input.itemUid, skill, addedBy, commit, at]
+      );
+    }
+  } catch {
+    return [];
+  }
+  return fresh;
+}
+function completeArrivals(itemUid, file) {
+  if (![...pendingArrivals(itemUid).values()].some((a) => !a.commit)) return;
+  const { addedBy, commit } = lastCommitOf(file);
+  if (!commit) return;
+  (0, import_database.getDb)().run(
+    "UPDATE skill_arrivals SET added_by = ?, commit_sha = ? WHERE item_uid = ? AND accepted_at IS NULL AND commit_sha IS NULL",
+    [addedBy, commit, itemUid]
+  );
+}
+function pendingArrivals(itemUid) {
+  try {
+    const rows = rowsOf(
+      "SELECT skill, added_by, commit_sha, arrived_at FROM skill_arrivals WHERE item_uid = ? AND accepted_at IS NULL ORDER BY arrived_at",
+      [itemUid]
+    );
+    return new Map(rows.map((r) => [r.skill, { itemUid, skill: r.skill, addedBy: r.added_by, commit: r.commit_sha, arrivedAt: Number(r.arrived_at) }]));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function planArrivals(planUid) {
+  try {
+    const rows = rowsOf(
+      `SELECT a.item_uid, i.title, i.skills, a.skill, a.added_by, a.commit_sha, a.arrived_at
+         FROM skill_arrivals a JOIN plan_items i ON i.uid = a.item_uid
+        WHERE i.plan_uid = ? AND a.accepted_at IS NULL ORDER BY a.arrived_at`,
+      [planUid]
+    );
+    return rows.filter((r) => {
+      try {
+        return JSON.parse(r.skills ?? "[]").some((s) => s.name === r.skill);
+      } catch {
+        return false;
+      }
+    }).map((r) => ({ itemUid: r.item_uid, itemTitle: r.title, skill: r.skill, addedBy: r.added_by, commit: r.commit_sha, arrivedAt: Number(r.arrived_at) }));
+  } catch {
+    return [];
+  }
+}
+function acceptArrival(input) {
+  if (!pendingArrivals(input.itemUid).has(input.skill)) return false;
+  (0, import_database.getDb)().run(
+    "UPDATE skill_arrivals SET accepted_at = ?, accepted_by = ?, accepted_by_type = ? WHERE item_uid = ? AND skill = ? AND accepted_at IS NULL",
+    [input.now ?? Date.now(), input.by, input.byType, input.itemUid, input.skill]
+  );
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  acceptArrival,
+  lastCommitOf,
+  noteArrivals,
+  pendingArrivals,
+  planArrivals
+});

package/src/backend/services/skill-model.js

@@ -0,0 +1,193 @@
+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 skill_model_exports = {};
+__export(skill_model_exports, {
+  MAX_SKILLS: () => MAX_SKILLS,
+  MAX_SKILL_NAME: () => MAX_SKILL_NAME,
+  MAX_SKILL_WHY: () => MAX_SKILL_WHY,
+  SKILL_SOURCES: () => SKILL_SOURCES,
+  agentView: () => agentView,
+  normaliseLocation: () => normaliseLocation,
+  normaliseRepoPath: () => normaliseRepoPath,
+  normaliseSkill: () => normaliseSkill,
+  normaliseSkills: () => normaliseSkills,
+  withoutLinks: () => withoutLinks
+});
+module.exports = __toCommonJS(skill_model_exports);
+const SKILL_SOURCES = ["mcp", "skill", "lang", "plugin"];
+const MAX_SKILLS = 30;
+const MAX_SKILL_NAME = 80;
+const MAX_SKILL_WHY = 200;
+const MAX_REPO_PATH = 300;
+const MAX_URL = 500;
+const NAME_RE = /^[^\u0000-\u001f\u007f`]+$/;
+const IDENT_RE = /^[A-Za-z0-9][A-Za-z0-9._@/:+-]{0,99}$/;
+const UID_RE = /^[A-Za-z0-9_-]{1,100}$/;
+function oneLine(s) {
+  return s.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function normaliseRepoPath(raw) {
+  if (typeof raw !== "string") return null;
+  let p = raw.trim();
+  if (!p || p.length > MAX_REPO_PATH || p.includes("\0") || p.includes("\\")) return null;
+  if (p.startsWith("/") || /^[A-Za-z]:/.test(p) || p.startsWith("~")) return null;
+  p = p.replace(/^\.\/+/, "").replace(/\/+$/, "").replace(/\/{2,}/g, "/");
+  const parts = p.split("/");
+  if (parts.some((x) => x === ".." || x === "." || x === "")) return null;
+  if (!/\.md$/i.test(p)) p = `${p}/SKILL.md`;
+  return p;
+}
+function normaliseLocation(raw) {
+  if (raw === void 0 || raw === null) return { where: null, problem: null };
+  const r = raw;
+  switch (r?.kind) {
+    case "repo": {
+      const path = normaliseRepoPath(r.path);
+      return path ? { where: { kind: "repo", path }, problem: null } : { where: null, problem: "a repo location must be a relative path inside the project" };
+    }
+    case "plugin":
+      return typeof r.name === "string" && IDENT_RE.test(r.name) ? { where: { kind: "plugin", name: r.name }, problem: null } : { where: null, problem: "a plugin location needs a plugin name" };
+    case "mcp":
+      return typeof r.server === "string" && IDENT_RE.test(r.server) ? { where: { kind: "mcp", server: r.server }, problem: null } : { where: null, problem: "an mcp location needs a server name" };
+    case "playbook":
+      return typeof r.uid === "string" && UID_RE.test(r.uid) ? { where: { kind: "playbook", uid: r.uid }, problem: null } : { where: null, problem: "a playbook location needs a playbook id" };
+    case "link": {
+      if (typeof r.url !== "string" || r.url.length > MAX_URL) return { where: null, problem: "a link needs an http(s) URL" };
+      try {
+        const u = new URL(r.url);
+        if (u.protocol !== "https:" && u.protocol !== "http:") throw new Error("protocol");
+        return { where: { kind: "link", url: u.toString() }, problem: null };
+      } catch {
+        return { where: null, problem: "a link needs an http(s) URL" };
+      }
+    }
+    default:
+      return { where: null, problem: "a location is one of repo, plugin, mcp, playbook or link" };
+  }
+}
+function normaliseSkill(raw) {
+  const problems = [];
+  const r = raw ?? {};
+  const name = typeof r.name === "string" ? oneLine(r.name) : "";
+  if (!name || name.length > MAX_SKILL_NAME || !NAME_RE.test(name)) {
+    return { skill: null, problems: [`a skill needs a name of at most ${MAX_SKILL_NAME} characters, on one line, without backticks`] };
+  }
+  if (r.source !== void 0 && r.source !== null && !SKILL_SOURCES.includes(r.source)) {
+    return { skill: null, problems: [`skill "${name}": source must be one of ${SKILL_SOURCES.join(", ")}`] };
+  }
+  const source = r.source ?? "skill";
+  const skill = { name, source, required: r.required === true };
+  if (r.use !== void 0 && r.use !== null) {
+    if (r.use === "recommended") skill.use = "recommended";
+    else problems.push(`skill "${name}": use can only be "recommended"`);
+  }
+  if (r.why !== void 0 && r.why !== null) {
+    const why = typeof r.why === "string" ? oneLine(r.why) : "";
+    if (typeof r.why !== "string") problems.push(`skill "${name}": why must be text`);
+    else if (why.length > MAX_SKILL_WHY) problems.push(`skill "${name}": why is at most ${MAX_SKILL_WHY} characters`);
+    if (why) skill.why = why.slice(0, MAX_SKILL_WHY);
+  }
+  const { where, problem } = normaliseLocation(r.where);
+  if (problem) problems.push(`skill "${name}": ${problem}`);
+  if (where) skill.where = where;
+  return { skill, problems };
+}
+function normaliseSkills(raw) {
+  if (raw === void 0 || raw === null) return { skills: [], problems: [] };
+  if (!Array.isArray(raw)) return { skills: [], problems: ["skills must be a list"] };
+  const problems = [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of raw) {
+    const { skill, problems: p } = normaliseSkill(entry);
+    problems.push(...p);
+    if (!skill) continue;
+    if (seen.has(skill.name)) {
+      problems.push(`skill "${skill.name}" is listed twice`);
+      continue;
+    }
+    if (out.length >= MAX_SKILLS) {
+      problems.push(`at most ${MAX_SKILLS} skills`);
+      break;
+    }
+    seen.add(skill.name);
+    out.push(skill);
+  }
+  return { skills: out, problems };
+}
+function withoutLinks(value, depth = 0, hide) {
+  if (depth > 6 || value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    let changed = false;
+    const out = value.map((v) => {
+      const w = withoutLinks(v, depth + 1, hide);
+      if (w !== v) changed = true;
+      return w;
+    });
+    return changed ? out : value;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype) return value;
+  let copy = null;
+  const rawUid = value.uid;
+  const ownerUid = typeof rawUid === "string" ? rawUid : null;
+  for (const [k, v] of Object.entries(value)) {
+    let w = v;
+    if (k === "skills" && Array.isArray(v)) {
+      const shown = hide && ownerUid ? v.filter((s) => !hide(ownerUid, s?.name)) : v;
+      w = shown.some((s) => s?.where?.kind === "link") ? shown.map((s) => {
+        if (s?.where?.kind !== "link") return s;
+        const { where: _link, ...rest } = s;
+        return rest;
+      }) : shown.length === v.length ? v : shown;
+    } else {
+      w = withoutLinks(v, depth + 1, hide);
+    }
+    if (w !== v) {
+      copy ??= { ...value };
+      copy[k] = w;
+    }
+  }
+  return copy ?? value;
+}
+function agentView(mod, hide) {
+  const out = {};
+  for (const [k, v] of Object.entries(mod)) {
+    if (typeof v === "function" && !/^class[\s{]/.test(Function.prototype.toString.call(v))) {
+      out[k] = (...args) => {
+        const r = v(...args);
+        return r instanceof Promise ? r.then((x) => withoutLinks(x, 0, hide)) : withoutLinks(r, 0, hide);
+      };
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_SKILLS,
+  MAX_SKILL_NAME,
+  MAX_SKILL_WHY,
+  SKILL_SOURCES,
+  agentView,
+  normaliseLocation,
+  normaliseRepoPath,
+  normaliseSkill,
+  normaliseSkills,
+  withoutLinks
+});

package/src/backend/services/skill-use-service.js

@@ -0,0 +1,140 @@
+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 skill_use_service_exports = {};
+__export(skill_use_service_exports, {
+  isClaudeCode: () => isClaudeCode,
+  recordSkillRead: () => recordSkillRead,
+  recordSkillUse: () => recordSkillUse,
+  skillProof: () => skillProof,
+  skillUseSources: () => skillUseSources,
+  skillUsesOf: () => skillUsesOf,
+  sourceOf: () => sourceOf
+});
+module.exports = __toCommonJS(skill_use_service_exports);
+var import_database = require("./database");
+const MAX_SKILL = 80;
+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 isClaudeCode(agentType) {
+  return !!agentType && /^claude(-code)?\b/i.test(agentType) && !/desktop/i.test(agentType);
+}
+function recordSkillUse(input) {
+  const skill = input.skill.replace(/[\u0000-\u001f\u007f]+/g, " ").trim().slice(0, MAX_SKILL);
+  if (!skill || !input.workstreamRoot) return [];
+  try {
+    const items = rowsOf(
+      `SELECT i.uid, s.agent_type FROM plan_items i JOIN agent_sessions s ON s.session_id = i.assignee_session
+        WHERE s.workstream_root = ? AND i.status IN ('assigned', 'in_progress')`,
+      [input.workstreamRoot]
+    ).filter((r) => isClaudeCode(r.agent_type)).map((r) => r.uid);
+    const at = input.at ?? Date.now();
+    for (const uid of items) {
+      (0, import_database.getDb)().run(
+        "INSERT INTO skill_uses (item_uid, skill, session_id, workstream_root, at, source) VALUES (?, ?, ?, ?, ?, ?)",
+        [uid, skill, input.sessionId, input.workstreamRoot, at, "session_log"]
+      );
+    }
+    return items;
+  } catch {
+    return [];
+  }
+}
+function recordSkillRead(input) {
+  const skill = input.skill.replace(/[\u0000-\u001f\u007f]+/g, " ").trim().slice(0, MAX_SKILL);
+  if (!skill) return [];
+  try {
+    const items = rowsOf(
+      `SELECT uid FROM plan_items WHERE assignee_session = ? AND status IN ('assigned', 'in_progress')`,
+      [input.sessionId]
+    ).map((r) => r.uid);
+    const at = input.at ?? Date.now();
+    for (const uid of items) {
+      (0, import_database.getDb)().run(
+        "INSERT INTO skill_uses (item_uid, skill, session_id, workstream_root, at, source) VALUES (?, ?, ?, ?, ?, ?)",
+        [uid, skill, input.sessionId, input.workstreamRoot, at, "mcp"]
+      );
+    }
+    return items;
+  } catch {
+    return [];
+  }
+}
+function sourceOf(sources, name) {
+  if (sources.has(name)) return sources.get(name);
+  for (const [k, v] of sources) if (k.endsWith(`:${name}`)) return v;
+  return null;
+}
+function skillUseSources(itemUid) {
+  try {
+    const rows = rowsOf("SELECT skill, source FROM skill_uses WHERE item_uid = ? ORDER BY at", [itemUid]);
+    const out = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const src = r.source === "mcp" ? "mcp" : "session_log";
+      if (!out.has(r.skill)) out.set(r.skill, src);
+    }
+    return out;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function skillUsesOf(itemUid) {
+  try {
+    const rows = rowsOf("SELECT skill, MIN(at) AS at FROM skill_uses WHERE item_uid = ? GROUP BY skill", [itemUid]);
+    return new Map(rows.map((r) => [r.skill, Number(r.at)]));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function assigneeAgentType(item) {
+  try {
+    const row = rowsOf(
+      `SELECT i.assignee_session AS session, s.agent_type FROM plan_items i LEFT JOIN agent_sessions s ON s.session_id = i.assignee_session WHERE i.uid = ?`,
+      [item.uid]
+    )[0];
+    if (!row?.session) return void 0;
+    return row.agent_type;
+  } catch {
+    return void 0;
+  }
+}
+function skillProof(item, skills) {
+  const uses = skillUsesOf(item.uid);
+  const agentType = assigneeAgentType(item);
+  if (agentType === void 0 && uses.size === 0) return null;
+  const out = /* @__PURE__ */ new Map();
+  for (const s of skills) {
+    if (!s.required && s.use !== "recommended") continue;
+    const used = uses.has(s.name) || [...uses.keys()].some((k) => k.endsWith(`:${s.name}`));
+    out.set(s.name, used ? "used" : isClaudeCode(agentType) ? "not_used" : "unknown");
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isClaudeCode,
+  recordSkillRead,
+  recordSkillUse,
+  skillProof,
+  skillUseSources,
+  skillUsesOf,
+  sourceOf
+});