@askexenow/exe-os 0.9.69 → 0.9.71

package/dist/lib/exe-daemon.js

@@ -2847,6 +2847,33 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_chat_history_session
       ON chat_history(session_id, id);
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_events (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      session_scope TEXT,
+      project_name  TEXT NOT NULL,
+      event_index   INTEGER NOT NULL,
+      event_type    TEXT NOT NULL,
+      tool_name     TEXT,
+      tool_use_id   TEXT,
+      content       TEXT NOT NULL,
+      payload_json  TEXT,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_agent_time
+      ON session_events(agent_id, created_at DESC);
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_session_index
+      ON session_events(session_id, event_index);
+
+    CREATE INDEX IF NOT EXISTS idx_session_events_scope_agent_time
+      ON session_events(session_scope, agent_id, created_at DESC);
+  `);
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS workspaces (
       id              TEXT PRIMARY KEY,
@@ -5790,6 +5817,12 @@ var init_platform_procedures = __esm({
         priority: "p0",
         content: "exe-build-adv is MANDATORY for ALL work touching 3+ files. Run /exe-build-adv --auto BEFORE implementation. Pipeline: Spec \u2192 AC \u2192 Tests \u2192 Evaluate \u2192 Fix. No multi-file feature ships without pipeline artifacts. No exceptions \u2014 managers reject work without them."
       },
+      {
+        title: "Code context first for repository orientation",
+        domain: "workflow",
+        priority: "p1",
+        content: "Before broad repo exploration, symbol tracing, blast-radius review, or codebase Q&A, agents should use the consolidated code_context MCP tool instead of manual grep/read loops. Use action=index or stats to refresh/check the index; action=search with query, limit, offset, languages, paths, refresh_index for fresh multi-language code/doc search; action=trace for symbol imports/dependents; action=blast_radius for impact analysis before edits. CLI parity exists via exe-os code-context init|index|status|stats|search|doctor. Keep code_context separate from durable employee memory: promote only validated decisions, procedures, or lessons into store_memory/commit_memory."
+      },
       {
         title: "Commit discipline \u2014 never leave verified work floating",
         domain: "workflow",
@@ -19020,13 +19053,25 @@ var init_export_graph = __esm({
 
 // src/lib/code-chunker.ts
 import ts from "typescript";
+function languageForFile(filePath) {
+  const base = filePath.split(/[\\/]/).pop()?.toLowerCase() ?? "";
+  if (["dockerfile", "makefile", "rakefile", "gemfile"].includes(base)) return base;
+  const ext = base.includes(".") ? base.split(".").pop() : void 0;
+  return ext ? LANGUAGE_BY_EXTENSION[ext] : void 0;
+}
 function chunkSourceFile(source, fileName = "file.ts") {
+  const language = languageForFile(fileName);
+  if (language === "typescript" || language === "javascript") {
+    return chunkTypeScriptLike(source, fileName);
+  }
+  return chunkGenericSource(source, fileName, language);
+}
+function chunkTypeScriptLike(source, fileName) {
   const sourceFile = ts.createSourceFile(
     fileName,
     source,
     ts.ScriptTarget.Latest,
     true,
-    // setParentNodes
     fileName.endsWith(".tsx") || fileName.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
   );
   const chunks = [];
@@ -19048,144 +19093,117 @@ function chunkSourceFile(source, fileName = "file.ts") {
     if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
       return node.name?.getText(sourceFile) ?? "(anonymous)";
     }
-    if (ts.isClassDeclaration(node)) {
-      return node.name?.getText(sourceFile) ?? "(anonymous class)";
-    }
-    if (ts.isInterfaceDeclaration(node)) {
-      return node.name.getText(sourceFile);
-    }
-    if (ts.isTypeAliasDeclaration(node)) {
-      return node.name.getText(sourceFile);
-    }
-    if (ts.isEnumDeclaration(node)) {
-      return node.name.getText(sourceFile);
-    }
-    if (ts.isVariableStatement(node)) {
-      const decls = node.declarationList.declarations;
-      return decls.map((d) => d.name.getText(sourceFile)).join(", ");
-    }
-    if (ts.isExportAssignment(node)) {
-      return "default export";
-    }
+    if (ts.isClassDeclaration(node)) return node.name?.getText(sourceFile) ?? "(anonymous class)";
+    if (ts.isInterfaceDeclaration(node)) return node.name.getText(sourceFile);
+    if (ts.isTypeAliasDeclaration(node)) return node.name.getText(sourceFile);
+    if (ts.isEnumDeclaration(node)) return node.name.getText(sourceFile);
+    if (ts.isVariableStatement(node)) return node.declarationList.declarations.map((d) => d.name.getText(sourceFile)).join(", ");
+    if (ts.isExportAssignment(node)) return "default export";
     return "(unknown)";
   }
   function visitTopLevel(node) {
     if (ts.isImportDeclaration(node)) {
-      importLines.push({
-        start: getLineNumber(node.getStart(sourceFile)),
-        end: getLineNumber(node.getEnd())
-      });
+      importLines.push({ start: getLineNumber(node.getStart(sourceFile)), end: getLineNumber(node.getEnd()) });
       return;
     }
     if (ts.isFunctionDeclaration(node)) {
-      chunks.push({
-        kind: "function",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+      chunks.push({ kind: "function", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
     if (ts.isClassDeclaration(node)) {
-      chunks.push({
-        kind: "class",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+      chunks.push({ kind: "class", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
-    if (ts.isInterfaceDeclaration(node)) {
-      chunks.push({
-        kind: "type",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
-      return;
-    }
-    if (ts.isTypeAliasDeclaration(node)) {
-      chunks.push({
-        kind: "type",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
-      return;
-    }
-    if (ts.isEnumDeclaration(node)) {
-      chunks.push({
-        kind: "type",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) {
+      chunks.push({ kind: "type", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
     if (ts.isVariableStatement(node)) {
-      const decls = node.declarationList.declarations;
-      const isFnLike = decls.some(
-        (d) => d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer))
-      );
-      chunks.push({
-        kind: isFnLike ? "function" : "variable",
-        name: getName(node),
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+      const isFnLike = node.declarationList.declarations.some((d) => d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer)));
+      chunks.push({ kind: isFnLike ? "function" : "variable", name: getName(node), text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
     if (ts.isExportAssignment(node)) {
-      chunks.push({
-        kind: "export",
-        name: "default export",
-        text: getNodeText(node),
-        startLine: getLineNumber(node.getStart(sourceFile)),
-        endLine: getLineNumber(node.getEnd()),
-        comment: getLeadingComment(node)
-      });
+      chunks.push({ kind: "export", name: "default export", text: getNodeText(node), startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()), comment: getLeadingComment(node) });
       return;
     }
     if (ts.isExpressionStatement(node)) {
       const text3 = getNodeText(node);
-      if (text3.length > 10) {
-        chunks.push({
-          kind: "other",
-          name: text3.slice(0, 40).replace(/\n/g, " "),
-          text: text3,
-          startLine: getLineNumber(node.getStart(sourceFile)),
-          endLine: getLineNumber(node.getEnd())
-        });
-      }
-      return;
+      if (text3.length > 10) chunks.push({ kind: "other", name: text3.slice(0, 40).replace(/\n/g, " "), text: text3, startLine: getLineNumber(node.getStart(sourceFile)), endLine: getLineNumber(node.getEnd()) });
     }
   }
   sourceFile.statements.forEach(visitTopLevel);
   if (importLines.length > 0) {
     const startLine = importLines[0].start;
     const endLine = importLines[importLines.length - 1].end;
-    const importText = lines.slice(startLine - 1, endLine).join("\n");
-    chunks.unshift({
-      kind: "import",
-      name: `${importLines.length} imports`,
-      text: importText,
-      startLine,
+    chunks.unshift({ kind: "import", name: `${importLines.length} imports`, text: lines.slice(startLine - 1, endLine).join("\n"), startLine, endLine });
+  }
+  chunks.sort((a, b) => a.startLine - b.startLine);
+  return chunks.length > 0 ? chunks : chunkByWindows(source, 80);
+}
+function chunkGenericSource(source, _fileName, language) {
+  const lines = source.split("\n");
+  if (source.trim().length === 0) return [];
+  if (language && TEXT_LIKE_LANGUAGES.has(language)) return chunkTextLike(lines, language);
+  const chunks = [];
+  const patterns = [
+    { kind: "function", regex: /^\s*(?:async\s+)?def\s+([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "class", regex: /^\s*class\s+([A-Za-z_][\w]*)\b/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*(?:pub\s+)?fn\s+([A-Za-z_][\w]*)\s*[<(]/, name: (m) => m[1] },
+    { kind: "class", regex: /^\s*(?:pub\s+)?(?:struct|enum|trait)\s+([A-Za-z_][\w]*)\b/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*func\s+(?:\([^)]*\)\s*)?([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*(?:public|private|protected|static|final|suspend|fun|override|open|internal|export|async|func|function|subroutine)\s+.*?([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "function", regex: /^\s*function\s+([A-Za-z_][\w]*)\s*\(/, name: (m) => m[1] },
+    { kind: "type", regex: /^\s*(?:interface|type|enum|record|data\s+class|case\s+class|contract|library)\s+([A-Za-z_][\w]*)\b/, name: (m) => m[1] },
+    { kind: "section", regex: /^\s{0,3}#{1,6}\s+(.+)$/, name: (m) => m[1].trim() }
+  ];
+  const starts = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const pattern of patterns) {
+      const match = line.match(pattern.regex);
+      if (match) {
+        starts.push({ line: i + 1, kind: pattern.kind, name: pattern.name(match) });
+        break;
+      }
+    }
+  }
+  if (starts.length === 0) return chunkByWindows(source, 80);
+  for (let i = 0; i < starts.length; i++) {
+    const start = starts[i];
+    const next = starts[i + 1]?.line ?? lines.length + 1;
+    const endLine = Math.max(start.line, next - 1);
+    chunks.push({
+      kind: start.kind,
+      name: start.name,
+      text: lines.slice(start.line - 1, endLine).join("\n"),
+      startLine: start.line,
       endLine
     });
   }
-  chunks.sort((a, b) => a.startLine - b.startLine);
+  return chunks;
+}
+function chunkTextLike(lines, language) {
+  if (language === "markdown" || language === "mdx") {
+    const starts = lines.map((line, i) => ({ line, i })).filter(({ line }) => /^\s{0,3}#{1,6}\s+/.test(line));
+    if (starts.length > 0) {
+      return starts.map((start, idx) => {
+        const end = starts[idx + 1]?.i ?? lines.length;
+        const title = start.line.replace(/^\s{0,3}#{1,6}\s+/, "").trim();
+        return { kind: "section", name: title, text: lines.slice(start.i, end).join("\n"), startLine: start.i + 1, endLine: end };
+      });
+    }
+  }
+  return chunkByWindows(lines.join("\n"), 80);
+}
+function chunkByWindows(source, windowLines) {
+  const lines = source.split("\n");
+  const chunks = [];
+  for (let i = 0; i < lines.length; i += windowLines) {
+    const end = Math.min(lines.length, i + windowLines);
+    const text3 = lines.slice(i, end).join("\n");
+    if (text3.trim()) chunks.push({ kind: "other", name: `lines ${i + 1}-${end}`, text: text3, startLine: i + 1, endLine: end });
+  }
   return chunks;
 }
 function summarizeChunk(chunk, filePath) {
@@ -19204,17 +19222,69 @@ function summarizeChunk(chunk, filePath) {
       return `Variable ${chunk.name} in ${location}`;
     case "export":
       return `Default export in ${location}`;
+    case "section":
+      return `Section ${chunk.name} in ${location}`;
     default:
       return `${chunk.kind} in ${location}`;
   }
 }
 function isChunkable(filePath) {
-  const ext = filePath.split(".").pop()?.toLowerCase();
-  return ext === "ts" || ext === "tsx" || ext === "js" || ext === "jsx";
+  return Boolean(languageForFile(filePath));
 }
+var LANGUAGE_BY_EXTENSION, TEXT_LIKE_LANGUAGES;
 var init_code_chunker = __esm({
   "src/lib/code-chunker.ts"() {
     "use strict";
+    LANGUAGE_BY_EXTENSION = {
+      c: "c",
+      cc: "cpp",
+      cpp: "cpp",
+      cxx: "cpp",
+      h: "c",
+      hh: "cpp",
+      hpp: "cpp",
+      cs: "csharp",
+      css: "css",
+      scss: "scss",
+      f: "fortran",
+      f90: "fortran",
+      f95: "fortran",
+      go: "go",
+      html: "html",
+      htm: "html",
+      java: "java",
+      js: "javascript",
+      jsx: "javascript",
+      json: "json",
+      kt: "kotlin",
+      kts: "kotlin",
+      lua: "lua",
+      md: "markdown",
+      mdx: "mdx",
+      pas: "pascal",
+      php: "php",
+      py: "python",
+      r: "r",
+      rb: "ruby",
+      rs: "rust",
+      scala: "scala",
+      sc: "scala",
+      sol: "solidity",
+      sql: "sql",
+      svelte: "svelte",
+      swift: "swift",
+      toml: "toml",
+      ts: "typescript",
+      tsx: "typescript",
+      vue: "vue",
+      xml: "xml",
+      yaml: "yaml",
+      yml: "yaml",
+      sh: "shell",
+      bash: "shell",
+      zsh: "shell"
+    };
+    TEXT_LIKE_LANGUAGES = /* @__PURE__ */ new Set(["json", "markdown", "mdx", "toml", "yaml", "xml", "html", "css", "scss", "sql"]);
   }
 });
 
@@ -29986,10 +30056,210 @@ var init_create_bug_report = __esm({
   }
 });
 
+// src/lib/session-events.ts
+import { randomUUID as randomUUID9 } from "crypto";
+async function ensureSessionEventsTable(client) {
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS session_events (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      session_scope TEXT,
+      project_name  TEXT NOT NULL,
+      event_index   INTEGER NOT NULL,
+      event_type    TEXT NOT NULL,
+      tool_name     TEXT,
+      tool_use_id   TEXT,
+      content       TEXT NOT NULL,
+      payload_json  TEXT,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    )
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_agent_time
+      ON session_events(agent_id, created_at DESC)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_session_index
+      ON session_events(session_id, event_index)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_scope_agent_time
+      ON session_events(session_scope, agent_id, created_at DESC)
+  `);
+}
+async function listRecentSessionEvents(client, options) {
+  await ensureSessionEventsTable(client);
+  const conditions = ["agent_id = ?"];
+  const args = [options.agentId];
+  if (options.sessionId) {
+    conditions.push("session_id = ?");
+    args.push(options.sessionId);
+  }
+  if (options.eventType) {
+    conditions.push("event_type = ?");
+    args.push(options.eventType);
+  }
+  if (options.projectName && options.projectName !== "all") {
+    conditions.push("project_name = ?");
+    args.push(options.projectName);
+  }
+  const scope = strictSessionScopeFilter(options.sessionScope);
+  const where = `WHERE ${conditions.join(" AND ")}${scope.sql}`;
+  args.push(...scope.args);
+  args.push(Math.min(Math.max(options.limit ?? 20, 1), 100));
+  const result2 = await client.execute({
+    sql: `SELECT id, agent_id, agent_role, session_id, session_scope,
+                 project_name, event_index, event_type, tool_name, tool_use_id,
+                 content, payload_json, has_error, created_at
+          FROM session_events
+          ${where}
+          ORDER BY created_at DESC, event_index DESC
+          LIMIT ?`,
+    args
+  });
+  return result2.rows.map((row) => ({
+    id: String(row.id),
+    agentId: String(row.agent_id),
+    agentRole: String(row.agent_role),
+    sessionId: String(row.session_id),
+    sessionScope: row.session_scope == null ? null : String(row.session_scope),
+    projectName: String(row.project_name),
+    eventIndex: Number(row.event_index),
+    eventType: String(row.event_type),
+    toolName: row.tool_name == null ? null : String(row.tool_name),
+    toolUseId: row.tool_use_id == null ? null : String(row.tool_use_id),
+    content: String(row.content),
+    payloadJson: row.payload_json == null ? null : String(row.payload_json),
+    hasError: Number(row.has_error) === 1,
+    createdAt: String(row.created_at)
+  }));
+}
+var init_session_events = __esm({
+  "src/lib/session-events.ts"() {
+    "use strict";
+    init_task_scope();
+    init_project_name();
+  }
+});
+
+// src/mcp/tools/get-session-events.ts
+import { z as z88 } from "zod";
+function canReadAgent(activeRole, activeAgent, requestedAgent) {
+  return requestedAgent === activeAgent || activeRole === "COO" || activeRole === "CTO";
+}
+function formatEvent(event) {
+  const header = [
+    `[${event.createdAt}]`,
+    `${event.agentId}`,
+    `${event.eventType}`,
+    `session=${event.sessionId}`,
+    `#${event.eventIndex}`,
+    event.toolName ? `tool=${event.toolName}` : "",
+    event.hasError ? "ERROR" : ""
+  ].filter(Boolean).join(" ");
+  return `${header}
+${event.content}`;
+}
+function registerGetSessionEvents(server) {
+  server.registerTool(
+    "get_session_events",
+    {
+      title: "Get Session Events",
+      description: "Return exact recent chronological user prompts, assistant responses, and tool calls from the append-only session journal. Use this when asked what happened last, not semantic memory search.",
+      inputSchema: {
+        agent_id: z88.string().optional().describe("Agent to inspect. Defaults to active agent. COO/CTO may inspect others."),
+        session_id: z88.string().optional().describe("Optional exact runtime session id."),
+        event_type: EVENT_TYPE.optional().describe("Filter to one event type."),
+        project_name: z88.string().optional().describe("Optional project filter. Pass 'all' for all projects."),
+        limit: z88.number().int().min(1).max(100).default(20).describe("Number of events to return.")
+      }
+    },
+    async ({ agent_id, session_id, event_type, project_name, limit }) => {
+      const active = getActiveAgent();
+      const targetAgent = agent_id?.trim() || active.agentId;
+      if (!canReadAgent(active.agentRole, active.agentId, targetAgent)) {
+        return {
+          content: [{ type: "text", text: "Permission denied: only COO/CTO may read another agent's session events." }],
+          isError: true
+        };
+      }
+      const client = await fastDbInit();
+      const events = await listRecentSessionEvents(client, {
+        agentId: targetAgent,
+        sessionId: session_id,
+        eventType: event_type,
+        projectName: project_name,
+        limit
+      });
+      if (events.length === 0) {
+        return { content: [{ type: "text", text: "No session events found." }] };
+      }
+      return {
+        content: [{ type: "text", text: events.map(formatEvent).join("\n\n---\n\n") }]
+      };
+    }
+  );
+}
+function registerGetLastAssistantResponse(server) {
+  server.registerTool(
+    "get_last_assistant_response",
+    {
+      title: "Get Last Assistant Response",
+      description: "Return the exact last assistant response for an agent from the session event journal. Use for 'what was the last thing you said?'",
+      inputSchema: {
+        agent_id: z88.string().optional().describe("Agent to inspect. Defaults to active agent. COO/CTO may inspect others."),
+        project_name: z88.string().optional().describe("Optional project filter. Pass 'all' for all projects.")
+      }
+    },
+    async ({ agent_id, project_name }) => {
+      const active = getActiveAgent();
+      const targetAgent = agent_id?.trim() || active.agentId;
+      if (!canReadAgent(active.agentRole, active.agentId, targetAgent)) {
+        return {
+          content: [{ type: "text", text: "Permission denied: only COO/CTO may read another agent's last response." }],
+          isError: true
+        };
+      }
+      const client = await fastDbInit();
+      const events = await listRecentSessionEvents(client, {
+        agentId: targetAgent,
+        eventType: "assistant_response",
+        projectName: project_name,
+        limit: 1
+      });
+      if (events.length === 0) {
+        return { content: [{ type: "text", text: "No assistant response found in the session journal." }] };
+      }
+      return {
+        content: [{ type: "text", text: formatEvent(events[0]) }]
+      };
+    }
+  );
+}
+var EVENT_TYPE;
+var init_get_session_events = __esm({
+  "src/mcp/tools/get-session-events.ts"() {
+    "use strict";
+    init_active_agent();
+    init_fast_db_init();
+    init_session_events();
+    EVENT_TYPE = z88.enum([
+      "user_prompt",
+      "assistant_response",
+      "tool_call",
+      "tool_result",
+      "system_event"
+    ]);
+  }
+});
+
 // src/lib/code-context-index.ts
 import crypto20 from "crypto";
 import path54 from "path";
-import { existsSync as existsSync43, mkdirSync as mkdirSync21, readFileSync as readFileSync35, statSync as statSync10, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync43, mkdirSync as mkdirSync21, readFileSync as readFileSync35, readdirSync as readdirSync14, statSync as statSync10, writeFileSync as writeFileSync24 } from "fs";
 import { spawnSync } from "child_process";
 function normalizeProjectRoot(projectRoot) {
   return path54.resolve(projectRoot || process.cwd());
@@ -30008,78 +30278,53 @@ function getCodeContextIndexPath(projectRoot) {
   return path54.join(indexDir(), `${rootHash}.json`);
 }
 function currentBranch(projectRoot) {
-  const result2 = spawnSync("git", ["branch", "--show-current"], {
-    cwd: projectRoot,
-    encoding: "utf8",
-    timeout: 2e3
-  });
+  const result2 = spawnSync("git", ["branch", "--show-current"], { cwd: projectRoot, encoding: "utf8", timeout: 2e3 });
   const branch = result2.status === 0 ? result2.stdout.trim() : "";
   return branch || "detached-or-unknown";
 }
 function shouldIgnore(relPath) {
-  const parts = relPath.split(path54.sep);
+  const parts = relPath.split(/[\\/]/);
   return parts.some((part) => IGNORE_SEGMENTS.has(part));
 }
-function isCodeFile(relPath) {
-  return CODE_EXTENSIONS.has(path54.extname(relPath).toLowerCase());
+function listRecursive(projectRoot, dir = projectRoot, out = []) {
+  for (const entry of readdirSync14(dir, { withFileTypes: true })) {
+    const abs = path54.join(dir, entry.name);
+    const rel = path54.relative(projectRoot, abs).replaceAll(path54.sep, "/");
+    if (shouldIgnore(rel)) continue;
+    if (entry.isDirectory()) listRecursive(projectRoot, abs, out);
+    else if (entry.isFile()) out.push(rel);
+  }
+  return out;
 }
 function listCodeFiles(projectRoot, maxFiles) {
-  const git = spawnSync("git", ["ls-files", "*.ts", "*.tsx", "*.js", "*.jsx"], {
-    cwd: projectRoot,
-    encoding: "utf8",
-    timeout: 5e3,
-    maxBuffer: 1024 * 1024 * 8
-  });
+  const git = spawnSync("git", ["ls-files"], { cwd: projectRoot, encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024 * 16 });
   let files = [];
   if (git.status === 0 && git.stdout.trim()) {
     files = git.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
   } else {
-    const rg = spawnSync("rg", ["--files", "-g", "*.ts", "-g", "*.tsx", "-g", "*.js", "-g", "*.jsx"], {
-      cwd: projectRoot,
-      encoding: "utf8",
-      timeout: 5e3,
-      maxBuffer: 1024 * 1024 * 8
-    });
-    if (rg.status === 0 && rg.stdout.trim()) {
-      files = rg.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
-    }
+    const rg = spawnSync("rg", ["--files"], { cwd: projectRoot, encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024 * 16 });
+    files = rg.status === 0 && rg.stdout.trim() ? rg.stdout.split("\n").map((s) => s.trim()).filter(Boolean) : listRecursive(projectRoot);
   }
-  return files.filter((file) => isCodeFile(file) && !shouldIgnore(file)).slice(0, maxFiles).sort();
+  return files.map((file) => file.replaceAll(path54.sep, "/")).filter((file) => isChunkable(file) && !shouldIgnore(file)).slice(0, maxFiles).sort();
 }
 function parseImportPaths2(importText) {
   const paths = [];
-  const fromRegex = /from\s+["']([^"']+)["']/g;
-  let match;
-  while ((match = fromRegex.exec(importText)) !== null) paths.push(match[1]);
-  const bareRegex = /^import\s+["']([^"']+)["']/gm;
-  while ((match = bareRegex.exec(importText)) !== null) {
-    if (!paths.includes(match[1])) paths.push(match[1]);
-  }
-  const requireRegex = /require\(["']([^"']+)["']\)/g;
-  while ((match = requireRegex.exec(importText)) !== null) {
-    if (!paths.includes(match[1])) paths.push(match[1]);
+  const patterns = [/from\s+["']([^"']+)["']/g, /^import\s+["']([^"']+)["']/gm, /require\(["']([^"']+)["']\)/g, /use\s+([A-Za-z0-9_:]+)::/g, /#include\s+[<"]([^>"]+)[>"]/g];
+  for (const regex of patterns) {
+    let match;
+    while ((match = regex.exec(importText)) !== null) if (!paths.includes(match[1])) paths.push(match[1]);
   }
   return paths;
 }
 function resolveImport(fromFile, importPath, allFiles) {
   if (!importPath.startsWith(".")) return null;
   const base = path54.posix.normalize(path54.posix.join(path54.posix.dirname(fromFile.replaceAll(path54.sep, "/")), importPath));
-  const withoutKnownExt = base.replace(/\.(?:js|jsx|ts|tsx)$/, "");
-  const candidates = [
-    base,
-    `${withoutKnownExt}.ts`,
-    `${withoutKnownExt}.tsx`,
-    `${withoutKnownExt}.js`,
-    `${withoutKnownExt}.jsx`,
-    `${base}.ts`,
-    `${base}.tsx`,
-    `${base}.js`,
-    `${base}.jsx`,
-    path54.posix.join(base, "index.ts"),
-    path54.posix.join(base, "index.tsx"),
-    path54.posix.join(base, "index.js"),
-    path54.posix.join(base, "index.jsx")
-  ];
+  const withoutKnownExt = base.replace(/\.(?:[a-z0-9]+)$/i, "");
+  const candidates = [base];
+  for (const ext of ["ts", "tsx", "js", "jsx", "py", "rs", "go", "java", "cs", "cpp", "c", "rb", "php", "swift", "kt", "scala", "sql", "md", "json", "yaml", "yml"]) {
+    candidates.push(`${withoutKnownExt}.${ext}`, `${base}.${ext}`);
+  }
+  for (const indexName of ["index.ts", "index.tsx", "index.js", "mod.rs", "__init__.py"]) candidates.push(path54.posix.join(base, indexName));
   return candidates.find((candidate) => allFiles.has(candidate)) ?? null;
 }
 function symbolId(filePath, chunk) {
@@ -30105,39 +30350,32 @@ function buildFileRecord(projectRoot, relPath, allFiles, previous) {
   try {
     stat = statSync10(absPath);
   } catch {
-    return null;
+    return { record: null, reused: false };
   }
-  if (!stat.isFile()) return null;
+  if (!stat.isFile()) return { record: null, reused: false };
+  const language = languageForFile(relPath);
+  if (!language || !isChunkable(relPath)) return { record: null, reused: false };
   const source = readFileSync35(absPath, "utf8");
   const hash = hashText(source);
-  if (previous && previous.hash === hash && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size) {
-    return previous;
+  if (previous && previous.hash === hash && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size && previous.language === language) {
+    return { record: previous, reused: true };
   }
-  if (!isChunkable(relPath)) return null;
   const chunks = chunkSourceFile(source, relPath);
   const imports = chunks.filter((chunk) => chunk.kind === "import").flatMap((chunk) => parseImportPaths2(chunk.text));
   const resolvedImports = imports.map((importPath) => resolveImport(relPath, importPath, allFiles)).filter((file) => Boolean(file));
-  const symbols = chunks.filter((chunk) => chunk.kind !== "import" && chunk.name !== "(unknown)").map((chunk) => ({
+  const symbols = chunks.filter((chunk) => chunk.name !== "(unknown)").map((chunk) => ({
     id: symbolId(relPath, chunk),
     name: chunk.name,
     kind: chunk.kind,
     filePath: relPath,
+    language,
     startLine: chunk.startLine,
     endLine: chunk.endLine,
     summary: summarizeChunk(chunk, relPath),
-    text: chunk.text.slice(0, 6e3),
+    text: chunk.text.slice(0, 8e3),
     comment: chunk.comment
   }));
-  return {
-    path: relPath,
-    absPath,
-    hash,
-    mtimeMs: stat.mtimeMs,
-    size: stat.size,
-    imports,
-    resolvedImports,
-    symbols
-  };
+  return { record: { path: relPath, absPath, language, hash, mtimeMs: stat.mtimeMs, size: stat.size, imports, resolvedImports, symbols }, reused: false };
 }
 function buildCodeContextIndex(options = {}) {
   const projectRoot = normalizeProjectRoot(options.projectRoot);
@@ -30147,17 +30385,27 @@ function buildCodeContextIndex(options = {}) {
   const files = listCodeFiles(projectRoot, maxFiles);
   const allFiles = new Set(files.map((file) => file.replaceAll(path54.sep, "/")));
   const fileRecords = {};
+  let rebuiltFiles = 0;
+  let reusedFiles = 0;
+  let skippedFiles = 0;
   for (const rel of files) {
     const normalized = rel.replaceAll(path54.sep, "/");
-    const record = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
-    if (record) fileRecords[normalized] = record;
-  }
+    const { record, reused } = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
+    if (record) {
+      fileRecords[normalized] = record;
+      if (reused) reusedFiles++;
+      else rebuiltFiles++;
+    } else skippedFiles++;
+  }
+  const languageBreakdown = {};
+  for (const file of Object.values(fileRecords)) languageBreakdown[file.language] = (languageBreakdown[file.language] ?? 0) + 1;
   const index = {
     version: INDEX_VERSION,
     projectRoot,
     rootHash: hashText(projectRoot).slice(0, 16),
     branch,
     indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stats: { filesSeen: files.length, filesIndexed: Object.keys(fileRecords).length, rebuiltFiles, reusedFiles, skippedFiles, languageBreakdown },
     files: fileRecords
   };
   saveIndex(index);
@@ -30185,13 +30433,60 @@ function loadOrBuildCodeContextIndex(options = {}) {
   }
   return buildCodeContextIndex(options);
 }
+function normalizeLanguage(language) {
+  return language.toLowerCase().replace(/^c\+\+$/, "cpp").replace(/^c#$/, "csharp").replace(/^js$/, "javascript").replace(/^ts$/, "typescript");
+}
 function tokenize(query) {
-  return query.toLowerCase().split(/[^a-z0-9_.$/-]+/).map((s) => s.trim()).filter((s) => s.length >= 2);
+  const raw = query.toLowerCase().replace(/([a-z])([A-Z])/g, "$1 $2").split(/[^a-z0-9_.$/-]+/).map((s) => s.trim()).filter((s) => s.length >= 2);
+  const expanded = /* @__PURE__ */ new Set();
+  for (const term of raw) {
+    expanded.add(term);
+    for (const part of term.split(/[_.$/-]+/)) if (part.length >= 2) expanded.add(part);
+    const dashed = term.replace(/[_.$/]+/g, "-");
+    if (dashed.length >= 2) expanded.add(dashed);
+    if (!term.includes("-")) expanded.add(`${term}s`);
+    if (term.endsWith("s") && term.length > 3) expanded.add(term.slice(0, -1));
+  }
+  return [...expanded];
+}
+function ngrams(terms) {
+  const grams = [...terms];
+  for (let i = 0; i < terms.length - 1; i++) grams.push(`${terms[i]} ${terms[i + 1]}`);
+  return grams;
+}
+function globToRegex(pattern) {
+  let out = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    const next = pattern[i + 1];
+    if (ch === "*" && next === "*") {
+      out += ".*";
+      i++;
+      continue;
+    }
+    if (ch === "*") {
+      out += "[^/]*";
+      continue;
+    }
+    if (".+^${}()|[]\\".includes(ch)) out += `\\${ch}`;
+    else out += ch;
+  }
+  return new RegExp(`^${out}$`);
+}
+function matchesPath(filePath, patterns) {
+  if (!patterns || patterns.length === 0) return true;
+  const normalized = filePath.replaceAll(path54.sep, "/");
+  return patterns.some((pattern) => {
+    const p = pattern.replaceAll(path54.sep, "/").replace(/^\.\//, "");
+    return normalized === p || normalized.startsWith(`${p}/`) || normalized.endsWith(p) || globToRegex(p).test(normalized);
+  });
 }
 function scoreSymbol(symbol, terms) {
+  const grams = ngrams(terms);
   const haystacks = {
     name: symbol.name.toLowerCase(),
     path: symbol.filePath.toLowerCase(),
+    language: symbol.language.toLowerCase(),
     summary: symbol.summary.toLowerCase(),
     text: symbol.text.toLowerCase()
   };
@@ -30199,41 +30494,73 @@ function scoreSymbol(symbol, terms) {
   const matches = [];
   for (const term of terms) {
     if (haystacks.name === term) {
-      score += 80;
+      score += 100;
       matches.push(`name=${term}`);
       continue;
     }
     if (haystacks.name.includes(term)) {
-      score += 40;
+      score += 45;
       matches.push(`name~${term}`);
     }
     if (haystacks.path.includes(term)) {
-      score += 15;
+      score += 18;
       matches.push(`path~${term}`);
     }
+    if (haystacks.language === term) {
+      score += 18;
+      matches.push(`language=${term}`);
+    }
     if (haystacks.summary.includes(term)) {
-      score += 12;
+      score += 16;
       matches.push(`summary~${term}`);
     }
     if (haystacks.text.includes(term)) {
-      score += 4;
+      score += 5;
       matches.push(`text~${term}`);
     }
   }
+  for (const gram of grams.filter((g) => g.includes(" "))) {
+    if (haystacks.text.includes(gram) || haystacks.summary.includes(gram)) {
+      score += 20;
+      matches.push(`phrase~${gram}`);
+    }
+  }
+  const uniqueMatches = new Set(matches.map((m) => m.replace(/^[^=~]+[=~]/, ""))).size;
+  score += uniqueMatches * 3;
   return { score, matches };
 }
+function filteredFiles(index, options = {}) {
+  const languages = options.languages?.map(normalizeLanguage).filter(Boolean);
+  return Object.values(index.files).filter((file) => {
+    if (languages && languages.length > 0 && !languages.includes(normalizeLanguage(file.language))) return false;
+    return matchesPath(file.path, options.paths);
+  });
+}
 function searchCodeContext(query, options = {}) {
   const terms = tokenize(query);
   if (terms.length === 0) return [];
-  const index = loadOrBuildCodeContextIndex(options);
+  const index = loadOrBuildCodeContextIndex({ projectRoot: options.projectRoot, force: options.force || options.refreshIndex, maxFiles: options.maxFiles });
   const results = [];
-  for (const file of Object.values(index.files)) {
+  for (const file of filteredFiles(index, options)) {
     for (const symbol of file.symbols) {
       const scored = scoreSymbol(symbol, terms);
-      if (scored.score > 0) results.push({ symbol, score: scored.score, matches: scored.matches });
+      if (scored.score > 0) {
+        results.push({
+          symbol,
+          score: scored.score,
+          matches: scored.matches,
+          filePath: symbol.filePath,
+          language: symbol.language,
+          content: symbol.text,
+          startLine: symbol.startLine,
+          endLine: symbol.endLine
+        });
+      }
     }
   }
-  return results.sort((a, b) => b.score - a.score || a.symbol.filePath.localeCompare(b.symbol.filePath)).slice(0, options.limit ?? 20);
+  const offset = Math.max(0, options.offset ?? 0);
+  const limit = options.limit ?? 20;
+  return results.sort((a, b) => b.score - a.score || a.filePath.localeCompare(b.filePath)).slice(offset, offset + limit);
 }
 function dependentsMap(index) {
   const map = /* @__PURE__ */ new Map();
@@ -30261,19 +30588,10 @@ function traceCodeSymbol(symbolName, options = {}) {
   const index = loadOrBuildCodeContextIndex(options);
   const matches = findSymbols(index, symbolName, options.limit ?? 20);
   const dependents = dependentsMap(index);
-  return {
-    query: symbolName,
-    matches,
-    definitions: matches.map((symbol) => {
-      const file = index.files[symbol.filePath];
-      return {
-        symbol,
-        imports: file.resolvedImports,
-        dependents: [...dependents.get(symbol.filePath) ?? /* @__PURE__ */ new Set()].sort(),
-        relatedSymbols: file.symbols.filter((s) => s.id !== symbol.id).slice(0, 20)
-      };
-    })
-  };
+  return { query: symbolName, matches, definitions: matches.map((symbol) => {
+    const file = index.files[symbol.filePath];
+    return { symbol, imports: file.resolvedImports, dependents: [...dependents.get(symbol.filePath) ?? /* @__PURE__ */ new Set()].sort(), relatedSymbols: file.symbols.filter((s) => s.id !== symbol.id).slice(0, 20) };
+  }) };
 }
 function resolveTargetFile(index, input) {
   if (input.filePath) {
@@ -30313,20 +30631,10 @@ function analyzeBlastRadius(input) {
     const lower = file.toLowerCase();
     return (lower.includes("test") || lower.includes("spec")) && (lower.includes(targetBase) || (symbolLower ? index.files[file].symbols.some((s) => s.text.toLowerCase().includes(symbolLower)) : false));
   });
-  for (const test of tests) {
-    if (!impacted.has(test)) impacted.set(test, { distance: 1, reason: "related test/spec" });
-  }
+  for (const test of tests) if (!impacted.has(test)) impacted.set(test, { distance: 1, reason: "related test/spec" });
   const impactedFiles = [...impacted.entries()].map(([filePath, value]) => ({ filePath, distance: value.distance, reason: value.reason })).sort((a, b) => a.distance - b.distance || a.filePath.localeCompare(b.filePath));
   const nonTestImpacted = impactedFiles.filter((f) => !f.filePath.match(/(test|spec)\./i)).length;
-  const riskLevel = nonTestImpacted >= 8 ? "high" : nonTestImpacted >= 4 ? "medium" : "low";
-  return {
-    target: target.target,
-    targetFile: target.filePath,
-    impactedFiles,
-    tests,
-    symbolsInTarget: index.files[target.filePath]?.symbols ?? [],
-    riskLevel
-  };
+  return { target: target.target, targetFile: target.filePath, impactedFiles, tests, symbolsInTarget: index.files[target.filePath]?.symbols ?? [], riskLevel: nonTestImpacted >= 8 ? "high" : nonTestImpacted >= 4 ? "medium" : "low" };
 }
 function getCodeContextStats(options = {}) {
   const index = loadOrBuildCodeContextIndex(options);
@@ -30334,27 +30642,31 @@ function getCodeContextStats(options = {}) {
     projectRoot: index.projectRoot,
     branch: index.branch,
     indexedAt: index.indexedAt,
+    indexAgeMs: Math.max(0, Date.now() - Date.parse(index.indexedAt)),
     files: Object.keys(index.files).length,
     symbols: Object.values(index.files).reduce((sum, file) => sum + file.symbols.length, 0),
     imports: Object.values(index.files).reduce((sum, file) => sum + file.resolvedImports.length, 0),
+    languageBreakdown: index.stats.languageBreakdown,
+    rebuiltFiles: index.stats.rebuiltFiles,
+    reusedFiles: index.stats.reusedFiles,
+    skippedFiles: index.stats.skippedFiles,
     indexPath: getCodeContextIndexPath(index.projectRoot)
   };
 }
-var INDEX_VERSION, DEFAULT_MAX_FILES, CODE_EXTENSIONS, IGNORE_SEGMENTS;
+var INDEX_VERSION, DEFAULT_MAX_FILES, IGNORE_SEGMENTS;
 var init_code_context_index = __esm({
   "src/lib/code-context-index.ts"() {
     "use strict";
     init_config();
     init_code_chunker();
-    INDEX_VERSION = 1;
-    DEFAULT_MAX_FILES = 2e3;
-    CODE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
-    IGNORE_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage", ".worktrees", ".next", "build"]);
+    INDEX_VERSION = 2;
+    DEFAULT_MAX_FILES = 5e3;
+    IGNORE_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage", ".worktrees", ".next", "build", "target", "vendor"]);
   }
 });
 
 // src/mcp/tools/code-context.ts
-import { z as z88 } from "zod";
+import { z as z89 } from "zod";
 function errorResult10(text3) {
   return { content: [{ type: "text", text: text3 }], isError: true };
 }
@@ -30366,17 +30678,21 @@ function registerCodeContext(server) {
     title: "Code Context",
     description: "Persistent codebase context engine. One consolidated tool to avoid MCP bloat. Actions: index, search, trace, blast_radius, stats.",
     inputSchema: {
-      action: z88.enum(["index", "search", "trace", "blast_radius", "stats"]).describe("Code context operation"),
-      project_root: z88.string().optional().describe("Repository root. Defaults to current working directory."),
-      query: z88.string().optional().describe("Search query for action=search"),
-      symbol: z88.string().optional().describe("Symbol/function/class/type name for trace or blast_radius"),
-      file_path: z88.string().optional().describe("File path for blast_radius"),
-      force: z88.boolean().optional().describe("Force rebuild before answering"),
-      limit: z88.coerce.number().int().min(1).max(100).optional().describe("Max results"),
-      depth: z88.coerce.number().int().min(1).max(5).optional().describe("Dependent traversal depth for blast_radius"),
-      max_files: z88.coerce.number().int().min(1).max(1e4).optional().describe("Max code files to index")
-    }
-  }, async ({ action, project_root, query, symbol, file_path, force, limit, depth, max_files }) => {
+      action: z89.enum(["index", "search", "trace", "blast_radius", "stats"]).describe("Code context operation"),
+      project_root: z89.string().optional().describe("Repository root. Defaults to current working directory."),
+      query: z89.string().optional().describe("Search query for action=search"),
+      symbol: z89.string().optional().describe("Symbol/function/class/type name for trace or blast_radius"),
+      file_path: z89.string().optional().describe("File path for blast_radius"),
+      force: z89.boolean().optional().describe("Force rebuild before answering"),
+      limit: z89.coerce.number().int().min(1).max(100).optional().describe("Max results"),
+      offset: z89.coerce.number().int().min(0).optional().describe("Search pagination offset"),
+      refresh_index: z89.boolean().optional().describe("Refresh/rebuild index before searching"),
+      languages: z89.array(z89.string()).optional().describe('Language filters, e.g. ["python", "typescript"]'),
+      paths: z89.array(z89.string()).optional().describe("Path/glob filters"),
+      depth: z89.coerce.number().int().min(1).max(5).optional().describe("Dependent traversal depth for blast_radius"),
+      max_files: z89.coerce.number().int().min(1).max(1e4).optional().describe("Max code files to index")
+    }
+  }, async ({ action, project_root, query, symbol, file_path, force, limit, offset, refresh_index, languages, paths, depth, max_files }) => {
     const opts = { projectRoot: project_root, force, maxFiles: max_files };
     if (action === "index") {
       const index = buildCodeContextIndex(opts);
@@ -30394,7 +30710,15 @@ function registerCodeContext(server) {
     }
     if (action === "search") {
       if (!query) return errorResult10('code_context action "search" requires query');
-      return jsonResult({ query, results: searchCodeContext(query, { ...opts, limit }) });
+      return jsonResult({
+        query,
+        limit: limit ?? 20,
+        offset: offset ?? 0,
+        refresh_index: refresh_index ?? false,
+        languages: languages ?? [],
+        paths: paths ?? [],
+        results: searchCodeContext(query, { ...opts, limit, offset, refreshIndex: refresh_index, languages, paths })
+      });
     }
     if (action === "trace") {
       if (!symbol) return errorResult10('code_context action "trace" requires symbol');
@@ -30417,7 +30741,7 @@ var init_code_context = __esm({
 });
 
 // src/mcp/tools/support-inbox.ts
-import { z as z89 } from "zod";
+import { z as z90 } from "zod";
 function adminToken() {
   return process.env.ASKEXE_SUPPORT_ADMIN_TOKEN || process.env.EXE_SUPPORT_ADMIN_TOKEN;
 }
@@ -30456,9 +30780,9 @@ function registerListBugReports(server) {
       title: "List Bug Reports",
       description: "AskExe-internal only: list incoming customer bug reports from the support inbox.",
       inputSchema: {
-        status: z89.enum(["all", "open", "triaged", "fixed", "closed", "wontfix"]).default("open"),
-        severity: z89.enum(["p0", "p1", "p2", "p3"]).optional(),
-        limit: z89.number().int().min(1).max(100).default(25)
+        status: z90.enum(["all", "open", "triaged", "fixed", "closed", "wontfix"]).default("open"),
+        severity: z90.enum(["p0", "p1", "p2", "p3"]).optional(),
+        limit: z90.number().int().min(1).max(100).default(25)
       }
     },
     async ({ status, severity, limit }) => {
@@ -30477,7 +30801,7 @@ function registerGetBugReport(server) {
     {
       title: "Get Bug Report",
       description: "AskExe-internal only: fetch one customer bug report with full markdown payload.",
-      inputSchema: { id: z89.string().min(8) }
+      inputSchema: { id: z90.string().min(8) }
     },
     async ({ id }) => {
       const data = await requestJson(`${endpoint()}/${encodeURIComponent(id)}`);
@@ -30492,12 +30816,12 @@ function registerTriageBugReport(server) {
       title: "Triage Bug Report",
       description: "AskExe-internal only: update bug report status and link task/commit/release metadata.",
       inputSchema: {
-        id: z89.string().min(8),
+        id: z90.string().min(8),
         status: STATUS.optional(),
-        triage_notes: z89.string().optional(),
-        linked_task_id: z89.string().optional(),
-        linked_commit: z89.string().optional(),
-        fixed_version: z89.string().optional()
+        triage_notes: z90.string().optional(),
+        linked_task_id: z90.string().optional(),
+        linked_commit: z90.string().optional(),
+        fixed_version: z90.string().optional()
       }
     },
     async ({ id, status, triage_notes, linked_task_id, linked_commit, fixed_version }) => {
@@ -30514,7 +30838,7 @@ var init_support_inbox = __esm({
   "src/mcp/tools/support-inbox.ts"() {
     "use strict";
     DEFAULT_ENDPOINT = "https://askexe.com/admin/support/bug-reports";
-    STATUS = z89.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
+    STATUS = z90.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
   }
 });
 
@@ -30588,6 +30912,8 @@ var init_tool_gates = __esm({
       registerStoreDecision: "core",
       registerGetDecision: "core",
       registerCreateBugReport: "core",
+      registerGetSessionEvents: "core",
+      registerGetLastAssistantResponse: "core",
       registerCodeContext: "graph-read",
       registerListBugReports: "admin",
       registerGetBugReport: "admin",
@@ -30843,6 +31169,8 @@ function registerAllTools(server) {
   gate("registerStoreDecision", registerStoreDecision);
   gate("registerGetDecision", registerGetDecision);
   gate("registerCreateBugReport", registerCreateBugReport);
+  gate("registerGetSessionEvents", registerGetSessionEvents);
+  gate("registerGetLastAssistantResponse", registerGetLastAssistantResponse);
   gate("registerCodeContext", registerCodeContext);
   if (process.env.ASKEXE_SUPPORT_ADMIN_TOKEN || process.env.EXE_SUPPORT_ADMIN_TOKEN) {
     gate("registerListBugReports", registerListBugReports);
@@ -30988,6 +31316,7 @@ var init_register_tools = __esm({
     init_activate_license();
     init_query_company_brain();
     init_create_bug_report();
+    init_get_session_events();
     init_code_context();
     init_support_inbox();
     init_tool_gates();
@@ -32055,7 +32384,7 @@ init_daemon_auth();
 import os24 from "os";
 import net2 from "net";
 import { createServer as createHttpServer } from "http";
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { writeFileSync as writeFileSync28, unlinkSync as unlinkSync14, mkdirSync as mkdirSync24, existsSync as existsSync46, readFileSync as readFileSync39, chmodSync as chmodSync2 } from "fs";
 import path59 from "path";
 
@@ -32139,6 +32468,7 @@ var DAEMON_TOKEN_ENV2 = "EXE_DAEMON_TOKEN";
 var _context = null;
 var _model = null;
 var _llama = null;
+var _shuttingDown = false;
 var _daemonToken = "";
 var MAX_QUEUE_SIZE = 1e3;
 var highQueue = [];
@@ -32240,6 +32570,8 @@ function checkIdle() {
   }
 }
 async function shutdown() {
+  if (_shuttingDown) return;
+  _shuttingDown = true;
   resetIdleTimer2();
   flushToDisk();
   try {
@@ -32252,6 +32584,19 @@ async function shutdown() {
     disposeShards2();
   } catch {
   }
+  if (process.platform === "darwin" && _llama) {
+    try {
+      unlinkSync14(SOCKET_PATH2);
+    } catch {
+    }
+    try {
+      unlinkSync14(PID_PATH4);
+    } catch {
+    }
+    process.stderr.write("[exed] Shutdown complete (darwin fast native exit).\n");
+    process.kill(process.pid, "SIGKILL");
+    process.exit(0);
+  }
   if (_context) {
     try {
       await _context.dispose();
@@ -32266,7 +32611,13 @@ async function shutdown() {
     }
     _model = null;
   }
-  _llama = null;
+  if (_llama) {
+    try {
+      await _llama.dispose();
+    } catch {
+    }
+    _llama = null;
+  }
   try {
     unlinkSync14(SOCKET_PATH2);
   } catch {
@@ -32423,7 +32774,7 @@ async function handleBatchWriteMemory(socket, requestId, entries) {
   }
 }
 async function writeMemoryRecord(entry) {
-  const id = randomUUID9();
+  const id = randomUUID10();
   const now2 = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
   const governed = governMemoryRecord({
     id,
@@ -32745,16 +33096,22 @@ async function startMcpHttpServer() {
       for (const [sid, lastSeen] of sessionLastSeen.entries()) {
         if (now2 - lastSeen > MCP_SESSION_TTL_MS) closeMcpSession2(sid, "session_expired");
       }
-    }, sendJsonRpcError2 = function(res, status, message, extra) {
+    }, getJsonRpcId2 = function(body) {
+      if (body && typeof body === "object" && !Array.isArray(body) && "id" in body) {
+        const id = body.id;
+        if (typeof id === "string" || typeof id === "number") return id;
+      }
+      return "unknown";
+    }, sendJsonRpcError2 = function(res, status, message, id, extra) {
       res.writeHead(status, { "Content-Type": "application/json" });
       res.end(JSON.stringify({
         jsonrpc: "2.0",
         error: { code: -32e3, message },
-        id: null
+        id
       }));
       recordMcpHttpEvent({ level: "warn", message, status, ...extra });
     };
-    var parseDurationMs = parseDurationMs2, closeMcpSession = closeMcpSession2, sweepStaleMcpSessions = sweepStaleMcpSessions2, sendJsonRpcError = sendJsonRpcError2;
+    var parseDurationMs = parseDurationMs2, closeMcpSession = closeMcpSession2, sweepStaleMcpSessions = sweepStaleMcpSessions2, getJsonRpcId = getJsonRpcId2, sendJsonRpcError = sendJsonRpcError2;
     const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
     const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
     const { isInitializeRequest } = await import("@modelcontextprotocol/sdk/types.js");
@@ -32783,14 +33140,14 @@ async function startMcpHttpServer() {
       const url = new URL(req.url || "/", `http://127.0.0.1:${MCP_HTTP_PORT}`);
       const authHeader = req.headers.authorization;
       if (!authHeader || authHeader !== `Bearer ${_daemonToken}`) {
-        sendJsonRpcError2(res, 401, "Unauthorized: invalid or missing daemon token", {
+        sendJsonRpcError2(res, 401, "Unauthorized: invalid or missing daemon token", "unknown", {
           method: req.method,
           path: url.pathname
         });
         return;
       }
       if (url.pathname !== "/mcp") {
-        sendJsonRpcError2(res, 404, "Not Found: MCP endpoint is /mcp", {
+        sendJsonRpcError2(res, 404, "Not Found: MCP endpoint is /mcp", "unknown", {
           method: req.method,
           path: url.pathname
         });
@@ -32814,7 +33171,7 @@ async function startMcpHttpServer() {
         });
         parsedBody = body ? JSON.parse(body) : void 0;
       } catch (err) {
-        sendJsonRpcError2(res, 400, "Bad Request: invalid JSON body", {
+        sendJsonRpcError2(res, 400, "Bad Request: invalid JSON body", "unknown", {
           method: req.method,
           agentId,
           agentRole,
@@ -32830,7 +33187,7 @@ async function startMcpHttpServer() {
         sessionLastSeen.set(sessionId, Date.now());
       } else if (!sessionId && req.method === "POST" && isInitializeRequest(parsedBody)) {
         transport = new StreamableHTTPServerTransport({
-          sessionIdGenerator: () => randomUUID9(),
+          sessionIdGenerator: () => randomUUID10(),
           onsessioninitialized: (sid) => {
             transports.set(sid, transport);
             sessionLastSeen.set(sid, Date.now());
@@ -32855,7 +33212,7 @@ async function startMcpHttpServer() {
         await sessionMcp.connect(transport);
       } else {
         const message = sessionId ? "Bad Request: MCP session is stale or unknown; reconnect MCP client" : "Bad Request: missing MCP session; initialize before tool calls";
-        sendJsonRpcError2(res, 400, message, {
+        sendJsonRpcError2(res, 400, message, getJsonRpcId2(parsedBody), {
           method: req.method,
           hasSessionId: Boolean(sessionId),
           sessionId,
@@ -32914,7 +33271,7 @@ async function startMcpHttpServer() {
           error: err instanceof Error ? err.message : String(err)
         });
         if (!res.headersSent) {
-          sendJsonRpcError2(res, 500, "Internal Server Error: MCP request failed", {
+          sendJsonRpcError2(res, 500, "Internal Server Error: MCP request failed", getJsonRpcId2(parsedBody), {
             method: req.method,
             sessionId,
             agentId,
@@ -33582,8 +33939,31 @@ function startBackgroundJobGuardrails() {
   timer.unref();
   process.stderr.write("[exed] Background job guardrails started (every 60s)\n");
 }
-process.on("SIGINT", () => void shutdown());
-process.on("SIGTERM", () => void shutdown());
+function handleSignalShutdown() {
+  if (process.platform === "darwin" && _llama) {
+    if (_shuttingDown) return;
+    _shuttingDown = true;
+    resetIdleTimer2();
+    try {
+      flushToDisk();
+    } catch {
+    }
+    try {
+      unlinkSync14(SOCKET_PATH2);
+    } catch {
+    }
+    try {
+      unlinkSync14(PID_PATH4);
+    } catch {
+    }
+    process.stderr.write("[exed] Shutdown complete (darwin signal fast native exit).\n");
+    process.kill(process.pid, "SIGKILL");
+    process.exit(0);
+  }
+  void shutdown();
+}
+process.on("SIGINT", handleSignalShutdown);
+process.on("SIGTERM", handleSignalShutdown);
 function checkExistingDaemon() {
   try {
     if (!existsSync46(PID_PATH4)) return false;