codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/ast-parser.js

@@ -0,0 +1,327 @@
+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 ast_parser_exports = {};
+__export(ast_parser_exports, {
+  computeFileHash: () => computeFileHash,
+  getParseableExtensions: () => getParseableExtensions,
+  getParserHealth: () => getParserHealth,
+  initParser: () => initParser,
+  parseFile: () => parseFile,
+  parseFiles: () => parseFiles,
+  parseVirtualFile: () => parseVirtualFile,
+  reinitParsers: () => reinitParsers
+});
+module.exports = __toCommonJS(ast_parser_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_parsers = require("./parsers");
+var import_project_scanner = require("./project-scanner");
+var import_callsites = require("./callsites");
+var import_sql = require("./sql");
+var import_embedded = require("./sql/embedded");
+var import_patterns = require("./patterns");
+var import_process_env = require("./callsites/process-env");
+function loadWebTreeSitter() {
+  const resourcesPath = process.resourcesPath;
+  if (resourcesPath) {
+    const packaged = import_node_path.default.join(resourcesPath, "web-tree-sitter", "web-tree-sitter.cjs");
+    if (import_node_fs.default.existsSync(packaged)) {
+      return require(packaged);
+    }
+  }
+  const wtsName = "web-tree-sitter";
+  return require(wtsName);
+}
+const TreeSitterModule = loadWebTreeSitter();
+const TreeSitter = TreeSitterModule.Parser || TreeSitterModule.default?.Parser || TreeSitterModule;
+const Language = TreeSitterModule.Language || TreeSitter.Language;
+const GRAMMAR_DIR = (() => {
+  const dev = import_node_path.default.resolve(__dirname, "../../../resources/tree-sitter");
+  if (import_node_fs.default.existsSync(dev)) return dev;
+  const resourcesPath = process.resourcesPath;
+  if (resourcesPath) {
+    const packaged = import_node_path.default.join(resourcesPath, "tree-sitter");
+    if (import_node_fs.default.existsSync(packaged)) return packaged;
+  }
+  return dev;
+})();
+let initialized = false;
+const parsersByGrammar = /* @__PURE__ */ new Map();
+let parsesSinceInit = 0;
+const PARSE_BUDGET = 2e3;
+const MAX_CONSECUTIVE_ERRORS = 3;
+let consecutiveParseErrors = 0;
+async function initParser() {
+  if (initialized) return;
+  await TreeSitter.init({
+    locateFile: () => import_node_path.default.join(GRAMMAR_DIR, "tree-sitter.wasm")
+  });
+  await loadGrammars();
+  try {
+    const unparsed = (0, import_parsers.findUnparsedLanguages)((0, import_project_scanner.listTaggedLanguages)());
+    if (unparsed.length > 0) {
+      console.warn(
+        `[AST] These languages are tagged by the scanner but have no parser: ${unparsed.join(", ")}. Files in them will show zero symbols and zero edges, which looks like a working scan of an empty file. Add a parser plugin or stop tagging them.`
+      );
+    }
+    const unscanned = (0, import_parsers.findUnscannedExtensions)((0, import_project_scanner.listTaggedExtensions)());
+    if (unscanned.length > 0) {
+      console.warn(
+        `[AST] These extensions have a parser but the scanner never ingests them: ${unscanned.join(", ")}. Files with them are absent from the graph entirely, and the file-watcher will queue re-parses for files no scan ever stored. Add them to the scanner's LANG_MAP or drop them from the plugin.`
+      );
+    }
+  } catch {
+  }
+  initialized = true;
+  parsesSinceInit = 0;
+  consecutiveParseErrors = 0;
+  console.log(`[AST] Initialized with grammars: ${[...parsersByGrammar.keys()].join(", ")}`);
+}
+async function loadGrammars() {
+  parsersByGrammar.clear();
+  for (const plugin of import_parsers.PARSER_PLUGINS) {
+    if (parsersByGrammar.has(plugin.grammarKey)) continue;
+    const grammarPath = import_node_path.default.join(GRAMMAR_DIR, plugin.grammarFile);
+    if (!import_node_fs.default.existsSync(grammarPath)) {
+      console.warn(`[AST] Skipping ${plugin.language} (${plugin.grammarKey}) \u2014 grammar missing at ${plugin.grammarFile}`);
+      continue;
+    }
+    try {
+      const language = await Language.load(grammarPath);
+      const parser = new TreeSitter();
+      parser.setLanguage(language);
+      parsersByGrammar.set(plugin.grammarKey, parser);
+    } catch (err) {
+      console.warn(`[AST] Failed to load grammar for ${plugin.language}:`, err);
+    }
+  }
+}
+async function reinitParsers() {
+  console.log(`[AST] Reinitialising parsers (${parsesSinceInit} parses since last init)`);
+  await loadGrammars();
+  parsesSinceInit = 0;
+  consecutiveParseErrors = 0;
+  console.log(`[AST] Parsers reinitialised: ${[...parsersByGrammar.keys()].join(", ")}`);
+}
+function dispatchParser(filePath) {
+  const plugin = (0, import_parsers.getPluginForFile)(filePath);
+  if (!plugin) return null;
+  const parser = parsersByGrammar.get(plugin.grammarKey);
+  if (!parser) return null;
+  return { plugin, parser };
+}
+const MAX_PARSE_BYTES = 2 * 1024 * 1024;
+function parseSqlSource(filePath, content) {
+  const byteLength = Buffer.byteLength(content, "utf-8");
+  if (byteLength > MAX_PARSE_BYTES) {
+    console.warn(
+      `[AST] Skipping ${filePath} \u2014 ${(byteLength / 1024 / 1024).toFixed(1)} MB exceeds the ${MAX_PARSE_BYTES / 1024 / 1024} MB parse budget. Almost certainly a data dump.`
+    );
+    return null;
+  }
+  const contentHash = (0, import_node_crypto.createHash)("md5").update(content).digest("hex");
+  let symbols = [];
+  let callsites = [];
+  try {
+    symbols = (0, import_sql.extractSqlSymbols)(content);
+    callsites = (0, import_sql.sqlRefsToCallsites)((0, import_sql.extractTableRefs)(content), "sql-file");
+  } catch (err) {
+    console.warn(`[AST] SQL extraction failed for ${filePath}:`, err);
+  }
+  return {
+    path: filePath,
+    contentHash,
+    language: "sql",
+    symbols,
+    imports: [],
+    exports: [],
+    callsites
+  };
+}
+function parseSource(filePath, content) {
+  if (filePath.toLowerCase().endsWith(".sql")) {
+    return parseSqlSource(filePath, content);
+  }
+  const dispatch = dispatchParser(filePath);
+  if (!dispatch) return null;
+  const { plugin, parser } = dispatch;
+  const byteLength = Buffer.byteLength(content, "utf-8");
+  if (byteLength > MAX_PARSE_BYTES) {
+    console.warn(
+      `[AST] Skipping ${filePath} \u2014 ${(byteLength / 1024 / 1024).toFixed(1)} MB exceeds the ${MAX_PARSE_BYTES / 1024 / 1024} MB parse budget. Symbols and edges for this file will be absent; it is almost certainly generated.`
+    );
+    return null;
+  }
+  let tree;
+  try {
+    tree = parser.parse(content);
+    parsesSinceInit++;
+    consecutiveParseErrors = 0;
+  } catch (err) {
+    consecutiveParseErrors++;
+    const msg = String(err);
+    if (msg.includes("memory access out of bounds") || msg.includes("RuntimeError")) {
+      console.error(`[AST] WASM memory error parsing ${filePath} (${consecutiveParseErrors} consecutive errors, ${parsesSinceInit} total parses)`);
+    } else {
+      console.warn(`[AST] Parse error for ${filePath}:`, err);
+    }
+    return null;
+  }
+  const root = tree.rootNode;
+  const contentHash = (0, import_node_crypto.createHash)("md5").update(content).digest("hex");
+  const symbols = plugin.extractSymbols(root);
+  const imports = plugin.extractImports(root);
+  const exports2 = plugin.extractExports?.(root) ?? [];
+  let callsites = [];
+  try {
+    const extractor = (0, import_callsites.getCallsiteExtractor)(plugin.language);
+    if (extractor) callsites = extractor.extract(content, filePath);
+  } catch (err) {
+    console.warn(`[AST] Callsite extraction failed for ${filePath}:`, err);
+  }
+  try {
+    callsites = [...callsites, ...(0, import_embedded.extractEmbeddedSql)(content)];
+  } catch (err) {
+    console.warn(`[AST] Embedded SQL extraction failed for ${filePath}:`, err);
+  }
+  try {
+    callsites = [...callsites, ...(0, import_process_env.extractProcessAndEnv)(plugin.language, content)];
+  } catch (err) {
+    console.warn(`[AST] Command and environment extraction failed for ${filePath}:`, err);
+  }
+  callsites = [...callsites, ...(0, import_patterns.patternCallsitesFor)(filePath, content)];
+  return {
+    path: filePath,
+    contentHash,
+    language: plugin.language,
+    symbols,
+    imports,
+    exports: exports2,
+    callsites
+  };
+}
+function computeFileHash(filePath) {
+  try {
+    const content = import_node_fs.default.readFileSync(filePath, "utf-8");
+    return (0, import_node_crypto.createHash)("md5").update(content).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function getParseableExtensions() {
+  return [...(0, import_parsers.listPluginExtensions)(), ".sql"];
+}
+function parseFile(filePath) {
+  let content;
+  try {
+    content = import_node_fs.default.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  return parseSource(filePath, content);
+}
+function parseVirtualFile(filePath, content) {
+  return parseSource(filePath, content);
+}
+const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+const PARSE_BATCH_SIZE = 8;
+async function parseFiles(filePaths) {
+  await initParser();
+  if (parsesSinceInit + filePaths.length > PARSE_BUDGET) {
+    await reinitParsers();
+  }
+  const results = [];
+  for (let i = 0; i < filePaths.length; i++) {
+    let parsed = parseFile(filePaths[i]);
+    if (!parsed && consecutiveParseErrors >= MAX_CONSECUTIVE_ERRORS) {
+      console.warn(`[AST] ${MAX_CONSECUTIVE_ERRORS} consecutive parse errors \u2014 reinitialising parsers`);
+      await reinitParsers();
+      parsed = parseFile(filePaths[i]);
+      if (!parsed) {
+        consecutiveParseErrors = 0;
+      }
+    }
+    if (parsed) results.push(parsed);
+    if ((i + 1) % PARSE_BATCH_SIZE === 0) {
+      await yieldToEventLoop();
+    }
+  }
+  const sqlFiles = results.filter((r) => r.language === "sql");
+  if (sqlFiles.length > 0) {
+    try {
+      const batchPaths = new Set(sqlFiles.map((f) => f.path));
+      const dirs = new Set(sqlFiles.map((f) => f.path.replace(/[\\/][^\\/]*$/, "")));
+      const siblings = [];
+      for (const dir of dirs) {
+        let entries = [];
+        try {
+          entries = import_node_fs.default.readdirSync(dir);
+        } catch {
+          continue;
+        }
+        for (const name of entries) {
+          if (!name.toLowerCase().endsWith(".sql")) continue;
+          const full = import_node_path.default.join(dir, name);
+          if (batchPaths.has(full)) continue;
+          siblings.push({ path: full, symbols: [], language: "sql" });
+        }
+      }
+      (0, import_sql.applyMigrationFold)([...sqlFiles, ...siblings], (p) => {
+        try {
+          return import_node_fs.default.readFileSync(p, "utf-8");
+        } catch {
+          return null;
+        }
+      });
+    } catch (err) {
+      console.warn("[AST] Migration fold failed \u2014 leaving SQL symbols as parsed:", err);
+    }
+  }
+  return results;
+}
+function getParserHealth() {
+  return {
+    initialized,
+    parsesSinceInit,
+    parseBudget: PARSE_BUDGET,
+    consecutiveErrors: consecutiveParseErrors,
+    loadedGrammars: [...parsersByGrammar.keys()]
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeFileHash,
+  getParseableExtensions,
+  getParserHealth,
+  initParser,
+  parseFile,
+  parseFiles,
+  parseVirtualFile,
+  reinitParsers
+});

package/src/backend/services/audio-buffer-service.js

@@ -0,0 +1,152 @@
+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 audio_buffer_service_exports = {};
+__export(audio_buffer_service_exports, {
+  AudioRequestError: () => AudioRequestError,
+  MAX_BUFFER_SECONDS_LIMIT: () => MAX_BUFFER_SECONDS_LIMIT,
+  MAX_CHUNK_MS: () => MAX_CHUNK_MS,
+  audioBuffer: () => audioBuffer,
+  checkBufferSeconds: () => checkBufferSeconds,
+  checkChunkMs: () => checkChunkMs
+});
+module.exports = __toCommonJS(audio_buffer_service_exports);
+const DEFAULT_MAX_BUFFER_MS = 12e4;
+const MAX_BUFFER_SECONDS_LIMIT = 600;
+const MAX_CHUNK_MS = 6e4;
+class AudioRequestError extends Error {
+}
+function checkBufferSeconds(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 1 || value > MAX_BUFFER_SECONDS_LIMIT) {
+    throw new AudioRequestError(`maxBufferSeconds must be a number from 1 to ${MAX_BUFFER_SECONDS_LIMIT}`);
+  }
+  return value;
+}
+function checkChunkMs(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value > MAX_CHUNK_MS) {
+    throw new AudioRequestError(`durationMs must be a number from 1 to ${MAX_CHUNK_MS}`);
+  }
+  return value;
+}
+class AudioBufferService {
+  chunks = [];
+  maxBufferMs = DEFAULT_MAX_BUFFER_MS;
+  capturing = false;
+  startedAt = null;
+  /**
+   * Start accepting audio chunks. Clears any existing buffer.
+   */
+  startCapture(maxBufferSeconds) {
+    this.maxBufferMs = (checkBufferSeconds(maxBufferSeconds) ?? DEFAULT_MAX_BUFFER_MS / 1e3) * 1e3;
+    this.chunks = [];
+    this.capturing = true;
+    this.startedAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Stop accepting audio chunks. Buffer is preserved until next start.
+   */
+  stopCapture() {
+    this.capturing = false;
+  }
+  /**
+   * Whether capture is currently active.
+   */
+  isCapturing() {
+    return this.capturing;
+  }
+  /**
+   * Add an audio chunk to the rolling buffer. Evicts old chunks
+   * that exceed the max buffer duration.
+   */
+  addChunk(data, durationMs) {
+    if (!this.capturing) return;
+    checkChunkMs(durationMs);
+    this.chunks.push({
+      data,
+      timestamp: Date.now(),
+      durationMs
+    });
+    this.evictOldChunks();
+  }
+  /**
+   * Get the most recent N seconds of audio as a concatenated buffer.
+   * If seconds is omitted, returns the entire buffer.
+   */
+  getRecentAudio(seconds) {
+    if (this.chunks.length === 0) return null;
+    let targetChunks = this.chunks;
+    if (seconds) {
+      const cutoffMs = seconds * 1e3;
+      const now = Date.now();
+      targetChunks = this.chunks.filter(
+        (c) => now - c.timestamp <= cutoffMs
+      );
+    }
+    if (targetChunks.length === 0) return null;
+    const totalData = Buffer.concat(targetChunks.map((c) => c.data));
+    const totalDurationMs = targetChunks.reduce((sum, c) => sum + c.durationMs, 0);
+    const startsAt = new Date(targetChunks[0].timestamp);
+    const lastChunk = targetChunks[targetChunks.length - 1];
+    const endsAt = new Date(lastChunk.timestamp + lastChunk.durationMs);
+    return {
+      audioBase64: totalData.toString("base64"),
+      mimeType: "audio/webm;codecs=opus",
+      durationSeconds: Math.round(totalDurationMs / 1e3 * 10) / 10,
+      startsAt: startsAt.toISOString(),
+      endsAt: endsAt.toISOString(),
+      chunkCount: targetChunks.length
+    };
+  }
+  /**
+   * Get current capture status.
+   */
+  getStatus() {
+    const bufferedMs = this.chunks.reduce((sum, c) => sum + c.durationMs, 0);
+    return {
+      capturing: this.capturing,
+      bufferedSeconds: Math.round(bufferedMs / 1e3 * 10) / 10,
+      chunkCount: this.chunks.length,
+      maxBufferSeconds: this.maxBufferMs / 1e3,
+      startedAt: this.startedAt?.toISOString() ?? null
+    };
+  }
+  /**
+   * Clear the buffer entirely.
+   */
+  clear() {
+    this.chunks = [];
+  }
+  // --- Internals ---
+  evictOldChunks() {
+    const now = Date.now();
+    const cutoff = now - this.maxBufferMs;
+    while (this.chunks.length > 0 && this.chunks[0].timestamp < cutoff) {
+      this.chunks.shift();
+    }
+  }
+}
+const audioBuffer = new AudioBufferService();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioRequestError,
+  MAX_BUFFER_SECONDS_LIMIT,
+  MAX_CHUNK_MS,
+  audioBuffer,
+  checkBufferSeconds,
+  checkChunkMs
+});

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

@@ -0,0 +1,139 @@
+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 awareness_notices_exports = {};
+__export(awareness_notices_exports, {
+  MAX_NOTE: () => MAX_NOTE,
+  markTold: () => markTold,
+  noticeFor: () => noticeFor,
+  noticeText: () => noticeText,
+  recordNote: () => recordNote,
+  setNoticeListener: () => setNoticeListener,
+  toldFor: () => toldFor,
+  withTold: () => withTold
+});
+module.exports = __toCommonJS(awareness_notices_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_awareness_service = require("./awareness-service");
+var import_session_service = require("./session-service");
+var import_project_config_service = require("./project-config-service");
+var import_task_workstreams = require("./task-workstreams");
+const MAX_NOTE = 500;
+const RANK = { high: 0, medium: 1, low: 2 };
+const NO_NOTICE = /* @__PURE__ */ new Set(["get_awareness", "acknowledge_signal"]);
+const CONCERNS = /* @__PURE__ */ new Set(["open", "acknowledged"]);
+let onChanged = () => {
+};
+function setNoticeListener(listener) {
+  onChanged = listener;
+}
+function toldTo(sessionId) {
+  const res = (0, import_database.getDb)().exec(
+    "SELECT signal_id FROM awareness_signal_notes WHERE session_id = ? AND told_at IS NOT NULL",
+    [sessionId]
+  );
+  return new Set((res[0]?.values ?? []).map((r) => r[0]));
+}
+function markTold(projectRoot, signalIds, sessionId, agentType, now = Date.now()) {
+  if (signalIds.length === 0) return;
+  const db = (0, import_database.getDb)();
+  for (const id of signalIds) {
+    db.run(
+      `INSERT INTO awareness_signal_notes (signal_id, session_id, agent_type, told_at) VALUES (?, ?, ?, ?)
+       ON CONFLICT(signal_id, session_id) DO UPDATE SET told_at = COALESCE(awareness_signal_notes.told_at, excluded.told_at)`,
+      [id, sessionId, agentType, now]
+    );
+  }
+  (0, import_persistence.markDirty)();
+  onChanged(projectRoot);
+}
+function recordNote(projectRoot, signalId, sessionId, agentType, note, now = Date.now()) {
+  (0, import_database.getDb)().run(
+    `INSERT INTO awareness_signal_notes (signal_id, session_id, agent_type, told_at, note, noted_at) VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(signal_id, session_id) DO UPDATE SET
+       note = excluded.note, noted_at = excluded.noted_at,
+       told_at = COALESCE(awareness_signal_notes.told_at, excluded.told_at)`,
+    [signalId, sessionId, agentType, now, note, now]
+  );
+  (0, import_persistence.markDirty)();
+  onChanged(projectRoot);
+}
+function toldFor(signalIds) {
+  const out = /* @__PURE__ */ new Map();
+  if (signalIds.length === 0) return out;
+  const res = (0, import_database.getDb)().exec(
+    `SELECT signal_id, session_id, agent_type, told_at, note, noted_at FROM awareness_signal_notes
+      WHERE signal_id IN (${signalIds.map(() => "?").join(",")}) ORDER BY COALESCE(noted_at, told_at)`,
+    [...signalIds]
+  );
+  for (const [id, sessionId, agentType, toldAt, note, notedAt] of res[0]?.values ?? []) {
+    const list = out.get(id) ?? [];
+    list.push({
+      sessionId,
+      agentType,
+      toldAt: toldAt ?? null,
+      ...note ? { note, notedAt } : {}
+    });
+    out.set(id, list);
+  }
+  return out;
+}
+function withTold(signals) {
+  const told = toldFor(signals.map((s) => s.id));
+  return signals.map((s) => told.has(s.id) ? { ...s, told: told.get(s.id) } : s);
+}
+function noticeText(signals) {
+  const lines = signals.map((s) => `- ${s.severity} ${s.kind}: ${s.summary}`);
+  const head = signals.length === 1 ? "1 new signal affects your work:" : `${signals.length} new signals affect your work:`;
+  return [
+    "\u2500\u2500 CodeTrellis awareness \u2500\u2500",
+    head,
+    ...lines,
+    "Call get_awareness for details, and acknowledge_signal to say what you will do. This is information about other work, not an instruction."
+  ].join("\n");
+}
+function noticeFor(sessionId, toolName, projectRoot) {
+  if (!projectRoot || NO_NOTICE.has(toolName)) return null;
+  try {
+    if (!(0, import_project_config_service.getEffectiveSensorConfig)(projectRoot).awareness.inlineNotices) return null;
+    const session = (0, import_session_service.getActiveSessions)().find((s) => s.sessionId === sessionId);
+    const mine = (0, import_task_workstreams.sessionWorkstreams)(session);
+    if (!session || mine.length === 0) return null;
+    const seen = toldTo(sessionId);
+    const byId = /* @__PURE__ */ new Map();
+    for (const w of mine) for (const s of (0, import_awareness_service.listSignals)(projectRoot, { workstream: w })) byId.set(s.id, s);
+    const fresh = [...byId.values()].sort((a, b) => RANK[a.severity] - RANK[b.severity] || b.lastSeen - a.lastSeen).filter((s) => (s.severity === "high" || s.severity === "medium") && CONCERNS.has(s.state) && !seen.has(s.id));
+    if (fresh.length === 0) return null;
+    markTold(projectRoot, fresh.map((s) => s.id), sessionId, session.agentType);
+    return noticeText(fresh);
+  } catch (err) {
+    console.warn("[Awareness] notice failed:", err instanceof Error ? err.message : err);
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_NOTE,
+  markTold,
+  noticeFor,
+  noticeText,
+  recordNote,
+  setNoticeListener,
+  toldFor,
+  withTold
+});