macro-agent 0.0.16 → 0.1.0

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

@@ -15,6 +15,22 @@ import type { AgentId } from "../../store/types/index.js";
 import { SessionMapper } from "../../acp/session-mapper.js";
 import type { ACPSessionId } from "../../acp/types.js";
 
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+/** Extract a plain-text output string from `rawOutput` (string | ContentBlock[] | undefined). */
+function extractToolOutput(rawOutput: unknown): string | undefined {
+  if (typeof rawOutput === "string") return rawOutput;
+  if (Array.isArray(rawOutput)) {
+    return rawOutput
+      .filter((item: any) => item.type === "text" && typeof item.text === "string")
+      .map((item: any) => item.text as string)
+      .join("\n") || undefined;
+  }
+  return undefined;
+}
+
 // ─────────────────────────────────────────────────────────────────
 // Types
 // ─────────────────────────────────────────────────────────────────
@@ -79,6 +95,20 @@ export class ACPOverMAPHandler {
     this.defaultCwd = config.defaultCwd ?? process.cwd();
   }
 
+  /**
+   * Abort all active streams targeting a specific agent.
+   * Called when an agent is stopped via MAP protocol to interrupt
+   * any in-progress ACP prompt streaming.
+   */
+  abortStreamsForAgent(agentId: AgentId): void {
+    for (const [streamId, streamState] of this.streams) {
+      if (streamState.agentId === agentId) {
+        console.error(`[ACP-over-MAP] Aborting stream ${streamId} for stopped agent ${agentId}`);
+        streamState.abortController.abort();
+      }
+    }
+  }
+
   /**
    * Process an ACP request and return the response.
    * @param targetAgentId - Target agent for the request
@@ -277,7 +307,7 @@ export class ACPOverMAPHandler {
         streamState.agentId = existing.id;
         this.sessionMapper.createMapping(sessionId as ACPSessionId, existing.id);
         this.emitSessionInfo(streamState, sessionId, emitNotification);
-        return {};
+        return { sessionId };
       }
 
       // Agent exists but no active session - resume it
@@ -287,7 +317,7 @@ export class ACPOverMAPHandler {
       streamState.agentId = spawned.id;
       this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
       this.emitSessionInfo(streamState, sessionId, emitNotification);
-      return {};
+      return { sessionId };
     }
 
     // No existing agent found - create new with the specified session ID
@@ -302,7 +332,7 @@ export class ACPOverMAPHandler {
     this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
     this.emitSessionInfo(streamState, sessionId, emitNotification);
 
-    return {};
+    return { sessionId };
   }
 
   private async handleAuthenticate(_params: unknown): Promise<unknown> {
@@ -322,7 +352,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");
     }
@@ -380,6 +412,21 @@ 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: { parts: Array<{ type: "text"; text: string } | ({ type: "tool" } & Record<string, unknown>)> } = {
+      parts: [],
+    };
+
+    // Track latest plan for persistence
+    let latestPlan: Array<{ content: string; priority: string; status: string }> | null = null;
+
+    // Track tool info from initial tool_call events (title, name, input)
+    // so we can merge them when tool_call_update arrives with status "completed"
+    const toolInfoCache = new Map<string, { title?: string; name?: string; input?: unknown }>();
+
     try {
       // Stream responses from the agent
       let updateCount = 0;
@@ -389,17 +436,76 @@ export class ACPOverMAPHandler {
           return { stopReason: "cancelled" };
         }
 
+        // Accumulate content for history persistence (preserving text/tool interleaving order)
+        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) {
+            const last = buffer.parts[buffer.parts.length - 1];
+            if (last && last.type === "text") {
+              last.text += content.text;
+            } else {
+              buffer.parts.push({ type: "text", text: content.text });
+            }
+          }
+        } else if (updateType === "plan") {
+          const entries = (u as { entries?: Array<{ content: string; priority: string; status: string }> }).entries;
+          if (entries) {
+            latestPlan = entries;
+          }
+        } else if (updateType === "tool_call" || updateType === "tool_call_update") {
+          const toolCallId = u.toolCallId as string | undefined;
+          const status = u.status as string | undefined;
+          const meta = u._meta as { claudeCode?: { toolName?: string } } | undefined;
+
+          // Cache tool info from initial tool_call events
+          if (updateType === "tool_call" && toolCallId) {
+            toolInfoCache.set(toolCallId, {
+              title: u.title as string | undefined,
+              name: meta?.claudeCode?.toolName,
+              input: u.rawInput,
+            });
+          }
+
+          if (status === "completed" || status === "failed") {
+            // Merge cached info for tool_call_update events that lack title/input
+            const cached = toolCallId ? toolInfoCache.get(toolCallId) : undefined;
+            buffer.parts.push({
+              type: "tool",
+              toolCallId,
+              title: u.title ?? cached?.title,
+              name: meta?.claudeCode?.toolName ?? cached?.name,
+              status: u.status,
+              input: u.rawInput ?? cached?.input,
+              output: extractToolOutput(u.rawOutput),
+            });
+          }
+        }
+
         // Stream the update back to the client
         emitSessionUpdate(update);
         updateCount++;
       }
 
-      console.error(`[ACP-over-MAP] Prompt completed for agent ${agentId}, ${updateCount} updates`);
+      // Check if the loop ended because of cancellation
+      const wasCancelled = streamState.abortController.signal.aborted;
+      const stopReason = wasCancelled ? "cancelled" : "end_turn";
+
+      console.error(`[ACP-over-MAP] Prompt completed for agent ${agentId}, ${updateCount} updates, stopReason=${stopReason}`);
+
+      // Persist conversation turns for history
+      this.recordPromptTurns(sessionId as ACPSessionId, agentId, messageContent, buffer);
+
+      // Persist latest plan in EventStore for history loading across restarts
+      if (latestPlan) {
+        this.eventStore.updateAgentPlan(agentId as AgentId, latestPlan);
+      }
 
       // Emit updated session info after prompt completes
       this.emitSessionInfo(streamState, sessionId, emitNotification);
 
-      return { stopReason: "end_turn" };
+      return { stopReason };
     } catch (error) {
       console.error(`[ACP-over-MAP] Prompt error:`, error);
       return {
@@ -417,31 +523,36 @@ 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();
+    const agentId = sessionId
+      ? this.sessionMapper.getAgentId(sessionId as ACPSessionId)
+      : streamState.agentId;
 
-    if (!sessionId) {
-      return { cancelled: true };
-    }
+    console.error(
+      `[ACP-over-MAP] Cancel - streamId=${streamState.streamId} sessionId=${sessionId} agentId=${agentId}`,
+    );
 
-    // Get the mapped agent
-    const agentId = this.sessionMapper.getAgentId(sessionId as ACPSessionId);
-    if (!agentId) {
-      return { cancelled: true };
-    }
+    // 1. Abort the for-await loop in handlePrompt so it stops yielding updates
+    streamState.abortController.abort();
 
-    // Terminate the agent
-    try {
-      await this.agentManager.terminate(agentId, "cancelled");
-    } catch (error) {
-      console.warn(`[ACP-over-MAP] Error terminating agent ${agentId}:`, error);
+    // 2. Cancel the agent's active session (sends session/cancel to the subprocess)
+    // This does NOT terminate the agent — it only interrupts the current prompt.
+    // The subprocess stays alive and can accept new prompts.
+    // Use map/agents/stop for full agent termination.
+    if (agentId) {
+      const session = this.agentManager.getSession(agentId);
+      if (session) {
+        try {
+          await session.cancel();
+          console.error(`[ACP-over-MAP] Session cancelled for agent ${agentId}`);
+        } catch (error) {
+          console.warn(`[ACP-over-MAP] session.cancel() failed for ${agentId}:`, error);
+        }
+      }
     }
 
-    // Clean up
-    this.sessionMapper.removeMapping(sessionId as ACPSessionId);
-
     return { cancelled: true };
   }
 
@@ -538,11 +649,157 @@ 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,
+        });
+
+        // Include persisted plan and agent cwd if available
+        const agent = historyAgentId ? this.eventStore.getAgent(historyAgentId as AgentId) : undefined;
+        const plan = agent?.plan ?? [];
+
+        return {
+          turns: turns.map((turn) => ({
+            role:
+              turn.contentType === "user_prompt"
+                ? ("user" as const)
+                : ("assistant" as const),
+            timestamp: turn.timestamp,
+            content: turn.content,
+          })),
+          plan,
+          cwd: agent?.cwd ?? null,
+        };
+      }
+
       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: { parts: Array<{ type: "text"; text: string } | ({ type: "tool" } & 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 (parts already in order)
+      const parts = buffer.parts;
+
+      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
   // ─────────────────────────────────────────────────────────────────

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

@@ -65,6 +65,7 @@ import {
   type ScopeId,
 } from "../types.js";
 import type { AgentId } from "../../store/types/index.js";
+import type { AgentStopReason } from "../../agent/types.js";
 import {
   createConnectionManager,
   type ConnectionManager,
@@ -712,6 +713,10 @@ export class MAPAdapterImpl implements MAPAdapter {
       "map/agents/get": async (params) =>
         this.handleGetAgent(participantId, params),
 
+      // Agent lifecycle
+      "map/agents/stop": async (params) =>
+        this.handleStopAgent(participantId, params),
+
       // Scope queries
       "map/scopes/list": async () => this.handleListScopes(participantId),
       "map/scopes/get": async (params) =>
@@ -764,6 +769,7 @@ export class MAPAdapterImpl implements MAPAdapter {
       "map/send": "canMessage",
       "map/agents/list": "canQuery",
       "map/agents/get": "canQuery",
+      "map/agents/stop": "canStop",
       "map/scopes/list": "canQuery",
       "map/scopes/get": "canQuery",
       "map/scopes/create": "canManageScopes",
@@ -808,16 +814,27 @@ export class MAPAdapterImpl implements MAPAdapter {
           break;
         }
 
-        const result = await session.rpcHandler.process(value, {
-          participantId: session.participantId,
-          capabilities: participant.capabilities,
-          signal: session.abortController.signal,
+        // Process messages concurrently (same pattern as toad reference).
+        // The message loop must not block on any handler, otherwise
+        // session/cancel can't be delivered while session/prompt is running.
+        // The stream writer queues writes safely, so concurrent responses
+        // don't interleave.
+        const processAndRespond = async () => {
+          const result = await session.rpcHandler.process(value, {
+            participantId: session.participantId,
+            capabilities: participant.capabilities,
+            signal: session.abortController.signal,
+          });
+
+          if (result.type === "response") {
+            await this.sendToSession(session, result.response);
+          }
+        };
+        processAndRespond().catch((err) => {
+          if (!session.abortController.signal.aborted) {
+            console.error(`[MAPAdapter] Error processing message:`, err);
+          }
         });
-
-        // Send response if needed
-        if (result.type === "response") {
-          await this.sendToSession(session, result.response);
-        }
       }
     } catch (error) {
       if (!session.abortController.signal.aborted) {
@@ -1181,6 +1198,59 @@ export class MAPAdapterImpl implements MAPAdapter {
     return { agent: agent ?? null };
   }
 
+  private async handleStopAgent(
+    _participantId: ParticipantId,
+    params: unknown,
+  ): Promise<{ stopping: boolean; agent?: AgentInfo }> {
+    const { agentId, reason, force } = (params as {
+      agentId?: AgentId;
+      reason?: string;
+      force?: boolean;
+    }) ?? {};
+
+    if (!agentId) {
+      throw RPCError.invalidParams("agentId required");
+    }
+
+    if (!this.services.agentManager) {
+      throw RPCError.internalError("Agent manager not available");
+    }
+
+    // Abort any active ACP streams for this agent
+    if (this.acpOverMapHandler) {
+      this.acpOverMapHandler.abortStreamsForAgent(agentId);
+    }
+
+    // Terminate the agent
+    try {
+      await this.services.agentManager.terminate(
+        agentId,
+        (reason ?? "cancelled") as AgentStopReason,
+      );
+    } catch (error) {
+      console.error(`[MAPAdapter] Error stopping agent ${agentId}:`, error);
+      throw RPCError.internalError(
+        `Failed to stop agent: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+
+    // Emit agent state changed event for subscribers
+    this.emitEvent({
+      eventId: `stop-${Date.now()}`,
+      type: "agent.state.changed" as MAPEventType,
+      timestamp: Date.now(),
+      agentId,
+      data: {
+        agentId,
+        current: "stopped",
+        previous: "running",
+        reason: reason ?? "cancelled",
+      },
+    });
+
+    return { stopping: true };
+  }
+
   private async handleListScopes(
     participantId: ParticipantId,
   ): Promise<{ scopes: ScopeInfo[] }> {

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 () => {
@@ -1064,6 +1056,46 @@ describe('Event Archival', () => {
       await store1.close();
       await store2.close();
     });
+
+    it('should preserve agent plan across reload (rebuildViews)', async () => {
+      const planStore = await createEventStore({
+        baseDir: testDir,
+        instanceId: 'plan-reload-test',
+      });
+
+      // Spawn an agent
+      planStore.emit({
+        type: 'spawn',
+        source: { agent_id: 'agent_plan' },
+        payload: {
+          agent_id: 'agent_plan',
+          session_id: 'sess_plan',
+          task: 'test plan persistence',
+        },
+      });
+
+      // Set plan via updateAgentPlan
+      const plan = [
+        { content: 'Read files', priority: 'high', status: 'completed' },
+        { content: 'Write code', priority: 'medium', status: 'in_progress' },
+      ];
+      planStore.updateAgentPlan('agent_plan' as AgentId, plan);
+
+      // Verify plan is set
+      const before = planStore.getAgent('agent_plan' as AgentId);
+      expect(before?.plan).toEqual(plan);
+
+      // Persist, then reload (simulates server restart: load from SQLite + rebuildViews)
+      await planStore.persist();
+      await planStore.reload();
+
+      // Plan should survive the reload
+      const after = planStore.getAgent('agent_plan' as AgentId);
+      expect(after).toBeDefined();
+      expect(after?.plan).toEqual(plan);
+
+      await planStore.close();
+    });
   });
 });
 

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', () => {