stagent 0.1.10 → 0.1.12

package/src/lib/agents/__tests__/pattern-extractor.test.ts

@@ -0,0 +1,243 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ─── Mock infrastructure ──────────────────────────────────────────────
+
+const {
+  mockAll,
+  mockLimit,
+  mockOrderBy,
+  mockWhere,
+  mockFrom,
+  mockSelect,
+  mockValues,
+  mockInsert,
+} = vi.hoisted(() => {
+  const mockAll = vi.fn();
+  const mockLimit = vi.fn().mockReturnValue(mockAll);
+  const mockOrderBy = vi.fn().mockReturnValue({ limit: mockLimit });
+  const mockWhere = vi.fn().mockReturnValue({ orderBy: mockOrderBy });
+  const mockFrom = vi.fn().mockReturnValue({ where: mockWhere });
+  const mockSelect = vi.fn().mockReturnValue({ from: mockFrom });
+  const mockValues = vi.fn().mockResolvedValue(undefined);
+  const mockInsert = vi.fn().mockReturnValue({ values: mockValues });
+
+  return {
+    mockAll,
+    mockLimit,
+    mockOrderBy,
+    mockWhere,
+    mockFrom,
+    mockSelect,
+    mockValues,
+    mockInsert,
+  };
+});
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    select: mockSelect,
+    insert: mockInsert,
+  },
+}));
+
+vi.mock("@/lib/db/schema", () => ({
+  tasks: {
+    id: "id",
+    title: "title",
+    description: "description",
+    result: "result",
+  },
+  agentLogs: {
+    taskId: "task_id",
+    event: "event",
+    payload: "payload",
+    timestamp: "timestamp",
+  },
+  notifications: { id: "id" },
+  learnedContext: {
+    profileId: "profile_id",
+    version: "version",
+    changeType: "change_type",
+    content: "content",
+    proposalNotificationId: "proposal_notification_id",
+  },
+}));
+
+vi.mock("drizzle-orm", () => ({
+  eq: vi.fn((_col: string, val: unknown) => ({ col: _col, val })),
+  and: vi.fn((...conditions: unknown[]) => conditions),
+  desc: vi.fn((col: string) => ({ desc: col })),
+}));
+
+const {
+  mockRunMetaCompletion,
+  mockGetActiveLearnedContext,
+  mockProposeContextAddition,
+} = vi.hoisted(() => ({
+  mockRunMetaCompletion: vi.fn(),
+  mockGetActiveLearnedContext: vi.fn().mockReturnValue(null),
+  mockProposeContextAddition: vi.fn().mockResolvedValue("notif-123"),
+}));
+
+vi.mock("../runtime/claude", () => ({
+  runMetaCompletion: mockRunMetaCompletion,
+}));
+
+vi.mock("../learned-context", () => ({
+  getActiveLearnedContext: mockGetActiveLearnedContext,
+  proposeContextAddition: mockProposeContextAddition,
+}));
+
+import { analyzeForLearnedPatterns } from "../pattern-extractor";
+
+// ─── Setup ────────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  vi.resetAllMocks();
+  mockSelect.mockReturnValue({ from: mockFrom });
+  mockFrom.mockReturnValue({ where: mockWhere });
+  mockWhere.mockReturnValue({ orderBy: mockOrderBy });
+  mockOrderBy.mockReturnValue({ limit: mockLimit });
+  mockLimit.mockReturnValue(mockAll);
+  mockInsert.mockReturnValue({ values: mockValues });
+  mockValues.mockResolvedValue(undefined);
+  mockGetActiveLearnedContext.mockReturnValue(null);
+  mockProposeContextAddition.mockResolvedValue("notif-123");
+});
+
+// ═════════════════════════════════════════════════════════════════════
+
+describe("analyzeForLearnedPatterns", () => {
+  it("returns null when task not found", async () => {
+    // Task query returns empty
+    mockWhere.mockResolvedValueOnce([]);
+
+    const result = await analyzeForLearnedPatterns("task-1", "general");
+
+    expect(result).toBeNull();
+    expect(mockRunMetaCompletion).not.toHaveBeenCalled();
+  });
+
+  it("proposes context when patterns are found", async () => {
+    // Task query
+    mockWhere.mockResolvedValueOnce([
+      {
+        title: "Fix auth bug",
+        description: "Token validation was broken",
+        result: "Fixed by adding null check",
+      },
+    ]);
+
+    // Agent logs query (returns array directly from .limit())
+    mockLimit.mockResolvedValueOnce([
+      { event: "completed", payload: '{"result":"done"}' },
+    ]);
+
+    // runMetaCompletion returns JSON text with patterns
+    mockRunMetaCompletion.mockResolvedValue({
+      text: JSON.stringify([
+        {
+          title: "Null check tokens",
+          description: "Always validate token existence before parsing",
+          category: "error_resolution",
+        },
+      ]),
+      usage: {},
+    });
+
+    const result = await analyzeForLearnedPatterns("task-1", "general");
+
+    expect(result).toBe("notif-123");
+    expect(mockRunMetaCompletion).toHaveBeenCalledWith(
+      expect.objectContaining({ activityType: "pattern_extraction" })
+    );
+    expect(mockProposeContextAddition).toHaveBeenCalledWith(
+      "general",
+      "task-1",
+      expect.stringContaining("Null check tokens")
+    );
+  });
+
+  it("returns null when no patterns are found", async () => {
+    mockWhere.mockResolvedValueOnce([
+      { title: "Routine task", description: "Nothing special", result: "Done" },
+    ]);
+    mockLimit.mockResolvedValueOnce([]);
+
+    mockRunMetaCompletion.mockResolvedValue({
+      text: "[]",
+      usage: {},
+    });
+
+    const result = await analyzeForLearnedPatterns("task-1", "general");
+
+    expect(result).toBeNull();
+    expect(mockProposeContextAddition).not.toHaveBeenCalled();
+  });
+
+  it("returns null when response has no valid JSON array", async () => {
+    mockWhere.mockResolvedValueOnce([
+      { title: "Task", description: "Desc", result: "Done" },
+    ]);
+    mockLimit.mockResolvedValueOnce([]);
+
+    mockRunMetaCompletion.mockResolvedValue({
+      text: "No patterns found in this task.",
+      usage: {},
+    });
+
+    const result = await analyzeForLearnedPatterns("task-1", "general");
+
+    expect(result).toBeNull();
+  });
+
+  it("passes existing learned context for dedup", async () => {
+    mockWhere.mockResolvedValueOnce([
+      { title: "Task", description: "Desc", result: "Done" },
+    ]);
+    mockLimit.mockResolvedValueOnce([]);
+    mockGetActiveLearnedContext.mockReturnValue("Existing pattern: check nulls");
+
+    mockRunMetaCompletion.mockResolvedValue({
+      text: "[]",
+      usage: {},
+    });
+
+    await analyzeForLearnedPatterns("task-1", "general");
+
+    // Verify prompt includes existing context for dedup
+    const callArgs = mockRunMetaCompletion.mock.calls[0][0];
+    expect(callArgs.prompt).toContain("Existing pattern: check nulls");
+  });
+
+  it("formats multiple patterns correctly", async () => {
+    mockWhere.mockResolvedValueOnce([
+      { title: "Task", description: "Desc", result: "Done" },
+    ]);
+    mockLimit.mockResolvedValueOnce([]);
+
+    mockRunMetaCompletion.mockResolvedValue({
+      text: JSON.stringify([
+        {
+          title: "Pattern A",
+          description: "Description A",
+          category: "best_practice",
+        },
+        {
+          title: "Pattern B",
+          description: "Description B",
+          category: "shortcut",
+        },
+      ]),
+      usage: {},
+    });
+
+    await analyzeForLearnedPatterns("task-1", "code-reviewer");
+
+    const additions = mockProposeContextAddition.mock.calls[0][2];
+    expect(additions).toContain("### Pattern A [best_practice]");
+    expect(additions).toContain("### Pattern B [shortcut]");
+    expect(additions).toContain("Description A");
+    expect(additions).toContain("Description B");
+  });
+});

package/src/lib/agents/__tests__/sweep.test.ts

@@ -0,0 +1,202 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ─── Mock infrastructure ──────────────────────────────────────────────
+
+const { mockWhere, mockFrom, mockSelect, mockValues, mockInsert } =
+  vi.hoisted(() => {
+    const mockWhere = vi.fn();
+    const mockFrom = vi.fn().mockReturnValue({ where: mockWhere });
+    const mockSelect = vi.fn().mockReturnValue({ from: mockFrom });
+    const mockValues = vi.fn().mockResolvedValue(undefined);
+    const mockInsert = vi.fn().mockReturnValue({ values: mockValues });
+
+    return { mockWhere, mockFrom, mockSelect, mockValues, mockInsert };
+  });
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    select: mockSelect,
+    insert: mockInsert,
+  },
+}));
+
+vi.mock("@/lib/db/schema", () => ({
+  tasks: {
+    id: "id",
+    result: "result",
+    projectId: "project_id",
+  },
+}));
+
+vi.mock("drizzle-orm", () => ({
+  eq: vi.fn((_col: string, val: unknown) => ({ col: _col, val })),
+}));
+
+import { processSweepResult } from "../sweep";
+
+// ─── Setup ────────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  vi.resetAllMocks();
+  mockSelect.mockReturnValue({ from: mockFrom });
+  mockFrom.mockReturnValue({ where: mockWhere });
+  mockInsert.mockReturnValue({ values: mockValues });
+  mockValues.mockResolvedValue(undefined);
+});
+
+// ═════════════════════════════════════════════════════════════════════
+// processSweepResult
+// ═════════════════════════════════════════════════════════════════════
+
+describe("processSweepResult", () => {
+  it("creates improvement tasks from valid JSON array in result", async () => {
+    const proposals = [
+      {
+        title: "Refactor auth module",
+        description: "Reduce duplication in token validation",
+        priority: 2,
+        suggestedProfile: "code-reviewer",
+      },
+      {
+        title: "Add missing test for parser",
+        description: "The CSV parser has no test coverage",
+        priority: 3,
+      },
+    ];
+
+    mockWhere.mockResolvedValueOnce([
+      { result: JSON.stringify(proposals), projectId: "proj-1" },
+    ]);
+
+    await processSweepResult("sweep-task-1");
+
+    expect(mockInsert).toHaveBeenCalledOnce();
+    expect(mockValues).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({
+          title: "Refactor auth module",
+          description: "[Sweep-generated] Reduce duplication in token validation",
+          status: "planned",
+          priority: 2,
+          agentProfile: "code-reviewer",
+          projectId: "proj-1",
+        }),
+        expect.objectContaining({
+          title: "Add missing test for parser",
+          agentProfile: "general", // default when not specified
+          priority: 3,
+        }),
+      ])
+    );
+  });
+
+  it("extracts JSON array from surrounding text", async () => {
+    const result = `Here are my findings:\n${JSON.stringify([
+      { title: "Fix bug", description: "Important fix", priority: 1 },
+    ])}\nEnd of report.`;
+
+    mockWhere.mockResolvedValueOnce([{ result, projectId: null }]);
+
+    await processSweepResult("sweep-task-1");
+
+    expect(mockInsert).toHaveBeenCalledOnce();
+    expect(mockValues).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({ title: "Fix bug" }),
+      ])
+    );
+  });
+
+  it("silently returns when task has no result", async () => {
+    mockWhere.mockResolvedValueOnce([{ result: null, projectId: null }]);
+
+    await processSweepResult("sweep-task-1");
+
+    expect(mockInsert).not.toHaveBeenCalled();
+  });
+
+  it("silently returns when task not found", async () => {
+    mockWhere.mockResolvedValueOnce([]);
+
+    await processSweepResult("sweep-task-1");
+
+    expect(mockInsert).not.toHaveBeenCalled();
+  });
+
+  it("silently returns when result contains no JSON array", async () => {
+    mockWhere.mockResolvedValueOnce([
+      { result: "No actionable findings.", projectId: null },
+    ]);
+
+    await processSweepResult("sweep-task-1");
+
+    expect(mockInsert).not.toHaveBeenCalled();
+  });
+
+  it("silently returns when result contains invalid JSON", async () => {
+    mockWhere.mockResolvedValueOnce([
+      { result: "[{broken json}]", projectId: null },
+    ]);
+
+    await processSweepResult("sweep-task-1");
+
+    expect(mockInsert).not.toHaveBeenCalled();
+  });
+
+  it("caps tasks at 10", async () => {
+    const proposals = Array.from({ length: 15 }, (_, i) => ({
+      title: `Task ${i + 1}`,
+      description: `Description ${i + 1}`,
+      priority: 3,
+    }));
+
+    mockWhere.mockResolvedValueOnce([
+      { result: JSON.stringify(proposals), projectId: null },
+    ]);
+
+    await processSweepResult("sweep-task-1");
+
+    const insertedValues = mockValues.mock.calls[0][0] as unknown[];
+    expect(insertedValues).toHaveLength(10);
+  });
+
+  it("clamps priority to 1-4 range", async () => {
+    mockWhere.mockResolvedValueOnce([
+      {
+        result: JSON.stringify([
+          { title: "Low", description: "d", priority: 0 },
+          { title: "High", description: "d", priority: 10 },
+        ]),
+        projectId: null,
+      },
+    ]);
+
+    await processSweepResult("sweep-task-1");
+
+    expect(mockValues).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({ title: "Low", priority: 1 }),
+        expect.objectContaining({ title: "High", priority: 4 }),
+      ])
+    );
+  });
+
+  it("filters out entries with missing title or description", async () => {
+    mockWhere.mockResolvedValueOnce([
+      {
+        result: JSON.stringify([
+          { title: "Valid", description: "Has both" },
+          { title: "No desc" },
+          { description: "No title" },
+          { title: "Also valid", description: "Also has both" },
+        ]),
+        projectId: null,
+      },
+    ]);
+
+    await processSweepResult("sweep-task-1");
+
+    const insertedValues = mockValues.mock.calls[0][0] as unknown[];
+    expect(insertedValues).toHaveLength(2);
+  });
+});

package/src/lib/agents/claude-agent.ts

@@ -4,7 +4,7 @@ import { db } from "@/lib/db";
 import { tasks, projects, agentLogs, notifications } from "@/lib/db/schema";
 import { eq } from "drizzle-orm";
 import { setExecution, removeExecution } from "./execution-manager";
-import { MAX_RESUME_COUNT } from "@/lib/constants/task-status";
+import { MAX_RESUME_COUNT, DEFAULT_MAX_TURNS, DEFAULT_MAX_BUDGET_USD } from "@/lib/constants/task-status";
 import { getAuthEnv, updateAuthStatus } from "@/lib/settings/auth";
 import { buildDocumentContext } from "@/lib/documents/context-builder";
 import {
@@ -13,7 +13,7 @@ import {
   scanTaskOutputDocuments,
 } from "@/lib/documents/output-scanner";
 import { getProfile } from "./profiles/registry";
-import { resolveProfileRuntimePayload } from "./profiles/compatibility";
+import { resolveProfileRuntimePayload, type ResolvedProfileRuntimePayload } from "./profiles/compatibility";
 import type { CanUseToolPolicy } from "./profiles/types";
 import { buildClaudeSdkEnv } from "./runtime/claude-sdk";
 import { getActiveLearnedContext } from "./learned-context";
@@ -368,6 +368,76 @@ async function processAgentStream(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Shared prompt & query context builder (F12: eliminate duplication)
+// ---------------------------------------------------------------------------
+
+interface TaskQueryContext {
+  /** User task content — goes into `prompt` */
+  userPrompt: string;
+  /** System instructions — goes into `options.systemPrompt` */
+  systemInstructions: string;
+  /** Resolved working directory */
+  cwd: string;
+  /** Profile payload (tools, MCP, policy) */
+  payload: ResolvedProfileRuntimePayload | null;
+  /** Profile's maxTurns or default */
+  maxTurns: number;
+  /** Profile's canUseToolPolicy */
+  canUseToolPolicy?: CanUseToolPolicy;
+}
+
+async function buildTaskQueryContext(
+  task: { id: string; title: string; description?: string | null; projectId?: string | null },
+  profileId: string
+): Promise<TaskQueryContext> {
+  const profile = getProfile(profileId);
+  const payload = profile
+    ? resolveProfileRuntimePayload(profile, "claude-code")
+    : null;
+  if (payload && !payload.supported) {
+    throw new Error(payload.reason ?? `Profile "${profile?.name}" is not supported on Claude Code`);
+  }
+
+  const profileInstructions = payload?.instructions ?? "";
+  const basePrompt = task.description || task.title;
+  const docContext = await buildDocumentContext(task.id);
+  const outputInstructions = buildTaskOutputInstructions(task.id);
+  const learnedCtx = getActiveLearnedContext(profileId);
+  const learnedCtxBlock = learnedCtx
+    ? `## Learned Context\nPatterns and insights learned from previous tasks:\n\n${learnedCtx}`
+    : "";
+
+  // F1: Separate system instructions from user content
+  const systemInstructions = [profileInstructions, learnedCtxBlock, docContext, outputInstructions]
+    .filter(Boolean)
+    .join("\n\n");
+
+  // Resolve working directory: project's workingDirectory > process.cwd()
+  let cwd = process.cwd();
+  if (task.projectId) {
+    const [project] = await db
+      .select({ workingDirectory: projects.workingDirectory })
+      .from(projects)
+      .where(eq(projects.id, task.projectId));
+    if (project?.workingDirectory) {
+      cwd = project.workingDirectory;
+    }
+  }
+
+  // F9: Use profile maxTurns or fall back to default
+  const maxTurns = profile?.maxTurns ?? DEFAULT_MAX_TURNS;
+
+  return {
+    userPrompt: basePrompt,
+    systemInstructions,
+    cwd,
+    payload,
+    maxTurns,
+    canUseToolPolicy: payload?.canUseToolPolicy,
+  };
+}
+
 export async function executeClaudeTask(taskId: string): Promise<void> {
   const [task] = await db.select().from(tasks).where(eq(tasks.id, taskId));
   if (!task) throw new Error(`Task ${taskId} not found`);
@@ -385,57 +455,35 @@ export async function executeClaudeTask(taskId: string): Promise<void> {
 
   try {
     await prepareTaskOutputDirectory(taskId, { clearExisting: true });
-    const profile = getProfile(agentProfileId);
-    const payload = profile
-      ? resolveProfileRuntimePayload(profile, "claude-code")
-      : null;
-    if (payload && !payload.supported) {
-      throw new Error(payload.reason ?? `Profile "${profile?.name}" is not supported on Claude Code`);
-    }
-    const systemPrompt = payload?.instructions ?? "";
-    const basePrompt = task.description || task.title;
-    const docContext = await buildDocumentContext(taskId);
-    const outputInstructions = buildTaskOutputInstructions(taskId);
-    const learnedCtx = getActiveLearnedContext(agentProfileId);
-    const learnedCtxBlock = learnedCtx
-      ? `## Learned Context\nPatterns and insights learned from previous tasks:\n\n${learnedCtx}`
-      : "";
-    const prompt = [systemPrompt, learnedCtxBlock, docContext, outputInstructions, basePrompt]
-      .filter(Boolean)
-      .join("\n\n");
-
-    // Resolve working directory: project's workingDirectory > process.cwd()
-    let cwd = process.cwd();
-    if (task.projectId) {
-      const [project] = await db
-        .select({ workingDirectory: projects.workingDirectory })
-        .from(projects)
-        .where(eq(projects.id, task.projectId));
-      if (project?.workingDirectory) {
-        cwd = project.workingDirectory;
-      }
-    }
+    const ctx = await buildTaskQueryContext(task, agentProfileId);
 
-    const policyForTask = payload?.canUseToolPolicy;
     const authEnv = await getAuthEnv();
     const response = query({
-      prompt,
+      prompt: ctx.userPrompt,
       options: {
         abortController,
         includePartialMessages: true,
-        cwd,
+        cwd: ctx.cwd,
         env: buildClaudeSdkEnv(authEnv),
-        ...(payload?.allowedTools && { allowedTools: payload.allowedTools }),
-        ...(payload?.mcpServers &&
-          Object.keys(payload.mcpServers).length > 0 && {
-            mcpServers: payload.mcpServers,
+        // F1: Use dedicated systemPrompt option with claude_code preset
+        systemPrompt: ctx.systemInstructions
+          ? { type: "preset" as const, preset: "claude_code" as const, append: ctx.systemInstructions }
+          : { type: "preset" as const, preset: "claude_code" as const },
+        // F9: Bounded turn limit from profile or default
+        maxTurns: ctx.maxTurns,
+        // F4: Per-execution budget cap
+        maxBudgetUsd: DEFAULT_MAX_BUDGET_USD,
+        ...(ctx.payload?.allowedTools && { allowedTools: ctx.payload.allowedTools }),
+        ...(ctx.payload?.mcpServers &&
+          Object.keys(ctx.payload.mcpServers).length > 0 && {
+            mcpServers: ctx.payload.mcpServers,
           }),
         // @ts-expect-error Agent SDK canUseTool types are incomplete — our async handler is compatible at runtime
         canUseTool: async (
           toolName: string,
           input: Record<string, unknown>
         ) => {
-          return handleToolPermission(taskId, toolName, input, policyForTask);
+          return handleToolPermission(taskId, toolName, input, ctx.canUseToolPolicy);
         },
       },
     });
@@ -513,58 +561,36 @@ export async function resumeClaudeTask(taskId: string): Promise<void> {
 
   try {
     await prepareTaskOutputDirectory(taskId);
-    const profile = getProfile(profileId);
-    const payload = profile
-      ? resolveProfileRuntimePayload(profile, "claude-code")
-      : null;
-    if (payload && !payload.supported) {
-      throw new Error(payload.reason ?? `Profile "${profile?.name}" is not supported on Claude Code`);
-    }
-    const systemPrompt = payload?.instructions ?? "";
-    const basePrompt = task.description || task.title;
-    const docContext = await buildDocumentContext(taskId);
-    const outputInstructions = buildTaskOutputInstructions(taskId);
-    const learnedCtx = getActiveLearnedContext(profileId);
-    const learnedCtxBlock = learnedCtx
-      ? `## Learned Context\nPatterns and insights learned from previous tasks:\n\n${learnedCtx}`
-      : "";
-    const prompt = [systemPrompt, learnedCtxBlock, docContext, outputInstructions, basePrompt]
-      .filter(Boolean)
-      .join("\n\n");
-
-    // Resolve working directory: project's workingDirectory > process.cwd()
-    let cwd = process.cwd();
-    if (task.projectId) {
-      const [project] = await db
-        .select({ workingDirectory: projects.workingDirectory })
-        .from(projects)
-        .where(eq(projects.id, task.projectId));
-      if (project?.workingDirectory) {
-        cwd = project.workingDirectory;
-      }
-    }
+    const ctx = await buildTaskQueryContext(task, profileId);
 
-    const policyForResume = payload?.canUseToolPolicy;
     const authEnv = await getAuthEnv();
     const response = query({
-      prompt,
+      prompt: ctx.userPrompt,
       options: {
         resume: task.sessionId,
         abortController,
         includePartialMessages: true,
-        cwd,
+        cwd: ctx.cwd,
         env: buildClaudeSdkEnv(authEnv),
-        ...(payload?.allowedTools && { allowedTools: payload.allowedTools }),
-        ...(payload?.mcpServers &&
-          Object.keys(payload.mcpServers).length > 0 && {
-            mcpServers: payload.mcpServers,
+        // F1: Use dedicated systemPrompt option with claude_code preset
+        systemPrompt: ctx.systemInstructions
+          ? { type: "preset" as const, preset: "claude_code" as const, append: ctx.systemInstructions }
+          : { type: "preset" as const, preset: "claude_code" as const },
+        // F9: Bounded turn limit from profile or default
+        maxTurns: ctx.maxTurns,
+        // F4: Per-execution budget cap
+        maxBudgetUsd: DEFAULT_MAX_BUDGET_USD,
+        ...(ctx.payload?.allowedTools && { allowedTools: ctx.payload.allowedTools }),
+        ...(ctx.payload?.mcpServers &&
+          Object.keys(ctx.payload.mcpServers).length > 0 && {
+            mcpServers: ctx.payload.mcpServers,
           }),
         // @ts-expect-error Agent SDK canUseTool types are incomplete — our async handler is compatible at runtime
         canUseTool: async (
           toolName: string,
           input: Record<string, unknown>
         ) => {
-          return handleToolPermission(taskId, toolName, input, policyForResume);
+          return handleToolPermission(taskId, toolName, input, ctx.canUseToolPolicy);
         },
       },
     });