@vellumai/assistant 0.8.8 → 0.8.9-staging.2

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

@@ -1,6 +1,12 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, 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";
 
 // ---------------------------------------------------------------------------
@@ -11,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
 // ---------------------------------------------------------------------------
@@ -19,14 +65,21 @@ 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`. The suite
-// below exercises that end-to-end path.
+// `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", () => {
-  test("injects workspace context when provided", async () => {
+  afterEach(() => {
+    clearConversations();
+  });
+
+  test("injects workspace context when registered", async () => {
+    seedWorkspaceContext(sampleContext);
     const messages: Message[] = [userMsg("Hello")];
     const { messages: result } = await applyRuntimeInjections(messages, {
-      workspaceTopLevelContext: sampleContext,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     expect(result).toHaveLength(1);
@@ -35,21 +88,43 @@ 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,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     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, {
+      conversationId: FALLBACK_CONVERSATION_ID,
+    });
+
+    // 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({
+      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, {
-      activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
-      workspaceTopLevelContext: sampleContext,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     // Workspace is injected last (in applyRuntimeInjections order) so it
@@ -64,15 +139,21 @@ 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", {
+        html: "<div>test</div>",
+        appId: app.id,
+      }),
+    });
     const messages: Message[] = [userMsg("Edit this app")];
     const { messages: result } = await applyRuntimeInjections(messages, {
-      activeSurface: {
-        surfaceId: "sf_1",
-        html: "<div>test</div>",
-        appId: "app-1",
-        appName: "Example App",
-      },
-      workspaceTopLevelContext: null,
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     const activeWorkspaceText = (result[0].content[0] as { text: string }).text;
@@ -82,10 +163,15 @@ 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,
+      conversationId: FALLBACK_CONVERSATION_ID,
       mode: "minimal",
     });
 
@@ -95,9 +181,13 @@ 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>" },
+      conversationId: FALLBACK_CONVERSATION_ID,
       mode: "minimal",
     });
 
@@ -107,10 +197,15 @@ describe("applyRuntimeInjections — minimal mode skips workspace blocks", () =>
   });
 
   test("full mode (default) still includes workspace blocks", async () => {
+    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, {
-      workspaceTopLevelContext: sampleContext,
-      activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
+      conversationId: FALLBACK_CONVERSATION_ID,
     });
 
     expect(result[0].content).toHaveLength(3);

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

@@ -156,6 +156,7 @@ mock.module("../memory/retriever.js", () => ({
 mock.module("../context/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -221,10 +222,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void | Promise<void>,
-    ): Promise<AgentLoopRunResult> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void | Promise<void>;
+    }): Promise<AgentLoopRunResult> {
+      const { messages, onEvent } = options;
       const history = await new Promise<Message[]>((resolve) => {
         pendingRuns.push({ resolve, messages, onEvent });
       });

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

@@ -157,6 +157,7 @@ mock.module("../memory/retriever.js", () => ({
 mock.module("../context/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -245,10 +246,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-    ): Promise<Message[]> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
+      const { messages, onEvent } = options;
       // Prime the assistant row anchor — production code emits this from
       // `AgentLoop.run` just before `provider.sendMessage`.
       await onEvent({ type: "llm_call_started" });

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

@@ -173,6 +173,7 @@ mock.module("../memory/retriever.js", () => ({
 mock.module("../context/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -198,11 +199,11 @@ let lastAgentLoopConfig: Partial<AgentLoopConfig> | undefined;
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
     compactionCircuit = new CompactionCircuit("test-conv");
-    constructor(
-      _provider: unknown,
-      _systemPrompt: string,
-      options?: { config?: Partial<AgentLoopConfig> },
-    ) {
+    constructor(options?: {
+      provider?: unknown;
+      systemPrompt?: string;
+      config?: Partial<AgentLoopConfig>;
+    }) {
       lastAgentLoopConfig = options?.config;
     }
     getToolTokenBudget() {
@@ -214,10 +215,10 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      _messages: Message[],
-      _onEvent: (event: AgentEvent) => void,
-    ): Promise<Message[]> {
+    async run(_options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
       return [];
     }
   },

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();

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -140,6 +140,7 @@ mock.module("../memory/retrieval-budget.js", () => ({
 mock.module("../context/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -176,10 +177,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-    ): Promise<Message[]> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
+      const { messages, onEvent } = options;
       const assistantMessage: Message = {
         role: "assistant",
         content: [{ type: "text", text: "ok" }],
@@ -198,6 +200,7 @@ mock.module("../agent/loop.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import { refreshWorkspaceTopLevelContextIfNeeded } from "../daemon/conversation-workspace.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -249,7 +252,7 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("refreshWorkspaceTopLevelContextIfNeeded populates context and clears dirty", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
     expect(conversation.getWorkspaceTopLevelContext()).not.toBeNull();
@@ -265,10 +268,10 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("refreshWorkspaceTopLevelContextIfNeeded no-ops when not dirty and cache exists", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     const first = conversation.getWorkspaceTopLevelContext();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     const second = conversation.getWorkspaceTopLevelContext();
 
     // Same reference — no recomputation
@@ -276,7 +279,7 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("markWorkspaceTopLevelDirty sets dirty flag", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     conversation.markWorkspaceTopLevelDirty();
@@ -284,10 +287,10 @@ describe("Conversation workspace cache state", () => {
   });
 
   test("refresh after marking dirty produces fresh context", () => {
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     conversation.markWorkspaceTopLevelDirty();
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     expect(conversation.getWorkspaceTopLevelContext()).not.toBeNull();
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
@@ -299,7 +302,7 @@ describe("Conversation workspace cache state", () => {
   test("renders client-reported host env when set on the conversation", () => {
     conversation.hostHomeDir = "/Users/alice";
     conversation.hostUsername = "alice";
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -309,7 +312,7 @@ describe("Conversation workspace cache state", () => {
 
   test("falls back to daemon os info when client host env is absent", async () => {
     const { homedir, userInfo } = await import("node:os");
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -320,7 +323,7 @@ describe("Conversation workspace cache state", () => {
   test("re-renders with updated host env after marking dirty", () => {
     conversation.hostHomeDir = "/Users/alice";
     conversation.hostUsername = "alice";
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
       "Host home directory: /Users/alice",
     );
@@ -328,7 +331,7 @@ describe("Conversation workspace cache state", () => {
     conversation.hostHomeDir = "/Users/bob";
     conversation.hostUsername = "bob";
     conversation.markWorkspaceTopLevelDirty();
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -344,7 +347,7 @@ describe("Conversation workspace cache state", () => {
     // Simulate a macOS turn populating host env.
     conversation.hostHomeDir = "/Users/alice";
     conversation.hostUsername = "alice";
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.getWorkspaceTopLevelContext()!).toContain(
       "Host home directory: /Users/alice",
     );
@@ -355,7 +358,7 @@ describe("Conversation workspace cache state", () => {
     conversation.hostHomeDir = undefined;
     conversation.hostUsername = undefined;
     conversation.markWorkspaceTopLevelDirty();
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
 
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block).not.toBeNull();
@@ -381,7 +384,7 @@ describe("Conversation workspace cache state", () => {
     expect(conversation.hostUsername).toBe("alice");
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(true);
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     const block = conversation.getWorkspaceTopLevelContext();
     expect(block!).toContain("Host home directory: /Users/alice");
     expect(block!).toContain("Host username: alice");
@@ -455,7 +458,7 @@ describe("Conversation workspace cache state", () => {
       hostUsername: "alice",
     });
     // Render once so the dirty flag clears.
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     // Re-apply the same values — dirty flag should remain false so we don't
@@ -476,7 +479,7 @@ describe("Conversation workspace cache state", () => {
       hostHomeDir: "/Users/alice",
       hostUsername: "alice",
     });
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     // New values — should mark dirty so the next render picks them up.
@@ -500,7 +503,7 @@ describe("Conversation workspace cache state", () => {
 
     try {
       const tempConversation = makeConversation(workspaceRoot);
-      tempConversation.refreshWorkspaceTopLevelContextIfNeeded();
+      refreshWorkspaceTopLevelContextIfNeeded(tempConversation);
 
       expect(tempConversation.getWorkspaceTopLevelContext()!).toContain(
         `Current conversation attachments: conversations/${legacyDirName}/attachments/`,

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

@@ -144,7 +144,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
   setLastNotifiedInferenceProfile: () => {},
-  getConversationOverrideProfileFromRow: () => undefined,
+  resolveOverrideProfile: () => undefined,
   updateMessageMetadata: () => {},
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
   updateMessageContent: mock(() => {}),
@@ -183,6 +183,7 @@ mock.module("../memory/retrieval-budget.js", () => ({
 }));
 mock.module("../context/window-manager.js", () => ({
   ContextWindowManager: class {
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -244,10 +245,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-    ): Promise<AgentLoopRunResult> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<AgentLoopRunResult> {
+      const { messages, onEvent } = options;
       // Prime the assistant row anchor — production code emits this from
       // `AgentLoop.run` just before `provider.sendMessage`.
       await onEvent({ type: "llm_call_started" });
@@ -295,6 +297,14 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import {
+  clearConversations,
+  findConversation,
+  removeSubagentConversation,
+  setConversation,
+  setSubagentConversation,
+} from "../daemon/conversation-registry.js";
+import { resolveWorkspaceTopLevelContext } from "../daemon/conversation-workspace.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 
 function makeConversation(): Conversation {
@@ -309,7 +319,7 @@ function makeConversation(): Conversation {
       };
     },
   };
-  return new Conversation(
+  const conversation = new Conversation(
     "conv-1",
     provider,
     "system prompt",
@@ -317,6 +327,10 @@ function makeConversation(): Conversation {
     "/tmp",
     { maxTokens: 4096 },
   );
+  // Mirror production: top-level conversations are registered in the store, so
+  // the workspace injector can resolve them by id via the conversation registry.
+  setConversation(conversation.conversationId, conversation);
+  return conversation;
 }
 
 function messageText(message: Message): string {
@@ -335,6 +349,7 @@ describe("Conversation workspace injection", () => {
     runCalls = [];
     agentLoopScript = () => {};
     scanCallCount = 0;
+    clearConversations();
     resetPluginRegistryAndRegisterDefaults();
   });
 
@@ -417,11 +432,58 @@ describe("Conversation workspace injection", () => {
   });
 });
 
+describe("Conversation workspace injection — subagents", () => {
+  beforeEach(() => {
+    scanCallCount = 0;
+    clearConversations();
+    resetPluginRegistryAndRegisterDefaults();
+  });
+
+  test("workspace context resolves for subagent conversations not in the store", () => {
+    const provider = {
+      name: "mock",
+      async sendMessage(): Promise<ProviderResponse> {
+        return {
+          content: [],
+          model: "mock",
+          usage: { inputTokens: 0, outputTokens: 0 },
+          stopReason: "end_turn",
+        };
+      },
+    };
+    const subagentId = "subagent-conv-1";
+    const conversation = new Conversation(
+      subagentId,
+      provider,
+      "system prompt",
+      () => {},
+      "/tmp",
+      { maxTokens: 4096 },
+    );
+    setSubagentConversation(subagentId, conversation);
+
+    try {
+      // Subagents live only in the manager's index, never in the
+      // eviction-managed store, so the store lookup must not see them.
+      expect(findConversation(subagentId)).toBeUndefined();
+
+      // The per-conversation workspace lookup still resolves them, so subagent
+      // turns retain workspace grounding.
+      const context = resolveWorkspaceTopLevelContext(subagentId);
+      expect(context).not.toBeNull();
+      expect(context).toContain("Root: /tmp");
+    } finally {
+      removeSubagentConversation(subagentId, conversation);
+    }
+  });
+});
+
 describe("Conversation workspace dirty-refresh E2E", () => {
   beforeEach(() => {
     runCalls = [];
     agentLoopScript = () => {};
     scanCallCount = 0;
+    clearConversations();
     resetPluginRegistryAndRegisterDefaults();
   });