codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/coalesce.js

@@ -0,0 +1,50 @@
+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 coalesce_exports = {};
+__export(coalesce_exports, {
+  coalesced: () => coalesced
+});
+module.exports = __toCommonJS(coalesce_exports);
+function coalesced(run) {
+  const state = /* @__PURE__ */ new Map();
+  const call = (key) => {
+    let s = state.get(key);
+    if (!s) state.set(key, s = { running: null, next: null });
+    const slot = s;
+    if (!slot.running) {
+      const started = (async () => run(key))();
+      slot.running = started;
+      started.then(() => {
+        if (slot.running === started) slot.running = null;
+      }, () => {
+        if (slot.running === started) slot.running = null;
+      });
+      return started;
+    }
+    slot.next ??= slot.running.then(() => void 0, () => void 0).then(() => {
+      slot.next = null;
+      return call(key);
+    });
+    return slot.next;
+  };
+  return Object.assign(call, { running: (key) => state.get(key)?.running ?? null });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  coalesced
+});

package/src/backend/services/code-breakpoints.js

@@ -0,0 +1,291 @@
+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 code_breakpoints_exports = {};
+__export(code_breakpoints_exports, {
+  BREAKPOINT_MARKER: () => BREAKPOINT_MARKER,
+  HOOK_AGENT: () => HOOK_AGENT,
+  breachNoticeFor: () => breachNoticeFor,
+  breachText: () => breachText,
+  codeBreakpoints: () => codeBreakpoints,
+  codeSubject: () => codeSubject,
+  editTouches: () => editTouches,
+  editView: () => editView,
+  enforceEdit: () => enforceEdit,
+  functionOf: () => functionOf,
+  heldEditText: () => heldEditText,
+  nameMatches: () => nameMatches,
+  recordBreaches: () => recordBreaches,
+  resetBreachNotices: () => resetBreachNotices,
+  symbolRanges: () => symbolRanges,
+  untoldBreaches: () => untoldBreaches
+});
+module.exports = __toCommonJS(code_breakpoints_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_agent_event_log = require("./agent-event-log");
+var import_session_service = require("./session-service");
+var import_workstream_service = require("./workstream-service");
+var import_breakpoint_service = require("./breakpoint-service");
+var import_push_notification_service = require("./push-notification-service");
+const HOOK_AGENT = "claude-code-hook";
+function codeBreakpoints(projectRoot) {
+  return (0, import_breakpoint_service.rowsOf)(`${import_breakpoint_service.ACTIVE_SELECT} AND b.kind = 'code' AND b.project_root = ? ORDER BY b.created_at`, [projectRoot]).map(import_breakpoint_service.toBreakpointRow);
+}
+function functionOf(target) {
+  const i = target.indexOf("#");
+  return i === -1 ? null : target.slice(i + 1) || null;
+}
+const QUALIFIED = /[.#)]/;
+const lastPart = (name) => name.split(/[.#)]/).filter(Boolean).pop() ?? name;
+function nameMatches(symbol, wanted) {
+  if (symbol === wanted) return true;
+  return !QUALIFIED.test(wanted) && lastPart(symbol) === wanted;
+}
+function symbolRanges(symbols) {
+  const out = [];
+  const visit = (list, parent) => {
+    for (const s of list) {
+      const name = parent && !QUALIFIED.test(s.name) ? `${parent}.${s.name}` : s.name;
+      out.push({ name, start: s.startLine, end: s.endLine });
+      if (s.children?.length) visit(s.children, name);
+    }
+  };
+  visit(symbols, null);
+  return out;
+}
+function lineAt(content, offset) {
+  let n = 1;
+  for (let i = 0; i < offset && i < content.length; i++) if (content.charCodeAt(i) === 10) n++;
+  return n;
+}
+function editTouches(content, oldTexts, ranges, name) {
+  const targets = ranges.filter((r) => nameMatches(r.name, name));
+  if (!targets.length || !oldTexts?.length) return null;
+  for (const text of oldTexts) {
+    if (!text) return null;
+    let at = content.indexOf(text);
+    if (at === -1) return null;
+    while (at !== -1) {
+      const start = lineAt(content, at);
+      const end = lineAt(content, at + text.length - 1);
+      if (targets.some((r) => start <= r.end && end >= r.start)) return true;
+      at = content.indexOf(text, at + 1);
+    }
+  }
+  return false;
+}
+function touchesFunction(workstreamRoot, file, name, oldTexts) {
+  if (!oldTexts?.length) return null;
+  const parse = (0, import_workstream_service.getSymbolParser)();
+  const abs = insideFolder(workstreamRoot, file);
+  if (!parse || !abs) return null;
+  let content;
+  try {
+    content = import_node_fs.default.readFileSync(abs, "utf-8");
+  } catch {
+    return null;
+  }
+  const symbols = parse(file, content);
+  if (!symbols) return null;
+  return editTouches(content, oldTexts, symbolRanges(symbols), name);
+}
+function relOf(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
+function newHit(input) {
+  const ref = `bp-${(0, import_node_crypto.randomBytes)(5).toString("hex")}`;
+  (0, import_database.getDb)().run(
+    `INSERT INTO breakpoint_hits (ref, breakpoint_id, tool, action, item_uid, path, breach, plan_uid, agent, session_id, workstream_root, hit_at)
+     VALUES (?, ?, ?, ?, '', ?, ?, NULL, ?, ?, ?, ?)`,
+    [ref, input.bp.id, input.tool, input.action, input.file, input.breach ? 1 : 0, input.caller.agent, input.caller.sessionId, input.caller.workstreamRoot, input.now]
+  );
+  const hit = (0, import_breakpoint_service.getHit)(ref);
+  (0, import_agent_event_log.recordBreakpointEvent)("breakpoint_hit", { ...(0, import_breakpoint_service.hitPayload)(hit), breakpointId: input.bp.id, on: input.bp.target }, input.caller.agent);
+  void (0, import_push_notification_service.pushForBreakpoint)(hit).catch(() => {
+  });
+  return hit;
+}
+function enforceEdit(projectRoot, rawFile, caller, now = Date.now(), oldTexts) {
+  if (!caller.workstreamRoot) return { kind: "pass" };
+  const file = relOf(rawFile);
+  let continued = null;
+  try {
+    for (const bp of codeBreakpoints(projectRoot).filter((b) => (0, import_breakpoint_service.codeCovers)(b.target, file))) {
+      const fn = functionOf(bp.target);
+      if (fn && touchesFunction(caller.workstreamRoot, file, fn, oldTexts) === false) continue;
+      const latest = (0, import_breakpoint_service.rowsOf)(
+        `${import_breakpoint_service.HIT_SELECT} WHERE h.breakpoint_id = ? AND h.path = ? AND h.workstream_root = ? AND h.action = 'edit_code' ORDER BY h.hit_at DESC LIMIT 1`,
+        [bp.id, file, caller.workstreamRoot]
+      ).map(import_breakpoint_service.toHitRow)[0];
+      if (!latest) return { kind: "paused", hit: newHit({ bp, tool: "check_breakpoint", action: "edit_code", file, caller, breach: false, now }), fresh: true };
+      if (latest.answeredAt === null) return { kind: "paused", hit: latest, fresh: false };
+      if (latest.decision === "stop") return { kind: "stop", hit: latest };
+      const untold = (0, import_breakpoint_service.rowsOf)("SELECT consumed_at FROM breakpoint_hits WHERE ref = ?", [latest.ref])[0]?.consumed_at === null;
+      if (untold) (0, import_database.getDb)().run("UPDATE breakpoint_hits SET consumed_at = ? WHERE ref = ?", [now, latest.ref]);
+      continued = { hit: latest, steer: untold ? latest.note : null };
+    }
+  } catch {
+    return { kind: "pass" };
+  }
+  return continued ? { kind: "continue", ...continued } : { kind: "pass" };
+}
+function insideFolder(folder, file) {
+  try {
+    const base = import_node_fs.default.realpathSync.native(folder);
+    const real = import_node_fs.default.realpathSync.native(import_node_path.default.join(folder, file));
+    return real === base || real.startsWith(base + import_node_path.default.sep) ? real : null;
+  } catch {
+    return null;
+  }
+}
+function recordBreaches(projectRoot, caller, changed, now = Date.now(), mtimeOf = (abs) => {
+  try {
+    return import_node_fs.default.statSync(abs).mtimeMs;
+  } catch {
+    return null;
+  }
+}) {
+  if (!caller.workstreamRoot || caller.agent === HOOK_AGENT) return [];
+  const bps = codeBreakpoints(projectRoot);
+  if (!bps.length) return [];
+  const out = [];
+  for (const change of changed) {
+    if (change.status === "deleted") continue;
+    const file = relOf(change.path);
+    for (const bp of bps.filter((b) => (0, import_breakpoint_service.codeCovers)(b.target, file))) {
+      const fn = functionOf(bp.target);
+      if (fn && Array.isArray(change.symbols) && !change.symbols.some((x) => nameMatches(x.name, fn))) continue;
+      const known = (0, import_breakpoint_service.rowsOf)(
+        `SELECT COUNT(*) AS n FROM breakpoint_hits WHERE breakpoint_id = ? AND path = ? AND workstream_root = ?
+           AND (breach = 1 OR (action = 'edit_code' AND decision IN ('continue', 'steer')))`,
+        [bp.id, file, caller.workstreamRoot]
+      )[0];
+      if (Number(known?.n) > 0) continue;
+      const abs = insideFolder(caller.workstreamRoot, file);
+      const mtime = abs ? mtimeOf(abs) : null;
+      if (mtime === null || mtime <= bp.createdAt) continue;
+      out.push(newHit({ bp, tool: "edit", action: "breach", file, caller, breach: true, now }));
+    }
+  }
+  return out;
+}
+const told = /* @__PURE__ */ new Map();
+function untoldBreaches(workstreamRoot, sessionId) {
+  const waiting = (0, import_breakpoint_service.rowsOf)(`${import_breakpoint_service.HIT_SELECT} WHERE h.breach = 1 AND h.workstream_root = ? AND h.answered_at IS NULL ORDER BY h.hit_at`, [workstreamRoot]).map(import_breakpoint_service.toHitRow);
+  const fresh = waiting.filter((h) => !told.get(h.ref)?.has(sessionId));
+  for (const h of fresh) told.set(h.ref, (told.get(h.ref) ?? /* @__PURE__ */ new Set()).add(sessionId));
+  return fresh;
+}
+function resetBreachNotices() {
+  told.clear();
+}
+const BREAKPOINT_MARKER = "\u2500\u2500 CodeTrellis breakpoint \u2500\u2500";
+function codeSubject(hit) {
+  const fn = hit.breakpointTarget ? functionOf(hit.breakpointTarget) : null;
+  return fn ? `${fn} in ${hit.path}` : String(hit.path);
+}
+function breachText(hits) {
+  return [
+    BREAKPOINT_MARKER,
+    ...hits.map((h) => `You changed ${codeSubject(h)}, which has a breakpoint: a person asked to be asked before it changes. CodeTrellis could not pause your editor, so this is recorded as a breach. Stop changing it and call await_decision with ref "${h.ref}" for their answer.` + (h.breakpointNote ? ` Their note on the breakpoint: ${h.breakpointNote}` : "")),
+    "This is the person's request, not information about other work."
+  ].join("\n");
+}
+async function breachNoticeFor(sessionId, projectRoot) {
+  if (!projectRoot) return null;
+  try {
+    const session = (0, import_session_service.getActiveSessions)().find((s) => s.sessionId === sessionId);
+    if (!session?.workstreamRoot || session.agentType === HOOK_AGENT) return null;
+    if (!codeBreakpoints(projectRoot).length) return null;
+    const canon = (p) => {
+      try {
+        return import_node_fs.default.realpathSync.native(p);
+      } catch {
+        return import_node_path.default.resolve(p);
+      }
+    };
+    const mine = canon(session.workstreamRoot);
+    const w = (await (0, import_workstream_service.listWorkstreams)(projectRoot, { fresh: true })).find((x) => canon(x.root) === mine);
+    const caller = { agent: session.agentType ?? "mcp-agent", sessionId, workstreamRoot: session.workstreamRoot };
+    if (w) recordBreaches(projectRoot, caller, w.changes.files);
+    const hits = untoldBreaches(session.workstreamRoot, sessionId);
+    return hits.length ? breachText(hits) : null;
+  } catch (err) {
+    console.warn("[Breakpoints] breach check failed:", err instanceof Error ? err.message : err);
+    return null;
+  }
+}
+function heldEditText(result) {
+  const h = result.hit;
+  const on = h.breakpointNote ? ` Their note: ${h.breakpointNote}` : "";
+  if (result.kind === "stop") {
+    return [
+      BREAKPOINT_MARKER,
+      `A person answered the breakpoint on ${codeSubject(h)}: stop. The edit was not made. Do not change ${codeSubject(h)}.${h.note ? ` Their answer: ${h.note}` : ""}`,
+      "Tell the person what you will do instead."
+    ].join("\n");
+  }
+  return [
+    BREAKPOINT_MARKER,
+    `paused: waiting for a decision. A person set a breakpoint and wants to be asked before ${codeSubject(h)} changes.${on} The edit was not made.`,
+    `Call the CodeTrellis await_decision tool with ref "${h.ref}", and call it again while it says it is still waiting (this can take a long time; do not work around it). If they answer continue, make the edit again.`
+  ].join("\n");
+}
+function editView(result) {
+  switch (result.kind) {
+    case "pass":
+      return { status: "pass" };
+    case "continue":
+      return { status: "continue", ref: result.hit.ref, steer: result.steer };
+    case "stop":
+      return { status: "stop", ref: result.hit.ref, message: heldEditText(result) };
+    case "paused":
+      return { status: "paused", ref: result.hit.ref, message: heldEditText(result) };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BREAKPOINT_MARKER,
+  HOOK_AGENT,
+  breachNoticeFor,
+  breachText,
+  codeBreakpoints,
+  codeSubject,
+  editTouches,
+  editView,
+  enforceEdit,
+  functionOf,
+  heldEditText,
+  nameMatches,
+  recordBreaches,
+  resetBreachNotices,
+  symbolRanges,
+  untoldBreaches
+});

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

@@ -0,0 +1,168 @@
+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 comment_service_exports = {};
+__export(comment_service_exports, {
+  addComment: () => addComment,
+  deleteComment: () => deleteComment,
+  getComments: () => getComments,
+  listCommentsFlat: () => listCommentsFlat,
+  listCommentsForPlanSince: () => listCommentsForPlanSince,
+  listItemComments: () => listItemComments
+});
+module.exports = __toCommonJS(comment_service_exports);
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+function inferSource(authorType, explicit) {
+  if (explicit) return explicit;
+  return authorType === "human" || authorType === "unverified" ? "human" : "agent";
+}
+function addComment(targetType, targetUid, author, authorType, body, commentTypeOrOpts = "comment", parentUidLegacy) {
+  const opts = typeof commentTypeOrOpts === "string" ? { commentType: commentTypeOrOpts, parentUid: parentUidLegacy } : commentTypeOrOpts;
+  const uid = (0, import_node_crypto.randomUUID)();
+  const now = Date.now();
+  const commentType = opts.commentType ?? "comment";
+  const kind = opts.kind ?? null;
+  const source = inferSource(authorType, opts.source);
+  const metadataJson = opts.metadata ? JSON.stringify(opts.metadata) : null;
+  (0, import_database.getDb)().run(
+    `INSERT INTO comments (uid, target_type, target_uid, parent_uid, author, author_type, body, comment_type, kind, source, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [uid, targetType, targetUid, opts.parentUid || null, author, authorType, body, commentType, kind, source, metadataJson, now]
+  );
+  (0, import_persistence.markDirty)();
+  return {
+    uid,
+    targetType,
+    targetUid,
+    parentUid: opts.parentUid || null,
+    author,
+    authorType,
+    body,
+    commentType,
+    kind: kind ?? void 0,
+    source,
+    metadata: opts.metadata,
+    createdAt: now
+  };
+}
+function rowToComment(r) {
+  let metadata;
+  try {
+    metadata = r[10] ? JSON.parse(r[10]) : void 0;
+  } catch {
+    metadata = void 0;
+  }
+  return {
+    uid: r[0],
+    targetType: r[1],
+    targetUid: r[2],
+    parentUid: r[3],
+    author: r[4],
+    authorType: r[5],
+    body: r[6],
+    commentType: r[7],
+    kind: r[8] ?? void 0,
+    source: r[9] ?? void 0,
+    metadata,
+    createdAt: r[11]
+  };
+}
+const COMMENT_COLUMNS = `uid, target_type, target_uid, parent_uid, author, author_type, body, comment_type, kind, source, metadata, created_at`;
+function deleteComment(uid) {
+  const db = (0, import_database.getDb)();
+  const before = db.exec(`SELECT uid FROM comments WHERE uid = ?`, [uid]);
+  if (!before[0]?.values[0]) return false;
+  db.run(`DELETE FROM comments WHERE uid = ?`, [uid]);
+  (0, import_persistence.markDirty)();
+  return true;
+}
+function getComments(targetUid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT ${COMMENT_COLUMNS}
+     FROM comments WHERE target_uid = ? ORDER BY created_at ASC`,
+    [targetUid]
+  );
+  if (!result[0]) return [];
+  const all = result[0].values.map((r) => ({
+    ...rowToComment(r),
+    replies: []
+  }));
+  const topLevel = [];
+  const byUid = /* @__PURE__ */ new Map();
+  for (const c of all) {
+    byUid.set(c.uid, c);
+  }
+  for (const c of all) {
+    if (c.parentUid && byUid.has(c.parentUid)) {
+      byUid.get(c.parentUid).replies.push(c);
+    } else {
+      topLevel.push(c);
+    }
+  }
+  return topLevel;
+}
+function listCommentsFlat(targetUid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT ${COMMENT_COLUMNS}
+     FROM comments WHERE target_uid = ? ORDER BY created_at ASC`,
+    [targetUid]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((r) => rowToComment(r));
+}
+function listItemComments(itemUid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT ${COMMENT_COLUMNS}
+     FROM comments
+     WHERE target_uid = ? AND target_type IN ('item', 'task')
+     ORDER BY created_at ASC`,
+    [itemUid]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((r) => rowToComment(r));
+}
+function listCommentsForPlanSince(planUid, since) {
+  const db = (0, import_database.getDb)();
+  const itemRows = db.exec(`SELECT uid FROM plan_items WHERE plan_uid = ?`, [planUid]);
+  let targetUids = (itemRows[0]?.values ?? []).map((r) => r[0]);
+  if (targetUids.length === 0) {
+    const taskRows = db.exec(`SELECT uid FROM tasks WHERE plan_uid = ?`, [planUid]);
+    targetUids = (taskRows[0]?.values ?? []).map((r) => r[0]);
+  }
+  if (targetUids.length === 0) return [];
+  const placeholders = targetUids.map(() => "?").join(", ");
+  const result = db.exec(
+    `SELECT ${COMMENT_COLUMNS}
+     FROM comments
+     WHERE target_uid IN (${placeholders}) AND created_at > ?
+     ORDER BY created_at ASC`,
+    [...targetUids, since]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((r) => rowToComment(r));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addComment,
+  deleteComment,
+  getComments,
+  listCommentsFlat,
+  listCommentsForPlanSince,
+  listItemComments
+});

package/src/backend/services/commit-attribution.js

@@ -0,0 +1,134 @@
+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 commit_attribution_exports = {};
+__export(commit_attribution_exports, {
+  NO_KNOWLEDGE: () => NO_KNOWLEDGE,
+  agentFromMessage: () => agentFromMessage,
+  attributeCommits: () => attributeCommits,
+  isProjectRelativePath: () => isProjectRelativePath,
+  recordedKnowledge: () => recordedKnowledge
+});
+module.exports = __toCommonJS(commit_attribution_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_database = require("./database");
+var import_replay_frames = require("./replay-frames");
+const NO_KNOWLEDGE = { seenBy: () => /* @__PURE__ */ new Map(), sessionAt: () => null, taskOf: () => null };
+const AGENT_NAMES = /\b(claude|codex|copilot|cursor|gemini|aider|devin|windsurf|amp)\b/i;
+function agentFromMessage(body) {
+  const line = body.match(/^agent:\s*(\S+)/m);
+  if (line) return { agent: line[1], how: "commit message", words: `${line[1]}, from the commit message` };
+  for (const m of body.matchAll(/^Co-Authored-By:\s*([^<\n]+?)\s*<[^>\n]*>\s*$/gim)) {
+    const name = m[1].match(AGENT_NAMES);
+    if (name) {
+      const agent = name[1].toLowerCase();
+      return { agent, how: "commit message", words: `${agent}, from the commit's Co-Authored-By trailer (${m[1].trim()})` };
+    }
+  }
+  return null;
+}
+const basename = (p) => p.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? p;
+function attributeCommits(rows, checkoutRoot, know = NO_KNOWLEDGE) {
+  const out = /* @__PURE__ */ new Map();
+  const seen = know.seenBy(rows.map((r) => r.sha));
+  for (const r of rows) {
+    const frame = seen.get(r.sha);
+    const fromMessage = agentFromMessage(r.body);
+    let a = fromMessage ? { ...fromMessage, sessionId: frame?.sessionId ?? null } : null;
+    if (!a && frame?.agentType) {
+      a = {
+        agent: frame.agentType,
+        how: "seen",
+        sessionId: frame.sessionId,
+        words: `${frame.agentType}, seen: it landed while CodeTrellis recorded ${frame.agentType}'s session${frame.workstreamRoot ? ` in ${basename(frame.workstreamRoot)}` : ""}`
+      };
+    }
+    if (!a && checkoutRoot) {
+      const open = know.sessionAt(checkoutRoot, r.at);
+      if (open) {
+        a = {
+          agent: open.agentType,
+          how: "timing",
+          sessionId: open.sessionId,
+          words: `probably ${open.agentType}: committed while ${open.agentType}'s session was open in this checkout`
+        };
+      }
+    }
+    if (!a) continue;
+    if (a.sessionId) {
+      const t = know.taskOf(a.sessionId);
+      if (t) {
+        a.task = t.task;
+        a.plan = t.plan;
+      }
+    }
+    out.set(r.sha, a);
+  }
+  return out;
+}
+const SESSION_GRACE_MS = 10 * 6e4;
+const trim = (p) => p.replace(/[\\/]+$/, "");
+function recordedKnowledge(projectPath) {
+  return {
+    seenBy: (shas) => (0, import_replay_frames.framesByCommit)(projectPath, shas),
+    sessionAt: (checkoutRoot, at) => {
+      const spelled = trim(checkoutRoot);
+      let real = spelled;
+      try {
+        real = import_node_fs.default.realpathSync.native(spelled);
+      } catch {
+      }
+      const row = (0, import_database.getDb)().exec(
+        `SELECT session_id, agent_type FROM agent_sessions
+         WHERE workstream_root IN (?, ?) AND connected_at <= ? AND last_seen + ? >= ?
+         ORDER BY connected_at DESC LIMIT 1`,
+        // A commit's time is whole seconds: one made in the second the session started is in it.
+        [spelled, real, at + 999, SESSION_GRACE_MS, at]
+      )[0]?.values?.[0];
+      return row ? { sessionId: String(row[0]), agentType: String(row[1]) } : null;
+    },
+    taskOf: (sessionId) => {
+      const row = (0, import_database.getDb)().exec(
+        `SELECT i.uid, i.title, p.uid, p.title FROM plan_items i JOIN plans p ON p.uid = i.plan_uid
+         WHERE i.assignee_session = ? ORDER BY i.rowid DESC LIMIT 1`,
+        [sessionId]
+      )[0]?.values?.[0];
+      return row ? { task: { uid: String(row[0]), title: String(row[1]) }, plan: { uid: String(row[2]), title: String(row[3]) } } : null;
+    }
+  };
+}
+function isProjectRelativePath(rel) {
+  return typeof rel === "string" && rel.length > 0 && !rel.startsWith("-") && !rel.startsWith(":") && !rel.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(rel) && !rel.split(/[\\/]/).includes("..");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NO_KNOWLEDGE,
+  agentFromMessage,
+  attributeCommits,
+  isProjectRelativePath,
+  recordedKnowledge
+});