@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/conversation-runtime-workspace.test.ts

@@ -1,11 +1,12 @@
-import { beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
 
-import { applyRuntimeInjections } from "../daemon/conversation-runtime-assembly.js";
-import { defaultInjectorsPlugin } from "../plugins/defaults/injectors.js";
 import {
-  registerPlugin,
-  resetPluginRegistryForTests,
-} from "../plugins/registry.js";
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { applyRuntimeInjections } from "../daemon/conversation-runtime-assembly.js";
+import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
+import { createApp } from "../memory/app-store.js";
 import type { Message } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -16,6 +17,46 @@ function userMsg(text: string): Message {
   return { role: "user", content: [{ type: "text", text }] };
 }
 
+// `applyRuntimeInjections` synthesizes this conversation id when no
+// `turnContext` is supplied, so the `workspace-context` injector resolves the
+// live workspace block from the registry under this key.
+const FALLBACK_CONVERSATION_ID = "runtime-assembly-fallback";
+
+// Register the fallback conversation in the live registry so the runtime
+// injectors resolve their blocks from it (the orchestrator no longer threads
+// workspace or active-surface content as options).
+function registerFallbackConversation(fields: Record<string, unknown>): void {
+  setConversation(FALLBACK_CONVERSATION_ID, {
+    conversationId: FALLBACK_CONVERSATION_ID,
+    workingDir: "/sandbox",
+    // Non-dirty empty workspace by default so the workspace-context injector
+    // skips both the filesystem rescan and the DB refresh unless a test
+    // explicitly seeds a block via `workspaceTopLevelContext`.
+    workspaceTopLevelContext: "",
+    workspaceTopLevelDirty: false,
+    ...fields,
+  } as never);
+}
+
+// Seed the live conversation registry with a pre-rendered top-level block. The
+// cache is non-dirty with non-null content, so `resolveWorkspaceTopLevelContext`
+// returns it verbatim without rescanning the filesystem.
+function seedWorkspaceContext(text: string): void {
+  registerFallbackConversation({
+    workspaceTopLevelContext: text,
+    workspaceTopLevelDirty: false,
+  });
+}
+
+// Build the conversation surface-state map that `buildActiveSurfaceContext`
+// reads to render the `<active_workspace>` block.
+function makeSurfaceState(
+  surfaceId: string,
+  data: SurfaceData,
+): Map<string, { surfaceType: SurfaceType; data: SurfaceData }> {
+  return new Map([[surfaceId, { surfaceType: "dynamic_page", data }]]);
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -23,26 +64,21 @@ function userMsg(text: string): Message {
 const sampleContext =
   "<workspace>\nRoot: /sandbox\nDirectories: src, lib, tests\n</workspace>";
 
-// The standalone `injectWorkspaceTopLevelContext` helper was removed in
-// G2.1. The workspace-context default injector (registered by
-// `defaultInjectorsPlugin`) now emits the workspace block as a
-// `prepend-user-tail` placement during `applyRuntimeInjections`. The suite
-// below exercises that end-to-end path instead.
+// The workspace-context default injector emits the workspace block as a
+// `prepend-user-tail` placement during `applyRuntimeInjections`. It sources
+// the rendered block from the per-conversation workspace registry and
+// (re)injects only when the block is absent from the working messages, so the
+// suite seeds the registry and exercises that end-to-end path.
 
 describe("applyRuntimeInjections — workspace top-level context", () => {
-  beforeEach(() => {
-    // Post-G2.1: workspace injection is driven by the `workspace-context`
-    // default injector, so the plugin must be registered for the chain to
-    // produce a block. Each test gets a clean registry.
-    resetPluginRegistryForTests();
-    registerPlugin(defaultInjectorsPlugin);
+  afterEach(() => {
+    clearConversations();
   });
 
-  test("injects workspace context when provided", async () => {
+  test("injects workspace context when registered", async () => {
+    seedWorkspaceContext(sampleContext);
     const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {
-      workspaceTopLevelContext: sampleContext,
-    });
+    const { messages: result } = await applyRuntimeInjections(messages, {});
 
     expect(result).toHaveLength(1);
     expect(result[0].content).toHaveLength(2);
@@ -50,22 +86,38 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
     expect((result[0].content[1] as { text: string }).text).toBe("Hello");
   });
 
-  test("does not inject when workspace context is null", async () => {
+  test("does not inject when no workspace context is registered", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {
-      workspaceTopLevelContext: null,
-    });
+    const { messages: result } = await applyRuntimeInjections(messages, {});
 
     expect(result).toHaveLength(1);
     expect(result[0].content).toHaveLength(1);
   });
 
+  test("does not re-inject when the workspace block is already present", async () => {
+    // GIVEN the registry holds a workspace block AND the working messages
+    // already carry that block (a normal cached turn, post-injection).
+    seedWorkspaceContext(sampleContext);
+    const messages: Message[] = [userMsg(sampleContext), userMsg("Hello")];
+
+    // WHEN injections are applied
+    const { messages: result } = await applyRuntimeInjections(messages, {});
+
+    // THEN presence detection skips the block to keep the prefix stable.
+    expect(result).toHaveLength(2);
+    expect(result[1].content).toHaveLength(1);
+    expect((result[1].content[0] as { text: string }).text).toBe("Hello");
+  });
+
   test("workspace context appears before active surface context in content", async () => {
-    const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {
-      activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
+    registerFallbackConversation({
       workspaceTopLevelContext: sampleContext,
+      workspaceTopLevelDirty: false,
+      currentActiveSurfaceId: "sf_1",
+      surfaceState: makeSurfaceState("sf_1", { html: "<div>test</div>" }),
     });
+    const messages: Message[] = [userMsg("Hello")];
+    const { messages: result } = await applyRuntimeInjections(messages, {});
 
     // Workspace is injected last (in applyRuntimeInjections order) so it
     // prepends to whatever was already prepended by activeSurface.
@@ -77,18 +129,38 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
     );
     expect((result[0].content[2] as { text: string }).text).toBe("Hello");
   });
+
+  test("app-backed active surface tells the model to load app-builder with the right argument", async () => {
+    const app = createApp({
+      name: "Example App",
+      schemaJson: "{}",
+      htmlDefinition: "<div>test</div>",
+    });
+    registerFallbackConversation({
+      currentActiveSurfaceId: "sf_1",
+      surfaceState: makeSurfaceState("sf_1", {
+        html: "<div>test</div>",
+        appId: app.id,
+      }),
+    });
+    const messages: Message[] = [userMsg("Edit this app")];
+    const { messages: result } = await applyRuntimeInjections(messages, {});
+
+    const activeWorkspaceText = (result[0].content[0] as { text: string }).text;
+    expect(activeWorkspaceText).toContain('skill: "app-builder"');
+    expect(activeWorkspaceText).not.toContain('id: "app-builder"');
+  });
 });
 
 describe("applyRuntimeInjections — minimal mode skips workspace blocks", () => {
-  beforeEach(() => {
-    resetPluginRegistryForTests();
-    registerPlugin(defaultInjectorsPlugin);
+  afterEach(() => {
+    clearConversations();
   });
 
   test("minimal mode skips workspace top-level context", async () => {
+    seedWorkspaceContext(sampleContext);
     const messages: Message[] = [userMsg("Hello")];
     const { messages: result } = await applyRuntimeInjections(messages, {
-      workspaceTopLevelContext: sampleContext,
       mode: "minimal",
     });
 
@@ -98,9 +170,12 @@ describe("applyRuntimeInjections — minimal mode skips workspace blocks", () =>
   });
 
   test("minimal mode skips active surface context", async () => {
+    registerFallbackConversation({
+      currentActiveSurfaceId: "sf_1",
+      surfaceState: makeSurfaceState("sf_1", { html: "<div>test</div>" }),
+    });
     const messages: Message[] = [userMsg("Hello")];
     const { messages: result } = await applyRuntimeInjections(messages, {
-      activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
       mode: "minimal",
     });
 
@@ -110,11 +185,14 @@ describe("applyRuntimeInjections — minimal mode skips workspace blocks", () =>
   });
 
   test("full mode (default) still includes workspace blocks", async () => {
-    const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {
+    registerFallbackConversation({
       workspaceTopLevelContext: sampleContext,
-      activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
+      workspaceTopLevelDirty: false,
+      currentActiveSurfaceId: "sf_1",
+      surfaceState: makeSurfaceState("sf_1", { html: "<div>test</div>" }),
     });
+    const messages: Message[] = [userMsg("Hello")];
+    const { messages: result } = await applyRuntimeInjections(messages, {});
 
     expect(result[0].content).toHaveLength(3);
     expect((result[0].content[0] as { text: string }).text).toBe(sampleContext);

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

@@ -140,53 +140,19 @@ describe("resolveSlash command contract", () => {
   });
 });
 
-describe("resolveSlash /compact target override", () => {
-  test("plain /compact returns no override", async () => {
+describe("resolveSlash /compact", () => {
+  test("plain /compact resolves to kind=compact", async () => {
     const result = await resolveSlash("/compact");
     expect(result).toEqual({ kind: "compact" });
   });
 
-  test("/compact <integer> sets explicit token target", async () => {
+  test("/compact rejects arguments with usage hint", async () => {
     const result = await resolveSlash("/compact 30000");
-    expect(result).toEqual({
-      kind: "compact",
-      targetInputTokensOverride: 30000,
-    });
-  });
-
-  test("/compact <n>k expands to thousands", async () => {
-    const result = await resolveSlash("/compact 30k");
-    expect(result).toEqual({
-      kind: "compact",
-      targetInputTokensOverride: 30_000,
-    });
-  });
-
-  test("/compact <n>m expands to millions", async () => {
-    const result = await resolveSlash("/compact 1.5M");
-    expect(result).toEqual({
-      kind: "compact",
-      targetInputTokensOverride: 1_500_000,
-    });
-  });
-
-  test("/compact rejects malformed args with usage hint", async () => {
-    const result = await resolveSlash("/compact bogus");
     expect(result.kind).toBe("unknown");
     if (result.kind !== "unknown") throw new Error("expected unknown");
-    expect(result.message).toContain("`bogus`");
+    expect(result.message).toContain("does not take arguments");
     expect(result.message).toContain("/compact");
   });
-
-  test("/compact rejects zero", async () => {
-    const result = await resolveSlash("/compact 0");
-    expect(result.kind).toBe("unknown");
-  });
-
-  test("/compact rejects negative numbers", async () => {
-    const result = await resolveSlash("/compact -50");
-    expect(result.kind).toBe("unknown");
-  });
 });
 
 describe("resolveSlash /clean", () => {
@@ -227,9 +193,9 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/status", kind: "unknown" },
     { input: "/commands", kind: "unknown" },
     { input: "/compact", kind: "compact" },
-    { input: "/compact 30000", kind: "compact" },
-    { input: "/compact 30k", kind: "compact" },
-    { input: "/compact 1.5M", kind: "compact" },
+    { input: "/compact 30000", kind: "unknown" },
+    { input: "/compact 30k", kind: "unknown" },
+    { input: "/compact 1.5M", kind: "unknown" },
     { input: "/compact bogus", kind: "unknown" },
     { input: "/clean", kind: "clean" },
     { input: "  /clean  ", kind: "clean" },
@@ -239,7 +205,7 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/opus", kind: "unknown" },
     { input: "hello", kind: "passthrough" },
     { input: "  /compact  ", kind: "compact" },
-    { input: "  /compact 50k  ", kind: "compact" },
+    { input: "  /compact 50k  ", kind: "unknown" },
     { input: "/models foo", kind: "passthrough" },
   ];
 

package/src/__tests__/conversation-slash-queue.test.ts

@@ -1,14 +1,11 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type {
-  AgentEvent,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent, AgentLoopRunResult } from "../agent/loop.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import {
   conversationMessagesSyncTag,
-  type SyncChangedMessage,
+  type SyncChangedEvent,
 } from "../daemon/message-types/sync.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
@@ -213,6 +210,7 @@ let pendingRuns: PendingRun[] = [];
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor() {}
     getToolTokenBudget() {
       return 0;
@@ -226,15 +224,16 @@ mock.module("../agent/loop.js", () => ({
     async run(
       messages: Message[],
       onEvent: (event: AgentEvent) => void | Promise<void>,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: (
-        checkpoint: CheckpointInfo,
-      ) => CheckpointDecision | Promise<CheckpointDecision>,
-    ): Promise<Message[]> {
-      return new Promise<Message[]>((resolve) => {
+    ): Promise<AgentLoopRunResult> {
+      const history = await new Promise<Message[]>((resolve) => {
         pendingRuns.push({ resolve, messages, onEvent });
       });
+      return {
+        history,
+        exitReason: null,
+        appendedNewMessages: history.length > messages.length,
+        newMessages: history.slice(messages.length),
+      };
     }
   },
 }));
@@ -306,9 +305,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
   // Bypass real workspace git init: with "/tmp" as the workspace dir, a real
   // ensureInitialized() walks all of /tmp and can exceed the 2s waitForPendingRun
@@ -357,10 +356,10 @@ async function resolveRun(index: number) {
 }
 
 function syncChangedMessages(): {
-  messages: SyncChangedMessage[];
+  messages: SyncChangedEvent[];
   dispose: () => void;
 } {
-  const messages: SyncChangedMessage[] = [];
+  const messages: SyncChangedEvent[] = [];
   const subscription = assistantEventHub.subscribe({
     type: "process",
     callback: (event) => {
@@ -393,12 +392,12 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     const events3: ServerMessage[] = [];
 
     // Start first message — blocks on agent loop
-    const p1 = conversation.processMessage(
-      "msg-1",
-      [],
-      (e) => events1.push(e),
-      "req-1",
-    );
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: (e) => events1.push(e),
+      requestId: "req-1",
+    });
     await waitForPendingRun(1);
 
     // Enqueue a slash-like passthrough and a normal passthrough after it.
@@ -438,7 +437,11 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     const sharedEvents: ServerMessage[] = [];
     const sharedOnEvent = (event: ServerMessage) => sharedEvents.push(event);
 
-    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      requestId: "req-1",
+    });
     await waitForPendingRun(1);
 
     conversation.enqueueMessage({
@@ -477,12 +480,12 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     const eventsSlash: ServerMessage[] = [];
 
     // Start first message — blocks on agent loop
-    const p1 = conversation.processMessage(
-      "msg-1",
-      [],
-      (e) => events1.push(e),
-      "req-1",
-    );
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: (e) => events1.push(e),
+      requestId: "req-1",
+    });
     await waitForPendingRun(1);
 
     // Enqueue a slash command that matches a skill name — still passes through
@@ -521,7 +524,11 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     const eventsBye: ServerMessage[] = [];
 
     // Start in-flight message
-    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      requestId: "req-1",
+    });
     await waitForPendingRun(1);
 
     // Enqueue ["hi", "/compact", "bye"]. /compact is non-passthrough, so the
@@ -576,7 +583,11 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     const sync = syncChangedMessages();
     try {
       await expect(
-        conversation.processMessage("/compact", [], () => {}, "req-compact"),
+        conversation.processMessage({
+          content: "/compact",
+          attachments: [],
+          requestId: "req-compact",
+        }),
       ).rejects.toThrow("compaction failed");
 
       await waitFor(

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -1,10 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type {
-  AgentEvent,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } from "../agent/loop.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
@@ -237,6 +234,7 @@ let agentLoopRunCalled = false;
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor() {}
     getToolTokenBudget() {
       return 0;
@@ -250,11 +248,6 @@ mock.module("../agent/loop.js", () => ({
     async run(
       messages: Message[],
       onEvent: (event: AgentEvent) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: (
-        checkpoint: CheckpointInfo,
-      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       // Prime the assistant row anchor — production code emits this from
       // `AgentLoop.run` just before `provider.sendMessage`.
@@ -318,9 +311,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
 }
 
@@ -336,7 +329,10 @@ describe("Conversation slash command — passthrough for unknown tokens", () =>
 
   test("unknown slash-like input passes through to agent loop", async () => {
     const conversation = makeConversation();
-    await conversation.processMessage("/not-a-skill", [], () => {});
+    await conversation.processMessage({
+      content: "/not-a-skill",
+      attachments: [],
+    });
 
     // Should go through the normal agent loop path
     expect(agentLoopRunCalled).toBe(true);
@@ -345,9 +341,11 @@ describe("Conversation slash command — passthrough for unknown tokens", () =>
   test("normal messages still go through standard path", async () => {
     const conversation = makeConversation();
     const events: ServerMessage[] = [];
-    await conversation.processMessage("hello world", [], (msg) =>
-      events.push(msg),
-    );
+    await conversation.processMessage({
+      content: "hello world",
+      attachments: [],
+      onEvent: (msg) => events.push(msg),
+    });
     expect(agentLoopRunCalled).toBe(true);
   });
 });

package/src/__tests__/conversation-speed-override.test.ts

@@ -7,12 +7,8 @@
  */
 import { describe, expect, mock, test } from "bun:test";
 
-import type {
-  AgentEvent,
-  AgentLoopConfig,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent, AgentLoopConfig } from "../agent/loop.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
@@ -201,12 +197,13 @@ let lastAgentLoopConfig: Partial<AgentLoopConfig> | undefined;
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor(
       _provider: unknown,
       _systemPrompt: string,
-      config?: Partial<AgentLoopConfig>,
+      options?: { config?: Partial<AgentLoopConfig> },
     ) {
-      lastAgentLoopConfig = config;
+      lastAgentLoopConfig = options?.config;
     }
     getToolTokenBudget() {
       return 0;
@@ -220,11 +217,6 @@ mock.module("../agent/loop.js", () => ({
     async run(
       _messages: Message[],
       _onEvent: (event: AgentEvent) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: (
-        checkpoint: CheckpointInfo,
-      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return [];
     }
@@ -292,11 +284,9 @@ describe("per-conversation speed override", () => {
       "conv-speed-override-1",
       makeProvider(),
       "system prompt",
-      4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // sharedCesClient
-      "standard", // speedOverride
+      { maxTokens: 4096, speedOverride: "standard" },
     );
 
     expect(lastAgentLoopConfig).toBeDefined();
@@ -312,11 +302,9 @@ describe("per-conversation speed override", () => {
       "conv-speed-global-1",
       makeProvider(),
       "system prompt",
-      4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // sharedCesClient
-      // no speedOverride — should fall back to global config "fast"
+      { maxTokens: 4096 },
     );
 
     expect(lastAgentLoopConfig).toBeDefined();
@@ -331,11 +319,9 @@ describe("per-conversation speed override", () => {
       "conv-speed-override-fast-1",
       makeProvider(),
       "system prompt",
-      4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // sharedCesClient
-      "fast", // speedOverride
+      { maxTokens: 4096, speedOverride: "fast" },
     );
 
     expect(lastAgentLoopConfig).toBeDefined();

package/src/__tests__/conversation-starter-routes.test.ts

@@ -339,8 +339,8 @@ describe("GET /v1/conversation-starters", () => {
 
   test("does not re-enqueue for invalid items when within cooldown period", async () => {
     const now = Date.now();
-    // Generation happened 30 seconds ago (within the 60s cooldown)
-    const recentGenAt = now - 30_000;
+    // Last attempt 30 seconds ago (within the 5-minute cooldown)
+    const recentAttemptAt = now - 30_000;
     insertStarter({
       label: "Let me check calendar",
       prompt: "Let me check what Alice has today.",
@@ -353,9 +353,13 @@ describe("GET /v1/conversation-starters", () => {
       category: "productivity",
       createdAt: now - 1,
     });
+    setCheckpoint(
+      "conversation_starters:last_attempt_at:default",
+      String(recentAttemptAt),
+    );
     setCheckpoint(
       "conversation_starters:last_gen_at:default",
-      String(recentGenAt),
+      String(recentAttemptAt),
     );
     setCheckpoint("conversation_starters:item_count_at_last_gen:default", "1");
     insertMemoryItem();
@@ -375,8 +379,8 @@ describe("GET /v1/conversation-starters", () => {
 
   test("re-enqueues for invalid items after cooldown expires", async () => {
     const now = Date.now();
-    // Generation happened 90 seconds ago (past the 60s cooldown)
-    const oldGenAt = now - 90_000;
+    // Last attempt 6 minutes ago (past the 5-minute cooldown)
+    const oldAttemptAt = now - 6 * 60_000;
     insertStarter({
       label: "Let me check calendar",
       prompt: "Let me check what Alice has today.",
@@ -389,9 +393,13 @@ describe("GET /v1/conversation-starters", () => {
       category: "productivity",
       createdAt: now - 1,
     });
+    setCheckpoint(
+      "conversation_starters:last_attempt_at:default",
+      String(oldAttemptAt),
+    );
     setCheckpoint(
       "conversation_starters:last_gen_at:default",
-      String(oldGenAt),
+      String(oldAttemptAt),
     );
     setCheckpoint("conversation_starters:item_count_at_last_gen:default", "1");
     insertMemoryItem();