@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.4

package/src/__tests__/filesystem-tools.test.ts

@@ -125,16 +125,19 @@ describe("FileSystemOps symlink handling", () => {
 });
 
 // ===========================================================================
-// FileSystemOps: read offset/limit edge cases
+// FileSystemOps: read character-window edge cases
 // ===========================================================================
 
-describe("FileSystemOps read offset/limit edge cases", () => {
-  test("offset beyond file length returns empty content", async () => {
+describe("FileSystemOps read character-window edge cases", () => {
+  test("startIndex beyond file length returns empty content", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "short.txt"), "a\nb\nc");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = await ops.readFileSafe({ path: "short.txt", offset: 100 });
+    const result = await ops.readFileSafe({
+      path: "short.txt",
+      startIndex: 100,
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
@@ -142,12 +145,12 @@ describe("FileSystemOps read offset/limit edge cases", () => {
     expect(result.value.content).toBe("");
   });
 
-  test("limit of zero returns empty content", async () => {
+  test("maxChars of zero returns empty content", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "file.txt"), "a\nb\nc");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = await ops.readFileSafe({ path: "file.txt", limit: 0 });
+    const result = await ops.readFileSafe({ path: "file.txt", maxChars: 0 });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
@@ -155,61 +158,57 @@ describe("FileSystemOps read offset/limit edge cases", () => {
     expect(result.value.content).toBe("");
   });
 
-  test("offset=1 reads from first line (1-indexed)", async () => {
+  test("startIndex=0 reads from the first character (0-indexed)", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "file.txt"), "first\nsecond\nthird");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = await ops.readFileSafe({
       path: "file.txt",
-      offset: 1,
-      limit: 1,
+      startIndex: 0,
+      maxChars: 5,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
     }
-    expect(result.value.content).toContain("first");
-    expect(result.value.content).not.toContain("second");
+    const [body] = result.value.content.split("\n\n[Truncated:");
+    expect(body).toBe("first");
   });
 
-  test("limit exceeding file length returns all remaining lines", async () => {
+  test("maxChars exceeding file length returns the rest of the file", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "file.txt"), "a\nb");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = await ops.readFileSafe({
       path: "file.txt",
-      offset: 1,
-      limit: 1000,
+      startIndex: 0,
+      maxChars: 1000,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
     }
-    expect(result.value.content).toContain("a");
-    expect(result.value.content).toContain("b");
+    expect(result.value.content).toBe("a\nb");
   });
 
-  test("read adds line numbers starting from offset", async () => {
+  test("the window starts at startIndex and carries no line numbers", async () => {
     const dir = makeTempDir();
     writeFileSync(join(dir, "file.txt"), "a\nb\nc\nd\ne");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = await ops.readFileSafe({
       path: "file.txt",
-      offset: 3,
-      limit: 2,
+      startIndex: 4,
+      maxChars: 3,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) {
       return;
     }
-    // Lines should be numbered 3 and 4
-    expect(result.value.content).toContain("3");
-    expect(result.value.content).toContain("4");
-    expect(result.value.content).toContain("c");
-    expect(result.value.content).toContain("d");
+    const [body] = result.value.content.split("\n\n[Truncated:");
+    expect(body).toBe("c\nd");
   });
 });
 

package/src/__tests__/gateway-only-guard.test.ts

@@ -83,11 +83,8 @@ function isGatewayInternal(filePath: string): boolean {
 /** Additional files allowed for the interpolated-port check only (use gateway port, not runtime). */
 const INTERPOLATED_PORT_ALLOWLIST = new Set([
   "clients/macos/src/main/bundle-flow.ts",
-  // Electron main bridges the host proxy to a local assistant's gateway
-  // (gatewayPort) over loopback with a Guardian-minted gateway token — same
-  // class as bundle-flow.ts. Added with #34049 (host proxy for cloud/managed
-  // assistants); the allowlist entry was missed there.
-  "clients/macos/src/main/host-proxy-router.ts",
+  // Desktop clients connect to local assistants through their loopback gateway.
+  "packages/electron-desktop/src/host-proxy/router.ts",
 ]);
 
 /** Shared violation filter: exempt test files, gateway internals, and allowlisted paths. */

package/src/__tests__/host-file-read-tool.test.ts

@@ -27,7 +27,7 @@ mock.module("../daemon/host-file-proxy.js", () => ({
 }));
 
 import { hostFileReadTool } from "../tools/host-filesystem/read.js";
-import { DEFAULT_READ_LINE_LIMIT } from "../tools/shared/filesystem/file-ops-service.js";
+import { READ_CHAR_BUDGET } from "../tools/shared/filesystem/file-ops-service.js";
 import type { ToolContext } from "../tools/types.js";
 
 const testDirs: string[] = [];
@@ -77,19 +77,19 @@ describe("host_file_read tool", () => {
     expect(result.content).toContain("must be absolute");
   });
 
-  test("reads file with line numbers", async () => {
+  test("reads a character window", async () => {
     const dir = mkdtempSync(join(tmpdir(), "host-file-read-test-"));
     testDirs.push(dir);
     const filePath = join(dir, "sample.txt");
     writeFileSync(filePath, "first\nsecond\nthird\n");
 
     const result = await hostFileReadTool.execute(
-      { path: filePath, offset: 2, limit: 2 },
+      { path: filePath, start_index: 6, max_chars: 6 },
       makeContext(),
     );
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("2  second");
-    expect(result.content).toContain("3  third");
+    expect(result.content).toContain("second");
+    expect(result.content).not.toContain("first");
   });
 
   test("returns error when file does not exist", async () => {
@@ -128,7 +128,7 @@ describe("host_file_read tool", () => {
     expect(result.content).toContain('Invalid input for tool "host_file_read"');
   });
 
-  test("reads entire file when no offset or limit specified", async () => {
+  test("reads the whole file when no window is specified", async () => {
     const dir = mkdtempSync(join(tmpdir(), "host-file-read-test-"));
     testDirs.push(dir);
     const filePath = join(dir, "full.txt");
@@ -139,9 +139,7 @@ describe("host_file_read tool", () => {
       makeContext(),
     );
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("1  line1");
-    expect(result.content).toContain("2  line2");
-    expect(result.content).toContain("3  line3");
+    expect(result.content).toBe("line1\nline2\nline3\n");
   });
 
   test("handles empty file", async () => {
@@ -157,20 +155,19 @@ describe("host_file_read tool", () => {
     expect(result.isError).toBe(false);
   });
 
-  test("offset starts from the correct line (1-indexed)", async () => {
+  test("start_index is 0-indexed", async () => {
     const dir = mkdtempSync(join(tmpdir(), "host-file-read-test-"));
     testDirs.push(dir);
     const filePath = join(dir, "lines.txt");
     writeFileSync(filePath, "a\nb\nc\nd\ne\n");
 
     const result = await hostFileReadTool.execute(
-      { path: filePath, offset: 3, limit: 1 },
+      { path: filePath, start_index: 4, max_chars: 1 },
       makeContext(),
     );
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("3  c");
-    expect(result.content).not.toContain("2  b");
-    expect(result.content).not.toContain("4  d");
+    const [body] = result.content.split("\n\n[Truncated:");
+    expect(body).toBe("c");
   });
 
   test("reads a file with symlinks resolved", async () => {
@@ -228,15 +225,15 @@ describe("host_file_read image support", () => {
     expect(result.isError).toBe(false);
     expect(result.contentBlocks).toHaveLength(1);
     // The proxied request carries the resolved default window, so a host read
-    // is bounded by the same limit as a local one rather than streaming a
+    // is bounded by the same budget as a local one rather than streaming a
     // whole file across the bridge.
     expect(requests).toEqual([
       {
         input: {
           operation: "read",
           path: "/host/screenshot.png",
-          offset: undefined,
-          limit: DEFAULT_READ_LINE_LIMIT,
+          startIndex: undefined,
+          maxChars: READ_CHAR_BUDGET,
         },
         conversationId: "test-conversation",
         signal: undefined,
@@ -306,8 +303,8 @@ describe("host_file_read image support", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain("1  hello world");
-    expect(result.content).toContain("2  second line");
+    expect(result.content).toContain("hello world");
+    expect(result.content).toContain("second line");
     expect((result as any).contentBlocks).toBeUndefined();
   });
 

package/src/__tests__/http-user-message-parity.test.ts

@@ -189,7 +189,7 @@ const _testAuthContext: AuthContext = {
 function makeConversation(overrides: Record<string, unknown> = {}) {
   return {
     setTrustContext: () => {},
-    updateClient: () => {},
+    replayActivityState: () => {},
     setHostBrowserProxy: () => {},
     setHostCuProxy: () => {},
     setHostAppControlProxy: () => {},

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -11,6 +11,7 @@ import {
   clearFeatureFlagOverridesCache,
   initFeatureFlagOverrides,
   isAssistantFeatureFlagEnabled,
+  refreshOverridesFromGateway,
 } from "../config/assistant-feature-flags.js";
 import { mockGatewayIpc, resetMockGatewayIpc } from "./mock-gateway-ipc.js";
 
@@ -110,3 +111,51 @@ describe("initFeatureFlagOverrides", () => {
     expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(false);
   });
 });
+
+describe("refreshOverridesFromGateway", () => {
+  it("replaces the cache with the new gateway values", async () => {
+    mockGatewayIpc({ "moving-flag": true });
+    await initFeatureFlagOverrides();
+
+    resetMockGatewayIpc();
+    mockGatewayIpc({ "moving-flag": false });
+
+    expect(await refreshOverridesFromGateway()).toBe(true);
+
+    const config = {} as any;
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(false);
+  });
+
+  it("keeps the last known values when the refresh fails", async () => {
+    mockGatewayIpc({ "moving-flag": true });
+    await initFeatureFlagOverrides();
+
+    resetMockGatewayIpc();
+    mockGatewayIpc(null, { error: true });
+
+    expect(await refreshOverridesFromGateway()).toBe(false);
+
+    // A failed refresh must not drop the flag to its registry default: a
+    // value the assistant selects behavior from (an experiment arm, a kill
+    // switch) would otherwise flip on one timed-out IPC call.
+    const config = {} as any;
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(true);
+  });
+
+  it("keeps the cache readable for the whole call", async () => {
+    mockGatewayIpc({ "moving-flag": true });
+    await initFeatureFlagOverrides();
+
+    resetMockGatewayIpc();
+    mockGatewayIpc({ "moving-flag": false });
+
+    const config = {} as any;
+    const inFlight = refreshOverridesFromGateway();
+    // A sync read landing mid-refresh sees the previous values, never an
+    // empty cache.
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(true);
+
+    await inFlight;
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(false);
+  });
+});

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -47,6 +47,9 @@ import { skillLoadTool } from "../tools/skills/load.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
+/** scaffold_managed_skill requires activation hints; a fixed set for tests. */
+const HINTS = ["user asks to run the lifecycle test procedure"];
+
 function makeContext(): ToolContext {
   return {
     workingDir: "/tmp",
@@ -126,6 +129,7 @@ Run the custom lifecycle verification procedure.
         name: "Lifecycle Test",
         description: "Integration test skill.",
         body_markdown: "Run the lifecycle test procedure.",
+        activation_hints: HINTS,
         emoji: "🧪",
       },
       makeContext(),
@@ -185,6 +189,7 @@ Run the custom lifecycle verification procedure.
         name: "V1",
         description: "Version 1.",
         body_markdown: "Original body.",
+        activation_hints: HINTS,
       },
       ctx,
     );
@@ -196,6 +201,7 @@ Run the custom lifecycle verification procedure.
         name: "V2",
         description: "Version 2.",
         body_markdown: "Updated body.",
+        activation_hints: HINTS,
         overwrite: true,
       },
       ctx,
@@ -241,6 +247,7 @@ Run the custom lifecycle verification procedure.
         description: "Created from scaffold.",
         body_markdown:
           "This skill was dynamically created.\n\nRun: `echo chain-test-ok`",
+        activation_hints: HINTS,
       },
       ctx,
     );

package/src/__tests__/media-generate-image.test.ts

@@ -1,6 +1,14 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { readFileSync } from "fs";
+import {
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "fs";
+import { tmpdir } from "os";
 import { dirname, join } from "path";
 
 import { __resetRegistryForTesting, getTool } from "../tools/registry.js";
@@ -97,8 +105,23 @@ import { run } from "../config/bundled-skills/image-studio/tools/media-generate-
 // Clean up after this file to prevent contamination of later test files.
 afterAll(() => {
   __resetRegistryForTesting();
+  for (const dir of tempWorkingDirs) {
+    rmSync(dir, { recursive: true, force: true });
+  }
 });
 
+const tempWorkingDirs: string[] = [];
+
+/** Build a ToolContext with a fresh temp working directory. */
+function makeContext(): ToolContext {
+  const workingDir = mkdtempSync(join(tmpdir(), "media-gen-test-"));
+  tempWorkingDirs.push(workingDir);
+  return {
+    conversationId: "conv-123",
+    workingDir,
+  } as unknown as ToolContext;
+}
+
 const CONFIG_DIR = join(
   dirname(import.meta.dirname!),
   "config",
@@ -128,12 +151,10 @@ beforeEach(() => {
     platformBaseUrl: "",
     assistantApiKey: "",
   };
+  fakeContext = makeContext();
 });
 
-const fakeContext = {
-  conversationId: "conv-123",
-  workingDir: "/tmp",
-} as unknown as ToolContext;
+let fakeContext: ToolContext;
 
 describe("image-studio skill script wrapper", () => {
   test("exports a run function without registering media_generate_image in the tool registry", async () => {
@@ -431,28 +452,117 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("reads source images from file paths on disk", async () => {
-    // Write a temp image file inside the workspace (fakeContext.workingDir = /tmp)
-    const tmpPath = join("/tmp", "test-source-image.png");
+    // Write a temp image file inside the workspace
+    const tmpPath = join(fakeContext.workingDir, "test-source-image.png");
     const pngBytes = Buffer.from(
       "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==",
       "base64",
     );
     await Bun.write(tmpPath, pngBytes);
 
-    try {
-      const result = await run(
-        { prompt: "edit this", mode: "edit", source_paths: [tmpPath] },
-        fakeContext,
-      );
-
-      expect(result.isError).toBe(false);
-      expect(result.content).toContain("Generated 1 image");
-    } finally {
-      const { unlink } = await import("fs/promises");
-      if (await Bun.file(tmpPath).exists()) {
-        await unlink(tmpPath);
-      }
-    }
+    const result = await run(
+      { prompt: "edit this", mode: "edit", source_paths: [tmpPath] },
+      fakeContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Generated 1 image");
+  });
+
+  test("saves the image into media/generated and returns the embed instruction", async () => {
+    const result = await run({ prompt: "a sunset" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Saved to media/generated/a-sunset.png");
+    expect(result.content).toContain(
+      "![description](vellum://workspace/media/generated/a-sunset.png)",
+    );
+    const saved = Bun.file(
+      join(fakeContext.workingDir, "media/generated/a-sunset.png"),
+    );
+    expect(await saved.exists()).toBe(true);
+    const bytes = Buffer.from(await saved.arrayBuffer());
+    expect(bytes.equals(Buffer.from("generated-data", "base64"))).toBe(true);
+  });
+
+  test("uses the image title for the filename when present", async () => {
+    mockGenerateResult = {
+      images: [
+        {
+          mimeType: "image/png",
+          dataBase64: "img1",
+          title: "Twilight Gremlin!",
+        } as never,
+      ],
+      text: "",
+      resolvedModel: "gemini-3.1-flash-image-preview",
+    };
+
+    const result = await run({ prompt: "a pond creature" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain(
+      "Saved to media/generated/twilight-gremlin.png",
+    );
+  });
+
+  test("gives each variant a distinct filename", async () => {
+    mockGenerateResult = {
+      images: [
+        { mimeType: "image/png", dataBase64: "img1" },
+        { mimeType: "image/png", dataBase64: "img2" },
+      ],
+      text: undefined as unknown as string,
+      resolvedModel: "gemini-3.1-flash-image-preview",
+    };
+
+    const result = await run({ prompt: "a robot", variants: 2 }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("- media/generated/a-robot.png");
+    expect(result.content).toContain("- media/generated/a-robot-2.png");
+    expect(
+      await Bun.file(
+        join(fakeContext.workingDir, "media/generated/a-robot-2.png"),
+      ).exists(),
+    ).toBe(true);
+  });
+
+  test("suffixes the filename when a previous generation already used it", async () => {
+    const first = await run({ prompt: "a fox" }, fakeContext);
+    expect(first.content).toContain("Saved to media/generated/a-fox.png");
+
+    const second = await run({ prompt: "a fox" }, fakeContext);
+    expect(second.content).toContain("Saved to media/generated/a-fox-2.png");
+  });
+
+  test("refuses to write through a symlink that escapes the workspace", async () => {
+    const outside = mkdtempSync(join(tmpdir(), "media-gen-outside-"));
+    tempWorkingDirs.push(outside);
+    symlinkSync(outside, join(fakeContext.workingDir, "media"));
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Could not save to the workspace");
+    expect(result.content).not.toContain("vellum://workspace/");
+    expect(readdirSync(outside)).toEqual([]);
+  });
+
+  test("falls back to inline-only when the workspace write fails", async () => {
+    // Occupy the media path with a regular file so the directory creation
+    // under it fails.
+    writeFileSync(join(fakeContext.workingDir, "media"), "not a directory");
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Could not save to the workspace");
+    expect(result.content).toContain(
+      "will be attached to your reply automatically",
+    );
+    expect(result.content).not.toContain("vellum://workspace/");
+    expect(result.contentBlocks).toHaveLength(1);
   });
 
   test("returns error when all source_paths are invalid", async () => {

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -64,9 +64,13 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: broadcastMessageMock,
 }));
 
-import type { UserPromptSubmitContext } from "@vellumai/plugin-api";
+import {
+  type UserPromptSubmitContext,
+  VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+} from "@vellumai/plugin-api";
 
 import type { AssistantEvent } from "../api/index.js";
+import { ESCALATION_CONTINUATION_CONTENT } from "../calls/voice-triage-escalate.js";
 import type { AssistantConfig } from "../config/schema.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { QdrantSparseVector } from "../persistence/embeddings/qdrant-client.js";
@@ -74,6 +78,7 @@ import type { ConversationGraphMemory } from "../plugins/defaults/memory/graph/c
 import userPromptSubmitMemoryRetrieval from "../plugins/defaults/memory/hooks/user-prompt-submit.js";
 import type { Message } from "../providers/types.js";
 import { asConversation } from "./helpers/mock-conversation.js";
+import { setConfig } from "./helpers/set-config.js";
 
 /** Canonical metrics payload the graph retriever attaches to a real hit. */
 function makeMetrics() {
@@ -175,13 +180,14 @@ function installConversation(
     trusted?: boolean;
     abortController?: AbortController;
   },
-): void {
+): Conversation {
   currentTrustClass = opts?.trusted === false ? "unknown" : "guardian";
   currentConversation = asConversation({
     graphMemory,
     trustContext: undefined,
     abortController: opts?.abortController ?? new AbortController(),
   });
+  return currentConversation;
 }
 
 beforeEach(() => {
@@ -192,9 +198,95 @@ beforeEach(() => {
   broadcastMessageMock.mockReset();
   currentConversation = undefined;
   currentTrustClass = "guardian";
+  setConfig("memory", { enabled: true, v3: { live: false } });
 });
 
 describe("user-prompt-submit hook (memory retrieval)", () => {
+  test("voice front door skips serial legacy retrieval", async () => {
+    const { memory, prepareMemoryMock, recordPkbQueryVectorsMock } =
+      makeFakeGraphMemory();
+    const conversation = installConversation(memory, { trusted: true });
+    conversation.currentCallSite = "voiceFrontDoor";
+    const ctx = makeHookCtx({ conversationId: "conv-voice" });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).not.toHaveBeenCalled();
+    expect(recordPkbQueryVectorsMock).toHaveBeenCalledWith(
+      undefined,
+      undefined,
+    );
+    expect(applyRuntimeInjectionsMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("voice escalation continuation routes legacy retrieval on the preceding user message", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    installConversation(memory, { trusted: true });
+    const latestMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<info>\ncarried context\n</info>" },
+          {
+            type: "text",
+            text: "<turn_context>\nturn context\n</turn_context>",
+          },
+          { type: "text", text: "What is my preferred editor?" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Let me check that." }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "Continue the answer." }],
+      },
+    ];
+    const ctx = makeHookCtx({
+      latestMessages,
+      isHiddenPrompt: true,
+      prompt: ESCALATION_CONTINUATION_CONTENT,
+      messageKind: VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+    });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).toHaveBeenCalledTimes(1);
+    expect(prepareMemoryMock.mock.calls[0]?.[0]).toBe(latestMessages);
+    expect(prepareMemoryMock.mock.calls[0]?.[4]).toEqual([
+      {
+        role: "user",
+        content: [{ type: "text", text: "What is my preferred editor?" }],
+      },
+    ]);
+  });
+
+  test("generic hidden prompts route legacy retrieval on their own content", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    installConversation(memory, { trusted: true });
+    const latestMessages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "Visible caller message" }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "Hidden prompt content" }],
+      },
+    ];
+    const ctx = makeHookCtx({
+      latestMessages,
+      isHiddenPrompt: true,
+      prompt: "Hidden prompt content",
+    });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).toHaveBeenCalledTimes(1);
+    expect(prepareMemoryMock.mock.calls[0]?.[4]).toBe(latestMessages);
+  });
+
   test("adopts the injected run messages when the actor is trusted", async () => {
     const injected: Message[] = [
       { role: "user", content: [{ type: "text", text: "injected" }] },