macro-agent 0.0.14 → 0.0.16

package/src/acp/types.ts

@@ -630,10 +630,44 @@ export interface ResumeAgentResponse {
   /** The resumed agent's ID */
   agentId: AgentId;
 
-  /** The agent's session ID */
+  /** The agent's session ID (from resume) */
   sessionId: string;
 }
 
+// ─────────────────────────────────────────────────────────────────
+// History Extension Types
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * A historical turn in a session conversation
+ */
+export interface HistoryTurn {
+  /** Turn role */
+  role: "user" | "assistant";
+  /** Timestamp of the turn */
+  timestamp: number;
+  /** Turn content — plain text for user, structured parts for assistant */
+  content: unknown;
+}
+
+/**
+ * Request for _macro/getHistory extension
+ */
+export interface GetHistoryRequest {
+  /** ACP session ID to get history for */
+  sessionId: string;
+  /** Maximum number of turns to return */
+  limit?: number;
+}
+
+/**
+ * Response for _macro/getHistory extension
+ */
+export interface GetHistoryResponse {
+  /** Conversation turns in chronological order */
+  turns: HistoryTurn[];
+}
+
 // ─────────────────────────────────────────────────────────────────
 // Extension Method Types (Union)
 // ─────────────────────────────────────────────────────────────────
@@ -657,7 +691,8 @@ export type ACPExtensionMethod =
   | "_macro/checkCapability"
   | "_macro/respondToPermission"
   | "_macro/cancelPermission"
-  | "_macro/resume";
+  | "_macro/resume"
+  | "_macro/getHistory";
 
 /**
  * Map of extension methods to their request types
@@ -679,6 +714,7 @@ export interface ACPExtensionRequests {
   "_macro/respondToPermission": RespondToPermissionRequest;
   "_macro/cancelPermission": CancelPermissionRequest;
   "_macro/resume": ResumeAgentRequest;
+  "_macro/getHistory": GetHistoryRequest;
 }
 
 /**
@@ -701,6 +737,7 @@ export interface ACPExtensionResponses {
   "_macro/respondToPermission": RespondToPermissionResponse;
   "_macro/cancelPermission": CancelPermissionResponse;
   "_macro/resume": ResumeAgentResponse;
+  "_macro/getHistory": GetHistoryResponse;
 }
 
 // ─────────────────────────────────────────────────────────────────

package/src/agent/__tests__/agent-manager.test.ts

@@ -455,7 +455,7 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
       });
 
       expect(result.id).toMatch(/^agent_/);
-      // Session ID is now pre-generated before createSession (for race condition fix)
+      // session_id is macro-agent's own ID (pre-generated before createSession)
       expect(result.session_id).toMatch(/^session_/);
       expect(result.session).toBeDefined();
 
@@ -464,6 +464,8 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
       expect(agent).toBeDefined();
       expect(agent?.state).toBe("running");
       expect(agent?.task).toBe("Test task");
+      // provider_session_id should be set from createSession's returned session.id
+      expect(agent?.provider_session_id).toBe("mock_session_1");
     });
 
     it("should set up default subscriptions", async () => {
@@ -684,6 +686,70 @@ describe("AgentManager Integration (with mocked acp-factory)", () => {
         "already has active session",
       );
     });
+
+    it("should use agent's original cwd when loading session", async () => {
+      const spawned = await agentManager.spawn({
+        task: "Test with custom cwd",
+        cwd: "/custom/project/path",
+      });
+      await agentManager.terminate(spawned.id, "completed");
+
+      await agentManager.resume(spawned.id);
+
+      // loadSession should be called with the agent's original cwd, not the default
+      expect(mockHandle.loadSession).toHaveBeenCalledWith(
+        expect.any(String), // session ID
+        "/custom/project/path",
+      );
+    });
+
+    it("should use provider_session_id when loading session", async () => {
+      const spawned = await agentManager.spawn({ task: "Test" });
+
+      // Verify the agent has provider_session_id from createSession
+      const agent = agentManager.get(spawned.id);
+      expect(agent?.provider_session_id).toBeDefined();
+
+      await agentManager.terminate(spawned.id, "completed");
+      await agentManager.resume(spawned.id);
+
+      // loadSession should be called with the provider_session_id (Claude Code UUID)
+      expect(mockHandle.loadSession).toHaveBeenCalledWith(
+        agent!.provider_session_id,
+        expect.any(String),
+      );
+    });
+
+    it("should fall back to session_id if provider_session_id is not set", async () => {
+      // Create agent directly without provider_session_id
+      const agentId = "agent_no_provider";
+      const sessionId = "session_no_provider";
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: agentId,
+          session_id: sessionId,
+          task: "Test",
+          parent: null,
+          cwd: "/tmp",
+        },
+      });
+      // Emit started status WITHOUT provider_session_id
+      eventStore.emit({
+        type: "status",
+        source: { agent_id: agentId },
+        payload: { status_type: "started" },
+      });
+
+      await agentManager.resume(agentId);
+
+      // Should fall back to the macro-agent session_id
+      expect(mockHandle.loadSession).toHaveBeenCalledWith(
+        sessionId,
+        "/tmp",
+      );
+    });
   });
 
   describe("getOrCreateHeadManager()", () => {

package/src/agent/agent-manager.ts

@@ -564,12 +564,15 @@ export function createAgentManager(
       });
 
       // Emit started status (session is ready)
+      // Include the provider's session ID (e.g., Claude Code UUID) so
+      // it can be used for handle.loadSession() during resume
       eventStore.emit({
         type: "status",
         source: { agent_id: agentId },
         payload: {
           status_type: "started",
           summary: "Agent session started",
+          provider_session_id: session.id,
         },
       });
 
@@ -703,7 +706,7 @@ export function createAgentManager(
 
       return {
         id: agentId,
-        session_id: sessionId, // Use our pre-generated ID (matches what's in EventStore)
+        session_id: sessionId, // Macro-agent's own session ID for ACP protocol mapping
         agent,
         session,
         workspace,
@@ -903,8 +906,11 @@ export function createAgentManager(
       permissionMode: defaultPermissionMode,
     });
 
-    // Load the existing session by ID
-    const session = await handle.loadSession(agent.session_id, defaultCwd);
+    // Load the existing session using the provider's session ID (e.g., Claude Code UUID)
+    // Falls back to macro-agent session_id for backwards compatibility
+    const loadSessionId = agent.provider_session_id ?? agent.session_id;
+    const agentCwd = agent.cwd ?? defaultCwd;
+    const session = await handle.loadSession(loadSessionId, agentCwd);
 
     // Track active session
     const activeSession: ActiveSession = {
@@ -928,7 +934,7 @@ export function createAgentManager(
 
     return {
       id: agentId,
-      session_id: session.id,
+      session_id: agent.session_id, // Macro-agent's own session ID
       agent: eventStore.getAgent(agentId)!,
       session,
     };

package/src/cli/__tests__/stable-instance-id.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Tests for getStableInstanceId
+ *
+ * Verifies that the stable instance ID is deterministic, consistent,
+ * and produces valid instance IDs for the EventStore.
+ */
+
+import { describe, it, expect } from "vitest";
+import { resolve } from "node:path";
+import { getStableInstanceId } from "../acp.js";
+
+describe("getStableInstanceId", () => {
+  it("should return the same ID for the same path", () => {
+    const id1 = getStableInstanceId("/Users/test/project");
+    const id2 = getStableInstanceId("/Users/test/project");
+    expect(id1).toBe(id2);
+  });
+
+  it("should return different IDs for different paths", () => {
+    const id1 = getStableInstanceId("/Users/test/project-a");
+    const id2 = getStableInstanceId("/Users/test/project-b");
+    expect(id1).not.toBe(id2);
+  });
+
+  it("should start with inst_ prefix", () => {
+    const id = getStableInstanceId("/tmp/test");
+    expect(id).toMatch(/^inst_/);
+  });
+
+  it("should produce a valid instance ID format (alphanumeric + underscore)", () => {
+    const id = getStableInstanceId("/tmp/test");
+    expect(id).toMatch(/^[a-zA-Z0-9_]+$/);
+  });
+
+  it("should normalize relative paths to absolute", () => {
+    // Both should resolve to the same absolute path
+    const absPath = resolve("./src");
+    const id1 = getStableInstanceId("./src");
+    const id2 = getStableInstanceId(absPath);
+    expect(id1).toBe(id2);
+  });
+
+  it("should handle paths with trailing slashes consistently", () => {
+    // resolve() strips trailing slashes, so these should be equal
+    const id1 = getStableInstanceId("/tmp/project");
+    const id2 = getStableInstanceId("/tmp/project/");
+    expect(id1).toBe(id2);
+  });
+
+  it("should produce a fixed-length ID", () => {
+    const short = getStableInstanceId("/a");
+    const long = getStableInstanceId("/very/long/path/to/some/deeply/nested/project/directory");
+    // Both should be inst_ + 12 hex chars = 17 chars total
+    expect(short.length).toBe(17);
+    expect(long.length).toBe(17);
+  });
+});

package/src/cli/acp.ts

@@ -39,7 +39,8 @@
  */
 
 import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+import { dirname, join, resolve } from "node:path";
 import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import {
@@ -119,6 +120,17 @@ export function parseArgs(argv?: string[]): ACPServerOptions {
   return options;
 }
 
+/**
+ * Generate a stable instance ID from the working directory.
+ * This ensures the same project always uses the same EventStore,
+ * so agents and sessions persist across server restarts.
+ */
+export function getStableInstanceId(cwd: string): string {
+  const normalizedPath = resolve(cwd);
+  const hash = createHash("sha256").update(normalizedPath).digest("hex").slice(0, 12);
+  return `inst_${hash}`;
+}
+
 // ─────────────────────────────────────────────────────────────────
 // Stream Setup
 // ─────────────────────────────────────────────────────────────────
@@ -159,9 +171,12 @@ async function main() {
   const defaultCwd = options.cwd ?? process.cwd();
 
   // Initialize services
+  // Use explicit --instance-id if provided, otherwise derive a stable ID from the CWD
+  // so the same project always reuses the same EventStore across server restarts
+  const instanceId = options.instanceId ?? getStableInstanceId(defaultCwd);
   const eventStore = await createEventStore({
     inMemory: false,
-    instanceId: options.instanceId,
+    instanceId,
   });
 
   // We need to create agentManager first (with a placeholder router),

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,6 +276,7 @@ export class ACPOverMAPHandler {
         streamState.sessionId = sessionId;
         streamState.agentId = existing.id;
         this.sessionMapper.createMapping(sessionId as ACPSessionId, existing.id);
+        this.emitSessionInfo(streamState, sessionId, emitNotification);
         return {};
       }
 
@@ -280,6 +286,7 @@ export class ACPOverMAPHandler {
       streamState.sessionId = sessionId;
       streamState.agentId = spawned.id;
       this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
+      this.emitSessionInfo(streamState, sessionId, emitNotification);
       return {};
     }
 
@@ -293,6 +300,7 @@ export class ACPOverMAPHandler {
     streamState.sessionId = sessionId;
     streamState.agentId = spawned.id;
     this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
+    this.emitSessionInfo(streamState, sessionId, emitNotification);
 
     return {};
   }
@@ -388,6 +396,9 @@ export class ACPOverMAPHandler {
 
       console.error(`[ACP-over-MAP] Prompt completed for agent ${agentId}, ${updateCount} updates`);
 
+      // 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);
@@ -532,6 +543,50 @@ export class ACPOverMAPHandler {
     }
   }
 
+  // ─────────────────────────────────────────────────────────────────
+  // 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/event-store.ts

@@ -1354,6 +1354,7 @@ function applySpawnEvent(
   store.setRow('agents', agentId, {
     id: agentId,
     session_id: payload.session_id,
+    provider_session_id: '',
     parent: parent ?? '',
     lineage: JSON.stringify(lineage),
     state: 'spawning',
@@ -1408,15 +1409,20 @@ function applyStatusEvent(
   const agentId = event.source.agent_id;
   if (!agentId) return;
 
-  const payload = event.payload as { status_type: string };
+  const payload = event.payload as { status_type: string; provider_session_id?: string };
 
   // Handle specific status types
   if (payload.status_type === 'started') {
-    store.setPartialRow('agents', agentId, {
+    const updates: Record<string, string | number> = {
       state: 'running',
       started_at: event.timestamp,
       last_activity_at: event.timestamp,
-    });
+    };
+    // Store the provider's session ID (e.g., Claude Code UUID for --resume)
+    if (payload.provider_session_id) {
+      updates.provider_session_id = payload.provider_session_id;
+    }
+    store.setPartialRow('agents', agentId, updates);
   } else {
     // Always update last_activity_at on any status event
     store.setPartialRow('agents', agentId, {
@@ -1696,6 +1702,7 @@ function rowToAgent(row: Record<string, unknown>): Agent {
   return {
     id: row.id as AgentId,
     session_id: row.session_id as string,
+    provider_session_id: (row.provider_session_id as string) || undefined,
     parent: (row.parent as string) || null,
     lineage: row.lineage ? JSON.parse(row.lineage as string) : [],
     state: row.state as AgentState,

package/src/store/types/agents.ts

@@ -29,6 +29,8 @@ export interface AgentConfig {
 export interface Agent {
   id: AgentId;
   session_id: SessionId;
+  /** Session ID from the underlying agent provider (e.g., Claude Code UUID for --resume) */
+  provider_session_id?: string;
   parent: AgentId | null;
   lineage: AgentId[];
   state: AgentState;