codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/awareness-replies.js

@@ -0,0 +1,194 @@
+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 awareness_replies_exports = {};
+__export(awareness_replies_exports, {
+  MAX_REPLY: () => MAX_REPLY,
+  cleanReply: () => cleanReply,
+  recordReply: () => recordReply,
+  repliesFor: () => repliesFor,
+  replyNoticeFor: () => replyNoticeFor,
+  replyText: () => replyText,
+  setReplyReadListener: () => setReplyReadListener,
+  tasksHeldIn: () => tasksHeldIn,
+  withReplies: () => withReplies
+});
+module.exports = __toCommonJS(awareness_replies_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_awareness_service = require("./awareness-service");
+var import_session_service = require("./session-service");
+const MAX_REPLY = 1e3;
+function cleanReply(message) {
+  if (typeof message !== "string") return null;
+  const m = message.trim();
+  return m && m.length <= MAX_REPLY ? m : null;
+}
+function canon(p) {
+  try {
+    return import_node_fs.default.realpathSync.native(p);
+  } catch {
+    return p;
+  }
+}
+function sessionsIn(workstreams) {
+  const roots = new Set(workstreams.map(canon));
+  return (0, import_session_service.getActiveSessions)().filter((s) => s.workstreamRoot && roots.has(canon(s.workstreamRoot))).map((s) => ({ sessionId: s.sessionId, agentType: s.agentType }));
+}
+function recordReply(projectRoot, signalId, message, by, now = Date.now()) {
+  const signal = (0, import_awareness_service.loadSignals)(projectRoot).find((s) => s.id === signalId && s.state !== "resolved");
+  if (!signal) return null;
+  const db = (0, import_database.getDb)();
+  db.run(
+    `INSERT INTO awareness_signal_replies (signal_id, project_root, message, actor, actor_type, channel, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [signalId, projectRoot, message, by.actor, by.actorType, by.channel, now]
+  );
+  const id = Number(db.exec("SELECT last_insert_rowid()")[0]?.values[0]?.[0] ?? 0);
+  (0, import_persistence.markDirty)();
+  return { signal, reply: { id, message, by, at: now, readBy: [] }, tasks: tasksHeldIn(signal.workstreams) };
+}
+function tasksHeldIn(workstreams) {
+  const sessions = sessionsIn(workstreams).map((s) => s.sessionId);
+  if (sessions.length === 0) return [];
+  const res = (0, import_database.getDb)().exec(
+    `SELECT plan_uid, uid FROM plan_items
+      WHERE assignee_session IN (${sessions.map(() => "?").join(",")})
+        AND status IN ('assigned', 'in_progress')
+      ORDER BY plan_uid, uid`,
+    sessions
+  );
+  return (res[0]?.values ?? []).map(([planUid, itemUid]) => ({ planUid, itemUid }));
+}
+function repliesFor(signalIds) {
+  const out = /* @__PURE__ */ new Map();
+  if (signalIds.length === 0) return out;
+  const db = (0, import_database.getDb)();
+  const res = db.exec(
+    `SELECT id, signal_id, message, actor, actor_type, channel, created_at FROM awareness_signal_replies
+      WHERE signal_id IN (${signalIds.map(() => "?").join(",")}) ORDER BY created_at, id`,
+    [...signalIds]
+  );
+  const byId = /* @__PURE__ */ new Map();
+  for (const [id, signalId, message, actor, actorType, channel, at] of res[0]?.values ?? []) {
+    const reply = {
+      id,
+      message,
+      by: { actor, actorType, channel },
+      at,
+      readBy: []
+    };
+    byId.set(reply.id, reply);
+    const list = out.get(signalId) ?? [];
+    list.push(reply);
+    out.set(signalId, list);
+  }
+  if (byId.size > 0) {
+    const reads = db.exec(
+      `SELECT reply_id, session_id, agent_type, read_at FROM awareness_signal_reply_reads
+        WHERE reply_id IN (${[...byId.keys()].map(() => "?").join(",")}) ORDER BY read_at`,
+      [...byId.keys()]
+    );
+    for (const [replyId, sessionId, agentType, readAt] of reads[0]?.values ?? []) {
+      byId.get(replyId)?.readBy.push({ sessionId, agentType, readAt });
+    }
+  }
+  return out;
+}
+function withReplies(signals) {
+  const replies = repliesFor(signals.map((s) => s.id));
+  return signals.map((s) => replies.has(s.id) ? { ...s, replies: replies.get(s.id) } : s);
+}
+function sender(by) {
+  if (by.actorType === "unverified") return "sent through the local API, not verified as the person";
+  return by.channel === "phone" ? "the person, from their phone" : "the person, from the CodeTrellis window";
+}
+function replyText(items) {
+  const lines = ["\u2500\u2500 CodeTrellis: a message about other work \u2500\u2500"];
+  for (const { signal, reply } of items) {
+    lines.push(`About ${signal.severity} ${signal.kind} ${signal.id}: ${signal.summary}`);
+    lines.push(`From ${sender(reply.by)}:`);
+    lines.push(...reply.message.split("\n").map((l) => `> ${l}`));
+  }
+  lines.push("Answer with acknowledge_signal(id, note) to say what you will do.");
+  return lines.join("\n");
+}
+function replyNoticeFor(sessionId, projectRoot, now = Date.now()) {
+  if (!projectRoot) return null;
+  try {
+    const session = (0, import_session_service.getActiveSessions)().find((s) => s.sessionId === sessionId);
+    if (!session?.workstreamRoot) return null;
+    const mine = canon(session.workstreamRoot);
+    const signals = (0, import_awareness_service.loadSignals)(projectRoot).filter((s) => s.workstreams.some((w) => canon(w) === mine));
+    if (signals.length === 0) return null;
+    const db = (0, import_database.getDb)();
+    const res = db.exec(
+      `SELECT r.id, r.signal_id, r.message, r.actor, r.actor_type, r.channel FROM awareness_signal_replies r
+        WHERE r.project_root = ? AND r.signal_id IN (${signals.map(() => "?").join(",")})
+          AND NOT EXISTS (SELECT 1 FROM awareness_signal_reply_reads d WHERE d.reply_id = r.id AND d.session_id = ?)
+        ORDER BY r.created_at, r.id`,
+      [projectRoot, ...signals.map((s) => s.id), sessionId]
+    );
+    const rows = res[0]?.values ?? [];
+    if (rows.length === 0) return null;
+    const byId = new Map(signals.map((s) => [s.id, s]));
+    const items = rows.map(([, signalId, message, actor, actorType, channel]) => ({
+      signal: byId.get(signalId),
+      reply: { message, by: { actor, actorType, channel } }
+    }));
+    for (const [id] of rows) {
+      db.run(
+        "INSERT OR IGNORE INTO awareness_signal_reply_reads (reply_id, session_id, agent_type, read_at) VALUES (?, ?, ?, ?)",
+        [id, sessionId, session.agentType, now]
+      );
+    }
+    (0, import_persistence.markDirty)();
+    onRead(projectRoot);
+    return replyText(items);
+  } catch (err) {
+    console.warn("[Awareness] reply delivery failed:", err instanceof Error ? err.message : err);
+    return null;
+  }
+}
+let onRead = () => {
+};
+function setReplyReadListener(listener) {
+  onRead = listener;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_REPLY,
+  cleanReply,
+  recordReply,
+  repliesFor,
+  replyNoticeFor,
+  replyText,
+  setReplyReadListener,
+  tasksHeldIn,
+  withReplies
+});

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

@@ -0,0 +1,344 @@
+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 awareness_service_exports = {};
+__export(awareness_service_exports, {
+  contractsOf: () => contractsOf,
+  countNeedsYou: () => countNeedsYou,
+  declaredFiles: () => declaredFiles,
+  filesDefining: () => filesDefining,
+  footprintsOf: () => footprintsOf,
+  listSignals: () => listSignals,
+  loadSignals: () => loadSignals,
+  mainChangesSince: () => mainChangesSince,
+  refreshSignals: () => refreshSignals,
+  refreshSignalsSoon: () => refreshSignalsSoon,
+  scopeOf: () => scopeOf,
+  setAwarenessListener: () => setAwarenessListener,
+  setSignalState: () => setSignalState
+});
+module.exports = __toCommonJS(awareness_service_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_database = require("./database");
+var import_agent_event_log = require("./agent-event-log");
+var import_persistence = require("./persistence");
+var import_git_safety = require("./git-safety");
+var import_git_env = require("./git-env");
+var import_coalesce = require("./coalesce");
+var import_workstream_service = require("./workstream-service");
+var import_importers = require("./importers");
+var import_intent_service = require("./intent-service");
+var import_awareness_signals = require("./awareness-signals");
+var import_push_notification_service = require("./push-notification-service");
+var import_material_signals = require("./material-signals");
+var import_material_footprints = require("./material-footprints");
+var import_split_signals = require("./task-records/split-signals");
+var import_architecture_rules = require("./architecture-rules");
+var import_architecture_rule = require("./architecture-rule");
+var import_workstream_imports = require("./workstream-imports");
+const SHA = /^[0-9a-f]{40}$/;
+async function mainChangesSince(folder, base, mainRef) {
+  if (!base || !SHA.test(base) || !mainRef || !(0, import_git_safety.isSafeGitRef)(mainRef)) return [];
+  try {
+    return (await (0, import_git_env.gitAsync)(folder, ["diff", "--name-only", "-z", base, mainRef, "--"])).split("\0").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function rowToSignal(r) {
+  return {
+    id: r[0],
+    kind: r[1],
+    severity: r[2],
+    subject: JSON.parse(r[3]),
+    workstreams: JSON.parse(r[4]),
+    summary: r[5],
+    firstSeen: r[6],
+    lastSeen: r[7],
+    state: r[8],
+    ...r[9] ? { stateBy: JSON.parse(r[9]) } : {},
+    ...r[10] != null ? { stateAt: r[10] } : {},
+    ...r[11] ? { shape: r[11] } : {},
+    ...r[12] ? { reopened: { from: r[12], at: r[13] } } : {}
+  };
+}
+const COLUMNS = "id, kind, severity, subject, workstreams, summary, first_seen, last_seen, state";
+const READ_COLUMNS = `${COLUMNS}, state_by, state_at, shape, reopened_from, reopened_at`;
+function loadSignals(projectRoot) {
+  const res = (0, import_database.getDb)().exec(`SELECT ${READ_COLUMNS} FROM awareness_signals WHERE project_root = ?`, [projectRoot]);
+  return (res[0]?.values ?? []).map(rowToSignal);
+}
+let onChanged = () => {
+};
+function setAwarenessListener(listener) {
+  onChanged = listener;
+}
+function contractsOf(projectRoot, w) {
+  return (0, import_awareness_signals.contractCandidates)(w.changes.files).map((c) => ({
+    ...c,
+    importers: (0, import_importers.importersOf)(import_node_path.default.join(projectRoot, c.file), [(0, import_awareness_signals.importableName)(c.symbol)]).map((i) => ({ path: i.relativePath, possibly: i.possibly }))
+  }));
+}
+async function footprintsOf(all, projectRoot) {
+  const main = all.find((w) => w.main);
+  const mainRef = main?.branch ?? main?.head ?? null;
+  const out = [];
+  for (const w of all.filter((x) => !x.idle)) {
+    out.push({
+      root: w.root,
+      branch: w.branch,
+      main: w.main,
+      files: w.changes.files,
+      // A branch workstream has no folder of its own: git runs in the main checkout.
+      mainSinceBase: w.main ? [] : await mainChangesSince(w.shape === "branch" && main ? main.root : w.root, w.changes.base, mainRef),
+      ...projectRoot ? { contracts: contractsOf(projectRoot, w) } : {},
+      ...w.intents?.length ? { intended: declaredFiles(w.intents) } : {},
+      ...scopeEntry(scopeOf(w)),
+      ...projectRoot ? await ruleEntry(projectRoot, w, main?.root ?? null) : {},
+      ...projectRoot && scopeOf(w) ? rulesAboutEntry(projectRoot) : {}
+    });
+  }
+  return out;
+}
+async function ruleEntry(projectRoot, w, mainRoot) {
+  const rules = (0, import_architecture_rules.rulesOf)(projectRoot);
+  if (rules.length === 0 || w.changes.files.length === 0) return {};
+  if (!(0, import_workstream_imports.importsReadableFor)(projectRoot)) return {};
+  const breaches = (0, import_architecture_rules.checkEdges)(rules, await (0, import_workstream_imports.importsAdded)(projectRoot, w, mainRoot, { packages: true, symbols: rules.some((r) => r.kind === "symbol"), calls: rules.some((r) => r.kind === "calls"), files: rules.some((r) => r.kind === "folder"), grep: rules.filter((r) => r.kind === "grep" && r.strength !== "guide") }));
+  if (breaches.length === 0) return {};
+  return {
+    ruleBreaches: rules.map((rule) => ({ rule, edges: breaches.filter((b) => b.rule === rule.id).map((b) => ({ from: b.from, to: b.to })) })).filter((r) => r.edges.length > 0)
+  };
+}
+const scopeEntry = (scope) => scope ? { scope } : {};
+function rulesAboutEntry(projectRoot) {
+  const rules = (0, import_architecture_rules.rulesOf)(projectRoot);
+  if (rules.length === 0) return {};
+  return { rules: rules.map((r) => ({ id: r.id, suite: r.suite, words: (0, import_architecture_rule.ruleStatement)(r), strength: r.strength, kind: r.kind, from: r.from, mayNotImport: r.mayNotImport, only: r.only, ...r.in ? { in: r.in, except: r.except } : {} })) };
+}
+function scopeOf(w) {
+  const sessions = w.agents.map((a) => a.sessionId);
+  const paths = /* @__PURE__ */ new Set();
+  const dirs = /* @__PURE__ */ new Set();
+  const items = [];
+  if (sessions.length) {
+    const res = (0, import_database.getDb)().exec(
+      `SELECT uid, file_specs, scope_path FROM plan_items
+        WHERE assignee_session IN (${sessions.map(() => "?").join(",")})
+          AND COALESCE(status, '') NOT IN ('done', 'skipped')`,
+      sessions
+    );
+    for (const [uid, specsJson, scopePath] of res[0]?.values ?? []) {
+      let specs = [];
+      try {
+        specs = JSON.parse(specsJson || "[]");
+      } catch {
+      }
+      const before = paths.size + dirs.size;
+      for (const s of specs) {
+        const clean = (p) => p.replace(/^\.\//, "");
+        (s.isDir ? dirs : paths).add(clean(s.path));
+        if (s.moveTo) paths.add(clean(s.moveTo));
+      }
+      if (typeof scopePath === "string" && scopePath.trim()) dirs.add(scopePath.trim().replace(/^\.\//, ""));
+      if (paths.size + dirs.size > before) items.push(uid);
+    }
+  }
+  const declared = declaredFiles(w.intents ?? []);
+  for (const f of declared) paths.add(f.path);
+  if (paths.size === 0 && dirs.size === 0) return null;
+  return { paths: [...paths].sort(), dirs: [...dirs].sort(), items, declared: declared.length > 0 };
+}
+function filesDefining(projectRoot, name, limit = 5) {
+  const root = projectRoot.endsWith(import_node_path.default.sep) ? projectRoot : projectRoot + import_node_path.default.sep;
+  const res = (0, import_database.getDb)().exec(
+    `SELECT DISTINCT f.relative_path FROM symbols s JOIN files f ON s.file_id = f.id
+      WHERE s.name = ? AND substr(f.path, 1, ?) = ? ORDER BY f.relative_path LIMIT ?`,
+    [name, root.length, root, limit]
+  );
+  return (res[0]?.values ?? []).map((r) => r[0]);
+}
+function declaredFiles(intents) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const i of intents) {
+    for (const f of (0, import_intent_service.intentFiles)(i)) {
+      const set = merged.get(f.path) ?? /* @__PURE__ */ new Set();
+      f.symbols.forEach((s) => set.add(s));
+      merged.set(f.path, set);
+    }
+  }
+  return [...merged].map(([p, s]) => ({ path: p, symbols: [...s].sort() })).sort((a, b) => a.path.localeCompare(b.path));
+}
+function recordSignalSpans(projectRoot, previous, upserts, resolved, now) {
+  const db = (0, import_database.getDb)();
+  const before = new Map(previous.map((s) => [s.id, s]));
+  for (const s of upserts) {
+    const open = db.exec("SELECT opened_at FROM awareness_signal_spans WHERE signal_id = ? AND closed_at IS NULL", [s.id])[0]?.values[0];
+    if (open) {
+      db.run(
+        "UPDATE awareness_signal_spans SET severity = ?, summary = ?, workstreams = ? WHERE signal_id = ? AND opened_at = ?",
+        [s.severity, s.summary, JSON.stringify(s.workstreams), s.id, open[0]]
+      );
+      continue;
+    }
+    const cameBack = before.get(s.id)?.state === "resolved";
+    db.run(
+      `INSERT OR IGNORE INTO awareness_signal_spans (signal_id, project_root, kind, severity, summary, workstreams, opened_at, closed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, NULL)`,
+      [s.id, projectRoot, s.kind, s.severity, s.summary, JSON.stringify(s.workstreams), cameBack ? now : s.firstSeen]
+    );
+  }
+  for (const id of resolved) {
+    db.run("UPDATE awareness_signal_spans SET closed_at = ? WHERE signal_id = ? AND closed_at IS NULL", [now, id]);
+  }
+}
+const refreshes = (0, import_coalesce.coalesced)((projectRoot) => runRefresh(projectRoot));
+function refreshSignals(projectRoot) {
+  return refreshes(projectRoot);
+}
+function refreshSignalsSoon(projectRoot) {
+  (refreshes.running(projectRoot) ?? refreshes(projectRoot)).catch((err) => console.warn("[Awareness] refresh failed:", err));
+}
+async function runRefresh(projectRoot) {
+  const footprints = await footprintsOf(await (0, import_workstream_service.listWorkstreams)(projectRoot, { includeIdle: true, fresh: true }), projectRoot);
+  const materials = (0, import_material_footprints.materialInputsOf)(projectRoot);
+  const drafts = [
+    ...(0, import_awareness_signals.computeSignals)(footprints),
+    ...(0, import_material_signals.computeMaterialSignals)(materials.tasks, materials.current),
+    // Teammates' records that set a task two ways at once (C3.2).
+    ...(0, import_split_signals.stateSplitDrafts)(projectRoot)
+  ];
+  const now = Date.now();
+  const previous = loadSignals(projectRoot);
+  const { upserts, resolved, reopened } = (0, import_awareness_signals.reconcileSignals)(previous, drafts, now);
+  if (upserts.length === 0 && resolved.length === 0) return false;
+  const db = (0, import_database.getDb)();
+  for (const s of upserts) {
+    db.run(
+      `INSERT INTO awareness_signals (${COLUMNS}, project_root, resolved_at, shape, reopened_from, reopened_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         severity = excluded.severity, subject = excluded.subject, workstreams = excluded.workstreams,
+         summary = excluded.summary, last_seen = excluded.last_seen, resolved_at = NULL, shape = excluded.shape,
+         -- Set when it reopens (A3.2); kept until the person answers again.
+         reopened_from = COALESCE(excluded.reopened_from, awareness_signals.reopened_from),
+         reopened_at = COALESCE(excluded.reopened_at, awareness_signals.reopened_at),
+         -- A signal that resolved and came back is open again: whoever
+         -- answered it before answered a different occurrence.
+         state_by = CASE WHEN awareness_signals.state = excluded.state THEN awareness_signals.state_by END,
+         state_at = CASE WHEN awareness_signals.state = excluded.state THEN awareness_signals.state_at END,
+         state = excluded.state`,
+      [
+        s.id,
+        s.kind,
+        s.severity,
+        JSON.stringify(s.subject),
+        JSON.stringify(s.workstreams),
+        s.summary,
+        s.firstSeen,
+        s.lastSeen,
+        s.state,
+        projectRoot,
+        s.shape ?? null,
+        s.reopened?.from ?? null,
+        s.reopened?.at ?? null
+      ]
+    );
+  }
+  for (const id of reopened) {
+    db.run("UPDATE awareness_signal_notes SET told_at = NULL WHERE signal_id = ?", [id]);
+  }
+  for (const id of resolved) {
+    db.run(`UPDATE awareness_signals SET state = 'resolved', resolved_at = ?, last_seen = ? WHERE id = ?`, [now, now, id]);
+  }
+  recordSignalSpans(projectRoot, previous, upserts, resolved, now);
+  (0, import_persistence.markDirty)();
+  onChanged(projectRoot);
+  for (const s of (0, import_awareness_signals.newlySerious)(previous, upserts, reopened)) void (0, import_push_notification_service.pushForSignal)(s).catch(() => {
+  });
+  return true;
+}
+function countNeedsYou(projectRoot) {
+  const res = (0, import_database.getDb)().exec(
+    `SELECT COUNT(*) FROM awareness_signals WHERE project_root = ? AND state = 'open' AND severity IN ('high', 'medium')`,
+    [projectRoot]
+  );
+  return Number(res[0]?.values[0]?.[0] ?? 0);
+}
+const RANK = { high: 0, medium: 1, low: 2 };
+function listSignals(projectRoot, opts = {}) {
+  const canon = (p) => {
+    try {
+      return import_node_fs.default.realpathSync.native(p);
+    } catch {
+      return p;
+    }
+  };
+  const mine = opts.workstream ? canon(opts.workstream) : null;
+  return loadSignals(projectRoot).filter((s) => s.state !== "resolved").filter((s) => !mine || s.workstreams.some((w) => canon(w) === mine)).sort((a, b) => RANK[a.severity] - RANK[b.severity] || b.lastSeen - a.lastSeen);
+}
+function setSignalState(projectRoot, id, state, by, now = Date.now()) {
+  const signal = loadSignals(projectRoot).find((s) => s.id === id && s.state !== "resolved");
+  if (!signal) return null;
+  (0, import_database.getDb)().run(
+    "UPDATE awareness_signals SET state = ?, state_by = ?, state_at = ?, reopened_from = NULL, reopened_at = NULL WHERE id = ? AND project_root = ?",
+    [state, JSON.stringify(by), now, id, projectRoot]
+  );
+  (0, import_persistence.markDirty)();
+  (0, import_agent_event_log.recordDecision)("signal_answered", {
+    signalId: id,
+    kind: signal.kind,
+    severity: signal.severity,
+    state,
+    projectRoot,
+    workstreams: signal.workstreams,
+    summary: signal.summary.slice(0, 200),
+    actor: by.actor,
+    actorType: by.actorType,
+    channel: by.channel
+  }, by.actorType);
+  onChanged(projectRoot);
+  const { reopened: _was, ...rest } = signal;
+  return { ...rest, state, stateBy: by, stateAt: now };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  contractsOf,
+  countNeedsYou,
+  declaredFiles,
+  filesDefining,
+  footprintsOf,
+  listSignals,
+  loadSignals,
+  mainChangesSince,
+  refreshSignals,
+  refreshSignalsSoon,
+  scopeOf,
+  setAwarenessListener,
+  setSignalState
+});