macro-agent 0.2.4 → 0.2.6

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

@@ -1,465 +0,0 @@
-/**
- * Tests for AgentStore — minimal SQLite store for agent lifecycle.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { AgentStore } from "../agent-store.js";
-import type { AgentRecord, SessionRecord } from "../agent-store.js";
-
-describe("AgentStore", () => {
-  let store: AgentStore;
-
-  beforeEach(() => {
-    store = new AgentStore(":memory:");
-  });
-
-  afterEach(() => {
-    store.close();
-  });
-
-  function makeAgent(overrides: Partial<AgentRecord> = {}): AgentRecord {
-    return {
-      id: `agent-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-      role: "worker",
-      state: "running",
-      parent_id: null,
-      lineage: [],
-      scope: "default",
-      task: "test task",
-      cwd: "/tmp/test",
-      capabilities: ["file.read", "file.write"],
-      created_at: Date.now(),
-      ...overrides,
-    };
-  }
-
-  // ── Agent CRUD ─────────────────────────────────────────────
-
-  describe("putAgent / getAgent", () => {
-    it("should store and retrieve an agent", () => {
-      const agent = makeAgent({ id: "agent-1", name: "Alice" });
-      store.putAgent(agent);
-
-      const retrieved = store.getAgent("agent-1");
-      expect(retrieved).not.toBeNull();
-      expect(retrieved!.id).toBe("agent-1");
-      expect(retrieved!.name).toBe("Alice");
-      expect(retrieved!.role).toBe("worker");
-      expect(retrieved!.state).toBe("running");
-      expect(retrieved!.capabilities).toEqual(["file.read", "file.write"]);
-    });
-
-    it("should return null for non-existent agent", () => {
-      expect(store.getAgent("nonexistent")).toBeNull();
-    });
-
-    it("should upsert on duplicate ID", () => {
-      store.putAgent(makeAgent({ id: "agent-1", name: "Alice" }));
-      store.putAgent(makeAgent({ id: "agent-1", name: "Bob" }));
-
-      const agent = store.getAgent("agent-1");
-      expect(agent!.name).toBe("Bob");
-    });
-
-    it("should handle all optional fields", () => {
-      const agent = makeAgent({
-        id: "agent-full",
-        name: "Full Agent",
-        stop_reason: "completed",
-        team: "team-alpha",
-        task_id: "task-1",
-        workspace_path: "/tmp/worktree",
-        workspace_stream_id: "stream-1",
-        config: { model: "claude-3" },
-        metadata: { custom: "value" },
-        started_at: Date.now(),
-        stopped_at: Date.now(),
-        last_activity_at: Date.now(),
-      });
-      store.putAgent(agent);
-
-      const retrieved = store.getAgent("agent-full")!;
-      expect(retrieved.team).toBe("team-alpha");
-      expect(retrieved.workspace_path).toBe("/tmp/worktree");
-      expect(retrieved.config).toEqual({ model: "claude-3" });
-      expect(retrieved.metadata).toEqual({ custom: "value" });
-      expect(retrieved.stop_reason).toBe("completed");
-    });
-
-    it("should preserve lineage as array", () => {
-      const agent = makeAgent({
-        id: "agent-child",
-        lineage: ["agent-root", "agent-parent"],
-      });
-      store.putAgent(agent);
-
-      const retrieved = store.getAgent("agent-child")!;
-      expect(retrieved.lineage).toEqual(["agent-root", "agent-parent"]);
-    });
-  });
-
-  // ── updateAgent ────────────────────────────────────────────
-
-  describe("updateAgent", () => {
-    it("should update specific fields", () => {
-      store.putAgent(makeAgent({ id: "agent-1", state: "running" }));
-      store.updateAgent("agent-1", {
-        state: "stopped",
-        stop_reason: "completed",
-        stopped_at: Date.now(),
-      });
-
-      const agent = store.getAgent("agent-1")!;
-      expect(agent.state).toBe("stopped");
-      expect(agent.stop_reason).toBe("completed");
-      expect(agent.stopped_at).toBeDefined();
-    });
-
-    it("should update JSON fields correctly", () => {
-      store.putAgent(makeAgent({ id: "agent-1" }));
-      store.updateAgent("agent-1", {
-        metadata: { updated: true },
-        capabilities: ["exec.command"],
-      });
-
-      const agent = store.getAgent("agent-1")!;
-      expect(agent.metadata).toEqual({ updated: true });
-      expect(agent.capabilities).toEqual(["exec.command"]);
-    });
-
-    it("should not modify other fields", () => {
-      store.putAgent(
-        makeAgent({ id: "agent-1", name: "Alice", role: "worker" })
-      );
-      store.updateAgent("agent-1", { state: "stopped" });
-
-      const agent = store.getAgent("agent-1")!;
-      expect(agent.name).toBe("Alice");
-      expect(agent.role).toBe("worker");
-    });
-
-    it("should handle empty updates gracefully", () => {
-      store.putAgent(makeAgent({ id: "agent-1" }));
-      store.updateAgent("agent-1", {});
-      expect(store.getAgent("agent-1")).not.toBeNull();
-    });
-  });
-
-  // ── removeAgent ────────────────────────────────────────────
-
-  describe("removeAgent", () => {
-    it("should delete an agent", () => {
-      store.putAgent(makeAgent({ id: "agent-1" }));
-      store.removeAgent("agent-1");
-      expect(store.getAgent("agent-1")).toBeNull();
-    });
-
-    it("should cascade delete sessions", () => {
-      store.putAgent(makeAgent({ id: "agent-1" }));
-      store.putSession({
-        agent_id: "agent-1",
-        session_id: "session-1",
-        created_at: Date.now(),
-      });
-      store.removeAgent("agent-1");
-      expect(store.getSession("agent-1")).toBeNull();
-    });
-  });
-
-  // ── listAgents ─────────────────────────────────────────────
-
-  describe("listAgents", () => {
-    beforeEach(() => {
-      store.putAgent(
-        makeAgent({
-          id: "w1",
-          role: "worker",
-          state: "running",
-          team: "alpha",
-          parent_id: "coord-1",
-        })
-      );
-      store.putAgent(
-        makeAgent({
-          id: "w2",
-          role: "worker",
-          state: "stopped",
-          team: "alpha",
-          parent_id: "coord-1",
-        })
-      );
-      store.putAgent(
-        makeAgent({
-          id: "c1",
-          role: "coordinator",
-          state: "running",
-          team: "beta",
-          parent_id: null,
-        })
-      );
-    });
-
-    it("should return all agents with no filter", () => {
-      expect(store.listAgents()).toHaveLength(3);
-    });
-
-    it("should filter by state", () => {
-      const running = store.listAgents({ state: "running" });
-      expect(running).toHaveLength(2);
-    });
-
-    it("should filter by role", () => {
-      const workers = store.listAgents({ role: "worker" });
-      expect(workers).toHaveLength(2);
-    });
-
-    it("should filter by team", () => {
-      const alpha = store.listAgents({ team: "alpha" });
-      expect(alpha).toHaveLength(2);
-    });
-
-    it("should filter by parent_id null (root agents)", () => {
-      const roots = store.listAgents({ parent_id: null });
-      expect(roots).toHaveLength(1);
-      expect(roots[0].id).toBe("c1");
-    });
-
-    it("should filter by parent_id value", () => {
-      const children = store.listAgents({ parent_id: "coord-1" });
-      expect(children).toHaveLength(2);
-    });
-
-    it("should combine filters", () => {
-      const result = store.listAgents({
-        role: "worker",
-        state: "running",
-      });
-      expect(result).toHaveLength(1);
-      expect(result[0].id).toBe("w1");
-    });
-  });
-
-  // ── Hierarchy ──────────────────────────────────────────────
-
-  describe("hierarchy queries", () => {
-    beforeEach(() => {
-      store.putAgent(makeAgent({ id: "root", parent_id: null }));
-      store.putAgent(makeAgent({ id: "child-1", parent_id: "root" }));
-      store.putAgent(makeAgent({ id: "child-2", parent_id: "root" }));
-      store.putAgent(
-        makeAgent({ id: "grandchild-1", parent_id: "child-1" })
-      );
-    });
-
-    it("getChildren should return direct children", () => {
-      const children = store.getChildren("root");
-      expect(children).toHaveLength(2);
-      expect(children.map((c) => c.id).sort()).toEqual([
-        "child-1",
-        "child-2",
-      ]);
-    });
-
-    it("getChildren should return empty for leaf nodes", () => {
-      expect(store.getChildren("grandchild-1")).toHaveLength(0);
-    });
-
-    it("getDescendants should return all descendants BFS", () => {
-      const desc = store.getDescendants("root");
-      expect(desc).toHaveLength(3);
-      expect(desc.map((d) => d.id)).toContain("grandchild-1");
-    });
-
-    it("getAncestors should return parent chain", () => {
-      const ancestors = store.getAncestors("grandchild-1");
-      expect(ancestors).toHaveLength(2);
-      expect(ancestors[0].id).toBe("child-1");
-      expect(ancestors[1].id).toBe("root");
-    });
-
-    it("getAncestors should return empty for root", () => {
-      expect(store.getAncestors("root")).toHaveLength(0);
-    });
-  });
-
-  // ── Change Subscriptions ────────────────────────────────────
-
-  describe("onChange", () => {
-    it("should fire on putAgent", () => {
-      const events: { type: string; agentId: string }[] = [];
-      store.onChange((e) => events.push(e));
-
-      store.putAgent(makeAgent({ id: "agent-1" }));
-
-      expect(events).toHaveLength(1);
-      expect(events[0]).toEqual({ type: "put", agentId: "agent-1" });
-    });
-
-    it("should fire on updateAgent", () => {
-      store.putAgent(makeAgent({ id: "agent-1" }));
-
-      const events: { type: string; agentId: string }[] = [];
-      store.onChange((e) => events.push(e));
-
-      store.updateAgent("agent-1", { state: "stopped" });
-
-      expect(events).toHaveLength(1);
-      expect(events[0]).toEqual({ type: "update", agentId: "agent-1" });
-    });
-
-    it("should fire on removeAgent", () => {
-      store.putAgent(makeAgent({ id: "agent-1" }));
-
-      const events: { type: string; agentId: string }[] = [];
-      store.onChange((e) => events.push(e));
-
-      store.removeAgent("agent-1");
-
-      expect(events).toHaveLength(1);
-      expect(events[0]).toEqual({ type: "remove", agentId: "agent-1" });
-    });
-
-    it("should support unsubscribe", () => {
-      const events: { type: string; agentId: string }[] = [];
-      const unsub = store.onChange((e) => events.push(e));
-
-      store.putAgent(makeAgent({ id: "agent-1" }));
-      expect(events).toHaveLength(1);
-
-      unsub();
-
-      store.putAgent(makeAgent({ id: "agent-2" }));
-      expect(events).toHaveLength(1); // No new events after unsub
-    });
-
-    it("should not break other listeners when one throws", () => {
-      const events: { type: string; agentId: string }[] = [];
-
-      store.onChange(() => {
-        throw new Error("listener error");
-      });
-      store.onChange((e) => events.push(e));
-
-      store.putAgent(makeAgent({ id: "agent-1" }));
-
-      expect(events).toHaveLength(1);
-      expect(events[0]).toEqual({ type: "put", agentId: "agent-1" });
-    });
-  });
-
-  // ── Sessions ───────────────────────────────────────────────
-
-  describe("sessions", () => {
-    beforeEach(() => {
-      store.putAgent(makeAgent({ id: "agent-1" }));
-    });
-
-    it("should store and retrieve a session", () => {
-      const session: SessionRecord = {
-        agent_id: "agent-1",
-        session_id: "session-abc",
-        provider_session_id: "uuid-123",
-        created_at: Date.now(),
-      };
-      store.putSession(session);
-
-      const retrieved = store.getSession("agent-1");
-      expect(retrieved).not.toBeNull();
-      expect(retrieved!.session_id).toBe("session-abc");
-      expect(retrieved!.provider_session_id).toBe("uuid-123");
-    });
-
-    it("should return null for non-existent session", () => {
-      expect(store.getSession("agent-1")).toBeNull();
-    });
-
-    it("should upsert sessions", () => {
-      store.putSession({
-        agent_id: "agent-1",
-        session_id: "session-1",
-        created_at: Date.now(),
-      });
-      store.putSession({
-        agent_id: "agent-1",
-        session_id: "session-2",
-        created_at: Date.now(),
-      });
-
-      const session = store.getSession("agent-1")!;
-      expect(session.session_id).toBe("session-2");
-    });
-
-    it("removeSession should delete a session", () => {
-      store.putSession({
-        agent_id: "agent-1",
-        session_id: "session-1",
-        created_at: Date.now(),
-      });
-      store.removeSession("agent-1");
-      expect(store.getSession("agent-1")).toBeNull();
-    });
-
-    it("should handle optional provider_session_id", () => {
-      store.putSession({
-        agent_id: "agent-1",
-        session_id: "session-1",
-        created_at: Date.now(),
-      });
-
-      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

@@ -1,231 +0,0 @@
-/**
- * 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();
-  });
-});