macro-agent 0.0.13 → 0.0.15

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/index.ts

@@ -114,6 +114,8 @@ export {
   unregisterWakeExtension,
   registerWorkspaceExtension,
   unregisterWorkspaceExtension,
+  registerWorkspaceFileExtensions,
+  unregisterWorkspaceFileExtensions,
   // Constants
   MACRO_EXTENSION_METHODS,
   EXTENSION_CAPABILITIES,
@@ -122,6 +124,7 @@ export {
   type TaskExtensionServices,
   type WakeExtensionServices,
   type WorkspaceExtensionServices,
+  type WorkspaceFileServices,
   type SessionInfo,
   type InternalWorkspace,
 } from "./extensions/index.js";

package/src/server/combined-server.ts

@@ -25,6 +25,7 @@ import { createAPIApp, setupAPIWebSocket } from "../api/server.js";
 import {
   createMAPAdapter,
   createMAPWebSocketHandler,
+  registerWorkspaceFileExtensions,
   type MAPAdapter,
   type MAPAdapterServices,
   type MAPWebSocketHandler,
@@ -240,6 +241,15 @@ export function createCombinedServer(
       { name: "macro-agent", version: "1.0.0" },
       mapServices
     );
+
+    // Register workspace file extensions for TUI file attachment.
+    // Uses defaultCwd (project root) as the workspace path for all agents,
+    // since the head manager doesn't have an isolated worktree.
+    registerWorkspaceFileExtensions(mapAdapter, {
+      getWorkspace: () => ({ path: defaultCwd } as any),
+      agentExists: () => true,
+    });
+
     mapHandler = createMAPWebSocketHandler(mapAdapter);
   }
 

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;