macro-agent 0.1.0 → 0.1.2

package/src/acp/__tests__/integration.test.ts

@@ -161,6 +161,28 @@ function createMockAgentManager(): AgentManager {
     getSession: vi.fn().mockReturnValue(null),
     onLifecycleEvent: vi.fn().mockReturnValue(() => {}),
     close: vi.fn().mockResolvedValue(undefined),
+    forkAgent: vi.fn().mockImplementation((sourceId) => {
+      const agentId = `agent-${++agentCounter}`;
+      const sessionId = `session-${++sessionCounter}`;
+      const agent: Agent = {
+        id: agentId,
+        session_id: sessionId,
+        state: "running",
+        task: `[Fork of ${sourceId}]`,
+        task_id: `task-${++taskCounter}`,
+        parent: null,
+        lineage: [],
+        created_at: Date.now(),
+        started_at: Date.now(),
+      };
+      agentStore.set(agent.id, agent);
+      return Promise.resolve({
+        id: agent.id,
+        session_id: agent.session_id,
+        agent,
+        session: { id: `provider-${sessionId}` },
+      });
+    }),
   } as unknown as AgentManager;
 }
 
@@ -238,7 +260,7 @@ describe("ACP Mode Integration", () => {
       expect(initResponse.agentCapabilities).toBeDefined();
       expect(initResponse.agentCapabilities?.loadSession).toBe(true);
       expect(initResponse.agentCapabilities?._meta?.extensions).toContain(
-        "_macro/spawnAgent"
+        "_macro/spawnAgent",
       );
 
       // Step 2: Create new session
@@ -286,8 +308,8 @@ describe("ACP Mode Integration", () => {
         cwd: "/test/project",
       });
 
-      // loadSession returns empty object on success
-      expect(loadResponse).toEqual({});
+      // loadSession returns model state (null when no models available)
+      expect(loadResponse).toEqual({ models: null });
     });
 
     it("should load session by agentId via _meta", async () => {
@@ -314,7 +336,7 @@ describe("ACP Mode Integration", () => {
         _meta: { agentId: originalAgentId },
       } as any);
 
-      expect(loadResponse).toEqual({});
+      expect(loadResponse).toEqual({ models: null });
     });
 
     it("should throw when _meta.agentId references non-existent agent", async () => {
@@ -323,7 +345,7 @@ describe("ACP Mode Integration", () => {
           sessionId: "_resume_",
           cwd: "/test/project",
           _meta: { agentId: "non-existent-agent" },
-        } as any)
+        } as any),
       ).rejects.toThrow("Agent not found: non-existent-agent");
     });
 
@@ -345,7 +367,7 @@ describe("ACP Mode Integration", () => {
       await expect(
         macroAgent.cancel({
           sessionId: sessionResponse.sessionId,
-        })
+        }),
       ).resolves.toBeUndefined();
     });
 
@@ -373,10 +395,11 @@ describe("ACP Mode Integration", () => {
       expect(extensions).toContain("_macro/cancelPermission");
       expect(extensions).toContain("_macro/resume");
       expect(extensions).toContain("_macro/getHistory");
-      expect(extensions?.length).toBe(17);
+      expect(extensions).toContain("_macro/forkAgent");
+      expect(extensions?.length).toBe(19);
 
       expect(initResponse.agentCapabilities?._meta?.agentType).toBe(
-        "macro-agent"
+        "macro-agent",
       );
     });
   });
@@ -474,7 +497,7 @@ describe("ACP Mode Integration", () => {
         expect.objectContaining({
           task: "Integration test task",
           cwd: "/test/spawn",
-        })
+        }),
       );
     });
 
@@ -497,7 +520,7 @@ describe("ACP Mode Integration", () => {
         expect.objectContaining({
           task: "Child agent task",
           parent: parentId,
-        })
+        }),
       );
     });
   });
@@ -545,7 +568,7 @@ describe("ACP Mode Integration", () => {
       await expect(
         macroAgent.extMethod("macro/getHierarchy", {
           rootAgentId: "non-existent-agent",
-        })
+        }),
       ).rejects.toThrow(ACPError);
     });
   });
@@ -576,7 +599,7 @@ describe("ACP Mode Integration", () => {
       await expect(
         macroAgent.extMethod("macro/getTask", {
           taskId: "non-existent-task",
-        })
+        }),
       ).rejects.toThrow(ACPError);
     });
   });
@@ -640,7 +663,7 @@ describe("ACP Mode Integration", () => {
         macroAgent.extMethod("macro/mountAgent", {
           sessionId: "non-existent-session",
           agentId: "some-agent",
-        })
+        }),
       ).rejects.toThrow(ACPError);
     });
 
@@ -653,7 +676,7 @@ describe("ACP Mode Integration", () => {
         macroAgent.extMethod("macro/mountAgent", {
           sessionId: sessionResponse.sessionId,
           agentId: "non-existent-agent",
-        })
+        }),
       ).rejects.toThrow(ACPError);
     });
   });
@@ -666,7 +689,7 @@ describe("ACP Mode Integration", () => {
       });
 
       const originalAgentId = macroAgent.getMappedAgentId(
-        sessionResponse.sessionId
+        sessionResponse.sessionId,
       );
 
       // Fork the agent
@@ -678,18 +701,20 @@ describe("ACP Mode Integration", () => {
       expect(forkResponse.newAgentId).toBeDefined();
       expect(forkResponse.newSessionId).toBeDefined();
       expect(forkResponse.originalAgentId).toBe(originalAgentId);
+      expect(forkResponse.providerSessionId).toBeDefined();
 
-      // Verify forked agent exists
-      const forkedAgent = agentStore.get(forkResponse.newAgentId as string);
-      expect(forkedAgent).not.toBeNull();
-      expect(forkedAgent?.task).toContain("Forked for testing");
+      // Verify forkAgent was called with correct args
+      expect(mockAgentManager.forkAgent).toHaveBeenCalledWith(
+        originalAgentId,
+        expect.objectContaining({ name: "Forked for testing" }),
+      );
     });
 
     it("should throw for non-existent agent", async () => {
       await expect(
         macroAgent.extMethod("macro/forkAgent", {
           agentId: "non-existent-agent",
-        })
+        }),
       ).rejects.toThrow(ACPError);
     });
   });
@@ -697,7 +722,7 @@ describe("ACP Mode Integration", () => {
   describe("Extension Error Handling", () => {
     it("should throw for unknown extension method", async () => {
       await expect(macroAgent.extMethod("unknown/method", {})).rejects.toThrow(
-        ACPError
+        ACPError,
       );
 
       try {
@@ -736,7 +761,7 @@ describe("ACP Mode Integration", () => {
 
       // Verify session2 is now controlling the child agent
       expect(macroAgent.getMappedAgentId(session2.sessionId)).toBe(
-        childSpawn.agentId
+        childSpawn.agentId,
       );
 
       // 5. Fork the child from session2's perspective
@@ -763,7 +788,7 @@ describe("ACP Mode Integration", () => {
 
       // Get session2's original agent
       const session2AgentBefore = macroAgent.getMappedAgentId(
-        session2.sessionId
+        session2.sessionId,
       );
 
       // Mount session1 to new agent
@@ -774,10 +799,10 @@ describe("ACP Mode Integration", () => {
 
       // Session2 should still point to its original head manager
       expect(macroAgent.getMappedAgentId(session1.sessionId)).toBe(
-        spawn1.agentId
+        spawn1.agentId,
       );
       expect(macroAgent.getMappedAgentId(session2.sessionId)).toBe(
-        session2AgentBefore
+        session2AgentBefore,
       );
     });
   });
@@ -883,7 +908,7 @@ describe("ACP Protocol Compliance", () => {
     headManagers.length = 0;
     const hierarchyResponse = await macroAgent.extMethod(
       "macro/getHierarchy",
-      {}
+      {},
     );
     expect(hierarchyResponse).toBeDefined();
     expect(hierarchyResponse.totalAgents).toBe(0);
@@ -967,7 +992,7 @@ describe("ACP Protocol Compliance", () => {
       await expect(
         macroAgent.extMethod("_macro/resume", {
           agentId: childAgentId,
-        })
+        }),
       ).rejects.toThrow("only stopped or failed");
     });
 
@@ -975,14 +1000,14 @@ describe("ACP Protocol Compliance", () => {
       await expect(
         macroAgent.extMethod("_macro/resume", {
           agentId: "non-existent-agent",
-        })
+        }),
       ).rejects.toThrow("Agent not found");
     });
 
     it("should reject resume without agentId", async () => {
-      await expect(
-        macroAgent.extMethod("_macro/resume", {})
-      ).rejects.toThrow("agentId is required");
+      await expect(macroAgent.extMethod("_macro/resume", {})).rejects.toThrow(
+        "agentId is required",
+      );
     });
 
     it("full lifecycle: spawn → stop → resume", async () => {

package/src/acp/__tests__/macro-agent.test.ts

@@ -98,6 +98,12 @@ function createMockAgentManager(): AgentManager {
     close: vi.fn().mockResolvedValue(undefined),
     respondToPermission: vi.fn().mockReturnValue(true),
     cancelPermission: vi.fn().mockReturnValue(true),
+    forkAgent: vi.fn().mockResolvedValue({
+      id: "agent-forked",
+      session_id: "session-forked",
+      agent: createMockAgent({ id: "agent-forked", session_id: "session-forked" }),
+      session: { id: "provider-session-forked" },
+    }),
   } as unknown as AgentManager;
 }
 
@@ -612,21 +618,23 @@ describe("MacroAgent", () => {
         agentId: "agent-1",
       });
 
-      expect(response).toHaveProperty("newAgentId");
-      expect(response).toHaveProperty("newSessionId");
+      expect(response).toHaveProperty("newAgentId", "agent-forked");
+      expect(response).toHaveProperty("newSessionId", "session-forked");
       expect(response).toHaveProperty("originalAgentId", "agent-1");
-      expect(mockAgentManager.spawn).toHaveBeenCalled();
+      expect(response).toHaveProperty("providerSessionId", "provider-session-forked");
+      expect(mockAgentManager.forkAgent).toHaveBeenCalledWith("agent-1", expect.any(Object));
     });
 
-    it("should use custom name in task description", async () => {
+    it("should pass custom name to forkAgent", async () => {
       await macroAgent.extMethod("macro/forkAgent", {
         agentId: "agent-1",
         name: "Custom fork name",
       });
 
-      expect(mockAgentManager.spawn).toHaveBeenCalledWith(
+      expect(mockAgentManager.forkAgent).toHaveBeenCalledWith(
+        "agent-1",
         expect.objectContaining({
-          task: expect.stringContaining("Custom fork name"),
+          name: "Custom fork name",
         })
       );
     });
@@ -641,8 +649,9 @@ describe("MacroAgent", () => {
       ).rejects.toThrow(ACPError);
     });
 
-    it("should throw if agent has no active session", async () => {
+    it("should throw if agent has no active session and no provider_session_id", async () => {
       vi.mocked(mockAgentManager.hasActiveSession).mockReturnValue(false);
+      // Default mock agent has no provider_session_id
 
       await expect(
         macroAgent.extMethod("macro/forkAgent", {

package/src/acp/macro-agent.ts

@@ -20,6 +20,7 @@ import type {
   PromptResponse,
   CancelNotification,
   SessionNotification,
+  SessionModelState,
 } from "@agentclientprotocol/sdk";
 import type { AgentManager } from "../agent/agent-manager.js";
 import type { EventStore } from "../store/event-store.js";
@@ -61,6 +62,8 @@ import type {
   RespondToPermissionResponse,
   CancelPermissionRequest,
   CancelPermissionResponse,
+  SetPermissionModeRequest,
+  SetPermissionModeResponse,
   ResumeAgentRequest,
   ResumeAgentResponse,
   GetHistoryRequest,
@@ -113,8 +116,10 @@ const SUPPORTED_EXTENSIONS: ACPExtensionMethod[] = [
   "_macro/checkCapability",
   "_macro/respondToPermission",
   "_macro/cancelPermission",
+  "_macro/setPermissionMode",
   "_macro/resume",
   "_macro/getHistory",
+  "_macro/getModels",
 ];
 
 // ─────────────────────────────────────────────────────────────────
@@ -144,6 +149,22 @@ export interface MacroAgentConfig {
   defaultCwd?: string;
 }
 
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * Build a SessionModelState from the acp-factory Session.models (string[]).
+ * Returns null if the models array is empty or missing.
+ */
+function buildModelState(models: string[]): SessionModelState | null {
+  if (!models || models.length === 0) return null;
+  return {
+    currentModelId: models[0],
+    availableModels: models.map((id) => ({ modelId: id, name: id })),
+  };
+}
+
 // ─────────────────────────────────────────────────────────────────
 // MacroAgent Implementation
 // ─────────────────────────────────────────────────────────────────
@@ -271,6 +292,7 @@ export class MacroAgent implements Agent {
 
     return {
       sessionId: acpSessionId,
+      models: buildModelState(spawned.session.models),
     };
   }
 
@@ -281,6 +303,7 @@ export class MacroAgent implements Agent {
     let acpSessionId = params.sessionId;
     const cwd = params.cwd ?? this.defaultCwd;
 
+    // DEBUG: Log loadSession params
     // Extension: If _meta.agentId provided, look up session from agent record
     // This allows resuming a stopped head manager by MAP agent ID
     // when the TUI doesn't know the ACP session ID
@@ -314,14 +337,18 @@ export class MacroAgent implements Agent {
         }
         this.ensureConversation(acpSessionId, existing.id);
         await this.emitSessionInfo(acpSessionId);
-        return {};
+        const activeSession = this.agentManager.getSession(existing.id);
+        return {
+          models: activeSession ? buildModelState(activeSession.models) : null,
+        };
       }
 
       // Agent exists but no active session - resume it
       console.log(
         `[MacroAgent] loadSession: Resuming stopped agent ${existing.id}`,
       );
-      const spawned = await this.agentManager.resume(existing.id);
+      const defaultConfig = this.initConfig.defaultSubAgentConfig;
+      const spawned = await this.agentManager.resume(existing.id, defaultConfig?.permissionMode);
 
       // Create session mapping
       this.sessionMapper.createMapping(acpSessionId, spawned.id);
@@ -329,16 +356,20 @@ export class MacroAgent implements Agent {
       this.ensureConversation(acpSessionId, spawned.id);
       await this.emitSessionInfo(acpSessionId);
 
-      return {};
+      return {
+        models: buildModelState(spawned.session.models),
+      };
     }
 
     // No existing agent found - try to get or create with the specific session ID
     console.log(
       `[MacroAgent] loadSession: No existing agent for session ${acpSessionId}, creating new`,
     );
+    const defaultConfig = this.initConfig.defaultSubAgentConfig;
     const spawned = await this.agentManager.getOrCreateHeadManager({
       cwd,
       sessionId: acpSessionId,
+      permissionMode: defaultConfig?.permissionMode,
     });
 
     // Create session mapping
@@ -347,7 +378,9 @@ export class MacroAgent implements Agent {
     this.ensureConversation(acpSessionId, spawned.id);
     await this.emitSessionInfo(acpSessionId);
 
-    return {};
+    return {
+      models: buildModelState(spawned.session.models),
+    };
   }
 
   /**
@@ -564,6 +597,11 @@ export class MacroAgent implements Agent {
           params as unknown as CancelPermissionRequest,
         ) as unknown as Record<string, unknown>;
 
+      case "_macro/setPermissionMode":
+        return this.handleSetPermissionMode(
+          params as unknown as SetPermissionModeRequest,
+        ) as unknown as Record<string, unknown>;
+
       case "_macro/resume":
         return this.handleResumeAgent(
           params as unknown as ResumeAgentRequest,
@@ -574,6 +612,11 @@ export class MacroAgent implements Agent {
           params as unknown as GetHistoryRequest,
         ) as unknown as Record<string, unknown>;
 
+      case "_macro/getModels":
+        return this.handleGetModels(
+          params as { sessionId: string },
+        ) as unknown as Record<string, unknown>;
+
       default:
         throw new ACPError(
           `Unknown extension method: ${method}`,
@@ -792,9 +835,9 @@ export class MacroAgent implements Agent {
   private async handleForkAgent(
     params: ForkAgentRequest,
   ): Promise<ForkAgentResponse> {
-    const { agentId, name } = params;
+    const { agentId, name, prompt, cwd } = params;
 
-    // Get the original agent
+    // Validate source agent exists
     const originalAgent = this.agentManager.get(agentId);
     if (!originalAgent) {
       throw new ACPError(`Agent not found: ${agentId}`, "AGENT_NOT_FOUND", {
@@ -802,41 +845,48 @@ export class MacroAgent implements Agent {
       });
     }
 
-    // Check if the agent has an active session we can fork from
-    const hasSession = this.agentManager.hasActiveSession(agentId);
-    if (!hasSession) {
+    // Check forkable: needs active session or persisted provider_session_id
+    if (
+      !this.agentManager.hasActiveSession(agentId) &&
+      !originalAgent.provider_session_id
+    ) {
       throw new ACPError(
-        `Agent has no active session to fork: ${agentId}`,
+        `Agent has no session to fork: ${agentId}`,
         "FORK_NOT_SUPPORTED",
         { agentId },
       );
     }
 
-    // For now, create a new agent with the same task as a "fork"
-    // In a full implementation, we would:
-    // 1. Check if acp-factory supports native fork
-    // 2. Use loadSession to clone the conversation state
-    // Since acp-factory doesn't expose these yet, we create a new agent
-    // with the same task description as a simplified fork
-
-    const taskDescription = name
-      ? `[Fork of ${agentId}] ${name}`
-      : `[Fork of ${agentId}] ${originalAgent.task ?? "Forked task"}`;
-
-    const spawned = await this.agentManager.spawn({
-      task: taskDescription,
-      parent: originalAgent.parent ?? null,
-      cwd: this.defaultCwd,
-      subscribeParent: false,
+    // Fork via AgentManager (handles forkWithFlush + new process + loadSession)
+    const forked = await this.agentManager.forkAgent(agentId, {
+      name,
+      cwd: cwd ?? originalAgent.cwd ?? this.defaultCwd,
     });
 
-    // Emit a fork event for tracking (the EventStore records this via spawn)
-    // In a more complete implementation, we'd add a dedicated "fork" event type
+    // Fire-and-forget initial prompt if provided
+    if (prompt) {
+      (async () => {
+        try {
+          for await (const _update of this.agentManager.prompt(
+            forked.id,
+            prompt,
+          )) {
+            // Drain the async iterable
+          }
+        } catch (err) {
+          console.warn(
+            `[MacroAgent] Failed to send initial prompt to forked agent ${forked.id}:`,
+            err,
+          );
+        }
+      })();
+    }
 
     return {
-      newAgentId: spawned.id,
-      newSessionId: spawned.session_id,
+      newAgentId: forked.id,
+      newSessionId: forked.session_id,
       originalAgentId: agentId,
+      providerSessionId: forked.session.id,
     };
   }
 
@@ -1182,6 +1232,41 @@ export class MacroAgent implements Agent {
     }
   }
 
+  /**
+   * Change the permission mode for a running agent at runtime
+   */
+  private async handleSetPermissionMode(
+    params: SetPermissionModeRequest,
+  ): Promise<SetPermissionModeResponse> {
+    const { agentId, permissionMode } = params;
+
+    // Get the current mode before changing
+    const previousMode = this.agentManager.getPermissionMode(
+      agentId as AgentId,
+    );
+
+    // Set the new mode via agent manager
+    const success = this.agentManager.setPermissionMode(
+      agentId as AgentId,
+      permissionMode,
+    );
+
+    if (success) {
+      console.log(
+        `[MacroAgent] Set permission mode for agent ${agentId} from ${previousMode} to ${permissionMode}`,
+      );
+      return {
+        success: true,
+        previousMode: previousMode ?? undefined,
+      };
+    } else {
+      return {
+        success: false,
+        error: `No active session found for agent ${agentId}`,
+      };
+    }
+  }
+
   /**
    * Resume a stopped/failed agent
    */
@@ -1315,7 +1400,7 @@ export class MacroAgent implements Agent {
 
       case "permission_request": {
         // Handle permission_request specially - ACP SDK doesn't recognize it as a session update
-        // We need to call requestPermission on the connection to forward to sudocode
+        // We need to call requestPermission on the connection to forward to the client
 
         // Extract permission request data
         const permReq = sessionUpdate as {
@@ -1334,17 +1419,20 @@ export class MacroAgent implements Agent {
           }>;
         };
 
-        // Get the agent ID for this session to forward the response back
-        const agentId = this.sessionMapper.getAgentId(permReq.sessionId);
+        // Look up agent ID using the ACP session ID (from the client connection),
+        // NOT permReq.sessionId which is the agent's internal session ID.
+        // The session mapper maps ACP session IDs → agent IDs, so using the
+        // internal session ID would fail silently and drop the permission request.
+        const agentId = this.sessionMapper.getAgentId(acpSessionId);
         if (!agentId) {
           console.warn(
-            `[MacroAgent] No agent found for session ${permReq.sessionId}, cannot forward permission request`,
+            `[MacroAgent] No agent found for ACP session ${acpSessionId}, cannot forward permission request`,
           );
           return;
         }
 
-        // Forward to sudocode via requestPermission RPC
-        // This will trigger sudocode's WebSocketClientHandler which will show the prompt
+        // Forward via requestPermission RPC
+        // This will trigger the client's handler which will show the prompt
         try {
           const response = await this.connection.requestPermission({
             sessionId: acpSessionId,
@@ -1700,6 +1788,52 @@ export class MacroAgent implements Agent {
     }
   }
 
+  /**
+   * Handle _macro/getModels extension — returns the session's available models.
+   * Claude Code populates models asynchronously after session creation
+   * (via _model_state_update notification), so this allows the TUI to poll
+   * for the model list once it's available.
+   *
+   * Returns full model info (modelId + name) since Claude Code uses shorthand
+   * model IDs ("default", "sonnet") that don't match models.dev. The name
+   * field (e.g., "Claude Sonnet 4") enables better model registry matching.
+   */
+  private handleGetModels(params: { sessionId: string }): {
+    currentModelId: string | null;
+    availableModels: Array<{ modelId: string; name: string }>;
+  } {
+    const { sessionId } = params;
+    const agentId = this.sessionMapper.getAgentId(sessionId);
+    if (!agentId) {
+      return { currentModelId: null, availableModels: [] };
+    }
+    const session = this.agentManager.getSession(agentId);
+    if (!session) {
+      return { currentModelId: null, availableModels: [] };
+    }
+    // Try clientHandler's model info store first (from _model_state_update notification)
+    const clientHandler = (session as unknown as {
+      clientHandler?: {
+        getSessionModelInfo?: (id: string) => {
+          currentModelId: string | null;
+          availableModels: Array<{ modelId: string; name: string }>;
+        } | null;
+      };
+    }).clientHandler;
+    const modelInfo = clientHandler?.getSessionModelInfo?.(session.id);
+    if (modelInfo && modelInfo.availableModels.length > 0) {
+      return modelInfo;
+    }
+    // Fall back to Session.models (from initial session response — just IDs)
+    if (session.models && session.models.length > 0) {
+      return {
+        currentModelId: session.models[0],
+        availableModels: session.models.map((id) => ({ modelId: id, name: id })),
+      };
+    }
+    return { currentModelId: null, availableModels: [] };
+  }
+
   /**
    * Handle _macro/getHistory extension — returns conversation turns for a session
    */