macro-agent 0.1.8 → 0.1.11

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

@@ -452,6 +452,72 @@ describe("AgentManagerV2", () => {
     });
   });
 
+  // ── getOrCreateHeadManager() ───────────────────────────────
+
+  describe("getOrCreateHeadManager()", () => {
+    it("reuses an existing head manager matching the requested cwd", async () => {
+      const first = await manager.getOrCreateHeadManager({ cwd: "/tmp/proj-a" });
+      const second = await manager.getOrCreateHeadManager({ cwd: "/tmp/proj-a" });
+      expect(second.id).toBe(first.id);
+    });
+
+    it("spawns a distinct head manager for a different cwd", async () => {
+      const a = await manager.getOrCreateHeadManager({ cwd: "/tmp/proj-a" });
+      const b = await manager.getOrCreateHeadManager({ cwd: "/tmp/proj-b" });
+      expect(b.id).not.toBe(a.id);
+    });
+
+    it("getActiveAgentSession returns null for unknown agents", () => {
+      expect(manager.getActiveAgentSession("never-spawned" as AgentId)).toBeNull();
+    });
+
+    it("getActiveAgentSession returns the spawned shape for any role with a live session", async () => {
+      // Spawn a non-coordinator (worker) so we exercise the role-agnostic path
+      const worker = await manager.spawn({ task: "Test work", role: "worker" });
+
+      const session = manager.getActiveAgentSession(worker.id as AgentId);
+      expect(session).not.toBeNull();
+      expect(session!.id).toBe(worker.id);
+      expect(session!.agent.role).toBe("worker");
+    });
+
+    it("getActiveAgentSession returns null after the agent is terminated", async () => {
+      const worker = await manager.spawn({ task: "Test work", role: "worker" });
+      await manager.terminate(worker.id as AgentId, "completed");
+      expect(manager.getActiveAgentSession(worker.id as AgentId)).toBeNull();
+    });
+
+    it("ignores stale 'running' store records whose session isn't live in this process", async () => {
+      // Simulate a crashed prior process: a coordinator record exists in the
+      // store with state='running' and parent_id=null, but has no matching
+      // activeSessions entry (the session was lost when the process died).
+      // Without the activeSessions filter in the predicate, getOrCreate would
+      // erroneously reuse this stale record and skip spawning.
+      agentStore.putAgent({
+        id: "stale-coord" as AgentId,
+        name: "stale-coord",
+        role: "coordinator",
+        state: "running",
+        parent_id: null,
+        lineage: [],
+        team: null,
+        scope: "default",
+        task: "",
+        task_id: "",
+        cwd: "/tmp/stale-proj",
+        capabilities: [],
+        created_at: Date.now() as any,
+        started_at: Date.now() as any,
+        config: {},
+        metadata: {},
+      });
+
+      const result = await manager.getOrCreateHeadManager({ cwd: "/tmp/stale-proj" });
+      expect(result.id).not.toBe("stale-coord");
+      expect(manager.hasActiveSession(result.id as AgentId)).toBe(true);
+    });
+  });
+
   // ── Lifecycle Callbacks ────────────────────────────────────
 
   describe("lifecycle callbacks", () => {

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

@@ -409,5 +409,57 @@ describe("AgentStore", () => {
       const session = store.getSession("agent-1")!;
       expect(session.provider_session_id).toBeUndefined();
     });
+
+    it("findSessionByProviderSessionId returns the matching session", () => {
+      store.putAgent(makeAgent({ id: "agent-2" }));
+      store.putSession({
+        agent_id: "agent-1",
+        session_id: "session-abc",
+        provider_session_id: "psid-xyz",
+        created_at: Date.now(),
+      });
+      store.putSession({
+        agent_id: "agent-2",
+        session_id: "session-def",
+        provider_session_id: "psid-other",
+        created_at: Date.now(),
+      });
+
+      const found = store.findSessionByProviderSessionId("psid-xyz");
+      expect(found).not.toBeNull();
+      expect(found!.agent_id).toBe("agent-1");
+      expect(found!.session_id).toBe("session-abc");
+    });
+
+    it("findSessionByProviderSessionId returns null when no match", () => {
+      store.putSession({
+        agent_id: "agent-1",
+        session_id: "session-1",
+        provider_session_id: "psid-1",
+        created_at: Date.now(),
+      });
+      expect(store.findSessionByProviderSessionId("psid-missing")).toBeNull();
+    });
+
+    it("findSessionByProviderSessionId returns most recent on duplicate psid", () => {
+      // Shouldn't normally happen but verify the ORDER BY created_at DESC path.
+      store.putAgent(makeAgent({ id: "agent-old" }));
+      store.putAgent(makeAgent({ id: "agent-new" }));
+      store.putSession({
+        agent_id: "agent-old",
+        session_id: "session-old",
+        provider_session_id: "psid-dup",
+        created_at: 1000,
+      });
+      store.putSession({
+        agent_id: "agent-new",
+        session_id: "session-new",
+        provider_session_id: "psid-dup",
+        created_at: 2000,
+      });
+
+      const found = store.findSessionByProviderSessionId("psid-dup");
+      expect(found!.agent_id).toBe("agent-new");
+    });
   });
 });

package/src/agent/__tests__/task-ref-resolution.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Tests for AgentManagerV2's three-level TaskRef resolution:
+ *   1. Explicit SpawnAgentOptions.taskRef wins.
+ *   2. resolveTaskRef(opts) runs when no explicit ref.
+ *   3. Fallback to taskResourceId + options.task_id when both above yield nothing.
+ *
+ * Verifies the G3/G14 closure: single-graph default via boot config + multi-graph
+ * resolver for deployments that touch more than one opentasks graph.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { createAgentManagerV2 } from "../agent-manager-v2.js";
+import { AgentStore } from "../agent-store.js";
+import type { AgentManager } from "../agent-manager.js";
+import type { InboxAdapter, TasksAdapter } from "../../adapters/types.js";
+import type { SpawnAgentOptions } from "../types.js";
+import type { TaskRef } from "git-cascade/events";
+
+vi.mock("acp-factory", () => ({
+  AgentFactory: {
+    spawn: vi.fn().mockResolvedValue({
+      createSession: vi.fn().mockResolvedValue({
+        id: "provider-session-1",
+        prompt: vi.fn().mockReturnValue({
+          [Symbol.asyncIterator]: () => ({
+            next: () => Promise.resolve({ done: true, value: undefined }),
+          }),
+        }),
+        forkWithFlush: vi.fn().mockResolvedValue({ id: "forked-session-1" }),
+      }),
+      loadSession: vi.fn(),
+      close: vi.fn().mockResolvedValue(undefined),
+      isRunning: vi.fn().mockReturnValue(true),
+    }),
+  },
+}));
+
+function mockInbox(): InboxAdapter {
+  return {
+    registerAgent: vi.fn().mockResolvedValue(undefined),
+    deregisterAgent: vi.fn().mockResolvedValue(undefined),
+    send: vi.fn().mockResolvedValue("msg-1"),
+    onDelivery: vi.fn(),
+    offDelivery: vi.fn(),
+    checkInbox: vi.fn().mockResolvedValue([]),
+    readThread: vi.fn().mockResolvedValue([]),
+    setSignalFilter: vi.fn(),
+    setEmissionValidator: vi.fn(),
+    socketPath: "/tmp/test-inbox.sock",
+    stop: vi.fn().mockResolvedValue(undefined),
+  } as unknown as InboxAdapter;
+}
+
+function mockTasks(): TasksAdapter {
+  return {
+    createTask: vi.fn().mockResolvedValue("ot-task-1"),
+    assignTask: vi.fn().mockResolvedValue(undefined),
+    transitionTask: vi.fn().mockResolvedValue(undefined),
+    getTask: vi.fn().mockResolvedValue({ id: "t-1", title: "x", status: "open" }),
+    queryReady: vi.fn().mockResolvedValue([]),
+    listTasks: vi.fn().mockResolvedValue([]),
+    addBlocker: vi.fn().mockResolvedValue(undefined),
+    removeBlocker: vi.fn().mockResolvedValue(undefined),
+    claimTask: vi.fn().mockResolvedValue(null),
+    unclaimTask: vi.fn().mockResolvedValue(undefined),
+    listClaimable: vi.fn().mockResolvedValue([]),
+    connect: vi.fn().mockResolvedValue(undefined),
+    disconnect: vi.fn(),
+    connected: true,
+  } as unknown as TasksAdapter;
+}
+
+describe("AgentManagerV2 taskRef resolution", () => {
+  let agentStore: AgentStore;
+  let inbox: InboxAdapter;
+  let tasks: TasksAdapter;
+  let manager: AgentManager;
+
+  afterEach(async () => {
+    await manager?.close();
+    agentStore?.close();
+  });
+
+  beforeEach(() => {
+    agentStore = new AgentStore(":memory:");
+    inbox = mockInbox();
+    tasks = mockTasks();
+  });
+
+  function getStoredTaskRef(agentId: string): TaskRef | undefined {
+    const record = agentStore.getAgent(agentId);
+    const meta = record?.metadata as Record<string, unknown> | undefined;
+    return meta?.task_ref as TaskRef | undefined;
+  }
+
+  it("uses taskResourceId + task_id when no other source resolves a ref", async () => {
+    manager = createAgentManagerV2(agentStore, inbox, tasks, {
+      defaultCwd: "/tmp/t",
+      taskResourceId: "resource-default",
+    });
+
+    const result = await manager.spawn({
+      task: "work",
+      task_id: "node-42" as unknown as SpawnAgentOptions["task_id"],
+      role: "worker",
+    });
+
+    expect(getStoredTaskRef(result.id)).toEqual({
+      resource_id: "resource-default",
+      node_id: "node-42",
+    });
+  });
+
+  it("falls through to no taskRef when neither resolver nor taskResourceId apply", async () => {
+    manager = createAgentManagerV2(agentStore, inbox, tasks, {
+      defaultCwd: "/tmp/t",
+      // No taskResourceId, no resolveTaskRef.
+    });
+
+    const result = await manager.spawn({ task: "work", role: "worker" });
+
+    expect(getStoredTaskRef(result.id)).toBeUndefined();
+  });
+
+  it("resolveTaskRef wins over the taskResourceId fallback", async () => {
+    const resolveTaskRef = vi
+      .fn()
+      .mockReturnValue({ resource_id: "resource-from-resolver", node_id: "n1" });
+
+    manager = createAgentManagerV2(agentStore, inbox, tasks, {
+      defaultCwd: "/tmp/t",
+      taskResourceId: "resource-default",
+      resolveTaskRef,
+    });
+
+    const result = await manager.spawn({ task: "work", role: "worker" });
+
+    expect(resolveTaskRef).toHaveBeenCalledOnce();
+    expect(getStoredTaskRef(result.id)).toEqual({
+      resource_id: "resource-from-resolver",
+      node_id: "n1",
+    });
+  });
+
+  it("resolveTaskRef returning undefined falls through to taskResourceId", async () => {
+    const resolveTaskRef = vi.fn().mockReturnValue(undefined);
+
+    manager = createAgentManagerV2(agentStore, inbox, tasks, {
+      defaultCwd: "/tmp/t",
+      taskResourceId: "resource-default",
+      resolveTaskRef,
+    });
+
+    const result = await manager.spawn({
+      task: "work",
+      task_id: "node-9" as unknown as SpawnAgentOptions["task_id"],
+      role: "worker",
+    });
+
+    expect(resolveTaskRef).toHaveBeenCalledOnce();
+    expect(getStoredTaskRef(result.id)).toEqual({
+      resource_id: "resource-default",
+      node_id: "node-9",
+    });
+  });
+
+  it("explicit SpawnAgentOptions.taskRef wins over resolver AND taskResourceId", async () => {
+    const resolveTaskRef = vi
+      .fn()
+      .mockReturnValue({ resource_id: "resource-from-resolver", node_id: "r1" });
+
+    manager = createAgentManagerV2(agentStore, inbox, tasks, {
+      defaultCwd: "/tmp/t",
+      taskResourceId: "resource-default",
+      resolveTaskRef,
+    });
+
+    const explicit: TaskRef = { resource_id: "resource-explicit", node_id: "e1" };
+    const result = await manager.spawn({
+      task: "work",
+      role: "worker",
+      taskRef: explicit,
+    });
+
+    // Resolver should NOT be called when caller already supplied taskRef.
+    expect(resolveTaskRef).not.toHaveBeenCalled();
+    expect(getStoredTaskRef(result.id)).toEqual(explicit);
+  });
+
+  it("resolver receives the intercepted SpawnAgentOptions (post-interceptor)", async () => {
+    const resolveTaskRef = vi.fn().mockReturnValue(undefined);
+
+    manager = createAgentManagerV2(agentStore, inbox, tasks, {
+      defaultCwd: "/tmp/t",
+      resolveTaskRef,
+    });
+    manager.setSpawnInterceptor((opts) => ({ ...opts, cwd: "/overridden/cwd" }));
+
+    await manager.spawn({ task: "x", role: "worker" });
+
+    expect(resolveTaskRef).toHaveBeenCalledOnce();
+    const passed = resolveTaskRef.mock.calls[0][0];
+    expect(passed.cwd).toBe("/overridden/cwd");
+  });
+
+  it("resolver throwing does not block spawn; falls through to taskResourceId", async () => {
+    const resolveTaskRef = vi.fn().mockImplementation(() => {
+      throw new Error("resolver exploded");
+    });
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    manager = createAgentManagerV2(agentStore, inbox, tasks, {
+      defaultCwd: "/tmp/t",
+      taskResourceId: "resource-safe",
+      resolveTaskRef,
+    });
+
+    const result = await manager.spawn({
+      task: "x",
+      task_id: "safe-node" as unknown as SpawnAgentOptions["task_id"],
+      role: "worker",
+    });
+
+    expect(warnSpy).toHaveBeenCalled();
+    expect(getStoredTaskRef(result.id)).toEqual({
+      resource_id: "resource-safe",
+      node_id: "safe-node",
+    });
+    warnSpy.mockRestore();
+  });
+});