macro-agent 0.0.15 → 0.0.17

package/src/map/adapter/acp-over-map.ts

@@ -117,11 +117,11 @@ export class ACPOverMAPHandler {
           break;
 
         case "session/new":
-          result = await this.handleNewSession(streamState, acp.params);
+          result = await this.handleNewSession(streamState, acp.params, emitNotification);
           break;
 
         case "session/load":
-          result = await this.handleLoadSession(streamState, acp.params);
+          result = await this.handleLoadSession(streamState, acp.params, emitNotification);
           break;
 
         case "authenticate":
@@ -201,6 +201,7 @@ export class ACPOverMAPHandler {
   private async handleNewSession(
     streamState: StreamState,
     params: unknown,
+    emitNotification?: ACPNotificationEmitter,
   ): Promise<unknown> {
     if (!streamState.initialized) {
       throw new Error("Must call initialize before newSession");
@@ -224,12 +225,16 @@ export class ACPOverMAPHandler {
 
     console.error(`[ACP-over-MAP] Created session ${sessionId} -> agent ${spawned.id}`);
 
+    // Emit session_info_update so client has title/timestamps
+    this.emitSessionInfo(streamState, sessionId, emitNotification);
+
     return { sessionId };
   }
 
   private async handleLoadSession(
     streamState: StreamState,
     params: unknown,
+    emitNotification?: ACPNotificationEmitter,
   ): Promise<unknown> {
     if (!streamState.initialized) {
       throw new Error("Must call initialize before loadSession");
@@ -271,7 +276,8 @@ export class ACPOverMAPHandler {
         streamState.sessionId = sessionId;
         streamState.agentId = existing.id;
         this.sessionMapper.createMapping(sessionId as ACPSessionId, existing.id);
-        return {};
+        this.emitSessionInfo(streamState, sessionId, emitNotification);
+        return { sessionId };
       }
 
       // Agent exists but no active session - resume it
@@ -280,7 +286,8 @@ export class ACPOverMAPHandler {
       streamState.sessionId = sessionId;
       streamState.agentId = spawned.id;
       this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
-      return {};
+      this.emitSessionInfo(streamState, sessionId, emitNotification);
+      return { sessionId };
     }
 
     // No existing agent found - create new with the specified session ID
@@ -293,8 +300,9 @@ export class ACPOverMAPHandler {
     streamState.sessionId = sessionId;
     streamState.agentId = spawned.id;
     this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
+    this.emitSessionInfo(streamState, sessionId, emitNotification);
 
-    return {};
+    return { sessionId };
   }
 
   private async handleAuthenticate(_params: unknown): Promise<unknown> {
@@ -314,7 +322,9 @@ export class ACPOverMAPHandler {
       messages?: Array<{ role: string; content: string }>;
     }) ?? {};
 
-    const sessionId = paramSessionId ?? sessionIdFromContext ?? streamState.sessionId;
+    // Prefer the server's resolved session ID (set during loadSession) over the
+    // client's acpContext.sessionId which may be stale (e.g., "_resolve_" sentinel)
+    const sessionId = streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
     if (!sessionId) {
       throw new Error("No session - call newSession or loadSession first");
     }
@@ -372,6 +382,15 @@ export class ACPOverMAPHandler {
       emitNotification(notification);
     };
 
+    // Ensure conversation exists in EventStore for history persistence
+    this.ensureConversation(sessionId as ACPSessionId, agentId);
+
+    // Accumulate response content for history recording
+    const buffer: { textChunks: string[]; toolCalls: Record<string, unknown>[] } = {
+      textChunks: [],
+      toolCalls: [],
+    };
+
     try {
       // Stream responses from the agent
       let updateCount = 0;
@@ -381,6 +400,27 @@ export class ACPOverMAPHandler {
           return { stopReason: "cancelled" };
         }
 
+        // Accumulate content for history persistence
+        const u = update as Record<string, unknown>;
+        const updateType = u.sessionUpdate as string ?? u.type as string;
+        if (updateType === "agent_message_chunk") {
+          const content = u.content as { type?: string; text?: string } | undefined;
+          if (content?.text) {
+            buffer.textChunks.push(content.text);
+          }
+        } else if (updateType === "tool_call" || updateType === "tool_call_update") {
+          const status = u.status as string | undefined;
+          if (status === "completed" || (updateType === "tool_call" && status !== "running")) {
+            buffer.toolCalls.push({
+              toolCallId: u.toolCallId,
+              title: u.title,
+              status: u.status,
+              input: u.rawInput,
+              output: u.output,
+            });
+          }
+        }
+
         // Stream the update back to the client
         emitSessionUpdate(update);
         updateCount++;
@@ -388,6 +428,12 @@ export class ACPOverMAPHandler {
 
       console.error(`[ACP-over-MAP] Prompt completed for agent ${agentId}, ${updateCount} updates`);
 
+      // Persist conversation turns for history
+      this.recordPromptTurns(sessionId as ACPSessionId, agentId, messageContent, buffer);
+
+      // Emit updated session info after prompt completes
+      this.emitSessionInfo(streamState, sessionId, emitNotification);
+
       return { stopReason: "end_turn" };
     } catch (error) {
       console.error(`[ACP-over-MAP] Prompt error:`, error);
@@ -406,7 +452,8 @@ export class ACPOverMAPHandler {
     sessionIdFromContext?: string,
   ): Promise<unknown> {
     const { sessionId: paramSessionId } = (params as { sessionId?: string }) ?? {};
-    const sessionId = paramSessionId ?? sessionIdFromContext ?? streamState.sessionId;
+    // Prefer server's resolved session ID over client's potentially stale one
+    const sessionId = streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
 
     // Signal cancellation
     streamState.abortController.abort();
@@ -527,11 +574,203 @@ export class ACPOverMAPHandler {
         };
       }
 
+      case "_macro/getHistory": {
+        const { sessionId, agentId: historyAgentId, limit } = methodParams as {
+          sessionId?: string;
+          agentId?: string;
+          limit?: number;
+        };
+
+        // Resolve conversationId: prefer agentId lookup (resolves to the
+        // original session_id where turns were recorded), fall back to
+        // explicit sessionId. This allows history to survive across server
+        // restarts even when the ACP session ID changes (e.g., resume()
+        // fails → TUI creates new session with different ID).
+        let conversationId: string | undefined;
+        if (historyAgentId) {
+          const agent = this.eventStore.getAgent(historyAgentId as AgentId);
+          if (agent) {
+            conversationId = agent.session_id;
+          }
+        }
+        if (!conversationId) {
+          conversationId = sessionId;
+        }
+        if (!conversationId) {
+          return { turns: [] };
+        }
+
+        const turns = this.eventStore.listTurns({
+          conversationId,
+          order: "asc",
+          limit: limit ?? 200,
+        });
+        return {
+          turns: turns.map((turn) => ({
+            role:
+              turn.contentType === "user_prompt"
+                ? ("user" as const)
+                : ("assistant" as const),
+            timestamp: turn.timestamp,
+            content: turn.content,
+          })),
+        };
+      }
+
       default:
         throw new Error(`Unknown extension method: ${method}`);
     }
   }
 
+  // ─────────────────────────────────────────────────────────────────
+  // History Persistence
+  // ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Ensure a conversation exists in the EventStore for a given session.
+   * This must be called before recording turns.
+   */
+  private ensureConversation(
+    acpSessionId: ACPSessionId,
+    agentId: AgentId,
+  ): void {
+    if (typeof this.eventStore.getConversation !== "function") {
+      return;
+    }
+
+    const existing = this.eventStore.getConversation(acpSessionId);
+    if (existing) return;
+
+    try {
+      this.eventStore.emit({
+        type: "conversation",
+        source: { agent_id: agentId },
+        payload: {
+          action: "created",
+          conversation_id: acpSessionId,
+          conversation_type: "session",
+          subject: `ACP session ${acpSessionId}`,
+        },
+      });
+    } catch (error) {
+      console.warn(
+        `[ACP-over-MAP] Failed to create conversation for session ${acpSessionId}:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
+  /**
+   * Record user and assistant turns after a prompt completes.
+   * Mirrors MacroAgent.recordPromptTurns() for the ACP-over-MAP path.
+   */
+  private recordPromptTurns(
+    acpSessionId: ACPSessionId,
+    agentId: AgentId,
+    userMessage: string,
+    buffer: { textChunks: string[]; toolCalls: Record<string, unknown>[] },
+  ): void {
+    const now = Date.now();
+
+    try {
+      // Record user turn
+      if (userMessage) {
+        this.eventStore.emit({
+          type: "turn",
+          source: { agent_id: agentId },
+          payload: {
+            action: "recorded",
+            turn_id: `turn_user_${now}_${Math.random().toString(36).slice(2, 8)}`,
+            conversation_id: acpSessionId,
+            participant: "user",
+            timestamp: now,
+            content_type: "user_prompt",
+            content: userMessage,
+            source_type: "explicit",
+          },
+        });
+      }
+
+      // Record assistant turn with accumulated content
+      const assistantText = buffer.textChunks.join("");
+      const parts: unknown[] = [];
+
+      if (assistantText) {
+        parts.push({ type: "text", text: assistantText });
+      }
+
+      for (const tool of buffer.toolCalls) {
+        parts.push({ type: "tool", ...tool });
+      }
+
+      if (parts.length > 0) {
+        this.eventStore.emit({
+          type: "turn",
+          source: { agent_id: agentId },
+          payload: {
+            action: "recorded",
+            turn_id: `turn_asst_${now}_${Math.random().toString(36).slice(2, 8)}`,
+            conversation_id: acpSessionId,
+            participant: agentId,
+            timestamp: now + 1,
+            content_type: "assistant_response",
+            content: { parts },
+            source_type: "explicit",
+          },
+        });
+      }
+    } catch (error) {
+      console.warn(
+        `[ACP-over-MAP] Failed to record turns for session ${acpSessionId}:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
+  // ─────────────────────────────────────────────────────────────────
+  // Session Info
+  // ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Emit a session_info_update notification with title and timestamps.
+   * Uses agent task as title and session mapping timestamps.
+   */
+  private emitSessionInfo(
+    streamState: StreamState,
+    sessionId: string,
+    emitNotification?: ACPNotificationEmitter,
+  ): void {
+    if (!emitNotification) return;
+
+    const mapping = this.sessionMapper.getMapping(sessionId as ACPSessionId);
+    const agentId = streamState.agentId;
+    const agent = agentId ? this.eventStore.getAgent(agentId as AgentId) : null;
+
+    const title = agent?.task ?? null;
+    const updatedAt = new Date(mapping?.updatedAt ?? Date.now()).toISOString();
+
+    const notification: ACPEnvelope = {
+      acp: {
+        jsonrpc: "2.0",
+        method: "session/update",
+        params: {
+          sessionId,
+          update: {
+            sessionUpdate: "session_info_update",
+            title,
+            updatedAt,
+          },
+        },
+      },
+      acpContext: {
+        streamId: streamState.streamId,
+        sessionId,
+        direction: "agent-to-client",
+      },
+    };
+    emitNotification(notification);
+  }
+
   // ─────────────────────────────────────────────────────────────────
   // Cleanup
   // ─────────────────────────────────────────────────────────────────

package/src/store/__tests__/event-store.test.ts

@@ -674,8 +674,7 @@ describe('Event Archival', () => {
   beforeEach(async () => {
     // Create a temporary directory for testing
     testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'event-store-test-'));
-    const storePath = path.join(testDir, 'store.json');
-    store = await createEventStore({ path: storePath });
+    store = await createEventStore({ baseDir: testDir, instanceId: 'archive-test' });
   });
 
   afterEach(async () => {
@@ -987,18 +986,11 @@ describe('Event Archival', () => {
       }
     });
 
-    it('should emit deprecation warning when using legacy path option', async () => {
+    it('should throw when using removed legacy path option', async () => {
       const legacyPath = path.join(testDir, 'legacy-store.json');
-      const legacyStore = await createEventStore({ path: legacyPath });
-
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('DEPRECATION WARNING')
-      );
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('path` option is deprecated')
+      await expect(createEventStore({ path: legacyPath })).rejects.toThrow(
+        'The `path` option has been removed'
       );
-
-      await legacyStore.close();
     });
 
     it('should not emit deprecation warning for new-style configuration', async () => {

package/src/store/__tests__/instance.test.ts

@@ -90,7 +90,6 @@ describe('Path Resolution', () => {
 
     expect(resolved.instancePath).toBe(':memory:');
     expect(resolved.isNew).toBe(true);
-    expect(resolved.isLegacy).toBe(false);
     expect(resolved.backendType).toBe('memory');
     expect(resolved.instanceId).toMatch(/^inst_/);
   });
@@ -142,15 +141,14 @@ describe('Path Resolution', () => {
     expect(resolved.namespace).toBe('my-project');
   });
 
-  it('should handle legacy path option', () => {
+  it('should ignore legacy path option and use defaults', () => {
     const legacyPath = path.join(testBaseDir, 'legacy-store.json');
-    const config: StoreConfig = { path: legacyPath };
+    const config: StoreConfig = { path: legacyPath, baseDir: testBaseDir };
     const resolved = resolveInstancePath(config);
 
-    expect(resolved.isLegacy).toBe(true);
-    expect(resolved.backendType).toBe('json');
-    expect(resolved.instancePath).toBe(legacyPath);
-    expect(resolved.instanceId).toBe('legacy-store');
+    // path option is no longer handled — resolveInstancePath ignores it
+    expect(resolved.backendType).toBe(DEFAULT_BACKEND_TYPE);
+    expect(resolved.instanceId).toMatch(/^inst_/);
   });
 
   it('should throw on invalid instance ID', () => {

package/src/store/event-store.ts

@@ -9,8 +9,8 @@
  */
 
 import { createStore, Store } from 'tinybase';
-import { createFilePersister } from 'tinybase/persisters/persister-file';
-import { createCustomPersister } from 'tinybase/persisters';
+import { createCustomPersister, createCustomSqlitePersister } from 'tinybase/persisters';
+import type { DatabasePersisterConfig } from 'tinybase/persisters';
 import Database from 'better-sqlite3';
 import { nanoid } from 'nanoid';
 import * as path from 'path';
@@ -65,38 +65,80 @@ import type { StorageBackend, ExportedEvent } from './backends/types.js';
 import { createTinyBaseBackend } from './backends/tinybase-backend.js';
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Custom better-sqlite3 Persister
+// Tabular better-sqlite3 Persister
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
- * Creates a custom TinyBase persister for better-sqlite3.
- * TinyBase's built-in createSqlite3Persister expects node-sqlite3 (async/callback API),
- * but we use better-sqlite3 (sync API). This custom persister bridges the gap.
+ * Build tabular config for the 10 TinyBase tables.
+ * Identity mapping: TinyBase table name === SQLite table name.
  */
-function createBetterSqlite3Persister(
+function getTabularConfig(): DatabasePersisterConfig {
+  const tableNames = [
+    'events', 'agents', 'tasks', 'messages',
+    'sessions', 'conversations', 'turns',
+    'threads', 'subscriptions', 'participants',
+  ];
+
+  const load: Record<string, string> = {};
+  const save: Record<string, string> = {};
+  for (const t of tableNames) {
+    load[t] = t;   // SQLite table -> TinyBase table (same name)
+    save[t] = t;   // TinyBase table -> SQLite table (same name)
+  }
+
+  return {
+    mode: 'tabular',
+    tables: { load, save },
+    autoLoadIntervalSeconds: 1,
+  };
+}
+
+/**
+ * Creates a tabular TinyBase persister backed by better-sqlite3.
+ *
+ * Unlike the old JSON blob approach (entire store as one JSON string in a
+ * single row), tabular mode maps each TinyBase table to a real SQLite table
+ * and only writes changed rows on autoSave — making persistence O(delta)
+ * instead of O(total).
+ */
+function createTabularBetterSqlite3Persister(
   store: Store,
   db: ReturnType<typeof Database>,
-  tableName: string = 'tinybase_store'
 ) {
-  // Create table if not exists
-  db.exec(`CREATE TABLE IF NOT EXISTS ${tableName} (_id TEXT PRIMARY KEY, store TEXT)`);
+  // Wrap better-sqlite3's sync API as the async DatabaseExecuteCommand.
+  // TinyBase generates SQL with $1, $2, ... placeholders (PostgreSQL-style),
+  // but better-sqlite3 uses ? for positional array binding. Convert them.
+  const executeCommand = async (sql: string, params?: any[]): Promise<Record<string, any>[]> => {
+    const convertedSql = sql.replace(/\$\d+/g, '?');
+    const trimmed = convertedSql.trimStart().toUpperCase();
+    const stmt = db.prepare(convertedSql);
+    if (trimmed.startsWith('SELECT') || trimmed.startsWith('PRAGMA')) {
+      return (params ? stmt.all(...params) : stmt.all()) as Record<string, any>[];
+    }
+    params ? stmt.run(...params) : stmt.run();
+    return [];
+  };
 
-  return createCustomPersister(
+  return createCustomSqlitePersister(
     store,
-    // getPersisted - load from SQLite
-    async () => {
-      const row = db.prepare(`SELECT store FROM ${tableName} WHERE _id = '_'`).get() as { store: string } | undefined;
-      return row ? JSON.parse(row.store) : undefined;
-    },
-    // setPersisted - save to SQLite
-    async (getContent) => {
-      const json = JSON.stringify(getContent());
-      db.prepare(`INSERT OR REPLACE INTO ${tableName} (_id, store) VALUES ('_', ?)`).run(json);
-    },
-    // addPersisterListener - poll for external changes (cross-process)
-    (listener) => setInterval(listener, 1000),
-    // delPersisterListener - cleanup polling
-    (interval: ReturnType<typeof setInterval>) => clearInterval(interval),
+    getTabularConfig(),
+    executeCommand,
+    // addChangeListener — better-sqlite3 has no native change events
+    (_listener: (tableName: string) => void) => null as any,
+    // delChangeListener — no-op
+    (_handle: any) => {},
+    // onSqlCommand
+    undefined,
+    // onIgnoredError
+    (error: any) => console.warn('[EventStore] Persister error:', error),
+    // destroy
+    () => db.close(),
+    // persist mode (1 = StoreOnly)
+    1 as any,
+    // thing (the db instance)
+    db,
+    // getThing accessor name
+    'getDb',
   );
 }
 
@@ -252,7 +294,15 @@ export function parseDuration(duration: string): number {
 export async function createEventStore(config: StoreConfig = {}): Promise<EventStore> {
   // Resolve instance configuration
   const resolved = resolveInstancePath(config);
-  const { instanceId, instancePath, namespace, isNew, isLegacy, backendType } = resolved;
+  const { instanceId, instancePath, namespace, isNew, backendType } = resolved;
+
+  // Reject deprecated legacy path option
+  if (config.path) {
+    throw new Error(
+      '[macro-agent] The `path` option has been removed. ' +
+        'Use `instanceId` and `baseDir` instead for per-instance isolation.'
+    );
+  }
 
   // Track baseDir for MCP subprocess communication
   const baseDir = config.baseDir ?? path.join(os.homedir(), '.multiagent');
@@ -261,15 +311,6 @@ export async function createEventStore(config: StoreConfig = {}): Promise<EventS
   const peerVisibility: PeerVisibilityConfig =
     config.peerVisibility ?? DEFAULT_PEER_VISIBILITY;
 
-  // Emit deprecation warning for legacy path option
-  if (isLegacy) {
-    console.warn(
-      '[macro-agent] DEPRECATION WARNING: The `path` option is deprecated and will be removed in a future version. ' +
-        'Use `instanceId` and `baseDir` instead for per-instance isolation. ' +
-        'See documentation for migration guide.'
-    );
-  }
-
   // Emit warning for in-memory mode (only in non-test environments)
   if (config.inMemory && process.env.NODE_ENV !== 'test') {
     console.warn(
@@ -282,31 +323,53 @@ export async function createEventStore(config: StoreConfig = {}): Promise<EventS
   const store = createStore();
 
   // Set up persister based on backend type
-  let persister: ReturnType<typeof createFilePersister> | ReturnType<typeof createBetterSqlite3Persister> | null = null;
+  let persister: ReturnType<typeof createTabularBetterSqlite3Persister> | null = null;
   let db: ReturnType<typeof Database> | null = null;
 
   if (!config.inMemory) {
-    if (isLegacy) {
-      // Legacy mode: Use JSON file persister at the specified path
-      const dir = path.dirname(instancePath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      persister = createFilePersister(store, instancePath);
-    } else {
-      // New instances: Use SQLite with custom better-sqlite3 persister
-      ensureInstanceDir(instancePath);
-      const dbPath = path.join(instancePath, 'store.sqlite');
-      db = new Database(dbPath);
-      db.pragma('journal_mode = WAL');
-      db.pragma('busy_timeout = 5000');
-      persister = createBetterSqlite3Persister(store, db);
+    ensureInstanceDir(instancePath);
+    const dbPath = path.join(instancePath, 'store.sqlite');
+    db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    db.pragma('busy_timeout = 5000');
+
+    // Migration: if old JSON blob table exists, load data from it first
+    const oldTableExists = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='tinybase_store'"
+    ).get();
+
+    if (oldTableExists) {
+      const oldPersister = createCustomPersister(
+        store,
+        async () => {
+          const row = db!.prepare("SELECT store FROM tinybase_store WHERE _id = '_'").get() as { store: string } | undefined;
+          return row ? JSON.parse(row.store) : undefined;
+        },
+        async () => {},
+        (listener) => setInterval(listener, 1000),
+        (interval: ReturnType<typeof setInterval>) => clearInterval(interval),
+      );
+      await oldPersister.load();
+      oldPersister.destroy();
     }
+
+    persister = createTabularBetterSqlite3Persister(store, db);
+
+    if (oldTableExists) {
+      // Save migrated data to new tabular format, then drop old table
+      await persister.save();
+      db.exec('DROP TABLE IF EXISTS tinybase_store');
+    }
+
     await persister.load();
+    // Auto-save: persist to disk whenever the in-memory store changes.
+    // Without this, emit() only writes to TinyBase's in-memory store and
+    // data is lost if the server is killed before an explicit persist().
+    await persister.startAutoSave();
   }
 
   // Initialize/update instance metadata
-  if (!config.inMemory && !isLegacy) {
+  if (!config.inMemory) {
     if (isNew) {
       const meta = createInstanceMeta(resolved, config);
       writeInstanceMeta(instancePath, meta);
@@ -876,11 +939,6 @@ export async function createEventStore(config: StoreConfig = {}): Promise<EventS
    * Get archives directory path
    */
   function getArchivesDir(): string {
-    // For legacy mode, use parent of the file path
-    // For new mode, use the instance directory
-    if (isLegacy) {
-      return path.join(path.dirname(instancePath), 'archives');
-    }
     return path.join(instancePath, 'archives');
   }