@aria-cli/tools 1.0.9 → 1.0.11

package/tests/definitions/delegation-pause-resume.test.ts

@@ -1,758 +0,0 @@
-/**
- * pause_delegation, resume_delegation, and check_delegation tool tests
- *
- * Tests the tool execute functions with mock registry and executor,
- * verifying all error paths, success paths, and quest-native identity.
- */
-
-import { describe, it, expect } from "vitest";
-import { DELEGATION_TOOL_DEFINITIONS } from "../../src/definitions/delegation.js";
-import type { ToolContext, DelegationRegistryRef, DelegationExecutorRef } from "../../src/types.js";
-
-const pauseTool = DELEGATION_TOOL_DEFINITIONS.find((t) => t.name === "pause_delegation")!;
-const resumeTool = DELEGATION_TOOL_DEFINITIONS.find((t) => t.name === "resume_delegation")!;
-const checkTool = DELEGATION_TOOL_DEFINITIONS.find((t) => t.name === "check_delegation")!;
-
-/** Create a mock delegation registry with pre-populated entries */
-function createMockRegistry(
-  entries: Record<
-    string,
-    {
-      id: string;
-      type: "arion" | "worker" | "cli_agent";
-      task: string;
-      status: "running" | "completed" | "failed" | "aborted";
-      arionName?: string;
-      result?: string;
-      error?: string;
-      metadata?: Record<string, unknown>;
-    }
-  > = {},
-): DelegationRegistryRef & { abortCalls: string[] } {
-  const abortCalls: string[] = [];
-  return {
-    abortCalls,
-    get: (id: string) => entries[id],
-    abort: (id: string) => {
-      if (!entries[id] || entries[id].status !== "running") return false;
-      abortCalls.push(id);
-      entries[id].status = "aborted";
-      return true;
-    },
-    await: async (id: string) => {
-      const e = entries[id];
-      if (!e) throw new Error(`Not found: ${id}`);
-      return e;
-    },
-    list: () => Object.values(entries),
-  };
-}
-
-/** Create a mock delegation executor that captures calls */
-function createMockExecutor(): DelegationExecutorRef & {
-  calls: Array<{ method: string; args: unknown[] }>;
-} {
-  const calls: Array<{ method: string; args: unknown[] }> = [];
-  return {
-    calls,
-    delegateToArion: async (name: string, task: string) => {
-      calls.push({ method: "delegateToArion", args: [name, task] });
-      return "quest_newarion123";
-    },
-    spawnWorker: async (task: string) => {
-      calls.push({ method: "spawnWorker", args: [task] });
-      return "quest_newworker12";
-    },
-    spawnCliAgent: async (opts: unknown) => {
-      calls.push({ method: "spawnCliAgent", args: [opts] });
-      return "quest_newcli1234";
-    },
-  };
-}
-
-/** Minimal context with only delegation-relevant fields */
-function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
-  return {
-    workingDir: "/tmp/test",
-    env: {},
-    ...overrides,
-  } as ToolContext;
-}
-
-// ---------------------------------------------------------------------------
-// pause_delegation
-// ---------------------------------------------------------------------------
-
-describe("pause_delegation", () => {
-  it("is defined in DELEGATION_TOOL_DEFINITIONS", () => {
-    expect(pauseTool).toBeDefined();
-    expect(pauseTool.name).toBe("pause_delegation");
-  });
-
-  it("returns error when no delegation registry", async () => {
-    const ctx = makeContext({ delegationRegistry: undefined });
-    const result = await pauseTool.execute({ id: "quest_abc123def4" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("No delegation registry");
-  });
-
-  it("returns error when delegation not found", async () => {
-    const registry = createMockRegistry({});
-    const ctx = makeContext({ delegationRegistry: registry });
-    const result = await pauseTool.execute({ id: "quest_ghost12345" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Delegation not found");
-  });
-
-  it("returns error when delegation not running", async () => {
-    const registry = createMockRegistry({
-      quest_done1234567: {
-        id: "quest_done1234567",
-        type: "worker",
-        task: "finished task",
-        status: "completed",
-        result: "all done",
-      },
-    });
-    const ctx = makeContext({ delegationRegistry: registry });
-    const result = await pauseTool.execute({ id: "quest_done1234567" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Cannot pause");
-    expect(result.message).toContain("completed");
-  });
-
-  it("calls registry.abort() on running delegation", async () => {
-    const registry = createMockRegistry({
-      quest_run12345678: {
-        id: "quest_run12345678",
-        type: "worker",
-        task: "active task",
-        status: "running",
-      },
-    });
-    const ctx = makeContext({ delegationRegistry: registry });
-
-    await pauseTool.execute({ id: "quest_run12345678" }, ctx);
-
-    expect(registry.abortCalls).toContain("quest_run12345678");
-  });
-
-  it("returns success with aborted status", async () => {
-    const registry = createMockRegistry({
-      quest_run12345678: {
-        id: "quest_run12345678",
-        type: "arion",
-        task: "running task",
-        status: "running",
-        arionName: "coder",
-      },
-    });
-    const ctx = makeContext({ delegationRegistry: registry });
-
-    const result = await pauseTool.execute({ id: "quest_run12345678" }, ctx);
-
-    expect(result.success).toBe(true);
-    expect(result.message).toContain("aborted");
-    expect(result.data).toEqual({ id: "quest_run12345678", status: "aborted" });
-  });
-
-  it("includes reason in success message when provided", async () => {
-    const registry = createMockRegistry({
-      quest_run12345678: {
-        id: "quest_run12345678",
-        type: "worker",
-        task: "task",
-        status: "running",
-      },
-    });
-    const ctx = makeContext({ delegationRegistry: registry });
-
-    const result = await pauseTool.execute(
-      { id: "quest_run12345678", reason: "need user input" },
-      ctx,
-    );
-
-    expect(result.success).toBe(true);
-    expect(result.message).toContain("need user input");
-  });
-
-  it("updates quest store to blocked on pause", async () => {
-    const registry = createMockRegistry({
-      quest_run12345678: {
-        id: "quest_run12345678",
-        type: "worker",
-        task: "task",
-        status: "running",
-      },
-    });
-    const updateCalls: Array<{ id: string; update: unknown }> = [];
-    const mockQuestStore = {
-      getQuest: () => null,
-      createQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      updateQuest: (id: string, update: unknown) => {
-        updateCalls.push({ id, update });
-        return {
-          id,
-          title: "",
-          status: "blocked" as const,
-          progress: "",
-          priority: 2,
-          attempts: 0,
-          createdAt: 0,
-          updatedAt: 0,
-        };
-      },
-      listQuests: () => [],
-    };
-    const ctx = makeContext({
-      delegationRegistry: registry,
-      questStore: mockQuestStore,
-    });
-
-    await pauseTool.execute({ id: "quest_run12345678", reason: "waiting for input" }, ctx);
-
-    expect(updateCalls).toHaveLength(1);
-    expect(updateCalls[0].id).toBe("quest_run12345678");
-    expect(updateCalls[0].update).toEqual({
-      status: "blocked",
-      progress: "waiting for input",
-    });
-  });
-
-  it("uses default progress when no reason provided on pause", async () => {
-    const registry = createMockRegistry({
-      quest_run12345678: {
-        id: "quest_run12345678",
-        type: "worker",
-        task: "task",
-        status: "running",
-      },
-    });
-    const updateCalls: Array<{ id: string; update: unknown }> = [];
-    const mockQuestStore = {
-      getQuest: () => null,
-      createQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      updateQuest: (id: string, update: unknown) => {
-        updateCalls.push({ id, update });
-        return {
-          id,
-          title: "",
-          status: "blocked" as const,
-          progress: "",
-          priority: 2,
-          attempts: 0,
-          createdAt: 0,
-          updatedAt: 0,
-        };
-      },
-      listQuests: () => [],
-    };
-    const ctx = makeContext({
-      delegationRegistry: registry,
-      questStore: mockQuestStore,
-    });
-
-    await pauseTool.execute({ id: "quest_run12345678" }, ctx);
-
-    expect(updateCalls).toHaveLength(1);
-    expect(updateCalls[0].update).toEqual({
-      status: "blocked",
-      progress: "Paused by user",
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resume_delegation
-// ---------------------------------------------------------------------------
-
-describe("resume_delegation", () => {
-  it("is defined in DELEGATION_TOOL_DEFINITIONS", () => {
-    expect(resumeTool).toBeDefined();
-    expect(resumeTool.name).toBe("resume_delegation");
-  });
-
-  it("returns error when no delegation executor", async () => {
-    const registry = createMockRegistry({});
-    const ctx = makeContext({
-      delegationExecutor: undefined,
-      delegationRegistry: registry,
-    });
-    const result = await resumeTool.execute({ id: "quest_abc123def4" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("executor not available");
-  });
-
-  it("returns error when no delegation registry", async () => {
-    const executor = createMockExecutor();
-    const ctx = makeContext({
-      delegationExecutor: executor,
-      delegationRegistry: undefined,
-    });
-    const result = await resumeTool.execute({ id: "quest_abc123def4" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("No delegation registry");
-  });
-
-  it("returns error when delegation not found", async () => {
-    const executor = createMockExecutor();
-    const registry = createMockRegistry({});
-    const ctx = makeContext({
-      delegationExecutor: executor,
-      delegationRegistry: registry,
-    });
-    const result = await resumeTool.execute({ id: "quest_ghost12345" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Delegation not found");
-  });
-
-  it("creates new arion delegation for arion type", async () => {
-    const executor = createMockExecutor();
-    const registry = createMockRegistry({
-      quest_paused12345: {
-        id: "quest_paused12345",
-        type: "arion",
-        task: "build feature",
-        status: "aborted",
-        arionName: "architect",
-      },
-    });
-    const ctx = makeContext({
-      delegationExecutor: executor,
-      delegationRegistry: registry,
-    });
-
-    const result = await resumeTool.execute({ id: "quest_paused12345" }, ctx);
-
-    expect(result.success).toBe(true);
-    expect(result.message).toContain("resumed");
-    expect(result.data).toEqual({
-      originalId: "quest_paused12345",
-      newId: "quest_newarion123",
-      type: "arion",
-    });
-
-    expect(executor.calls).toHaveLength(1);
-    expect(executor.calls[0].method).toBe("delegateToArion");
-    expect(executor.calls[0].args[0]).toBe("architect");
-    expect(executor.calls[0].args[1] as string).toContain("build feature");
-  });
-
-  it("creates new worker delegation for worker type", async () => {
-    const executor = createMockExecutor();
-    const registry = createMockRegistry({
-      quest_paused12345: {
-        id: "quest_paused12345",
-        type: "worker",
-        task: "run tests",
-        status: "aborted",
-      },
-    });
-    const ctx = makeContext({
-      delegationExecutor: executor,
-      delegationRegistry: registry,
-    });
-
-    const result = await resumeTool.execute({ id: "quest_paused12345" }, ctx);
-
-    expect(result.success).toBe(true);
-    expect(result.data).toEqual({
-      originalId: "quest_paused12345",
-      newId: "quest_newworker12",
-      type: "worker",
-    });
-
-    expect(executor.calls).toHaveLength(1);
-    expect(executor.calls[0].method).toBe("spawnWorker");
-    expect(executor.calls[0].args[0] as string).toContain("run tests");
-  });
-
-  it("includes additional context in task when provided", async () => {
-    const executor = createMockExecutor();
-    const registry = createMockRegistry({
-      quest_paused12345: {
-        id: "quest_paused12345",
-        type: "worker",
-        task: "original task",
-        status: "aborted",
-      },
-    });
-    const ctx = makeContext({
-      delegationExecutor: executor,
-      delegationRegistry: registry,
-    });
-
-    await resumeTool.execute(
-      { id: "quest_paused12345", additionalContext: "also check edge cases" },
-      ctx,
-    );
-
-    const taskArg = executor.calls[0].args[0] as string;
-    expect(taskArg).toContain("original task");
-    expect(taskArg).toContain("also check edge cases");
-    expect(taskArg).toContain("Additional context:");
-  });
-
-  it("builds continuation task without additional context", async () => {
-    const executor = createMockExecutor();
-    const registry = createMockRegistry({
-      quest_paused12345: {
-        id: "quest_paused12345",
-        type: "worker",
-        task: "my task",
-        status: "aborted",
-      },
-    });
-    const ctx = makeContext({
-      delegationExecutor: executor,
-      delegationRegistry: registry,
-    });
-
-    await resumeTool.execute({ id: "quest_paused12345" }, ctx);
-
-    const taskArg = executor.calls[0].args[0] as string;
-    expect(taskArg).toContain("Continue the previous task:");
-    expect(taskArg).toContain("my task");
-    expect(taskArg).not.toContain("Additional context");
-  });
-
-  it("returns error when executor throws", async () => {
-    const executor = createMockExecutor();
-    executor.delegateToArion = async () => {
-      throw new Error("arion not found");
-    };
-    const registry = createMockRegistry({
-      quest_paused12345: {
-        id: "quest_paused12345",
-        type: "arion",
-        task: "task",
-        status: "aborted",
-        arionName: "nonexistent",
-      },
-    });
-    const ctx = makeContext({
-      delegationExecutor: executor,
-      delegationRegistry: registry,
-    });
-
-    const result = await resumeTool.execute({ id: "quest_paused12345" }, ctx);
-
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Resume failed");
-    expect(result.message).toContain("arion not found");
-  });
-
-  it("returns error for cli_agent without driver metadata", async () => {
-    const executor = createMockExecutor();
-    const registry = createMockRegistry({
-      quest_cli123456789: {
-        id: "quest_cli123456789",
-        type: "cli_agent",
-        task: "cli task",
-        status: "aborted",
-      },
-    });
-    const ctx = makeContext({
-      delegationExecutor: executor,
-      delegationRegistry: registry,
-    });
-
-    const result = await resumeTool.execute({ id: "quest_cli123456789" }, ctx);
-
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("Cannot resume CLI agent delegation");
-    expect(executor.calls).toHaveLength(0);
-  });
-
-  it("resumes cli_agent with driver metadata via spawnCliAgent", async () => {
-    const executor = createMockExecutor();
-    const registry = createMockRegistry({
-      quest_cli123456789: {
-        id: "quest_cli123456789",
-        type: "cli_agent",
-        task: "cli task",
-        status: "aborted",
-        metadata: { driver: "claude-code", workspace: "cwd", model: "opus" },
-      },
-    });
-    const ctx = makeContext({
-      delegationExecutor: executor,
-      delegationRegistry: registry,
-    });
-
-    const result = await resumeTool.execute({ id: "quest_cli123456789" }, ctx);
-
-    expect(result.success).toBe(true);
-    expect(executor.calls[0].method).toBe("spawnCliAgent");
-    expect(executor.calls[0].args[0]).toMatchObject({
-      driver: "claude-code",
-      workspace: "cwd",
-      model: "opus",
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// check_delegation
-// ---------------------------------------------------------------------------
-
-describe("check_delegation", () => {
-  it("is defined in DELEGATION_TOOL_DEFINITIONS", () => {
-    expect(checkTool).toBeDefined();
-    expect(checkTool.name).toBe("check_delegation");
-  });
-
-  it("looks up by quest ID directly", async () => {
-    const registry = createMockRegistry({
-      quest_abc123def456: {
-        id: "quest_abc123def456",
-        type: "worker",
-        task: "some task",
-        status: "completed",
-        result: "All done",
-      },
-    });
-    const ctx = makeContext({ delegationRegistry: registry });
-
-    const result = await checkTool.execute({ id: "quest_abc123def456" }, ctx);
-    expect(result.success).toBe(true);
-    expect(result.message).toBe("All done");
-  });
-
-  it("falls back to quest store for evicted entries", async () => {
-    const registry = createMockRegistry({});
-    const mockQuestStore = {
-      getQuest: (id: string) =>
-        id === "quest_evicted1234"
-          ? {
-              id: "quest_evicted1234",
-              title: "Test",
-              status: "done" as const,
-              progress: "Finished!",
-              priority: 2,
-              attempts: 1,
-              createdAt: 1,
-              updatedAt: 1,
-            }
-          : null,
-      createQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      updateQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      listQuests: () => [],
-    };
-    const ctx = makeContext({
-      delegationRegistry: registry,
-      questStore: mockQuestStore,
-    });
-
-    const result = await checkTool.execute({ id: "quest_evicted1234" }, ctx);
-    expect(result.success).toBe(true);
-    expect(result.message).toBe("Finished!");
-    expect((result.data as Record<string, unknown>).status).toBe("done");
-  });
-
-  it("returns not found for unknown quest ID", async () => {
-    const registry = createMockRegistry({});
-    const ctx = makeContext({ delegationRegistry: registry });
-
-    const result = await checkTool.execute({ id: "quest_ghost12345" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toContain("not found");
-  });
-
-  it("returns running status for in-flight delegation", async () => {
-    const registry = createMockRegistry({
-      quest_inflight1234: {
-        id: "quest_inflight1234",
-        type: "arion",
-        task: "working on it",
-        status: "running",
-      },
-    });
-    const ctx = makeContext({ delegationRegistry: registry });
-
-    const result = await checkTool.execute({ id: "quest_inflight1234" }, ctx);
-    expect(result.success).toBe(true);
-    expect(result.message).toContain("running");
-  });
-
-  it("returns success:false for blocked quest in store fallback", async () => {
-    const registry = createMockRegistry({});
-    const mockQuestStore = {
-      getQuest: (id: string) =>
-        id === "quest_blocked12345"
-          ? {
-              id: "quest_blocked12345",
-              title: "Test",
-              status: "blocked" as const,
-              progress: "Paused by user",
-              priority: 2,
-              attempts: 1,
-              createdAt: 1,
-              updatedAt: 1,
-            }
-          : null,
-      createQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      updateQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      listQuests: () => [],
-    };
-    const ctx = makeContext({
-      delegationRegistry: registry,
-      questStore: mockQuestStore,
-    });
-
-    const result = await checkTool.execute({ id: "quest_blocked12345" }, ctx);
-    expect(result.success).toBe(false);
-    expect(result.message).toBe("Paused by user");
-    expect((result.data as Record<string, unknown>).status).toBe("blocked");
-  });
-
-  it("returns success:true for done quest in store fallback", async () => {
-    const registry = createMockRegistry({});
-    const mockQuestStore = {
-      getQuest: (id: string) =>
-        id === "quest_done12345678"
-          ? {
-              id: "quest_done12345678",
-              title: "Test",
-              status: "done" as const,
-              progress: "All done",
-              priority: 2,
-              attempts: 1,
-              createdAt: 1,
-              updatedAt: 1,
-            }
-          : null,
-      createQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      updateQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      listQuests: () => [],
-    };
-    const ctx = makeContext({
-      delegationRegistry: registry,
-      questStore: mockQuestStore,
-    });
-
-    const result = await checkTool.execute({ id: "quest_done12345678" }, ctx);
-    expect(result.success).toBe(true);
-    expect(result.message).toBe("All done");
-  });
-
-  it("returns success:true for active quest in store fallback", async () => {
-    const registry = createMockRegistry({});
-    const mockQuestStore = {
-      getQuest: (id: string) =>
-        id === "quest_active123456"
-          ? {
-              id: "quest_active123456",
-              title: "Test",
-              status: "active" as const,
-              progress: "In progress",
-              priority: 2,
-              attempts: 1,
-              createdAt: 1,
-              updatedAt: 1,
-            }
-          : null,
-      createQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      updateQuest: () => ({
-        id: "",
-        title: "",
-        status: "open" as const,
-        progress: "",
-        priority: 2,
-        attempts: 0,
-        createdAt: 0,
-        updatedAt: 0,
-      }),
-      listQuests: () => [],
-    };
-    const ctx = makeContext({
-      delegationRegistry: registry,
-      questStore: mockQuestStore,
-    });
-
-    const result = await checkTool.execute({ id: "quest_active123456" }, ctx);
-    expect(result.success).toBe(true);
-    expect(result.message).toBe("Quest is active");
-  });
-});