stagent 0.9.5 → 0.10.0

package/src/instrumentation-node.ts

@@ -0,0 +1,94 @@
+export async function registerNodeInstrumentation() {
+  try {
+    // Instance bootstrap — creates local branch, handles dev-mode gates, consent flow.
+    // Runs BEFORE other startup so instance config is available downstream.
+    // Safe in the canonical stagent dev repo thanks to STAGENT_DEV_MODE=true
+    // in .env.local plus the .git/stagent-dev-mode sentinel file.
+    const { ensureInstance } = await import("@/lib/instance/bootstrap");
+    const instanceResult = await ensureInstance();
+    if (instanceResult.skipped) {
+      console.log(`[instance] bootstrap skipped: ${instanceResult.skipped}`);
+    } else {
+      for (const step of instanceResult.steps) {
+        if (step.status === "failed") {
+          console.error(`[instance] ${step.step} failed: ${step.reason}`);
+        }
+      }
+    }
+
+    // Run pending Drizzle migrations (DROP TABLE, CREATE INDEX, etc.)
+    // that can't be handled by bootstrap's IF NOT EXISTS pattern.
+    // Runs here (not in db/index.ts) to avoid SQLITE_BUSY during next build.
+    await runPendingMigrations();
+
+    // Instance upgrade poller — hourly `git fetch` to detect upstream commits.
+    // Skipped in dev mode; lightweight; uses advisory lock to prevent overlap.
+    const { startUpgradePoller } = await import("@/lib/instance/upgrade-poller");
+    startUpgradePoller();
+
+    const { startScheduler } = await import("@/lib/schedules/scheduler");
+    startScheduler();
+
+    const { startChannelPoller } = await import("@/lib/channels/poller");
+    startChannelPoller();
+
+    const { startAutoBackup } = await import("@/lib/snapshots/auto-backup");
+    startAutoBackup();
+
+    // History retention cleanup — prunes old agent_logs and usage_ledger
+    startHistoryCleanup();
+
+  } catch (err) {
+    console.error("Instrumentation startup failed:", err);
+  }
+}
+
+async function startHistoryCleanup() {
+  const CLEANUP_INTERVAL = 24 * 60 * 60 * 1000;
+  const RETENTION_DAYS = 365;
+
+  async function cleanup() {
+    const { db } = await import("@/lib/db");
+    const { agentLogs, usageLedger } = await import("@/lib/db/schema");
+    const { lt } = await import("drizzle-orm");
+
+    const cutoff = new Date(Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1000);
+    db.delete(agentLogs).where(lt(agentLogs.timestamp, cutoff)).run();
+    db.delete(usageLedger).where(lt(usageLedger.startedAt, cutoff)).run();
+  }
+
+  cleanup().catch(() => {});
+  setInterval(() => cleanup().catch(() => {}), CLEANUP_INTERVAL);
+}
+
+async function runPendingMigrations() {
+  const { join } = await import("path");
+  const { existsSync } = await import("fs");
+  const { getAppRoot } = await import("@/lib/utils/app-root");
+
+  const appRoot = getAppRoot(import.meta.dirname, 1);
+  const migrationsDir = join(appRoot, "src", "lib", "db", "migrations");
+  if (!existsSync(migrationsDir)) return; // npx distribution — no migration files
+
+  const { sqlite } = await import("@/lib/db");
+  const { drizzle } = await import("drizzle-orm/better-sqlite3");
+  const { migrate } = await import("drizzle-orm/better-sqlite3/migrator");
+  const {
+    hasLegacyStagentTables,
+    hasMigrationHistory,
+    markAllMigrationsApplied,
+    bootstrapStagentDatabase,
+  } = await import("@/lib/db/bootstrap");
+
+  const needsLegacyRecovery =
+    hasLegacyStagentTables(sqlite) && !hasMigrationHistory(sqlite);
+
+  if (needsLegacyRecovery) {
+    bootstrapStagentDatabase(sqlite);
+    markAllMigrationsApplied(sqlite, migrationsDir);
+    console.log("[db] Recovered legacy database — all migrations stamped.");
+  } else {
+    const db = drizzle(sqlite);
+    migrate(db, { migrationsFolder: migrationsDir });
+  }
+}

package/src/instrumentation.ts

@@ -1,51 +1,7 @@
-export async function register() {
-  // Only start background services on the server (not during build or edge)
-  if (process.env.NEXT_RUNTIME === "nodejs") {
-    try {
-      // License manager — initialize from DB (creates default row if needed)
-      const { licenseManager } = await import("@/lib/license/manager");
-      licenseManager.initialize();
-      licenseManager.startValidationTimer();
-
-      const { startScheduler } = await import("@/lib/schedules/scheduler");
-      startScheduler();
-
-      const { startChannelPoller } = await import("@/lib/channels/poller");
-      startChannelPoller();
-
-      const { startAutoBackup } = await import("@/lib/snapshots/auto-backup");
-      startAutoBackup();
-
-      // History retention cleanup — prunes old agent_logs and usage_ledger
-      // based on tier retention limit (Community: 30 days)
-      startHistoryCleanup(licenseManager);
-
-      // Telemetry batch flush (opt-in, every 5 minutes)
-      const { startTelemetryFlush } = await import("@/lib/telemetry/queue");
-      startTelemetryFlush();
-    } catch (err) {
-      console.error("Instrumentation startup failed:", err);
-    }
-  }
-}
-
-async function startHistoryCleanup(licenseManager: { getLimit: (r: "historyRetentionDays") => number }) {
-  const CLEANUP_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
-
-  async function cleanup() {
-    const retentionDays = licenseManager.getLimit("historyRetentionDays");
-    if (!Number.isFinite(retentionDays)) return; // Unlimited retention
-
-    const { db } = await import("@/lib/db");
-    const { agentLogs, usageLedger } = await import("@/lib/db/schema");
-    const { lt } = await import("drizzle-orm");
-
-    const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
-    db.delete(agentLogs).where(lt(agentLogs.timestamp, cutoff)).run();
-    db.delete(usageLedger).where(lt(usageLedger.startedAt, cutoff)).run();
+export function register() {
+  if (process.env.NEXT_RUNTIME !== "nodejs") {
+    return;
   }
 
-  // Run once at startup, then daily
-  cleanup().catch(() => {});
-  setInterval(() => cleanup().catch(() => {}), CLEANUP_INTERVAL);
+  return require("./instrumentation-node").registerNodeInstrumentation();
 }

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

@@ -141,10 +141,16 @@ vi.mock("@/lib/agents/browser-mcp", () => ({
   isExaTool: vi.fn().mockReturnValue(false),
   isExaReadOnly: vi.fn().mockReturnValue(false),
 }));
+vi.mock("@/lib/chat/stagent-tools", () => ({
+  createToolServer: vi.fn((_projectId?: string | null) => ({
+    asMcpServer: () => ({ __mockStagentServer: true }),
+  })),
+}));
 
 // Static imports (works because vi.mock is hoisted)
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { executeClaudeTask, resumeClaudeTask } from "../claude-agent";
+import { createToolServer } from "@/lib/chat/stagent-tools";
 
 const mockQuery = vi.mocked(query);
 
@@ -238,6 +244,72 @@ describe("executeClaudeTask", () => {
     expect(mockRemoveExecution).toHaveBeenCalledWith("task-1");
   });
 
+  it("A-stagent-1: injects stagent MCP server into query mcpServers", async () => {
+    mockWhere.mockResolvedValueOnce([makeTask({ projectId: "proj-7" })]);
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await executeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { mcpServers?: Record<string, unknown> };
+    };
+    expect(queryCall.options.mcpServers).toBeDefined();
+    expect(queryCall.options.mcpServers!.stagent).toEqual({ __mockStagentServer: true });
+    expect(vi.mocked(createToolServer)).toHaveBeenCalledWith("proj-7");
+  });
+
+  it("A-stagent-2: prepends mcp__stagent__* when profile has allowedTools", async () => {
+    mockWhere.mockResolvedValueOnce([makeTask({ projectId: "proj-7" })]);
+    mockGetProfile.mockReturnValueOnce({
+      id: "restricted",
+      name: "Restricted",
+      systemPrompt: "",
+      allowedTools: ["Read", "Grep"],
+    });
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await executeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { allowedTools?: string[] };
+    };
+    expect(queryCall.options.allowedTools).toBeDefined();
+    expect(queryCall.options.allowedTools).toContain("mcp__stagent__*");
+    expect(queryCall.options.allowedTools).toContain("Read");
+    expect(queryCall.options.allowedTools).toContain("Grep");
+    // Duplicates not added when profile didn't already include the pattern
+    const stagentCount = queryCall.options.allowedTools!.filter(
+      (t) => t === "mcp__stagent__*"
+    ).length;
+    expect(stagentCount).toBe(1);
+  });
+
+  it("A-stagent-3: omits allowedTools when profile has none (preset defaults preserved)", async () => {
+    mockWhere.mockResolvedValueOnce([makeTask({ projectId: "proj-7" })]);
+    // Default mockGetProfile returns allowedTools: undefined, so ctx.payload.allowedTools
+    // will also be undefined — the query() call should NOT include an allowedTools option.
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await executeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { allowedTools?: string[] };
+    };
+    expect(queryCall.options.allowedTools).toBeUndefined();
+  });
+
   it("A3: captures sessionId from init message and re-calls setExecution", async () => {
     mockWhere.mockResolvedValueOnce([makeTask()]);
     mockQuery.mockReturnValue(
@@ -337,6 +409,51 @@ describe("executeClaudeTask", () => {
     expect(callOptions.maxTurns).toBeDefined();
     expect(callOptions.maxBudgetUsd).toBeDefined();
   });
+
+  it("A8: waits for learned-pattern extraction before final cleanup", async () => {
+    let resolveAnalysis: (() => void) | null = null;
+    mockWhere.mockResolvedValueOnce([makeTask()]);
+    mockQuery.mockReturnValue(
+      createMockStream([{ type: "result", result: "done" }]) as unknown as ReturnType<typeof query>
+    );
+    mockAnalyzeForLearnedPatterns.mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolveAnalysis = () => resolve(null);
+      })
+    );
+
+    const runPromise = executeClaudeTask("task-1");
+    await vi.waitFor(() => {
+      expect(mockAnalyzeForLearnedPatterns).toHaveBeenCalledWith("task-1", "general");
+    });
+
+    expect(mockRemoveExecution).not.toHaveBeenCalled();
+
+    resolveAnalysis?.();
+    await runPromise;
+
+    expect(mockRemoveExecution).toHaveBeenCalledWith("task-1");
+  });
+
+  it("A9: logs learned-pattern extraction failures without failing the task", async () => {
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    mockWhere.mockResolvedValueOnce([makeTask()]);
+    mockQuery.mockReturnValue(
+      createMockStream([{ type: "result", result: "done" }]) as unknown as ReturnType<typeof query>
+    );
+    mockAnalyzeForLearnedPatterns.mockRejectedValueOnce(new Error("extract failed"));
+
+    await executeClaudeTask("task-1");
+
+    expect(mockSet).toHaveBeenCalledWith(
+      expect.objectContaining({ status: "completed", result: "done" })
+    );
+    expect(errorSpy).toHaveBeenCalledWith(
+      "[self-improvement] pattern extraction failed:",
+      expect.any(Error)
+    );
+    errorSpy.mockRestore();
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -527,6 +644,88 @@ describe("resumeClaudeTask", () => {
       expect.objectContaining({ event: "error" })
     );
   });
+
+  it("C5: waits for learned-pattern extraction before final cleanup on resume", async () => {
+    let resolveAnalysis: (() => void) | null = null;
+    mockWhere.mockResolvedValueOnce([
+      makeTask({ sessionId: "sess-123", resumeCount: 0 }),
+    ]);
+    mockQuery.mockReturnValue(
+      createMockStream([{ type: "result", result: "resumed ok" }]) as unknown as ReturnType<typeof query>
+    );
+    mockAnalyzeForLearnedPatterns.mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolveAnalysis = () => resolve(null);
+      })
+    );
+
+    const runPromise = resumeClaudeTask("task-1");
+    await vi.waitFor(() => {
+      expect(mockAnalyzeForLearnedPatterns).toHaveBeenCalledWith("task-1", "general");
+    });
+
+    expect(mockRemoveExecution).not.toHaveBeenCalled();
+
+    resolveAnalysis?.();
+    await runPromise;
+
+    expect(mockRemoveExecution).toHaveBeenCalledWith("task-1");
+  });
+
+  it("R-stagent-1: injects stagent MCP server into query mcpServers on resume", async () => {
+    mockWhere.mockResolvedValueOnce([
+      makeTask({
+        projectId: "proj-7",
+        sessionId: "session-abc",
+        resumeCount: 1,
+      }),
+    ]);
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "resumed and done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await resumeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { mcpServers?: Record<string, unknown>; resume?: string };
+    };
+    expect(queryCall.options.resume).toBe("session-abc");
+    expect(queryCall.options.mcpServers).toBeDefined();
+    expect(queryCall.options.mcpServers!.stagent).toEqual({ __mockStagentServer: true });
+    expect(vi.mocked(createToolServer)).toHaveBeenCalledWith("proj-7");
+  });
+
+  it("R-stagent-2: prepends mcp__stagent__* on resume when profile has allowedTools", async () => {
+    mockWhere.mockResolvedValueOnce([
+      makeTask({
+        projectId: "proj-7",
+        sessionId: "session-abc",
+        resumeCount: 1,
+      }),
+    ]);
+    mockGetProfile.mockReturnValueOnce({
+      id: "restricted",
+      name: "Restricted",
+      systemPrompt: "",
+      allowedTools: ["Read", "Grep"],
+    });
+    mockQuery.mockReturnValue(
+      createMockStream([
+        { type: "result", result: "resumed and done" },
+      ]) as unknown as ReturnType<typeof query>
+    );
+
+    await resumeClaudeTask("task-1");
+
+    const queryCall = mockQuery.mock.calls[0][0] as {
+      options: { allowedTools?: string[] };
+    };
+    expect(queryCall.options.allowedTools).toContain("mcp__stagent__*");
+    expect(queryCall.options.allowedTools).toContain("Read");
+    expect(queryCall.options.allowedTools![0]).toBe("mcp__stagent__*");
+  });
 });
 
 // ═══════════════════════════════════════════════════════════════════════

package/src/lib/agents/__tests__/execution-manager.test.ts

@@ -1,22 +1,10 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-vi.mock("@/lib/license/manager", () => ({
-  licenseManager: {
-    getLimit: vi.fn().mockReturnValue(Infinity),
-    getTier: vi.fn().mockReturnValue("scale"),
-  },
-}));
-
-vi.mock("@/lib/license/notifications", () => ({
-  createTierLimitNotification: vi.fn().mockResolvedValue(undefined),
-}));
+import { describe, it, expect, beforeEach } from "vitest";
 
 import {
   getExecution,
   setExecution,
   removeExecution,
   getAllExecutions,
-  ParallelLimitError,
 } from "@/lib/agents/execution-manager";
 
 function makeExecution(taskId: string) {
@@ -73,18 +61,4 @@ describe("execution-manager", () => {
   it("removing non-existent task does not throw", () => {
     expect(() => removeExecution("nonexistent")).not.toThrow();
   });
-
-  it("throws ParallelLimitError when limit is reached", async () => {
-    const { licenseManager } = await import("@/lib/license/manager");
-    (licenseManager.getLimit as ReturnType<typeof vi.fn>).mockReturnValue(2);
-    (licenseManager.getTier as ReturnType<typeof vi.fn>).mockReturnValue("community");
-
-    setExecution("task-1", makeExecution("task-1"));
-    setExecution("task-2", makeExecution("task-2"));
-
-    expect(() => setExecution("task-3", makeExecution("task-3"))).toThrow(ParallelLimitError);
-
-    // Restore unlimited for other tests
-    (licenseManager.getLimit as ReturnType<typeof vi.fn>).mockReturnValue(Infinity);
-  });
 });

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?.();
+  });
+});