@vellumai/assistant 0.8.4 → 0.8.5

package/src/__tests__/conversation-fork-crud.test.ts

@@ -214,6 +214,115 @@ describe("forkConversation", () => {
     ]);
   });
 
+  test("advances fork boundary through consecutive assistant rows after the requested message", async () => {
+    // When the read-path merges consecutive assistant DB rows into a single
+    // display row, the client only addresses the anchor id. Forking through
+    // the anchor must still include the merged tail rows that follow.
+    const source = createConversation("Multi-row turn thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const anchor = await addMessage(
+      source.id,
+      "assistant",
+      "Assistant text segment",
+      undefined,
+      { skipIndexing: true },
+    );
+    const toolRow = await addMessage(
+      source.id,
+      "assistant",
+      "Tool turn row",
+      undefined,
+      { skipIndexing: true },
+    );
+    const tailRow = await addMessage(
+      source.id,
+      "assistant",
+      "Final assistant segment",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "user", "Next user turn", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: anchor.id,
+    });
+
+    // Boundary advances past the entire consecutive-assistant cluster, so the
+    // full turn is preserved in the fork — not just the anchor row.
+    expect(getMessages(fork.id).map((message) => message.content)).toEqual([
+      "Message 1",
+      "Assistant text segment",
+      "Tool turn row",
+      "Final assistant segment",
+    ]);
+    expect(fork.forkParentMessageId).toBe(tailRow.id);
+    expect(toolRow.id).not.toBe(anchor.id);
+  });
+
+  test("advances fork boundary across tool-result-only user rows between assistant rows", async () => {
+    // Read-path collapse folds tool-result-only user rows into the
+    // surrounding assistant turn (`mergeToolResultsIntoAssistantMessages`
+    // suppresses them). The client only sees a single display turn anchored
+    // at the first assistant row, so forking through the anchor must include
+    // both halves of the assistant turn plus the suppressed user row in
+    // between — otherwise the fork loses tool_use ↔ tool_result pairing
+    // and produces an invalid LLM history.
+    const source = createConversation("Tool-result gap thread");
+    await addMessage(source.id, "user", "Find the latest sales numbers", undefined, {
+      skipIndexing: true,
+    });
+    const anchor = await addMessage(
+      source.id,
+      "assistant",
+      JSON.stringify([
+        { type: "text", text: "Looking up the data." },
+        { type: "tool_use", id: "tool_1", name: "lookup", input: {} },
+      ]),
+      undefined,
+      { skipIndexing: true },
+    );
+    const toolResultUserRow = await addMessage(
+      source.id,
+      "user",
+      JSON.stringify([
+        { type: "tool_result", tool_use_id: "tool_1", content: "data" },
+      ]),
+      undefined,
+      { skipIndexing: true },
+    );
+    const tailAssistantRow = await addMessage(
+      source.id,
+      "assistant",
+      "Here are the numbers.",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "user", "Thanks", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: anchor.id,
+    });
+
+    // All three DB rows of the assistant display turn — including the
+    // suppressed tool-result user row in the middle — land in the fork.
+    const forkedContent = getMessages(fork.id).map((m) => m.content);
+    expect(forkedContent).toHaveLength(4);
+    expect(forkedContent[0]).toBe("Find the latest sales numbers");
+    expect(forkedContent[1]).toContain("tool_use");
+    expect(forkedContent[2]).toContain("tool_result");
+    expect(forkedContent[3]).toBe("Here are the numbers.");
+    expect(fork.forkParentMessageId).toBe(tailAssistantRow.id);
+    expect(toolResultUserRow.id).not.toBe(anchor.id);
+  });
+
   test("preserves compacted context when forking from the visible window", async () => {
     const source = createConversation("Compacted thread");
     await addMessage(source.id, "user", "Message 1", undefined, {
@@ -297,7 +406,7 @@ describe("forkConversation", () => {
     ]);
   });
 
-  test("inherits cleanedAt when forking past the clean event", async () => {
+  test("inherits historyStrippedAt when forking past the clean event", async () => {
     const source = createConversation("Clean thread");
     await addMessage(source.id, "user", "Message 1", undefined, {
       skipIndexing: true,
@@ -310,10 +419,10 @@ describe("forkConversation", () => {
       { skipIndexing: true },
     );
 
-    const cleanedAt = preClean.createdAt + 1;
+    const historyStrippedAt = preClean.createdAt + 1;
     getDb()
       .update(conversations)
-      .set({ cleanedAt })
+      .set({ historyStrippedAt })
       .where(eq(conversations.id, source.id))
       .run();
 
@@ -324,17 +433,17 @@ describe("forkConversation", () => {
       undefined,
       { skipIndexing: true },
     );
-    expect(postClean.createdAt).toBeGreaterThanOrEqual(cleanedAt);
+    expect(postClean.createdAt).toBeGreaterThanOrEqual(historyStrippedAt);
 
     const fork = forkConversation({
       conversationId: source.id,
       throughMessageId: postClean.id,
     });
 
-    expect(fork.cleanedAt).toBe(cleanedAt);
+    expect(fork.historyStrippedAt).toBe(historyStrippedAt);
   });
 
-  test("does not inherit cleanedAt when forking before the clean event", async () => {
+  test("does not inherit historyStrippedAt when forking before the clean event", async () => {
     const source = createConversation("Clean thread");
     await addMessage(source.id, "user", "Message 1", undefined, {
       skipIndexing: true,
@@ -347,10 +456,10 @@ describe("forkConversation", () => {
       { skipIndexing: true },
     );
 
-    const cleanedAt = preClean.createdAt + 1;
+    const historyStrippedAt = preClean.createdAt + 1;
     getDb()
       .update(conversations)
-      .set({ cleanedAt })
+      .set({ historyStrippedAt })
       .where(eq(conversations.id, source.id))
       .run();
 
@@ -363,10 +472,10 @@ describe("forkConversation", () => {
       throughMessageId: preClean.id,
     });
 
-    expect(fork.cleanedAt).toBeNull();
+    expect(fork.historyStrippedAt).toBeNull();
   });
 
-  test("inherits cleanedAt on a full-history fork", async () => {
+  test("inherits historyStrippedAt on a full-history fork", async () => {
     const source = createConversation("Clean thread");
     await addMessage(source.id, "user", "Message 1", undefined, {
       skipIndexing: true,
@@ -379,19 +488,19 @@ describe("forkConversation", () => {
       { skipIndexing: true },
     );
 
-    const cleanedAt = last.createdAt - 1;
+    const historyStrippedAt = last.createdAt - 1;
     getDb()
       .update(conversations)
-      .set({ cleanedAt })
+      .set({ historyStrippedAt })
       .where(eq(conversations.id, source.id))
       .run();
 
     const fork = forkConversation({ conversationId: source.id });
 
-    expect(fork.cleanedAt).toBe(cleanedAt);
+    expect(fork.historyStrippedAt).toBe(historyStrippedAt);
   });
 
-  test("leaves cleanedAt null when the source has no clean event", async () => {
+  test("leaves historyStrippedAt null when the source has no clean event", async () => {
     const source = createConversation("Unclean thread");
     await addMessage(source.id, "user", "Message 1", undefined, {
       skipIndexing: true,
@@ -402,7 +511,61 @@ describe("forkConversation", () => {
 
     const fork = forkConversation({ conversationId: source.id });
 
-    expect(fork.cleanedAt).toBeNull();
+    expect(fork.historyStrippedAt).toBeNull();
+  });
+
+  test("fork from a pre-compaction message preserves historical injection metadata", async () => {
+    const source = createConversation("Compacted thread");
+    const m1 = await addMessage(
+      source.id,
+      "user",
+      "Historical question",
+      {
+        pkbContextBlock: "<knowledge_base>\nstale\n</knowledge_base>",
+        nowScratchpadBlock:
+          "<NOW.md Always keep this up to date>\nstale\n</NOW.md>",
+      },
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "assistant", "Reply 1", undefined, {
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "user", "Tail turn", undefined, {
+      skipIndexing: true,
+    });
+    const compactedAt = Date.now();
+    getDb()
+      .update(conversations)
+      .set({
+        contextSummary: "summary",
+        contextCompactedMessageCount: 2,
+        contextCompactedAt: compactedAt,
+        historyStrippedAt: compactedAt,
+      })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: m1.id,
+    });
+
+    expect(fork.historyStrippedAt).toBeNull();
+    expect(fork.contextSummary).toBeNull();
+    expect(fork.contextCompactedMessageCount).toBe(0);
+
+    const forkedMessages = getMessages(fork.id);
+    expect(forkedMessages).toHaveLength(1);
+    const meta = parseMetadata(forkedMessages[0].metadata) as Record<
+      string,
+      unknown
+    >;
+    expect(meta.pkbContextBlock).toBe(
+      "<knowledge_base>\nstale\n</knowledge_base>",
+    );
+    expect(meta.nowScratchpadBlock).toBe(
+      "<NOW.md Always keep this up to date>\nstale\n</NOW.md>",
+    );
   });
 
   test("rejects forks when the source conversation has no persisted messages", () => {

package/src/__tests__/conversation-lifecycle.test.ts

@@ -379,7 +379,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         metadata: JSON.stringify({
           memoryInjectedBlock: "mem payload",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+            "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
           pkbSystemReminderBlock:
             "<system_reminder>\npkb payload\n</system_reminder>",
         }),
@@ -406,7 +406,7 @@ describe("loadFromDb metadata injection rehydration", () => {
       { type: "text", text: "<memory>\nmem payload\n</memory>" },
       {
         type: "text",
-        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+        text: "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
       },
       {
         type: "text",
@@ -416,6 +416,47 @@ describe("loadFromDb metadata injection rehydration", () => {
     ]);
   });
 
+  test("legacy <memory>-wrapped memoryV2StaticBlock rehydrates verbatim", async () => {
+    // `meta.memoryV2StaticBlock` may carry either `<info>…</info>` or
+    // legacy `<memory>…</memory>` wrappers depending on when the row was
+    // persisted. The rehydrate path replays the stored text verbatim,
+    // so both wrappers must round-trip unchanged.
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First turn" }]),
+        metadata: JSON.stringify({
+          memoryV2StaticBlock:
+            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail turn" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages[0].content).toEqual([
+      {
+        type: "text",
+        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+      },
+      { type: "text", text: "First turn" },
+    ]);
+  });
+
   test("tail user row skips memoryV2StaticBlock", async () => {
     mockConversation = defaultConv();
     mockDbMessages = [
@@ -434,7 +475,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         role: "user",
         content: JSON.stringify([{ type: "text", text: "Tail" }]),
         metadata: JSON.stringify({
-          memoryV2StaticBlock: "<memory>\n## Essentials\n\nleak\n</memory>",
+          memoryV2StaticBlock: "<info>\n## Essentials\n\nleak\n</info>",
         }),
       },
     ];
@@ -471,7 +512,7 @@ describe("loadFromDb metadata injection rehydration", () => {
           // survive the row-level filter for non-guardian views.
           provenanceTrustClass: "trusted_contact",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+            "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
         }),
       },
       {
@@ -500,7 +541,7 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[0].content).toEqual([
       {
         type: "text",
-        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+        text: "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
       },
       { type: "text", text: "First" },
     ]);
@@ -510,7 +551,7 @@ describe("loadFromDb metadata injection rehydration", () => {
     // Injection-time layout (per `applyRuntimeInjections` after-memory-
     // prefix splicing in ascending injector order: pkb-context 30,
     // pkb-reminder 35, memory-v2-static 38, now-md 40):
-    //   [<memory __injected>, <memory>v2static</memory>, <NOW.md>,
+    //   [<memory>dynamic</memory>, <info>v2static</info>, <NOW.md>,
     //    <system_reminder>, <knowledge_base>, ...original]
     // Rehydration must reproduce this exactly so Anthropic's prefix cache
     // matches msg[0] across daemon restarts.
@@ -523,7 +564,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         metadata: JSON.stringify({
           memoryInjectedBlock: "mem payload",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+            "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
           nowScratchpadBlock: "<NOW.md>\nnow body\n</NOW.md>",
           pkbSystemReminderBlock:
             "<system_reminder>\npkb reminder body\n</system_reminder>",
@@ -551,7 +592,7 @@ describe("loadFromDb metadata injection rehydration", () => {
       { type: "text", text: "<memory>\nmem payload\n</memory>" },
       {
         type: "text",
-        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+        text: "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
       },
       { type: "text", text: "<NOW.md>\nnow body\n</NOW.md>" },
       {
@@ -575,7 +616,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         metadata: JSON.stringify({
           provenanceTrustClass: "trusted_contact",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nprivate memory\n</memory>",
+            "<info>\n## Essentials\n\nprivate memory\n</info>",
         }),
       },
       {
@@ -621,7 +662,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         metadata: JSON.stringify({
           provenanceTrustClass: "trusted_contact",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nprivate memory\n</memory>",
+            "<info>\n## Essentials\n\nprivate memory\n</info>",
         }),
       },
       {
@@ -649,7 +690,7 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(conversation.getMessages()[0].content).toEqual([
       {
         type: "text",
-        text: "<memory>\n## Essentials\n\nprivate memory\n</memory>",
+        text: "<info>\n## Essentials\n\nprivate memory\n</info>",
       },
       { type: "text", text: "First" },
     ]);

package/src/__tests__/{conversation-load-cleaned-at.test.ts → conversation-load-history-stripped.test.ts}

@@ -84,7 +84,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversation: () => mockConversation,
   createConversation: () => ({ id: "conv-1" }),
   addMessage: async () => ({ id: "persisted" }),
-  setConversationCleanedAt: () => {},
+  setConversationHistoryStrippedAt: () => {},
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
 }));
@@ -123,19 +123,19 @@ function textBlocks(content: ReadonlyArray<{ type: string; text?: string }>) {
     .map((b) => b.text);
 }
 
-describe("loadFromDb with cleanedAt", () => {
+describe("loadFromDb with historyStrippedAt", () => {
   beforeEach(() => {
     mockDbMessages = [];
     mockConversation = null;
   });
 
-  test("strips injection prefixes from pre-clean user content", async () => {
-    const cleanedAt = 1000;
+  test("strips injection prefixes from pre-strip user content", async () => {
+    const historyStrippedAt = 1000;
     mockConversation = {
       id: "conv-1",
       contextSummary: null,
       contextCompactedMessageCount: 0,
-      cleanedAt,
+      historyStrippedAt,
       totalInputTokens: 0,
       totalOutputTokens: 0,
       totalEstimatedCost: 0,
@@ -186,13 +186,13 @@ describe("loadFromDb with cleanedAt", () => {
     ]);
   });
 
-  test("skips metadata rehydration for pre-clean messages", async () => {
-    const cleanedAt = 1000;
+  test("skips metadata rehydration for pre-strip messages", async () => {
+    const historyStrippedAt = 1000;
     mockConversation = {
       id: "conv-1",
       contextSummary: null,
       contextCompactedMessageCount: 0,
-      cleanedAt,
+      historyStrippedAt,
       totalInputTokens: 0,
       totalOutputTokens: 0,
       totalEstimatedCost: 0,
@@ -201,7 +201,7 @@ describe("loadFromDb with cleanedAt", () => {
       {
         id: "m1",
         role: "user",
-        content: JSON.stringify([{ type: "text", text: "Pre-clean turn" }]),
+        content: JSON.stringify([{ type: "text", text: "Pre-strip turn" }]),
         createdAt: 500,
         metadata: JSON.stringify({
           pkbContextBlock: "<knowledge_base>stale</knowledge_base>",
@@ -217,7 +217,7 @@ describe("loadFromDb with cleanedAt", () => {
         id: "m3",
         role: "user",
         content: JSON.stringify([
-          { type: "text", text: "Mid post-clean turn" },
+          { type: "text", text: "Mid post-strip turn" },
         ]),
         createdAt: 1500,
         metadata: JSON.stringify({
@@ -236,18 +236,18 @@ describe("loadFromDb with cleanedAt", () => {
     await conversation.loadFromDb();
     const messages = conversation.getMessages();
 
-    expect(textBlocks(messages[0].content)).toEqual(["Pre-clean turn"]);
+    expect(textBlocks(messages[0].content)).toEqual(["Pre-strip turn"]);
     expect(textBlocks(messages[2].content).join("\n")).toContain(
       "<knowledge_base>kept</knowledge_base>",
     );
   });
 
-  test("leaves messages untouched when cleanedAt is null", async () => {
+  test("leaves messages untouched when historyStrippedAt is null", async () => {
     mockConversation = {
       id: "conv-1",
       contextSummary: null,
       contextCompactedMessageCount: 0,
-      cleanedAt: null,
+      historyStrippedAt: null,
       totalInputTokens: 0,
       totalOutputTokens: 0,
       totalEstimatedCost: 0,

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -179,6 +179,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
   updateConversationContextWindow: () => {},
+  setConversationHistoryStrippedAt: () => {},
   getConversationOriginChannel: () => null,
   getConversationOriginInterface: () => null,
   provenanceFromTrustContext: () => ({}),

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -498,6 +498,115 @@ describe("macOS browser backend fallback (no extension, no cdp-inspect)", () =>
   });
 });
 
+describe("POST /v1/messages — body.conversationId direct id lookup", () => {
+  // The handler accepts two scope inputs with distinct semantics:
+  //
+  //   - `body.conversationId` is the assistant-minted internal id and is
+  //     looked up directly. A missing row is a 404 — clients must obtain
+  //     the id from a prior daemon response.
+  //   - `body.conversationKey` is an external key (non-vellum channels /
+  //     web idempotency); resolved via the conversation_keys table and
+  //     materialised on first use.
+  //
+  // When both are sent, `conversationId` wins and `conversationKey` is
+  // ignored. (Don't combine — fetch by one and then the other.)
+
+  async function sendMessage(
+    body: Record<string, unknown>,
+    successStatus = 202,
+  ): Promise<Response> {
+    return callHandler(
+      (args) =>
+        handleSendMessage(args, {
+          sendMessageDeps: {
+            getOrCreateConversation: async (conversationId: string) =>
+              getOrCreateFakeConversation(conversationId),
+            assistantEventHub: new AssistantEventHub(),
+            resolveAttachments: () => [],
+          },
+        }),
+      new Request("http://localhost/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-vellum-principal-type": authContext.principalType,
+        },
+        body: JSON.stringify(body),
+      }),
+      undefined,
+      successStatus,
+    );
+  }
+
+  test("body.conversationId=<existing-id> scopes the send to that conversation", async () => {
+    // Pre-materialise a conversation via the key path, then send a message
+    // by its assistant-minted internal id.
+    const externalKey = `pre-materialised-${crypto.randomUUID()}`;
+    const seeded = getOrCreateConversationMapping(externalKey);
+
+    const response = await sendMessage({
+      conversationId: seeded.conversationId,
+      content: "Direct id lookup — should reuse the existing conversation.",
+      sourceChannel: "vellum",
+      interface: "macos",
+    });
+
+    expect(response.status).toBe(202);
+    const body = (await response.json()) as {
+      accepted: boolean;
+      conversationId: string;
+    };
+    expect(body.accepted).toBe(true);
+    expect(body.conversationId).toBe(seeded.conversationId);
+
+    // No new external-key row should be materialised under the internal id.
+    expect(getConversationByKey(seeded.conversationId)).toBeNull();
+  });
+
+  test("body.conversationId=<non-existent-id> returns 404", async () => {
+    const response = await sendMessage(
+      {
+        conversationId: `does-not-exist-${crypto.randomUUID()}`,
+        content: "Should 404 — unknown internal id.",
+        sourceChannel: "vellum",
+        interface: "macos",
+      },
+      404,
+    );
+    expect(response.status).toBe(404);
+    const body = (await response.json()) as {
+      error?: { code?: string; message?: string };
+    };
+    expect(body.error?.code).toBe("NOT_FOUND");
+    expect(body.error?.message).toMatch(/not found/i);
+  });
+
+  test("body.conversationId is honored and body.conversationKey is ignored when both are sent", async () => {
+    // Seed a conversation for the id we'll send. Also seed a separate
+    // conversation under a key the client will pass alongside — but the
+    // handler must scope to the id, NOT the key.
+    const idSeed = getOrCreateConversationMapping(
+      `id-honored-${crypto.randomUUID()}`,
+    );
+    const keyValue = `key-ignored-${crypto.randomUUID()}`;
+    const keySeed = getOrCreateConversationMapping(keyValue);
+    expect(idSeed.conversationId).not.toBe(keySeed.conversationId);
+
+    const response = await sendMessage({
+      conversationId: idSeed.conversationId,
+      conversationKey: keyValue,
+      content: "Both fields sent — id should win.",
+      sourceChannel: "vellum",
+      interface: "macos",
+    });
+
+    expect(response.status).toBe(202);
+    const body = (await response.json()) as { conversationId: string };
+    expect(body.conversationId).toBe(idSeed.conversationId);
+    expect(body.conversationId).not.toBe(keySeed.conversationId);
+  });
+});
+
 describe("conversationKey send path disk-view regression", () => {
   test("first send on a fresh conversationKey creates disk-view dir and writes user+assistant records", async () => {
     const conversationKey = `fresh-conv-key-${crypto.randomUUID()}`;

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -370,6 +370,41 @@ describe("handleSendMessage slash command interception", () => {
     expect(runAgentLoop).not.toHaveBeenCalled();
   });
 
+  test("clears processing and drains the queue when /compact's initial persist fails", async () => {
+    const { conversation } = makeConversation();
+    const drainQueue = mock(async () => {});
+    (
+      conversation as unknown as { drainQueue: () => Promise<void> }
+    ).drainQueue = drainQueue;
+
+    // Force the user-message persist (the first addMessage in the /compact
+    // branch, on the synchronous pre-202 path) to throw.
+    addMessageMock.mockImplementationOnce(async () => {
+      throw new Error("disk full");
+    });
+
+    // The failure surfaces to the caller rather than silently 202-ing.
+    let caught: Error | undefined;
+    try {
+      await callHandler(
+        (args) => handleSendMessage(args, makeDeps(conversation)),
+        makeRequest("/compact"),
+        undefined,
+        202,
+      );
+    } catch (err) {
+      caught = err as Error;
+    }
+    expect(caught?.message).toBe("disk full");
+
+    // Regression: without the guard `processing` stays stuck true, leaving
+    // every later send queued forever; the queue must also be drained.
+    expect(
+      (conversation as unknown as { processing: boolean }).processing,
+    ).toBe(false);
+    expect(drainQueue).toHaveBeenCalledTimes(1);
+  });
+
   test("passes regular messages through to agent loop unchanged", async () => {
     const {
       conversation,