@askexenow/exe-os 0.9.70 → 0.9.71

package/dist/mcp/server.js

@@ -2915,6 +2915,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,
@@ -26997,9 +27024,199 @@ Upstream status: ${upstreamStatus}`
   );
 }
 
-// src/mcp/tools/code-context.ts
+// src/mcp/tools/get-session-events.ts
+init_active_agent();
+init_fast_db_init();
 import { z as z88 } from "zod";
 
+// src/lib/session-events.ts
+init_task_scope();
+init_project_name();
+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)
+  }));
+}
+
+// src/mcp/tools/get-session-events.ts
+var EVENT_TYPE = z88.enum([
+  "user_prompt",
+  "assistant_response",
+  "tool_call",
+  "tool_result",
+  "system_event"
+]);
+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(server2) {
+  server2.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(server2) {
+  server2.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]) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/code-context.ts
+import { z as z89 } from "zod";
+
 // src/lib/code-context-index.ts
 init_config();
 import crypto19 from "crypto";
@@ -27414,19 +27631,19 @@ function registerCodeContext(server2) {
     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"),
-      offset: z88.coerce.number().int().min(0).optional().describe("Search pagination offset"),
-      refresh_index: z88.boolean().optional().describe("Refresh/rebuild index before searching"),
-      languages: z88.array(z88.string()).optional().describe('Language filters, e.g. ["python", "typescript"]'),
-      paths: z88.array(z88.string()).optional().describe("Path/glob filters"),
-      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")
+      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 };
@@ -27471,9 +27688,9 @@ function registerCodeContext(server2) {
 }
 
 // src/mcp/tools/support-inbox.ts
-import { z as z89 } from "zod";
+import { z as z90 } from "zod";
 var DEFAULT_ENDPOINT = "https://askexe.com/admin/support/bug-reports";
-var STATUS = z89.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
+var STATUS = z90.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
 function adminToken() {
   return process.env.ASKEXE_SUPPORT_ADMIN_TOKEN || process.env.EXE_SUPPORT_ADMIN_TOKEN;
 }
@@ -27512,9 +27729,9 @@ function registerListBugReports(server2) {
       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 }) => {
@@ -27533,7 +27750,7 @@ function registerGetBugReport(server2) {
     {
       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)}`);
@@ -27548,12 +27765,12 @@ function registerTriageBugReport(server2) {
       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 }) => {
@@ -27616,6 +27833,8 @@ var TOOL_CATEGORIES = {
   registerStoreDecision: "core",
   registerGetDecision: "core",
   registerCreateBugReport: "core",
+  registerGetSessionEvents: "core",
+  registerGetLastAssistantResponse: "core",
   registerCodeContext: "graph-read",
   registerListBugReports: "admin",
   registerGetBugReport: "admin",
@@ -27881,6 +28100,8 @@ function registerAllTools(server2) {
   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);

package/dist/runtime/index.js

@@ -3006,6 +3006,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,

package/dist/tui/App.js

@@ -3258,6 +3258,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.9.70",
+  "version": "0.9.71",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",