stagent 0.9.6 → 0.11.0

package/src/lib/agents/__tests__/failure-reason.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { db } from "@/lib/db";
+import { tasks, projects } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { randomUUID } from "crypto";
+import { writeTerminalFailureReason } from "../claude-agent";
+
+function seedRunningTask(): string {
+  const pid = randomUUID();
+  const tid = randomUUID();
+  const now = new Date();
+  db.insert(projects)
+    .values({ id: pid, name: "p", status: "active", createdAt: now, updatedAt: now })
+    .run();
+  db.insert(tasks)
+    .values({
+      id: tid,
+      projectId: pid,
+      title: "t",
+      status: "running",
+      priority: 2,
+      resumeCount: 0,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return tid;
+}
+
+describe("writeTerminalFailureReason", () => {
+  beforeEach(() => {
+    db.delete(tasks).run();
+    db.delete(projects).run();
+  });
+
+  it("writes 'turn_limit_exceeded' on turn limit errors", async () => {
+    const tid = seedRunningTask();
+    await writeTerminalFailureReason(
+      tid,
+      new Error("Agent exhausted its turn limit (42 turns used)"),
+    );
+    const row = db.select().from(tasks).where(eq(tasks.id, tid)).get();
+    expect(row?.failureReason).toBe("turn_limit_exceeded");
+  });
+
+  it("writes 'aborted' on AbortError", async () => {
+    const tid = seedRunningTask();
+    const err = new Error("aborted");
+    err.name = "AbortError";
+    await writeTerminalFailureReason(tid, err);
+    const row = db.select().from(tasks).where(eq(tasks.id, tid)).get();
+    expect(row?.failureReason).toBe("aborted");
+  });
+
+  it("writes 'sdk_error' for unknown errors", async () => {
+    const tid = seedRunningTask();
+    await writeTerminalFailureReason(tid, new Error("something weird"));
+    const row = db.select().from(tasks).where(eq(tasks.id, tid)).get();
+    expect(row?.failureReason).toBe("sdk_error");
+  });
+
+  it("writes 'rate_limited' on 429 errors", async () => {
+    const tid = seedRunningTask();
+    await writeTerminalFailureReason(tid, new Error("HTTP 429 rate limit"));
+    const row = db.select().from(tasks).where(eq(tasks.id, tid)).get();
+    expect(row?.failureReason).toBe("rate_limited");
+  });
+});

package/src/lib/agents/__tests__/learned-context.test.ts

@@ -88,17 +88,6 @@ vi.mock("@/lib/constants/settings", () => ({
   },
 }));
 
-vi.mock("@/lib/license/limit-check", () => ({
-  checkLimit: vi.fn().mockReturnValue({ allowed: true, current: 0, limit: 10, tier: "community", requiredTier: "community" }),
-}));
-
-vi.mock("@/lib/license/limit-queries", () => ({
-  getContextVersionCount: vi.fn().mockReturnValue(0),
-}));
-
-vi.mock("@/lib/license/notifications", () => ({
-  createTierLimitNotification: vi.fn().mockResolvedValue(undefined),
-}));
 
 // ─── Import under test ────────────────────────────────────────────────
 

package/src/lib/agents/__tests__/learning-session.test.ts

@@ -0,0 +1,158 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const {
+  mockAll,
+  mockLimit,
+  mockOrderBy,
+  mockWhere,
+  mockFrom,
+  mockSelect,
+  mockValues,
+  mockInsert,
+  mockSetWhere,
+  mockSet,
+  mockUpdate,
+  mockGetActiveLearnedContext,
+  mockCheckContextSize,
+  mockSummarizeContext,
+} = vi.hoisted(() => {
+  const mockAll = vi.fn();
+  const mockLimit = vi.fn().mockReturnValue({ all: mockAll });
+  const mockOrderBy = vi.fn().mockReturnValue({ limit: mockLimit });
+  const mockWhere = vi.fn().mockReturnValue({ all: mockAll, 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 });
+  const mockSetWhere = vi.fn().mockResolvedValue(undefined);
+  const mockSet = vi.fn().mockReturnValue({ where: mockSetWhere });
+  const mockUpdate = vi.fn().mockReturnValue({ set: mockSet });
+  return {
+    mockAll,
+    mockLimit,
+    mockOrderBy,
+    mockWhere,
+    mockFrom,
+    mockSelect,
+    mockValues,
+    mockInsert,
+    mockSetWhere,
+    mockSet,
+    mockUpdate,
+    mockGetActiveLearnedContext: vi.fn(),
+    mockCheckContextSize: vi.fn(),
+    mockSummarizeContext: vi.fn(),
+  };
+});
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    select: mockSelect,
+    insert: mockInsert,
+    update: mockUpdate,
+  },
+}));
+
+vi.mock("@/lib/db/schema", () => ({
+  learnedContext: {
+    id: "id",
+    profileId: "profile_id",
+    changeType: "change_type",
+    version: "version",
+  },
+  notifications: {
+    id: "id",
+    toolInput: "tool_input",
+    type: "type",
+    response: "response",
+  },
+  tasks: {
+    workflowId: "workflow_id",
+    id: "id",
+  },
+}));
+
+vi.mock("drizzle-orm", () => ({
+  eq: vi.fn((_col: string, val: unknown) => ({ val })),
+  and: vi.fn((...conditions: unknown[]) => conditions),
+  desc: vi.fn((col: string) => ({ desc: col })),
+  isNull: vi.fn((col: string) => ({ isNull: col })),
+}));
+
+vi.mock("../learned-context", () => ({
+  getActiveLearnedContext: mockGetActiveLearnedContext,
+  checkContextSize: mockCheckContextSize,
+  summarizeContext: mockSummarizeContext,
+}));
+
+import { batchApproveProposals } from "../learning-session";
+
+describe("batchApproveProposals", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSelect.mockReturnValue({ from: mockFrom });
+    mockFrom.mockReturnValue({ where: mockWhere });
+    mockWhere.mockReturnValue({ all: mockAll, orderBy: mockOrderBy });
+    mockOrderBy.mockReturnValue({ limit: mockLimit });
+    mockLimit.mockReturnValue({ all: mockAll });
+    mockInsert.mockReturnValue({ values: mockValues });
+    mockUpdate.mockReturnValue({ set: mockSet });
+    mockSet.mockReturnValue({ where: mockSetWhere });
+    mockValues.mockResolvedValue(undefined);
+    mockSetWhere.mockResolvedValue(undefined);
+    mockGetActiveLearnedContext.mockReturnValue("Existing context");
+    mockCheckContextSize.mockReturnValue({
+      currentSize: 9000,
+      limit: 8000,
+      needsSummarization: true,
+    });
+    mockSummarizeContext.mockResolvedValue(undefined);
+  });
+
+  it("resolves without waiting for summarization and checks each profile once", async () => {
+    let releaseSummaries: (() => void) | null = null;
+    mockSummarizeContext.mockReturnValueOnce(
+      new Promise<void>((resolve) => {
+        releaseSummaries = resolve;
+      })
+    );
+
+    mockAll
+      .mockReturnValueOnce([
+        {
+          id: "proposal-1",
+          profileId: "general",
+          proposedAdditions: "First addition",
+          sourceTaskId: "task-1",
+          proposalNotificationId: null,
+        },
+      ])
+      .mockReturnValueOnce([{ version: 2 }])
+      .mockReturnValueOnce([
+        {
+          id: "proposal-2",
+          profileId: "general",
+          proposedAdditions: "Second addition",
+          sourceTaskId: "task-2",
+          proposalNotificationId: null,
+        },
+      ])
+      .mockReturnValueOnce([{ version: 3 }])
+      .mockReturnValueOnce([
+        {
+          id: "batch-notif-1",
+          toolInput: JSON.stringify({ proposalIds: ["proposal-1", "proposal-2"] }),
+        },
+      ]);
+
+    const result = await batchApproveProposals(["proposal-1", "proposal-2"]);
+
+    expect(result).toBe(2);
+    expect(mockCheckContextSize).toHaveBeenCalledTimes(1);
+    expect(mockCheckContextSize).toHaveBeenCalledWith("general");
+    expect(mockSummarizeContext).toHaveBeenCalledTimes(1);
+    expect(mockSummarizeContext).toHaveBeenCalledWith("general");
+
+    releaseSummaries?.();
+  });
+});

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

@@ -73,10 +73,16 @@ const {
   mockRunMetaCompletion,
   mockGetActiveLearnedContext,
   mockProposeContextAddition,
+  mockGetTaskWorkflowId,
+  mockHasLearningSession,
+  mockBufferProposal,
 } = vi.hoisted(() => ({
   mockRunMetaCompletion: vi.fn(),
   mockGetActiveLearnedContext: vi.fn().mockReturnValue(null),
   mockProposeContextAddition: vi.fn().mockResolvedValue("notif-123"),
+  mockGetTaskWorkflowId: vi.fn().mockReturnValue(null),
+  mockHasLearningSession: vi.fn().mockReturnValue(false),
+  mockBufferProposal: vi.fn(),
 }));
 
 vi.mock("../runtime/claude", () => ({
@@ -87,6 +93,11 @@ vi.mock("../learned-context", () => ({
   getActiveLearnedContext: mockGetActiveLearnedContext,
   proposeContextAddition: mockProposeContextAddition,
 }));
+vi.mock("../learning-session", () => ({
+  getTaskWorkflowId: mockGetTaskWorkflowId,
+  hasLearningSession: mockHasLearningSession,
+  bufferProposal: mockBufferProposal,
+}));
 
 import { analyzeForLearnedPatterns } from "../pattern-extractor";
 
@@ -103,6 +114,9 @@ beforeEach(() => {
   mockValues.mockResolvedValue(undefined);
   mockGetActiveLearnedContext.mockReturnValue(null);
   mockProposeContextAddition.mockResolvedValue("notif-123");
+  mockGetTaskWorkflowId.mockReturnValue(null);
+  mockHasLearningSession.mockReturnValue(false);
+  mockBufferProposal.mockReset();
 });
 
 // ═════════════════════════════════════════════════════════════════════
@@ -240,4 +254,38 @@ describe("analyzeForLearnedPatterns", () => {
     expect(additions).toContain("Description A");
     expect(additions).toContain("Description B");
   });
+
+  it("buffers workflow proposals into the active learning session", 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",
+        },
+      ]),
+      usage: {},
+    });
+    mockGetTaskWorkflowId.mockReturnValue("workflow-1");
+    mockHasLearningSession.mockReturnValue(true);
+    mockProposeContextAddition.mockResolvedValue("proposal-row-1");
+
+    const result = await analyzeForLearnedPatterns("task-1", "general");
+
+    expect(result).toBe("proposal-row-1");
+    expect(mockProposeContextAddition).toHaveBeenCalledWith(
+      "general",
+      "task-1",
+      expect.stringContaining("Pattern A"),
+      { silent: true }
+    );
+    expect(mockBufferProposal).toHaveBeenCalledWith(
+      "workflow-1",
+      "proposal-row-1"
+    );
+  });
 });

package/src/lib/agents/__tests__/task-dispatch.test.ts

@@ -0,0 +1,166 @@
+import { randomUUID } from "crypto";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { eq } from "drizzle-orm";
+import { db } from "@/lib/db";
+import { agentLogs, notifications, tasks } from "@/lib/db/schema";
+import { RetryableRuntimeLaunchError } from "@/lib/agents/runtime/launch-failure";
+
+const {
+  mockExecuteTaskWithRuntime,
+  mockResumeTaskWithRuntime,
+  mockResolveTaskExecutionTarget,
+  mockResolveResumeExecutionTarget,
+} = vi.hoisted(() => ({
+  mockExecuteTaskWithRuntime: vi.fn(),
+  mockResumeTaskWithRuntime: vi.fn(),
+  mockResolveTaskExecutionTarget: vi.fn(),
+  mockResolveResumeExecutionTarget: vi.fn(),
+}));
+
+vi.mock("@/lib/agents/runtime", () => ({
+  executeTaskWithRuntime: mockExecuteTaskWithRuntime,
+  resumeTaskWithRuntime: mockResumeTaskWithRuntime,
+}));
+
+vi.mock("@/lib/agents/runtime/execution-target", () => ({
+  resolveTaskExecutionTarget: mockResolveTaskExecutionTarget,
+  resolveResumeExecutionTarget: mockResolveResumeExecutionTarget,
+}));
+
+import { startTaskExecution } from "../task-dispatch";
+
+function seedTask() {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(tasks)
+    .values({
+      id,
+      title: "Upgrade local clone",
+      description: "Merge upstream changes safely",
+      status: "queued",
+      assignedAgent: "claude-code",
+      agentProfile: "upgrade-assistant",
+      priority: 2,
+      resumeCount: 0,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return id;
+}
+
+describe("startTaskExecution", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    db.delete(notifications).run();
+    db.delete(agentLogs).run();
+    db.delete(tasks).run();
+  });
+
+  it("retries once on a retryable launch failure and persists the fallback runtime", async () => {
+    const taskId = seedTask();
+
+    mockResolveTaskExecutionTarget
+      .mockResolvedValueOnce({
+        requestedRuntimeId: "claude-code",
+        effectiveRuntimeId: "claude-code",
+        requestedModelId: null,
+        effectiveModelId: null,
+        fallbackApplied: false,
+        fallbackReason: null,
+      })
+      .mockResolvedValueOnce({
+        requestedRuntimeId: "claude-code",
+        effectiveRuntimeId: "openai-codex-app-server",
+        requestedModelId: null,
+        effectiveModelId: null,
+        fallbackApplied: false,
+        fallbackReason: null,
+      });
+
+    mockExecuteTaskWithRuntime
+      .mockRejectedValueOnce(
+        new RetryableRuntimeLaunchError({
+          runtimeId: "claude-code",
+          message:
+            "Claude Code failed to launch before task execution started: Claude Code process exited with code 1",
+          cause: new Error("Claude Code process exited with code 1"),
+        })
+      )
+      .mockResolvedValueOnce(undefined);
+
+    await startTaskExecution(taskId, { requestedRuntimeId: "claude-code" });
+
+    expect(mockExecuteTaskWithRuntime).toHaveBeenNthCalledWith(1, taskId, "claude-code");
+    expect(mockExecuteTaskWithRuntime).toHaveBeenNthCalledWith(
+      2,
+      taskId,
+      "openai-codex-app-server"
+    );
+    expect(mockResolveTaskExecutionTarget).toHaveBeenNthCalledWith(2, {
+      title: "Upgrade local clone",
+      description: "Merge upstream changes safely",
+      requestedRuntimeId: "claude-code",
+      profileId: "upgrade-assistant",
+      unavailableRuntimeIds: ["claude-code"],
+      unavailableReasons: {
+        "claude-code":
+          "Claude Code failed to launch before task execution started: Claude Code process exited with code 1",
+      },
+    });
+
+    const row = db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+    expect(row?.status).toBe("running");
+    expect(row?.effectiveRuntimeId).toBe("openai-codex-app-server");
+    expect(row?.runtimeFallbackReason).toContain("Fell back to OpenAI Codex App Server.");
+
+    const logs = db
+      .select({ event: agentLogs.event, payload: agentLogs.payload })
+      .from(agentLogs)
+      .where(eq(agentLogs.taskId, taskId))
+      .all();
+    expect(logs.map((log) => log.event)).toContain("runtime_launch_failed");
+    expect(logs.map((log) => log.event)).toContain("runtime_fallback");
+  });
+
+  it("marks the task failed when a retryable launch failure has no compatible alternate", async () => {
+    const taskId = seedTask();
+
+    mockResolveTaskExecutionTarget
+      .mockResolvedValueOnce({
+        requestedRuntimeId: "claude-code",
+        effectiveRuntimeId: "claude-code",
+        requestedModelId: null,
+        effectiveModelId: null,
+        fallbackApplied: false,
+        fallbackReason: null,
+      })
+      .mockRejectedValueOnce(
+        new Error("No compatible configured runtime is available for this task.")
+      );
+
+    mockExecuteTaskWithRuntime.mockRejectedValueOnce(
+      new RetryableRuntimeLaunchError({
+        runtimeId: "claude-code",
+        message:
+          "Claude Code failed to launch before task execution started: Claude Code process exited with code 1",
+        cause: new Error("Claude Code process exited with code 1"),
+      })
+    );
+
+    await expect(
+      startTaskExecution(taskId, { requestedRuntimeId: "claude-code" })
+    ).rejects.toThrow("No compatible configured runtime is available for this task.");
+
+    const row = db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+    expect(row?.status).toBe("failed");
+    expect(row?.result).toBe("No compatible configured runtime is available for this task.");
+
+    const taskNotifications = db
+      .select()
+      .from(notifications)
+      .where(eq(notifications.taskId, taskId))
+      .all();
+    expect(taskNotifications).toHaveLength(1);
+  });
+});

package/src/lib/agents/__tests__/tool-permissions.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    insert: vi.fn(() => ({ values: vi.fn().mockResolvedValue(undefined) })),
+    select: vi.fn(() => ({ from: vi.fn(() => ({ where: vi.fn().mockResolvedValue([]) })) })),
+  },
+}));
+
+vi.mock("@/lib/settings/permissions", () => ({
+  isToolAllowed: vi.fn().mockResolvedValue(false),
+}));
+
+import { handleToolPermission, clearPermissionCache } from "@/lib/agents/tool-permissions";
+
+describe("handleToolPermission — SDK filesystem and Skill auto-allow", () => {
+  beforeEach(() => {
+    clearPermissionCache("test-task");
+    clearPermissionCache("test-task-edit");
+  });
+
+  it("auto-allows Read without creating a notification", async () => {
+    const result = await handleToolPermission("test-task", "Read", { file_path: "/tmp/x" });
+    expect(result.behavior).toBe("allow");
+    expect(result.updatedInput).toEqual({ file_path: "/tmp/x" });
+  });
+
+  it("auto-allows Grep", async () => {
+    const result = await handleToolPermission("test-task", "Grep", { pattern: "foo" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Glob", async () => {
+    const result = await handleToolPermission("test-task", "Glob", { pattern: "**/*.ts" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Skill invocations", async () => {
+    const result = await handleToolPermission("test-task", "Skill", { skill: "code-reviewer" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("does NOT auto-allow Edit (must route through notification flow)", async () => {
+    const { db } = await import("@/lib/db");
+    const insertSpy = vi.spyOn(db, "insert");
+    handleToolPermission("test-task-edit", "Edit", { file_path: "/tmp/x", content: "y" });
+    await new Promise((r) => setTimeout(r, 10));
+    expect(insertSpy).toHaveBeenCalled();
+  });
+
+  it("profile autoDeny for Read wins over auto-allow", async () => {
+    const result = await handleToolPermission(
+      "test-task",
+      "Read",
+      { file_path: "/tmp/x" },
+      { autoApprove: [], autoDeny: ["Read"] },
+    );
+    expect(result.behavior).toBe("deny");
+  });
+});