@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/assistant-attachments.test.ts

@@ -9,6 +9,7 @@ import {
   drainDirectiveDisplayBuffer,
   estimateBase64Bytes,
   extractVellumLinks,
+  incompleteVellumLinkSuffixLength,
   inferMimeType,
   MAX_ASSISTANT_ATTACHMENT_BYTES,
   stripVellumLinks,
@@ -386,8 +387,7 @@ describe("extractVellumLinks", () => {
   });
 
   test("decodes URL-encoded spaces in host paths", () => {
-    const text =
-      "[my file.pdf](vellum://host/Users/me/my%20file.pdf)";
+    const text = "[my file.pdf](vellum://host/Users/me/my%20file.pdf)";
     const result = extractVellumLinks(text);
 
     expect(result.directiveRequests).toHaveLength(1);
@@ -406,8 +406,7 @@ describe("extractVellumLinks", () => {
   });
 
   test("warns on malformed percent-encoding and skips the link", () => {
-    const text =
-      "[bad file](vellum://workspace/scratch/100%complete.txt)";
+    const text = "[bad file](vellum://workspace/scratch/100%complete.txt)";
     const result = extractVellumLinks(text);
 
     expect(result.directiveRequests).toHaveLength(0);
@@ -484,6 +483,65 @@ describe("stripVellumLinks", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// incompleteVellumLinkSuffixLength
+// ---------------------------------------------------------------------------
+
+describe("incompleteVellumLinkSuffixLength", () => {
+  const suffix = (text: string) =>
+    text.slice(text.length - incompleteVellumLinkSuffixLength(text));
+
+  test("returns 0 for text with no trailing link", () => {
+    expect(incompleteVellumLinkSuffixLength("all done, no links here")).toBe(0);
+  });
+
+  test("returns 0 for a completed vellum link", () => {
+    expect(
+      incompleteVellumLinkSuffixLength(
+        "see [report.pdf](vellum://workspace/scratch/report.pdf)",
+      ),
+    ).toBe(0);
+  });
+
+  test("returns 0 for a completed link followed by trailing text", () => {
+    expect(
+      incompleteVellumLinkSuffixLength(
+        "[a.pdf](vellum://host/tmp/a.pdf) and more",
+      ),
+    ).toBe(0);
+  });
+
+  test.each([
+    ["mid path", "grab [a.pdf](vellum://host/tmp/a"],
+    ["at slash", "grab [a.pdf](vellum://host/"],
+    ["at authority", "grab [a.pdf](vellum://host"],
+    ["partial authority", "grab [a.pdf](vellum://ho"],
+    ["partial scheme", "grab [a.pdf](vel"],
+    ["open paren", "grab [a.pdf]("],
+    ["closed label", "grab [a.pdf]"],
+    ["open label", "grab [a.pd"],
+  ])("withholds an in-progress vellum link (%s)", (_name, text) => {
+    expect(suffix(text).startsWith("[")).toBe(true);
+    expect(
+      stripVellumLinks(
+        text.slice(0, text.length - incompleteVellumLinkSuffixLength(text)),
+      ),
+    ).not.toContain("vellum://");
+  });
+
+  test("withholds only the trailing in-progress link, not an earlier complete one", () => {
+    const text =
+      "[done.pdf](vellum://host/tmp/done.pdf) then [next](vellum://workspace/scratch/n";
+    expect(suffix(text)).toBe("[next](vellum://workspace/scratch/n");
+  });
+
+  test("stops withholding once the URL diverges from the vellum scheme", () => {
+    expect(
+      incompleteVellumLinkSuffixLength("see [site](https://example.com"),
+    ).toBe(0);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // cleanAssistantContent — vellum:// links
 // ---------------------------------------------------------------------------

package/src/__tests__/assistant-id-boundary-guard.test.ts

@@ -91,7 +91,6 @@ describe("assistant ID boundary", () => {
       "runtime/verification-outbound-actions.ts",
       "daemon/handlers/config-channels.ts",
       "runtime/routes/channel-route-shared.ts",
-      "calls/relay-server.ts",
     ];
 
     const srcDir = join(import.meta.dir, "..");

package/src/__tests__/attachments-store-heic-normalize.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Wiring tests for HEIF/HEIC storage normalization: user-sourced ingress
+ * paths store a JPEG master (rewritten filename, mime, size, bytes) while
+ * register and assistant-outbound paths keep content verbatim.
+ *
+ * The converter module is mocked (keyed on the declared mime type) so these
+ * tests run identically with and without macOS sips; real conversion is
+ * covered in image-conversion.test.ts. mock.module is process-global — keep
+ * these cases in this file.
+ */
+
+import { beforeAll, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  loadConfig: () => ({}),
+  getConfig: () => ({}),
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => true,
+  getAssistantDomain: () => "vellum.me",
+}));
+
+const FAKE_JPEG = Buffer.from("fake-jpeg-master-bytes");
+const FAKE_JPEG_B64 = FAKE_JPEG.toString("base64");
+
+mock.module("../util/image-conversion.js", () => ({
+  convertImageToJpeg: () => FAKE_JPEG,
+  isHeifImage: (bytes: Uint8Array) => bytes.length >= 12,
+  jpegFilenameFor: (filename: string) =>
+    `${filename.replace(/\.[^./\\]+$/, "")}.jpg`,
+  normalizeImageBytes: (mimeType: string, bytes: Uint8Array) =>
+    mimeType === "image/heic"
+      ? { mimeType: "image/jpeg", bytes: FAKE_JPEG, converted: true }
+      : { mimeType, bytes, converted: false },
+  normalizeImageBase64: (mimeType: string, dataBase64: string) =>
+    mimeType === "image/heic"
+      ? { mimeType: "image/jpeg", dataBase64: FAKE_JPEG_B64, converted: true }
+      : { mimeType, dataBase64, converted: false },
+}));
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  attachInlineAttachmentToMessage,
+  getAttachmentById,
+  getFilePathForAttachment,
+  uploadAttachment,
+  uploadAttachmentFromBytes,
+} from "../persistence/attachments-store.js";
+import {
+  addMessage,
+  createConversation,
+} from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  attachmentMetadataSchema,
+  ROUTES,
+} from "../runtime/routes/attachment-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+import { getWorkspaceDir } from "../util/platform.js";
+import { fakeHeifHeaderBytes } from "./heic-fixture.js";
+
+const uploadRoute = ROUTES.find((r) => r.operationId === "attachment_upload")!;
+const registerRoute = ROUTES.find(
+  (r) => r.operationId === "attachment_register",
+)!;
+
+const HEIC_BYTES = fakeHeifHeaderBytes();
+const HEIC_B64 = HEIC_BYTES.toString("base64");
+
+function jsonUploadArgs(body: Record<string, unknown>): RouteHandlerArgs {
+  return {
+    body,
+    rawBody: new TextEncoder().encode(JSON.stringify(body)),
+    headers: { "content-type": "application/json" },
+    queryParams: {},
+  };
+}
+
+describe("HEIC upload normalization wiring", () => {
+  beforeAll(async () => {
+    await initializeDb();
+  }, 30_000);
+
+  test("uploadAttachmentFromBytes stores a JPEG master for HEIC", () => {
+    const stored = uploadAttachmentFromBytes(
+      "IMG_5487.HEIC",
+      "image/heic",
+      HEIC_BYTES,
+    );
+
+    expect(stored.originalFilename).toBe("IMG_5487.jpg");
+    expect(stored.mimeType).toBe("image/jpeg");
+    expect(stored.sizeBytes).toBe(FAKE_JPEG.length);
+    const stagedPath = getFilePathForAttachment(stored.id);
+    expect(stagedPath).not.toBeNull();
+    expect(readFileSync(stagedPath!).equals(FAKE_JPEG)).toBe(true);
+  });
+
+  test("uploadAttachmentFromBytes leaves non-HEIC uploads verbatim", () => {
+    const stored = uploadAttachmentFromBytes(
+      "photo.png",
+      "image/png",
+      HEIC_BYTES,
+    );
+
+    expect(stored.originalFilename).toBe("photo.png");
+    expect(stored.mimeType).toBe("image/png");
+    expect(stored.sizeBytes).toBe(HEIC_BYTES.length);
+  });
+
+  test("uploadAttachment (base64) stores a JPEG master for HEIC", () => {
+    const stored = uploadAttachment("IMG_1.heic", "image/heic", HEIC_B64);
+
+    expect(stored.originalFilename).toBe("IMG_1.jpg");
+    expect(stored.mimeType).toBe("image/jpeg");
+    expect(stored.sizeBytes).toBe(FAKE_JPEG.length);
+    const row = getAttachmentById(stored.id);
+    expect(row?.dataBase64).toBe(FAKE_JPEG_B64);
+  });
+
+  test("uploadAttachment (base64) leaves non-HEIC uploads verbatim", () => {
+    const stored = uploadAttachment("photo.png", "image/png", HEIC_B64);
+
+    expect(stored.originalFilename).toBe("photo.png");
+    expect(stored.mimeType).toBe("image/png");
+    expect(stored.sizeBytes).toBe(HEIC_BYTES.length);
+  });
+
+  test("attachInlineAttachmentToMessage normalizes only when opted in", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "photos" }]),
+    );
+
+    const normalized = attachInlineAttachmentToMessage(
+      msg.id,
+      0,
+      "IMG_2.HEIC",
+      "image/heic",
+      HEIC_B64,
+      { normalizeImage: true },
+    );
+    expect(normalized.originalFilename).toBe("IMG_2.jpg");
+    expect(normalized.mimeType).toBe("image/jpeg");
+
+    // Assistant-outbound attachments are stored verbatim: no normalizeImage
+    // flag, no rewrite, even for HEIC content.
+    const verbatim = attachInlineAttachmentToMessage(
+      msg.id,
+      1,
+      "IMG_3.HEIC",
+      "image/heic",
+      HEIC_B64,
+    );
+    expect(verbatim.originalFilename).toBe("IMG_3.HEIC");
+    expect(verbatim.mimeType).toBe("image/heic");
+    expect(verbatim.sizeBytes).toBe(HEIC_BYTES.length);
+  });
+
+  test("JSON file-path upload converts the daemon-owned copy", async () => {
+    const sourceDir = mkdtempSync(join(tmpdir(), "vellum-heic-src-"));
+    const sourcePath = join(sourceDir, "IMG_4.HEIC");
+    writeFileSync(sourcePath, HEIC_BYTES);
+
+    const raw = await uploadRoute.handler(
+      jsonUploadArgs({
+        filename: "IMG_4.HEIC",
+        mimeType: "image/heic",
+        filePath: sourcePath,
+      }),
+    );
+    const result = attachmentMetadataSchema.parse(raw);
+
+    expect(result.filename).toBe("IMG_4.jpg");
+    expect(result.mimeType).toBe("image/jpeg");
+    expect(result.sizeBytes).toBe(FAKE_JPEG.length);
+    // The caller's source file is never mutated.
+    expect(readFileSync(sourcePath).equals(HEIC_BYTES)).toBe(true);
+    // The staged raw copy is replaced by the converted one.
+    const stagedPath = getFilePathForAttachment(result.id);
+    expect(stagedPath).not.toBeNull();
+    expect(stagedPath!.endsWith(".jpg")).toBe(true);
+    expect(readFileSync(stagedPath!).equals(FAKE_JPEG)).toBe(true);
+  });
+
+  test("attachment register keeps workspace files verbatim", async () => {
+    const registerDir = join(getWorkspaceDir(), "register-fixtures");
+    mkdirSync(registerDir, { recursive: true });
+    const registeredPath = join(registerDir, "IMG_5.HEIC");
+    writeFileSync(registeredPath, HEIC_BYTES);
+
+    const raw = await registerRoute.handler(
+      jsonUploadArgs({
+        path: registeredPath,
+        mimeType: "image/heic",
+        filename: "IMG_5.HEIC",
+      }),
+    );
+    const result = raw as {
+      originalFilename: string;
+      mimeType: string;
+    };
+
+    expect(result.originalFilename).toBe("IMG_5.HEIC");
+    expect(result.mimeType).toBe("image/heic");
+    // Registered files are referenced in place, never rewritten.
+    expect(existsSync(registeredPath)).toBe(true);
+    expect(readFileSync(registeredPath).equals(HEIC_BYTES)).toBe(true);
+  });
+});

package/src/__tests__/attachments-store.test.ts

@@ -100,6 +100,7 @@ describe("uploadAttachment", () => {
 
     // Staged uploads keep the payload inline until they are attached to a message.
     const rawRow = rawGet<{ data_base64: string }>(
+      "test:fetchAttachmentData",
       "SELECT data_base64 FROM attachments WHERE id = ?",
       stored.id,
     );
@@ -285,6 +286,7 @@ describe("deleteAttachment", () => {
     expect(existsSync(filePath!)).toBe(true);
 
     rawRun(
+      "test:unlinkAttachment",
       "DELETE FROM message_attachments WHERE attachment_id = ?",
       stored.id,
     );
@@ -493,6 +495,7 @@ describe("deleteOrphanAttachments", () => {
     expect(existsSync(filePath!)).toBe(true);
 
     rawRun(
+      "test:unlinkOrphanAttachment",
       "DELETE FROM message_attachments WHERE attachment_id = ?",
       stored.id,
     );

package/src/__tests__/background-shell-bash.test.ts

@@ -80,6 +80,7 @@ const mockIsBackgroundToolLimitReached = mock(() => false);
 mock.module("../tools/background-tool-registry.js", () => ({
   registerBackgroundTool: mockRegisterBackgroundTool,
   removeBackgroundTool: mockRemoveBackgroundTool,
+  recordCompletedBackgroundTool: () => {},
   generateBackgroundToolId: mockGenerateBackgroundToolId,
   isBackgroundToolLimitReached: mockIsBackgroundToolLimitReached,
   MAX_BACKGROUND_TOOLS: 20,
@@ -188,6 +189,10 @@ describe("bash tool background mode", () => {
     // Command stdout is fenced as untrusted output, not inlined in the hint.
     expect(wakeCall.untrustedOutput?.content).toContain("bg_output_12345");
     expect(wakeCall.untrustedOutput?.source).toBe("tool_result");
+    // Durable completion record stamped onto the persisted wake.
+    expect(wakeCall.backgroundToolCompletion?.id).toBe("bg-test1234");
+    expect(wakeCall.backgroundToolCompletion?.status).toBe("completed");
+    expect(wakeCall.backgroundToolCompletion?.exitCode).toBe(0);
   });
 
   test("failing background process delivers an error hint via wake", async () => {
@@ -209,6 +214,35 @@ describe("bash tool background mode", () => {
     expect(wakeCall.hint).toContain("bg-test1234");
     // The command fails with exit code 1, so the hint should reflect failure
     expect(wakeCall.hint).toContain("exit=1");
+    expect(wakeCall.backgroundToolCompletion?.id).toBe("bg-test1234");
+    expect(wakeCall.backgroundToolCompletion?.status).toBe("failed");
+    expect(wakeCall.backgroundToolCompletion?.exitCode).toBe(1);
+  });
+
+  test("cancelled background process wakes with the cancellation, not a completed result", async () => {
+    await shellTool.execute(
+      { command: "sleep 30", activity: "test", background: true },
+      baseContext,
+    );
+
+    // User presses Stop: cancel aborts the run and kills the process.
+    const registered = mockRegisterBackgroundTool.mock
+      .calls[0]![0] as BackgroundTool;
+    registered.cancel();
+
+    await waitForWake(mockWakeAgentForOpportunity);
+
+    const wakeCall = mockWakeAgentForOpportunity.mock
+      .calls[0]![0] as WakeOptions;
+    // The wake must reflect the cancellation, not the generic "completed"
+    // framing + SIGKILL-failed output the assistant used to receive — so it
+    // matches the recorded/broadcast status and the inline card.
+    expect(wakeCall.hint).toContain("bg-test1234");
+    expect(wakeCall.hint).toContain("cancelled");
+    expect(wakeCall.hint).not.toContain("completed");
+    expect(wakeCall.untrustedOutput?.content).toContain("cancelled");
+    expect(wakeCall.backgroundToolCompletion?.id).toBe("bg-test1234");
+    expect(wakeCall.backgroundToolCompletion?.status).toBe("cancelled");
   });
 
   test("foreground mode still works when background is not set", async () => {

package/src/__tests__/background-shell-host-bash.test.ts

@@ -23,6 +23,7 @@ const mockIsBackgroundToolLimitReached = mock(() => false);
 mock.module("../tools/background-tool-registry.js", () => ({
   registerBackgroundTool: mockRegisterBackgroundTool,
   removeBackgroundTool: mockRemoveBackgroundTool,
+  recordCompletedBackgroundTool: () => {},
   generateBackgroundToolId: mockGenerateBackgroundToolId,
   isBackgroundToolLimitReached: mockIsBackgroundToolLimitReached,
   MAX_BACKGROUND_TOOLS: 20,
@@ -117,6 +118,7 @@ mock.module("../daemon/host-bash-proxy.js", () => ({
 // Import under test — MUST come after mock.module calls.
 // ---------------------------------------------------------------------------
 
+import type { CompletedBackgroundTool } from "../tools/background-tool-registry.js";
 import { hostShellTool } from "../tools/host-terminal/host-shell.js";
 import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
 
@@ -257,6 +259,11 @@ describe("host_bash background mode — proxy path", () => {
       maxChars: 40_000,
     });
     expect(wakeCall.source).toBe("background-tool");
+    const completion =
+      wakeCall.backgroundToolCompletion as CompletedBackgroundTool;
+    expect(completion.id).toBe("bg-test-0001");
+    expect(completion.status).toBe("completed");
+    expect(completion.exitCode).toBeNull();
   });
 
   test("calls wakeAgentForOpportunity on proxy error result", async () => {
@@ -397,6 +404,11 @@ describe("host_bash background mode — direct execution path", () => {
     expect((wakeCall.untrustedOutput as { content: string }).content).toContain(
       "hello world",
     );
+    const completion =
+      wakeCall.backgroundToolCompletion as CompletedBackgroundTool;
+    expect(completion.id).toBe("bg-test-0001");
+    expect(completion.status).toBe("completed");
+    expect(completion.exitCode).toBe(0);
   });
 
   test("calls wakeAgentForOpportunity with error hint on non-zero exit", async () => {

package/src/__tests__/background-tool-registry.test.ts

@@ -4,9 +4,13 @@ import {
   _clearRegistryForTesting,
   type BackgroundTool,
   cancelBackgroundTool,
+  type CompletedBackgroundTool,
   generateBackgroundToolId,
   listBackgroundTools,
+  listCompletedBackgroundTools,
   MAX_BACKGROUND_TOOLS,
+  MAX_COMPLETED_BACKGROUND_TOOLS,
+  recordCompletedBackgroundTool,
   registerBackgroundTool,
   removeBackgroundTool,
 } from "../tools/background-tool-registry.js";
@@ -129,6 +133,99 @@ describe("background-tool-registry", () => {
     });
   });
 
+  describe("completed ring (recordCompletedBackgroundTool)", () => {
+    function makeCompletion(
+      overrides: Partial<CompletedBackgroundTool> = {},
+    ): CompletedBackgroundTool {
+      return {
+        id: overrides.id ?? "bg-done-1",
+        toolName: overrides.toolName ?? "bash",
+        conversationId: overrides.conversationId ?? "conv-1",
+        command: overrides.command ?? "echo hi",
+        startedAt: overrides.startedAt ?? 1,
+        status: overrides.status ?? "completed",
+        exitCode: overrides.exitCode ?? 0,
+        output: overrides.output ?? "hi",
+        completedAt: overrides.completedAt ?? 2,
+      };
+    }
+
+    test("records a completed tool and lists it with terminal fields", () => {
+      recordCompletedBackgroundTool(
+        makeCompletion({ id: "bg-c1", status: "failed", exitCode: 1 }),
+      );
+
+      const listed = listCompletedBackgroundTools();
+      expect(listed).toHaveLength(1);
+      expect(listed[0]).toMatchObject({
+        id: "bg-c1",
+        status: "failed",
+        exitCode: 1,
+        output: "hi",
+      });
+    });
+
+    test("filters completed tools by conversationId", () => {
+      recordCompletedBackgroundTool(
+        makeCompletion({ id: "bg-c1", conversationId: "conv-1" }),
+      );
+      recordCompletedBackgroundTool(
+        makeCompletion({ id: "bg-c2", conversationId: "conv-2" }),
+      );
+
+      expect(listCompletedBackgroundTools("conv-1").map((t) => t.id)).toEqual([
+        "bg-c1",
+      ]);
+      expect(listCompletedBackgroundTools("conv-9")).toHaveLength(0);
+    });
+
+    test("re-recording the same id replaces rather than duplicates", () => {
+      recordCompletedBackgroundTool(
+        makeCompletion({ id: "bg-c1", status: "completed" }),
+      );
+      recordCompletedBackgroundTool(
+        makeCompletion({ id: "bg-c1", status: "cancelled" }),
+      );
+
+      const listed = listCompletedBackgroundTools();
+      expect(listed).toHaveLength(1);
+      expect(listed[0]!.status).toBe("cancelled");
+    });
+
+    test("evicts the oldest beyond MAX_COMPLETED_BACKGROUND_TOOLS", () => {
+      for (let i = 0; i < MAX_COMPLETED_BACKGROUND_TOOLS + 5; i++) {
+        recordCompletedBackgroundTool(makeCompletion({ id: `bg-r${i}` }));
+      }
+
+      const listed = listCompletedBackgroundTools();
+      expect(listed).toHaveLength(MAX_COMPLETED_BACKGROUND_TOOLS);
+      // Oldest five evicted; newest retained.
+      expect(listed.some((t) => t.id === "bg-r0")).toBe(false);
+      expect(listed.some((t) => t.id === "bg-r5")).toBe(true);
+      expect(
+        listed.some(
+          (t) => t.id === `bg-r${MAX_COMPLETED_BACKGROUND_TOOLS + 4}`,
+        ),
+      ).toBe(true);
+    });
+
+    test("recording a completion does not touch the active registry", () => {
+      registerBackgroundTool(makeTool({ id: "bg-active" }));
+      recordCompletedBackgroundTool(makeCompletion({ id: "bg-done" }));
+
+      expect(listBackgroundTools().map((t) => t.id)).toEqual(["bg-active"]);
+      expect(listCompletedBackgroundTools().map((t) => t.id)).toEqual([
+        "bg-done",
+      ]);
+    });
+
+    test("_clearRegistryForTesting clears the completed ring", () => {
+      recordCompletedBackgroundTool(makeCompletion({ id: "bg-c1" }));
+      _clearRegistryForTesting();
+      expect(listCompletedBackgroundTools()).toHaveLength(0);
+    });
+  });
+
   describe("generateBackgroundToolId", () => {
     test("returns a bg- prefixed string", () => {
       const id = generateBackgroundToolId();

package/src/__tests__/background-tool-routes.test.ts

@@ -5,6 +5,7 @@ import { BadRequestError } from "../runtime/routes/errors.js";
 import type { RouteDefinition } from "../runtime/routes/types.js";
 import {
   _clearRegistryForTesting,
+  recordCompletedBackgroundTool,
   registerBackgroundTool,
 } from "../tools/background-tool-registry.js";
 
@@ -45,13 +46,83 @@ afterEach(() => {
 
 describe("background tool routes", () => {
   describe("GET /v1/background-tools (list)", () => {
-    test("returns empty array when no tools are registered", async () => {
+    test("returns empty arrays when no tools are registered", async () => {
       const route = findRoute("background_tool_list")!;
       const result = (await route.handler({})) as {
         tools: unknown[];
+        completed: unknown[];
       };
 
       expect(result.tools).toEqual([]);
+      expect(result.completed).toEqual([]);
+    });
+
+    test("returns recently-completed tools with terminal fields", async () => {
+      recordCompletedBackgroundTool({
+        id: "bg-done-1",
+        toolName: "bash",
+        conversationId: "conv-1",
+        command: "npm run build",
+        startedAt: 1700000000000,
+        status: "completed",
+        exitCode: 0,
+        output: "built",
+        completedAt: 1700000004200,
+      });
+
+      const route = findRoute("background_tool_list")!;
+      const result = (await route.handler({})) as {
+        tools: unknown[];
+        completed: Array<{
+          id: string;
+          status: string;
+          exitCode: number | null;
+          output: string;
+          completedAt: number;
+        }>;
+      };
+
+      expect(result.tools).toEqual([]);
+      expect(result.completed).toHaveLength(1);
+      expect(result.completed[0]).toMatchObject({
+        id: "bg-done-1",
+        status: "completed",
+        exitCode: 0,
+        output: "built",
+        completedAt: 1700000004200,
+      });
+    });
+
+    test("filters completed tools by conversationId", async () => {
+      recordCompletedBackgroundTool({
+        id: "bg-d1",
+        toolName: "bash",
+        conversationId: "conv-a",
+        command: "x",
+        startedAt: 1,
+        status: "completed",
+        exitCode: 0,
+        output: "",
+        completedAt: 2,
+      });
+      recordCompletedBackgroundTool({
+        id: "bg-d2",
+        toolName: "bash",
+        conversationId: "conv-b",
+        command: "x",
+        startedAt: 1,
+        status: "failed",
+        exitCode: 1,
+        output: "",
+        completedAt: 2,
+      });
+
+      const route = findRoute("background_tool_list")!;
+      const result = (await route.handler({
+        queryParams: { conversationId: "conv-a" },
+      })) as { completed: Array<{ id: string }> };
+
+      expect(result.completed.map((t) => t.id)).toEqual(["bg-d1"]);
     });
 
     test("returns registered tools with toolName field", async () => {

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -122,7 +122,6 @@ mock.module("../persistence/conversation-crud.js", () => ({
   })),
   deleteLastExchange: mock(() => 0),
   findAnalysisConversationFor: mock(() => null),
-  findMostRecentRetrospectiveFor: mock(() => null),
   forkConversation: mock(() => ({ id: "conv-fork" })),
   forkConversationForRetrospective: mock(async () => ({ id: "conv-fork" })),
   getConversationOverrideProfile: () => undefined,
@@ -186,6 +185,7 @@ mock.module("../persistence/jobs-store.js", () => ({
   enqueuePruneOldConversationsJob: mock(() => "job-prune-conv"),
   enqueuePruneOldLlmRequestLogsJob: mock(() => "job-prune-llm"),
   enqueuePruneOldTraceEventsJob: mock(() => "job-prune-trace"),
+  enqueuePruneOldToolInvocationsJob: mock(() => "job-prune-tool"),
   failMemoryJob: mock(() => {}),
   failStalledJobs: mockFailStalledJobs,
   getMemoryJobCounts: mock(() => ({})),
@@ -195,6 +195,7 @@ mock.module("../persistence/jobs-store.js", () => ({
     automatic: "automatic",
     manual: "manual",
   },
+  MESSAGE_LEXICAL_JOB_TYPES: [],
   resetRunningJobsToPending: mock(() => 0),
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),