@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

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

@@ -35,10 +35,6 @@ mock.module("../memory/pkb/pkb-search.js", () => ({
   },
 }));
 
-import {
-  clearConversations,
-  setConversation,
-} from "../daemon/conversation-registry.js";
 import type {
   ChannelCapabilities,
   SlackTranscriptInputRow,
@@ -63,7 +59,6 @@ import {
   stripInjectionsForCompaction,
   stripNowScratchpad,
 } from "../daemon/conversation-runtime-assembly.js";
-import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
 import { buildPkbReminder } from "../daemon/pkb-reminder-builder.js";
 import type { MessageRow } from "../memory/conversation-crud.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
@@ -108,62 +103,6 @@ function clearNowScratchpad(): void {
   rmSync(getWorkspacePromptPath("NOW.md"), { force: true });
 }
 
-// The workspace-context injector sources its block off the live `Conversation`
-// looked up by `conversationId`. Register a fake instance carrying both a
-// non-dirty workspace context (non-null content, not dirty) so
-// `resolveWorkspaceTopLevelContext` returns it verbatim without rescanning the
-// filesystem, and an active dynamic-page surface, so `applyRuntimeInjections`
-// resolves the `<workspace>` and `<active_workspace>` blocks from it;
-// `clearConversations()` between tests keeps suites that assert the blocks are
-// absent unaffected.
-function seedActiveSurfaceConversation(
-  conversationId: string,
-  workspaceText: string,
-  surfaceId: string,
-  data: SurfaceData,
-  channelCapabilities?: ChannelCapabilities,
-  commandIntent?: { type: string; payload?: string; languageCode?: string },
-): void {
-  setConversation(conversationId, {
-    conversationId,
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: workspaceText,
-    workspaceTopLevelDirty: false,
-    currentActiveSurfaceId: surfaceId,
-    surfaceState: new Map<
-      string,
-      { surfaceType: SurfaceType; data: SurfaceData }
-    >([[surfaceId, { surfaceType: "dynamic_page", data }]]),
-    channelCapabilities: channelCapabilities ?? undefined,
-    commandIntent,
-  } as never);
-}
-
-function clearWorkspaceContext(): void {
-  clearConversations();
-}
-
-// The `<channel_capabilities>` branch and the Slack gates source the channel
-// capabilities off the live `Conversation` looked up by `conversationId`.
-// Register a fake fallback instance carrying the given capabilities (and a
-// non-dirty empty workspace + empty surface so the other live-sourced branches
-// stay inert) so `applyRuntimeInjections` resolves them; `clearConversations()`
-// between tests keeps suites asserting absence unaffected.
-function seedChannelCapabilitiesConversation(
-  caps: ChannelCapabilities | null,
-  transportHints?: string[],
-): void {
-  setConversation("runtime-assembly-fallback", {
-    conversationId: "runtime-assembly-fallback",
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: "",
-    workspaceTopLevelDirty: false,
-    surfaceState: new Map(),
-    channelCapabilities: caps ?? undefined,
-    transportHints,
-  } as never);
-}
-
 // ---------------------------------------------------------------------------
 // resolveChannelCapabilities
 // ---------------------------------------------------------------------------
@@ -636,8 +575,6 @@ describe("stripChannelCapabilityContext", () => {
 // ---------------------------------------------------------------------------
 
 describe("applyRuntimeInjections with channelCapabilities", () => {
-  afterEach(clearConversations);
-
   const baseMessages: Message[] = [
     {
       role: "user",
@@ -653,8 +590,9 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
       supportsVoiceInput: false,
     };
 
-    seedChannelCapabilitiesConversation(caps);
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
+      channelCapabilities: caps,
+    });
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(2);
@@ -665,8 +603,9 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
   });
 
   test("does not inject when channelCapabilities is null", async () => {
-    seedChannelCapabilitiesConversation(null);
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
+      channelCapabilities: null,
+    });
 
     expect(result.length).toBe(1);
     expect(result[0].content.length).toBe(1);
@@ -687,8 +626,9 @@ describe("applyRuntimeInjections with channelCapabilities", () => {
       supportsVoiceInput: false,
     };
 
-    seedChannelCapabilitiesConversation(caps);
-    const { messages: result } = await applyRuntimeInjections(baseMessages, {});
+    const { messages: result } = await applyRuntimeInjections(baseMessages, {
+      channelCapabilities: caps,
+    });
 
     expect(result.length).toBe(1);
     // channelCapabilities prepends
@@ -815,14 +755,16 @@ describe("applyRuntimeInjections — injection mode", () => {
     },
   ];
 
-  const channelCapabilities: ChannelCapabilities = {
-    channel: "telegram",
-    dashboardCapable: false,
-    supportsDynamicUi: false,
-    supportsVoiceInput: false,
-  };
-
   const fullOptions = {
+    workspaceTopLevelContext: "<workspace>\nRoot: /sandbox\n</workspace>",
+    channelCommandContext: { type: "start" } as const,
+    activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
+    channelCapabilities: {
+      channel: "telegram",
+      dashboardCapable: false,
+      supportsDynamicUi: false,
+      supportsVoiceInput: false,
+    } as ChannelCapabilities,
     unifiedTurnContext:
       "<turn_context>\ncurrent_time: 2026-03-04 (Tuesday) 12:00:00 +00:00 (UTC)\ninterface: telegram\n</turn_context>",
     isNonInteractive: true,
@@ -846,19 +788,10 @@ describe("applyRuntimeInjections — injection mode", () => {
   beforeEach(() => {
     seedPkbContent();
     seedNowScratchpad("Current focus: shipping PR 3");
-    seedActiveSurfaceConversation(
-      "injection-mode-conv",
-      "<workspace>\nRoot: /sandbox\n</workspace>",
-      "sf_1",
-      { html: "<div>test</div>" },
-      channelCapabilities,
-      { type: "start" },
-    );
   });
   afterEach(() => {
     clearPkbContent();
     clearNowScratchpad();
-    clearWorkspaceContext();
   });
 
   test("full mode (default) includes all injections", async () => {
@@ -1118,7 +1051,7 @@ describe("stripInjectionsForCompaction preserves persistent blocks", () => {
     ).toContain("<turn_context>");
   });
 
-  test("<workspace> blocks ARE stripped so the injector re-sources them post-compaction", () => {
+  test("<workspace> blocks are NOT stripped", () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -1134,10 +1067,10 @@ describe("stripInjectionsForCompaction preserves persistent blocks", () => {
 
     const result = stripInjectionsForCompaction(messages);
     expect(result.length).toBe(1);
-    expect(result[0].content.length).toBe(1);
-    expect((result[0].content[0] as { type: "text"; text: string }).text).toBe(
-      "Hello",
-    );
+    expect(result[0].content.length).toBe(2);
+    expect(
+      (result[0].content[0] as { type: "text"; text: string }).text,
+    ).toContain("<workspace>");
   });
 
   test("legacy <workspace_top_level> blocks ARE stripped for backward compat", () => {
@@ -2419,8 +2352,6 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
 // ---------------------------------------------------------------------------
 
 describe("Slack channel chronological rendering — multi-thread", () => {
-  afterEach(clearConversations);
-
   // Slack ts values are seconds-since-epoch with microsecond precision.
   // Pick a few stable anchors so thread aliases (sha-derived) stay
   // predictable across the scenarios.
@@ -2506,8 +2437,8 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "current turn" }],
     };
-    seedChannelCapabilitiesConversation(slackChannelCaps);
     const { messages } = await applyRuntimeInjections([lastUserMessage], {
+      channelCapabilities: slackChannelCaps,
       slackChronologicalMessages,
     });
     return messages;
@@ -2795,15 +2726,15 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "vellum question" }],
     };
-    seedChannelCapabilitiesConversation({
-      channel: "vellum",
-      dashboardCapable: true,
-      supportsDynamicUi: true,
-      supportsVoiceInput: true,
-    });
     const { messages: result } = await applyRuntimeInjections(
       [lastUserMessage],
       {
+        channelCapabilities: {
+          channel: "vellum",
+          dashboardCapable: true,
+          supportsDynamicUi: true,
+          supportsVoiceInput: true,
+        },
         // Even if we accidentally pass a chronological transcript, the
         // branch must be a no-op for non-slack channels.
         slackChronologicalMessages: [
@@ -2833,16 +2764,16 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "DM question" }],
     };
-    seedChannelCapabilitiesConversation({
-      channel: "slack",
-      dashboardCapable: false,
-      supportsDynamicUi: false,
-      supportsVoiceInput: false,
-      chatType: "im",
-    });
     const { messages: result } = await applyRuntimeInjections(
       [lastUserMessage],
       {
+        channelCapabilities: {
+          channel: "slack",
+          dashboardCapable: false,
+          supportsDynamicUi: false,
+          supportsVoiceInput: false,
+          chatType: "im",
+        },
         slackChronologicalMessages: [
           {
             role: "user",
@@ -2901,10 +2832,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
         ],
       },
     ];
-    seedChannelCapabilitiesConversation(slackCaps);
     const { messages: result } = await applyRuntimeInjections(
       runMessagesWithMemory,
       {
+        channelCapabilities: slackCaps,
         slackChronologicalMessages: [
           {
             role: "user",
@@ -2965,10 +2896,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
         ],
       },
     ];
-    seedChannelCapabilitiesConversation(slackCaps);
     const { messages: result } = await applyRuntimeInjections(
       runMessagesWithMemory,
       {
+        channelCapabilities: slackCaps,
         slackChronologicalMessages: [
           {
             role: "user",
@@ -3004,10 +2935,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       supportsVoiceInput: false,
       chatType: "im",
     };
-    seedChannelCapabilitiesConversation(slackCaps);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "inbound" }] }],
       {
+        channelCapabilities: slackCaps,
         slackChronologicalMessages: [
           {
             role: "user",
@@ -3048,13 +2979,12 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       { loader: () => rows, trustClass: "guardian" },
     );
 
-    seedChannelCapabilitiesConversation(slackChannelCaps, [
-      "thread context: ...",
-    ]);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "current turn" }] }],
       {
+        channelCapabilities: slackChannelCaps,
         slackChronologicalMessages,
+        transportHints: ["thread context: ..."],
       },
     );
 
@@ -3079,10 +3009,12 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       chatType: "im",
     };
 
-    seedChannelCapabilitiesConversation(slackDmCaps, ["dm context: ..."]);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "hi DM" }] }],
-      {},
+      {
+        channelCapabilities: slackDmCaps,
+        transportHints: ["dm context: ..."],
+      },
     );
 
     const allText = result
@@ -3096,19 +3028,18 @@ describe("Slack channel chronological rendering — multi-thread", () => {
 
   // ── transport_hints kept for non-slack channels ───────────────────────
   test("non-slack conversations still receive <transport_hints>", async () => {
-    seedChannelCapabilitiesConversation(
-      {
-        channel: "telegram",
-        dashboardCapable: false,
-        supportsDynamicUi: false,
-        supportsVoiceInput: false,
-        chatType: "private",
-      },
-      ["please answer concisely"],
-    );
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "hi" }] }],
-      {},
+      {
+        channelCapabilities: {
+          channel: "telegram",
+          dashboardCapable: false,
+          supportsDynamicUi: false,
+          supportsVoiceInput: false,
+          chatType: "private",
+        },
+        transportHints: ["please answer concisely"],
+      },
     );
     const allText = result
       .flatMap((m) => m.content)
@@ -3433,8 +3364,8 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       role: "user",
       content: [{ type: "text", text: "current turn" }],
     };
-    seedChannelCapabilitiesConversation(slackChannelCaps);
     const { messages } = await applyRuntimeInjections([lastUserMessage], {
+      channelCapabilities: slackChannelCaps,
       slackChronologicalMessages,
       slackActiveThreadFocusBlock: focusBlock,
     });
@@ -3703,8 +3634,8 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       chatType: "channel",
     };
     const newFocus = "<active_thread>\nnewly built\n</active_thread>";
-    seedChannelCapabilitiesConversation(slackChannelCaps);
     const { messages: reInjected } = await applyRuntimeInjections(stripped, {
+      channelCapabilities: slackChannelCaps,
       slackActiveThreadFocusBlock: newFocus,
     });
     const reInjectedTexts = reInjected
@@ -3724,15 +3655,15 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     // Defensive: the focus injection is gated on `slackChannel` (i.e.
     // `isSlackChannelConversation`). Even if a caller mistakenly forwards
     // a focus block on a non-Slack channel, it must NOT be appended.
-    seedChannelCapabilitiesConversation({
-      channel: "vellum",
-      dashboardCapable: true,
-      supportsDynamicUi: true,
-      supportsVoiceInput: true,
-    });
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "vellum question" }] }],
       {
+        channelCapabilities: {
+          channel: "vellum",
+          dashboardCapable: true,
+          supportsDynamicUi: true,
+          supportsVoiceInput: true,
+        },
         slackActiveThreadFocusBlock: "<active_thread>\nbogus\n</active_thread>",
       },
     );
@@ -3749,16 +3680,16 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     // Same as above but for Slack DMs (chatType === "im"). The focus
     // injection is keyed on `isSlackChannelConversation` which excludes
     // DMs, so the block must not appear.
-    seedChannelCapabilitiesConversation({
-      channel: "slack",
-      dashboardCapable: false,
-      supportsDynamicUi: false,
-      supportsVoiceInput: false,
-      chatType: "im",
-    });
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "DM question" }] }],
       {
+        channelCapabilities: {
+          channel: "slack",
+          dashboardCapable: false,
+          supportsDynamicUi: false,
+          supportsVoiceInput: false,
+          chatType: "im",
+        },
         slackActiveThreadFocusBlock: "<active_thread>\nbogus\n</active_thread>",
       },
     );

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

@@ -1,12 +1,6 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 
-import {
-  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";
 
 // ---------------------------------------------------------------------------
@@ -17,46 +11,6 @@ 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
 // ---------------------------------------------------------------------------
@@ -65,20 +19,15 @@ const sampleContext =
   "<workspace>\nRoot: /sandbox\nDirectories: src, lib, tests\n</workspace>";
 
 // 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.
+// `prepend-user-tail` placement during `applyRuntimeInjections`. The suite
+// below exercises that end-to-end path.
 
 describe("applyRuntimeInjections — workspace top-level context", () => {
-  afterEach(() => {
-    clearConversations();
-  });
-
-  test("injects workspace context when registered", async () => {
-    seedWorkspaceContext(sampleContext);
+  test("injects workspace context when provided", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {});
+    const { messages: result } = await applyRuntimeInjections(messages, {
+      workspaceTopLevelContext: sampleContext,
+    });
 
     expect(result).toHaveLength(1);
     expect(result[0].content).toHaveLength(2);
@@ -86,38 +35,22 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
     expect((result[0].content[1] as { text: string }).text).toBe("Hello");
   });
 
-  test("does not inject when no workspace context is registered", async () => {
+  test("does not inject when workspace context is null", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const { messages: result } = await applyRuntimeInjections(messages, {});
+    const { messages: result } = await applyRuntimeInjections(messages, {
+      workspaceTopLevelContext: null,
+    });
 
     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 () => {
-    registerFallbackConversation({
+    const messages: Message[] = [userMsg("Hello")];
+    const { messages: result } = await applyRuntimeInjections(messages, {
+      activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
       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.
@@ -131,20 +64,16 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
   });
 
   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", {
+    const messages: Message[] = [userMsg("Edit this app")];
+    const { messages: result } = await applyRuntimeInjections(messages, {
+      activeSurface: {
+        surfaceId: "sf_1",
         html: "<div>test</div>",
-        appId: app.id,
-      }),
+        appId: "app-1",
+        appName: "Example App",
+      },
+      workspaceTopLevelContext: null,
     });
-    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"');
@@ -153,14 +82,10 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
 });
 
 describe("applyRuntimeInjections — minimal mode skips workspace blocks", () => {
-  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",
     });
 
@@ -170,12 +95,9 @@ 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",
     });
 
@@ -185,14 +107,11 @@ describe("applyRuntimeInjections — minimal mode skips workspace blocks", () =>
   });
 
   test("full mode (default) still includes workspace blocks", async () => {
-    registerFallbackConversation({
+    const messages: Message[] = [userMsg("Hello")];
+    const { messages: result } = await applyRuntimeInjections(messages, {
       workspaceTopLevelContext: sampleContext,
-      workspaceTopLevelDirty: false,
-      currentActiveSurfaceId: "sf_1",
-      surfaceState: makeSurfaceState("sf_1", { html: "<div>test</div>" }),
+      activeSurface: { surfaceId: "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-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();
-    // Last attempt 30 seconds ago (within the 5-minute cooldown)
-    const recentAttemptAt = now - 30_000;
+    // Generation happened 30 seconds ago (within the 60s cooldown)
+    const recentGenAt = now - 30_000;
     insertStarter({
       label: "Let me check calendar",
       prompt: "Let me check what Alice has today.",
@@ -353,13 +353,9 @@ 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(recentAttemptAt),
+      String(recentGenAt),
     );
     setCheckpoint("conversation_starters:item_count_at_last_gen:default", "1");
     insertMemoryItem();
@@ -379,8 +375,8 @@ describe("GET /v1/conversation-starters", () => {
 
   test("re-enqueues for invalid items after cooldown expires", async () => {
     const now = Date.now();
-    // Last attempt 6 minutes ago (past the 5-minute cooldown)
-    const oldAttemptAt = now - 6 * 60_000;
+    // Generation happened 90 seconds ago (past the 60s cooldown)
+    const oldGenAt = now - 90_000;
     insertStarter({
       label: "Let me check calendar",
       prompt: "Let me check what Alice has today.",
@@ -393,13 +389,9 @@ 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(oldAttemptAt),
+      String(oldGenAt),
     );
     setCheckpoint("conversation_starters:item_count_at_last_gen:default", "1");
     insertMemoryItem();