macro-agent 0.0.17 → 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
@@ -386,11 +416,17 @@ export class ACPOverMAPHandler {
     this.ensureConversation(sessionId as ACPSessionId, agentId);
 
     // Accumulate response content for history recording
-    const buffer: { textChunks: string[]; toolCalls: Record<string, unknown>[] } = {
-      textChunks: [],
-      toolCalls: [],
+    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;
@@ -400,23 +436,49 @@ export class ACPOverMAPHandler {
           return { stopReason: "cancelled" };
         }
 
-        // Accumulate content for history persistence
+        // 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) {
-            buffer.textChunks.push(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;
-          if (status === "completed" || (updateType === "tool_call" && status !== "running")) {
-            buffer.toolCalls.push({
-              toolCallId: u.toolCallId,
-              title: u.title,
-              status: u.status,
+          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,
-              output: u.output,
+            });
+          }
+
+          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),
             });
           }
         }
@@ -426,15 +488,24 @@ export class ACPOverMAPHandler {
         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 {
@@ -455,29 +526,33 @@ export class ACPOverMAPHandler {
     // 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 };
   }
 
@@ -605,6 +680,11 @@ export class ACPOverMAPHandler {
           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:
@@ -614,6 +694,8 @@ export class ACPOverMAPHandler {
             timestamp: turn.timestamp,
             content: turn.content,
           })),
+          plan,
+          cwd: agent?.cwd ?? null,
         };
       }
 
@@ -668,7 +750,7 @@ export class ACPOverMAPHandler {
     acpSessionId: ACPSessionId,
     agentId: AgentId,
     userMessage: string,
-    buffer: { textChunks: string[]; toolCalls: Record<string, unknown>[] },
+    buffer: { parts: Array<{ type: "text"; text: string } | ({ type: "tool" } & Record<string, unknown>)> },
   ): void {
     const now = Date.now();
 
@@ -691,17 +773,8 @@ export class ACPOverMAPHandler {
         });
       }
 
-      // 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 });
-      }
+      // Record assistant turn with accumulated content (parts already in order)
+      const parts = buffer.parts;
 
       if (parts.length > 0) {
         this.eventStore.emit({

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

@@ -1056,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/event-store.ts

@@ -203,6 +203,7 @@ export interface EventStore {
   // Agent view
   getAgent(agentId: AgentId): Agent | null;
   listAgents(filter?: { state?: AgentState; parent?: AgentId | null }): Agent[];
+  updateAgentPlan(agentId: AgentId, plan: Array<{ content: string; priority: string; status: string }>): void;
 
   // Task view
   getTask(taskId: TaskId): Task | null;
@@ -519,6 +520,25 @@ export async function createEventStore(config: StoreConfig = {}): Promise<EventS
     return agents;
   }
 
+  /**
+   * Update an agent's plan entries (persisted to SQLite via TinyBase)
+   */
+  function updateAgentPlan(
+    agentId: AgentId,
+    plan: Array<{ content: string; priority: string; status: string }>,
+  ): void {
+    const row = store.getRow('agents', agentId);
+    if (!row.id) return;
+
+    store.setPartialRow('agents', agentId, {
+      plan: JSON.stringify(plan),
+      last_activity_at: Date.now(),
+    });
+
+    const agent = rowToAgent(store.getRow('agents', agentId));
+    notifyAgentChange(agentId, agent);
+  }
+
   /**
    * Get task by ID
    */
@@ -1203,6 +1223,7 @@ export async function createEventStore(config: StoreConfig = {}): Promise<EventS
     // Views
     getAgent,
     listAgents,
+    updateAgentPlan,
     getTask,
     listTasks,
     getMessages,
@@ -1269,6 +1290,17 @@ function initializeTables(store: Store): void {
  * Rebuild materialized views from the event log
  */
 function rebuildViews(store: Store): void {
+  // Preserve out-of-band agent fields that aren't derived from events.
+  // `plan` is written directly via updateAgentPlan(), not through events,
+  // so it would be lost when we clear and replay.
+  const savedAgentPlan = new Map<string, string>();
+  for (const rowId of store.getRowIds('agents')) {
+    const row = store.getRow('agents', rowId);
+    if (row.plan && row.plan !== '[]') {
+      savedAgentPlan.set(rowId, row.plan as string);
+    }
+  }
+
   // Clear existing views
   for (const rowId of store.getRowIds('agents')) {
     store.delRow('agents', rowId);
@@ -1324,6 +1356,14 @@ function rebuildViews(store: Store): void {
   for (const event of events) {
     applyEventToViews(store, event, noop, noop, noop, noop, noop, noop);
   }
+
+  // Restore out-of-band agent fields preserved before the wipe
+  for (const [agentId, plan] of savedAgentPlan) {
+    const row = store.getRow('agents', agentId);
+    if (row.id) {
+      store.setPartialRow('agents', agentId, { plan });
+    }
+  }
 }
 
 /**
@@ -1422,6 +1462,7 @@ function applySpawnEvent(
     role: payload.role ?? '',
     config: JSON.stringify(payload.config ?? {}),
     cwd: payload.cwd ?? process.cwd(),
+    plan: '[]',
     created_at: event.timestamp,
     started_at: 0,
     stopped_at: 0,
@@ -1770,6 +1811,7 @@ function rowToAgent(row: Record<string, unknown>): Agent {
     role: (row.role as string) || undefined,
     config: row.config ? JSON.parse(row.config as string) : {},
     cwd: (row.cwd as string) || process.cwd(),
+    plan: row.plan ? JSON.parse(row.plan as string) : [],
     created_at: row.created_at as Timestamp,
     started_at: (row.started_at as number) || undefined,
     stopped_at: (row.stopped_at as number) || undefined,

package/src/store/types/agents.ts

@@ -40,6 +40,7 @@ export interface Agent {
   role?: string;
   config: AgentConfig;
   cwd: string;
+  plan: Array<{ content: string; priority: string; status: string }>;
   created_at: Timestamp;
   started_at?: Timestamp;
   stopped_at?: Timestamp;