@aria-cli/tools 1.0.0

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

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