diff --git a/CHANGELOG.md b/CHANGELOG.md
index fb0b77747..947185fab 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,39 @@ See [`RELEASE.md`](RELEASE.md) for publication and verification procedures.
 
 ## [Unreleased]
 
+- Personal chat keeps its admitted provider and credential when marketplace
+  availability changes. Already-admitted direct calls skip Surplus discovery,
+  and protected Memory retains its approved marketplace embedding disclosure.
+
+- Surplus model selection and requests now use its live catalogue for confirmed
+  model names, capabilities, reasoning parameters, and token limits. Auto skips
+  unconfirmed routes, and chat and Soul share the same marketplace budget.
+  Responses with an adapted output ceiling are accepted when they finish
+  naturally and reported output stays within the original request budget.
+
+- Onboarding waits for an in-progress Soul before saving the final profile,
+  and automatic foreground chat selection supports Surplus-only servers.
+
+- Invite room pickers now list only public rooms and exclude external rooms.
+
+- Web Genie customization now loads the default shell avatar correctly instead
+  of showing a missing-image error and requiring a replacement.
+
+- Surplus-only chat can use available sellers for eligible ordinary models,
+  preserves streamed tool calls, and respects qualified marketplace output
+  limits. Missing recovery keys retain the original marketplace failure;
+  pre-routing error traces no longer become pending cost receipts.
+
+- Embeddings can use Surplus with an explicit Venice text-embedding-3-large
+  selection and Prefer Surplus enabled. Protected Memory shows and binds the
+  processing route before saving or searching, and usage receipts track
+  marketplace costs without replaying provider requests.
+
+- Soul generation supports a server Surplus key without a direct provider key,
+  including streamed customization previews and service cost tracking. Eligible
+  Surplus-only requests let the marketplace choose an available seller and can
+  recover from confirmed supply refusals through other eligible models.
+
 - Operators can connect a selected Genie to mAgent through a private Unix socket,
   with a fresh external-context Room and a fixed sponsor and sender identity.
 
diff --git a/apps/desktop/electron/foreground-shadow-controller.ts b/apps/desktop/electron/foreground-shadow-controller.ts
index 08396ab99..1717005cb 100644
--- a/apps/desktop/electron/foreground-shadow-controller.ts
+++ b/apps/desktop/electron/foreground-shadow-controller.ts
@@ -1,4 +1,8 @@
-import type { NautiloApiClient, ProtectedMemoryProjectionV1 } from "@nautilo/api-client";
+import { type NautiloApiClient, type ProtectedMemoryProjectionV1 } from "@nautilo/api-client";
+import {
+  sameMemoryEmbeddingDisclosureV2,
+  type MemoryEmbeddingDisclosureV2,
+} from "@nautilo/lattice-crypto/wire";
 import type {
   TaskOperationRunResultReadV1,
   TaskOperationRunTranscriptReadV1,
@@ -743,18 +747,27 @@ export class ElectronForegroundShadowController {
     type: string;
     content: string;
     importance: number;
+    requestedEmbedding?: MemoryEmbeddingDisclosureV2;
   }>) {
     return this.#runMemory(async () => {
-      const recipient = await this.#api.getMemoryProcessorRecipient();
-      if (recipient.embedding === undefined) {
-        throw new TypeError("Memory embedding is unavailable");
+      const embedding = input.requestedEmbedding === undefined
+        ? (await this.#api.getMemoryProcessorRecipient()).embedding
+        : (await this.#api.getMemoryProcessorRecipientV2()).embedding;
+      if (embedding === undefined) throw new TypeError("Memory embedding is unavailable");
+      if (input.requestedEmbedding !== undefined
+        && (!("canonicalSpace" in embedding)
+          || !sameMemoryEmbeddingDisclosureV2(input.requestedEmbedding, embedding))) {
+        throw new TypeError(
+          "The Memory embedding disclosure changed. Reload it before trying again.",
+        );
       }
       let item: unknown;
       const receipt = await this.#humanMemory.update(input.memoryId, {
         payload: { formatVersion: 1, type: input.type, content: input.content },
         importance: input.importance,
-        requestedProvider: recipient.embedding.provider,
-        requestedModel: recipient.embedding.model,
+        ...("canonicalSpace" in embedding
+          ? { requestedEmbedding: input.requestedEmbedding! }
+          : { requestedProvider: embedding.provider, requestedModel: embedding.model }),
       }, (opened) => {
         item = protectedOpenedMemory(opened);
       });
diff --git a/apps/desktop/electron/main.ts b/apps/desktop/electron/main.ts
index 517d9c412..4bd09db21 100644
--- a/apps/desktop/electron/main.ts
+++ b/apps/desktop/electron/main.ts
@@ -1,4 +1,9 @@
 import { createChatGPTDesktopListener } from "./chatgpt-plan-loopback";
+import {
+  assertMemoryEmbeddingDisclosureV2,
+  decodeMemoryEmbeddingDisclosureV2,
+  encodeMemoryEmbeddingDisclosureV2,
+} from "@nautilo/lattice-crypto/wire";
 import "./instance-argv-bootstrap.ts";
 import { LOCAL_EXECUTION_MAX_IDENTITIES } from "@nautilo/relay";
 import { developmentProfileScope, projectAgentAccess, selectionForAgentAccess, selectionForReadyComponents } from "./agent-access";
@@ -8601,10 +8606,21 @@ ipcMain.handle("foregroundShadow:memory:list", async (e, raw: unknown) => {
 });
 
 ipcMain.handle("foregroundShadow:memory:search", async (e, raw: unknown) => {
-  const options = boundedForegroundShadowValue(raw, "Protected Memory search") as
-    Parameters<ElectronForegroundShadowController["memorySearch"]>[0];
+  const value = boundedForegroundShadowValue(raw, "Protected Memory search") as
+    Parameters<ElectronForegroundShadowController["memorySearch"]>[0] & {
+      embeddingDisclosure?: unknown;
+    };
+  let embeddingDisclosure;
+  if (value.embeddingDisclosure !== undefined) {
+    assertMemoryEmbeddingDisclosureV2(value.embeddingDisclosure);
+    embeddingDisclosure = decodeMemoryEmbeddingDisclosureV2(
+      encodeMemoryEmbeddingDisclosureV2(value.embeddingDisclosure),
+    );
+  }
+  const { embeddingDisclosure: _untrustedEmbedding, ...options } = value;
   const { controller } = await foregroundShadowControllerForSender(e);
-  return controller.memorySearch(options);
+  return controller.memorySearch({ ...options,
+    ...(embeddingDisclosure === undefined ? {} : { embeddingDisclosure }) });
 });
 
 ipcMain.handle("foregroundShadow:memory:detail", async (e, raw: unknown) => {
@@ -8618,12 +8634,21 @@ ipcMain.handle("foregroundShadow:memory:detail", async (e, raw: unknown) => {
 ipcMain.handle("foregroundShadow:memory:update", async (e, raw: unknown) => {
   const value = boundedForegroundShadowValue(raw, "Protected Memory update") as {
     memoryId?: unknown; type?: unknown; content?: unknown; importance?: unknown;
+    requestedEmbedding?: unknown;
   };
+  let requestedEmbedding;
+  if (value.requestedEmbedding !== undefined) {
+    assertMemoryEmbeddingDisclosureV2(value.requestedEmbedding);
+    requestedEmbedding = decodeMemoryEmbeddingDisclosureV2(
+      encodeMemoryEmbeddingDisclosureV2(value.requestedEmbedding),
+    );
+  }
   const input = Object.freeze({
     memoryId: foregroundShadowString(value.memoryId, "Memory id", 200),
     type: foregroundShadowString(value.type, "Memory type", 4_096),
     content: foregroundShadowString(value.content, "Memory content", 65_536),
     importance: value.importance,
+    ...(requestedEmbedding === undefined ? {} : { requestedEmbedding }),
   });
   if (typeof input.importance !== "number" || !Number.isFinite(input.importance)
     || input.importance < 0 || input.importance > 1) {
@@ -15003,26 +15028,8 @@ function showOnboardingWizard(
             "POST /api/profile/generate-soul/stream returned no final soul file",
           );
         }
-        // First-run onboarding must never hold its final save screen open for
-        // model latency. The renderer is allowed to close as soon as the
-        // ordinary profile write finishes, so Desktop durably commits the soul
-        // from this detached main-process request when generation completes.
-        // A final profile write that omits `soulFile` preserves this result no
-        // matter which request wins the insert/update race.
-        const persistResp = await fetch(`${serverUrl}/api/profile`, {
-          method: "PUT",
-          headers,
-          body: JSON.stringify({ soulFile: finalSoulFile }),
-        });
-        if (!persistResp.ok) {
-          console.warn(
-            `[onboarding:soul] generated in ${Date.now() - generationStartedAt}ms but background persistence failed: ${persistResp.status}`,
-          );
-        } else {
-          console.log(
-            `[onboarding:soul] generated and persisted in ${Date.now() - generationStartedAt}ms`,
-          );
-        }
+        // Generation is a preview. The shared wizard waits for this result and
+        // commits it in the final profile write, just as the web adapter does.
         return ipcOk({ soulFile: finalSoulFile });
       } catch (err) {
         const error = err instanceof Error ? err.message : String(err);
diff --git a/apps/desktop/electron/preload.ts b/apps/desktop/electron/preload.ts
index b72230c90..55423593c 100644
--- a/apps/desktop/electron/preload.ts
+++ b/apps/desktop/electron/preload.ts
@@ -25,6 +25,7 @@ import type {
 } from "@nautilo/api-client";
 import type { AtomicDocumentMutationEventBatch } from "@nautilo/document-mutations";
 import type { MessagePayloadV2 } from "@nautilo/lattice-bridge";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/lattice-crypto/wire";
 import type {
   BrowserRoomHistoryShadowAcknowledgementInput,
   HumanPeerLiveShadowReceiveResult,
@@ -2082,12 +2083,14 @@ const foregroundShadowAPI = {
     search: (options: Readonly<{
       q: string; mode: "text" | "semantic"; limit?: number;
       includeArchive?: boolean;
+      embeddingDisclosure?: MemoryEmbeddingDisclosureV2;
     }>) => ipcRenderer.invoke("foregroundShadow:memory:search", options),
     detail: (memoryId: string) => ipcRenderer.invoke(
       "foregroundShadow:memory:detail", { memoryId },
     ),
     update: (input: Readonly<{
       memoryId: string; type: string; content: string; importance: number;
+      requestedEmbedding?: MemoryEmbeddingDisclosureV2;
     }>) => ipcRenderer.invoke("foregroundShadow:memory:update", input),
     retryPendingMutations: () => ipcRenderer.invoke(
       "foregroundShadow:memory:retryPending",
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index c8038329f..a6157e294 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -62,6 +62,7 @@
     "@nautilo/config": "workspace:*",
     "@nautilo/instance-discovery": "workspace:*",
     "@nautilo/lattice-bridge": "workspace:*",
+    "@nautilo/lattice-crypto": "workspace:*",
     "@nautilo/logger": "workspace:*",
     "@nautilo/mcp-client": "workspace:*",
     "@nautilo/relay": "workspace:*",
diff --git a/apps/desktop/tests/unit/foreground-shadow-controller.test.ts b/apps/desktop/tests/unit/foreground-shadow-controller.test.ts
index a1dc636e1..c04fbe5fc 100644
--- a/apps/desktop/tests/unit/foreground-shadow-controller.test.ts
+++ b/apps/desktop/tests/unit/foreground-shadow-controller.test.ts
@@ -843,6 +843,89 @@ describe("ElectronForegroundShadowController", () => {
     await controller.dispose();
   });
 
+  test("signs Desktop Memory edits with the advertised marketplace disclosure", async () => {
+    let intent: unknown;
+    const embedding = {
+      contractVersion: 2 as const,
+      canonicalSpace: { provider: "venice" as const,
+        model: "text-embedding-3-large", dimensions: 1536 as const },
+      processingRoute: { transport: "surplus_marketplace" as const,
+        marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+        dataRecipientClasses: [
+          "surplus", "marketplace_seller", "seller_upstream_processor",
+        ] as const },
+    };
+    const controller = createElectronForegroundShadowController(controllerInput({
+      api: {
+        setToken: () => undefined,
+        admin: { encryptionTransition: { getPolicy: async () => ({
+          policy: { mode: "shadow_encryption", shadowBehavior: "fallback",
+            revision: 1, updatedAt: "2026-09-01T00:00:00.000Z" },
+        }) } },
+        getMemoryProcessorRecipientV2: async () => ({ formatVersion: 2,
+          purpose: "memory.foreground_embedding", recipientId: "A".repeat(43),
+          publicKeyBase64url: "B".repeat(87), embedding }),
+      } as unknown as ElectronForegroundShadowApi,
+      factories: factories({ humanMemory: {
+        update: async (_memoryId: string, value: unknown) => {
+          intent = value;
+          return { status: "ordinary_fallback", memoryId: "memory-1",
+            reason: "target_encryption_not_ready" };
+        },
+      } }),
+    }));
+    expect(await controller.memoryUpdate({ memoryId: "memory-1", type: "fact",
+      content: "private", importance: 0.8,
+      requestedEmbedding: embedding })).toMatchObject({
+      status: "ordinary_fallback", memoryId: "memory-1",
+    });
+    expect(intent).toEqual({
+      payload: { formatVersion: 1, type: "fact", content: "private" },
+      importance: 0.8,
+      requestedEmbedding: embedding,
+    });
+    await controller.dispose();
+  });
+
+  test("rejects a Desktop Memory edit when the displayed route no longer matches", async () => {
+    const direct = {
+      contractVersion: 2 as const,
+      canonicalSpace: { provider: "venice" as const,
+        model: "text-embedding-3-large", dimensions: 1536 as const },
+      processingRoute: { transport: "direct" as const },
+    };
+    const marketplace = { ...direct, processingRoute: {
+      transport: "surplus_marketplace" as const,
+      marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+      dataRecipientClasses: [
+        "surplus", "marketplace_seller", "seller_upstream_processor",
+      ] as const,
+    } };
+    let updates = 0;
+    const controller = createElectronForegroundShadowController(controllerInput({
+      api: {
+        setToken: () => undefined,
+        admin: { encryptionTransition: { getPolicy: async () => ({
+          policy: { mode: "shadow_encryption", shadowBehavior: "fallback",
+            revision: 1, updatedAt: "2026-09-01T00:00:00.000Z" },
+        }) } },
+        getMemoryProcessorRecipientV2: async () => ({ formatVersion: 2,
+          purpose: "memory.foreground_embedding", recipientId: "A".repeat(43),
+          publicKeyBase64url: "B".repeat(87), embedding: marketplace }),
+      } as unknown as ElectronForegroundShadowApi,
+      factories: factories({ humanMemory: {
+        update: async () => { updates += 1; throw new Error("unexpected update"); },
+      } }),
+    }));
+    const failure = await rejected(controller.memoryUpdate({ memoryId: "memory-1",
+      type: "fact", content: "private", importance: 0.8,
+      requestedEmbedding: direct }));
+    expect(failure).toBeInstanceOf(TypeError);
+    expect((failure as TypeError).message).toContain("embedding disclosure changed");
+    expect(updates).toBe(0);
+    await controller.dispose();
+  });
+
   test("withholds a Memory result when policy changes during the operation", async () => {
     const started = deferred();
     const release = deferred();
diff --git a/apps/desktop/tests/unit/foreground-shadow-main-contract.test.ts b/apps/desktop/tests/unit/foreground-shadow-main-contract.test.ts
index e003b19da..a182fc413 100644
--- a/apps/desktop/tests/unit/foreground-shadow-main-contract.test.ts
+++ b/apps/desktop/tests/unit/foreground-shadow-main-contract.test.ts
@@ -91,6 +91,21 @@ describe("foreground Shadow main-process contract", () => {
     }
   });
 
+  test("strictly decodes the renderer-approved Memory disclosure before custody", () => {
+    const search = handler("foregroundShadow:memory:search", "foregroundShadow:memory:detail");
+    const update = handler("foregroundShadow:memory:update", "foregroundShadow:memory:retryPending");
+    for (const operation of [search, update]) {
+      expect(operation).toContain("assertMemoryEmbeddingDisclosureV2(");
+      expect(operation).toContain("decodeMemoryEmbeddingDisclosureV2(");
+      expect(operation).toContain("encodeMemoryEmbeddingDisclosureV2(");
+      expect(operation.indexOf("assertMemoryEmbeddingDisclosureV2(")).toBeLessThan(
+        operation.indexOf("foregroundShadowControllerForSender(e)"),
+      );
+    }
+    expect(search).toContain("embeddingDisclosure");
+    expect(update).toContain("requestedEmbedding");
+  });
+
   test("binds one controller to the active sender/session and disposes on lifecycle exits", () => {
     const factory = main.slice(
       main.indexOf("async function foregroundShadowControllerForSender("),
diff --git a/apps/desktop/tests/unit/foreground-shadow-preload-contract.test.ts b/apps/desktop/tests/unit/foreground-shadow-preload-contract.test.ts
index 2231d1c4e..c69b7d415 100644
--- a/apps/desktop/tests/unit/foreground-shadow-preload-contract.test.ts
+++ b/apps/desktop/tests/unit/foreground-shadow-preload-contract.test.ts
@@ -80,4 +80,11 @@ describe("M300 foreground Shadow preload contract", () => {
       "DesktopForegroundShadowStoredMessage",
     );
   });
+
+  test("carries the displayed Memory embedding disclosure across the IPC surface", () => {
+    expect(preload).toContain("embeddingDisclosure?: MemoryEmbeddingDisclosureV2");
+    expect(preload).toContain("requestedEmbedding?: MemoryEmbeddingDisclosureV2");
+    expect(workbenchDesktop).toContain("embeddingDisclosure?: MemoryEmbeddingDisclosureV2");
+    expect(workbenchDesktop).toContain("requestedEmbedding?: MemoryEmbeddingDisclosureV2");
+  });
 });
diff --git a/apps/desktop/tests/unit/onboarding-soul-preview-contract.test.ts b/apps/desktop/tests/unit/onboarding-soul-preview-contract.test.ts
new file mode 100644
index 000000000..3e2e27449
--- /dev/null
+++ b/apps/desktop/tests/unit/onboarding-soul-preview-contract.test.ts
@@ -0,0 +1,32 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import ts from "typescript";
+
+test("Desktop Soul generation remains a preview until the wizard saves the profile", () => {
+  const source = readFileSync(join(import.meta.dir, "../../electron/main.ts"), "utf8");
+  const file = ts.createSourceFile("main.ts", source, ts.ScriptTarget.Latest, true);
+  let handler: ts.Node | undefined;
+  function find(node: ts.Node): void {
+    if (ts.isCallExpression(node)
+      && ts.isPropertyAccessExpression(node.expression)
+      && node.expression.getText(file) === "ipcMain.handle"
+      && node.arguments[0] && ts.isStringLiteral(node.arguments[0])
+      && node.arguments[0].text === "onboarding:generate-soul") {
+      handler = node.arguments[1];
+    }
+    ts.forEachChild(node, find);
+  }
+  find(file);
+  if (!handler) throw new Error("Missing Desktop Soul generation handler");
+  const requests: string[] = [];
+  function inspect(node: ts.Node): void {
+    if (ts.isCallExpression(node) && node.expression.getText(file) === "fetch") {
+      requests.push(node.arguments[0]?.getText(file) ?? "");
+    }
+    ts.forEachChild(node, inspect);
+  }
+  inspect(handler);
+  expect(requests).toEqual(["`${serverUrl}/api/profile/generate-soul/stream`"]);
+  expect(handler.getText(file)).toContain("return ipcOk({ soulFile: finalSoulFile })");
+});
diff --git a/apps/workbench/package.json b/apps/workbench/package.json
index 103af6237..9f6145d44 100644
--- a/apps/workbench/package.json
+++ b/apps/workbench/package.json
@@ -106,6 +106,7 @@
     "@nautilo/agent": "workspace:*",
     "@nautilo/computer-use-contracts": "workspace:*",
     "@nautilo/lattice-bridge": "workspace:*",
+    "@nautilo/lattice-crypto": "workspace:*",
     "@tailwindcss/typography": "0.5.19",
     "@tailwindcss/vite": "4.2.2",
     "@testing-library/react": "16.3.2",
diff --git a/apps/workbench/src/genie-customization/workbench-onboarding-api.ts b/apps/workbench/src/genie-customization/workbench-onboarding-api.ts
index b55dd88c9..a752fa767 100644
--- a/apps/workbench/src/genie-customization/workbench-onboarding-api.ts
+++ b/apps/workbench/src/genie-customization/workbench-onboarding-api.ts
@@ -96,7 +96,8 @@ function toSnapshot(profile: AgentProfileFull, avatarUrl: string | null): Profil
 }
 
 function onboardingAvatarUrl(avatar: AvatarRef): string | null {
-  return avatar.kind === "preset"
+  // The shell is rendered by the authenticated avatar route, not a preset file.
+  return avatar.kind === "preset" && avatar.id !== "shell"
     ? `/api/onboarding/images/avatars/${encodeURIComponent(avatar.id)}.webp`
     : null;
 }
diff --git a/apps/workbench/src/lib/desktop.ts b/apps/workbench/src/lib/desktop.ts
index 4799b949e..a127cc61a 100644
--- a/apps/workbench/src/lib/desktop.ts
+++ b/apps/workbench/src/lib/desktop.ts
@@ -44,6 +44,7 @@ import type {
   TaskContentBackfillProgressResponse,
 } from "@nautilo/api-client/browser";
 import type { MessagePayloadV2 } from "@nautilo/lattice-bridge";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/lattice-crypto/wire";
 import type {
   AuthorizedHumanMemoryClient,
   BrowserRoomHistoryShadowAcknowledgementInput,
@@ -374,6 +375,7 @@ export interface DesktopForegroundShadowAPI {
     search(options: Readonly<{
       q: string; mode: "text" | "semantic"; limit?: number;
       includeArchive?: boolean;
+      embeddingDisclosure?: MemoryEmbeddingDisclosureV2;
     }>): Promise<Readonly<{
       items: readonly WorkbenchProtectedMemorySearchResult[];
       memoryMode: "namespace" | "scope";
@@ -388,6 +390,7 @@ export interface DesktopForegroundShadowAPI {
     }>>;
     update(input: Readonly<{
       memoryId: string; type: string; content: string; importance: number;
+      requestedEmbedding?: MemoryEmbeddingDisclosureV2;
     }>): Promise<Readonly<{
       status: "published" | "replayed";
       memoryId: string;
diff --git a/apps/workbench/src/lib/memory-read-operations.ts b/apps/workbench/src/lib/memory-read-operations.ts
index 7f79c084b..d123d77d1 100644
--- a/apps/workbench/src/lib/memory-read-operations.ts
+++ b/apps/workbench/src/lib/memory-read-operations.ts
@@ -1,4 +1,5 @@
 import { ClassifiedDataOperationError, type EncryptionDataOperationOwner } from "@nautilo/lattice-bridge";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/api-client/browser";
 
 import type { MemoryDetail, MemoryDetailResponse, MemoryListItem, MemoryMode } from "./memory-api";
 import type {
@@ -121,7 +122,7 @@ export function createWorkbenchMemoryReadOperations(input: Readonly<{
   disposeProtected?: () => Promise<void>;
   resolveEmbedding?: () => Promise<Readonly<{
     provider: "openai" | "openrouter" | "venice"; model: string;
-  }>>;
+  }> | MemoryEmbeddingDisclosureV2>;
 }>): WorkbenchMemoryReadOperations {
   return Object.freeze({
     async list(options: MemoryListOptions) {
@@ -173,9 +174,17 @@ export function createWorkbenchMemoryReadOperations(input: Readonly<{
             ...item, updatedAt: item.createdAt, namespaceIds: [],
           }));
         },
-        protected: async () => (await protectedPort(input.protected).search({
-          ...options, mode: "semantic",
-        })).items.map(row),
+        protected: async () => {
+          const embedding = await input.resolveEmbedding?.();
+          if (embedding === undefined) throw new ClassifiedDataOperationError(
+            "unsupported", "Memory embedding is unavailable",
+          );
+          return (await protectedPort(input.protected).search({
+            ...options, mode: "semantic",
+            ...( "canonicalSpace" in embedding
+              ? { embeddingDisclosure: embedding } : {}),
+          })).items.map(row);
+        },
         consumeOrdinary: (value) => value,
         consumeProtected: (value) => value,
       })).value;
@@ -213,13 +222,17 @@ export function createWorkbenchMemoryReadOperations(input: Readonly<{
           const embedding = await input.resolveEmbedding?.();
           if (embedding === undefined) throw new ClassifiedDataOperationError("unsupported", "Memory embedding is unavailable");
           return protectedMutationPort(input.protected).update({ memoryId, ...edit,
-            requestedProvider: embedding.provider, requestedModel: embedding.model });
+            ...("canonicalSpace" in embedding
+              ? { requestedEmbedding: embedding }
+              : { requestedProvider: embedding.provider, requestedModel: embedding.model }) });
         },
         protected: async () => {
           const embedding = await input.resolveEmbedding?.();
           if (embedding === undefined) throw new ClassifiedDataOperationError("unsupported", "Memory embedding is unavailable");
           return protectedMutationPort(input.protected).update({ memoryId, ...edit,
-            requestedProvider: embedding.provider, requestedModel: embedding.model });
+            ...("canonicalSpace" in embedding
+              ? { requestedEmbedding: embedding }
+              : { requestedProvider: embedding.provider, requestedModel: embedding.model }) });
         },
       });
     },
diff --git a/apps/workbench/src/lib/protected-human-memory-controller.ts b/apps/workbench/src/lib/protected-human-memory-controller.ts
index 135bd23f3..6b9420614 100644
--- a/apps/workbench/src/lib/protected-human-memory-controller.ts
+++ b/apps/workbench/src/lib/protected-human-memory-controller.ts
@@ -5,6 +5,7 @@ import type {
   AuthorizedHumanMemoryUnavailableReason,
 } from "@nautilo/lattice-bridge/client/browser";
 import type { ProtectedMemoryProjectionV1 } from "@nautilo/api-client/browser";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/api-client/browser";
 import { runWithCryptoAdmission } from "./crypto-admission-access";
 
 export type WorkbenchProtectedMemoryContent =
@@ -151,9 +152,10 @@ function createUnfencedWorkbenchProtectedHumanMemoryController(
       type: string;
       content: string;
       importance: number;
+    } & ({
       requestedProvider: "openai" | "openrouter" | "venice";
       requestedModel: string;
-    }>) {
+    } | { requestedEmbedding: MemoryEmbeddingDisclosureV2 })>) {
       let memory: WorkbenchProtectedMemory | undefined;
       const response = await client.update(input.memoryId, {
         payload: {
@@ -162,8 +164,10 @@ function createUnfencedWorkbenchProtectedHumanMemoryController(
           content: input.content,
         },
         importance: input.importance,
-        requestedProvider: input.requestedProvider,
-        requestedModel: input.requestedModel,
+        ...("requestedEmbedding" in input
+          ? { requestedEmbedding: input.requestedEmbedding }
+          : { requestedProvider: input.requestedProvider,
+            requestedModel: input.requestedModel }),
       }, (value) => {
         memory = protectedOpened(value);
       });
diff --git a/apps/workbench/src/pages/admin/sections/models-section.test.tsx b/apps/workbench/src/pages/admin/sections/models-section.test.tsx
index 64ac06f9e..afa68a0a5 100644
--- a/apps/workbench/src/pages/admin/sections/models-section.test.tsx
+++ b/apps/workbench/src/pages/admin/sections/models-section.test.tsx
@@ -623,7 +623,7 @@ describe("ModelsSection Embedding model", () => {
     expect(select.selectedOptions[0]?.textContent).toBe("Server configuration");
     expect(Array.from(select.options).map((option) => option.textContent)).toEqual([
       "Server configuration",
-      "Automatic — Venice → OpenRouter → OpenAI",
+      "Automatic — Venice → OpenRouter → OpenAI → Surplus fallback",
       "Qwen3 Embedding 8B (Venice)",
       "Qwen3 Embedding 8B (OpenRouter)",
       "Text Embedding 3 Small (Venice)",
@@ -631,6 +631,8 @@ describe("ModelsSection Embedding model", () => {
       "Text Embedding 3 Small (OpenAI) (Unavailable)",
     ]);
     expect(select.options[6]?.disabled).toBe(true);
+    expect(view.getByText(/If no direct embedding credential is ready, Prefer Surplus can use/))
+      .toBeTruthy();
   });
 
   test("persists automatic independently", async () => {
diff --git a/apps/workbench/src/pages/admin/sections/models-section.tsx b/apps/workbench/src/pages/admin/sections/models-section.tsx
index 5f7ab2913..862d19603 100644
--- a/apps/workbench/src/pages/admin/sections/models-section.tsx
+++ b/apps/workbench/src/pages/admin/sections/models-section.tsx
@@ -33,6 +33,7 @@ const SUPPORTED_EMBEDDING_MODEL_IDS = new Set([
   "venice:text-embedding-3-small",
   "openrouter:openai/text-embedding-3-small",
   "openai:text-embedding-3-small",
+  "venice:text-embedding-3-large",
 ]);
 
 type SaveState = "idle" | "saving" | "saved" | { error: string };
@@ -665,7 +666,7 @@ export function ModelsSection() {
                 Embedding model
               </label>
               <p className="text-[11px] text-foreground-muted">
-                Creates vectors for semantic Memory search and Reflection. Server configuration inherits the operator setting. Automatic selects the first configured provider: Qwen3 Embedding 8B on Venice or OpenRouter, then text-embedding-3-small on OpenAI.
+                Creates vectors for semantic Memory search and Reflection. Server configuration inherits the operator setting. Automatic keeps the first configured direct provider: Qwen3 Embedding 8B on Venice or OpenRouter, then text-embedding-3-small on OpenAI. If no direct embedding credential is ready, Prefer Surplus can use the qualified Venice text-embedding-3-large route.
               </p>
               <select
                 id="server-embedding-model"
@@ -680,7 +681,7 @@ export function ModelsSection() {
                 })}
               >
                 <option value={SERVER_EMBEDDING_CONFIGURATION}>Server configuration</option>
-                <option value="">Automatic — Venice → OpenRouter → OpenAI</option>
+                <option value="">Automatic — Venice → OpenRouter → OpenAI → Surplus fallback</option>
                 {draft.embeddingModel !== null && draft.embeddingModel !== "" &&
                 !supportedEmbeddingModels.some((model) => model.id === draft.embeddingModel) ? (
                   <option value={draft.embeddingModel} disabled>
diff --git a/apps/workbench/src/pages/admin/sections/provider-key-coverage.tsx b/apps/workbench/src/pages/admin/sections/provider-key-coverage.tsx
index b04d29eab..0f665b156 100644
--- a/apps/workbench/src/pages/admin/sections/provider-key-coverage.tsx
+++ b/apps/workbench/src/pages/admin/sections/provider-key-coverage.tsx
@@ -46,6 +46,7 @@ const COVERAGE_ROWS = [
       ["venice", "Venice"],
       ["openrouter", "OpenRouter"],
       ["openai", "OpenAI"],
+      ["surplus", "Surplus Intelligence (Venice 3-large)"],
     ],
   },
   { functionality: "Text-to-speech", providers: [["elevenlabs", "ElevenLabs"]] },
@@ -105,7 +106,7 @@ export function ProviderKeyCoverage({
       </h3>
       <p className="mt-1 text-xs text-foreground-muted">
         Shows API key coverage, not service availability. Surplus rows require Prefer Surplus
-        and a matching qualified route in the signed catalogue. Additional configuration and
+        and a matching qualified model route. Additional configuration and
         local alternatives are not evaluated.
       </p>
 
diff --git a/apps/workbench/src/pages/memory/memory-page.tsx b/apps/workbench/src/pages/memory/memory-page.tsx
index c526dcaa6..f6cf78b9a 100644
--- a/apps/workbench/src/pages/memory/memory-page.tsx
+++ b/apps/workbench/src/pages/memory/memory-page.tsx
@@ -8,6 +8,8 @@ import {
 } from "react";
 import { useVirtualizer } from "@tanstack/react-virtual";
 import { useNavigate, useParams } from "react-router-dom";
+import { ApiError } from "@nautilo/api-client/browser";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/lattice-crypto/wire";
 import { useAuth } from "../../hooks/use-auth";
 import { useCan } from "../../hooks/use-can";
 import { GuestPlaceholder } from "../settings/ui";
@@ -76,6 +78,65 @@ type DirectoryHuman = { userId: string; handle: string; displayName: string };
 
 /** Sentinel value for the "Just me" (private-only) option in the audience picker. */
 const PRIVATE_FILTER = "__private__";
+
+type MemoryEmbeddingApproval =
+  | Readonly<{ kind: "v2"; embedding: MemoryEmbeddingDisclosureV2 }>
+  | Readonly<{ kind: "v1"; embedding: Readonly<{
+    provider: "openai" | "openrouter" | "venice";
+    model: string;
+    dimensions: 1536;
+  }> }>;
+
+type MemoryEmbeddingApprovalState =
+  | Readonly<{ status: "inactive" }>
+  | Readonly<{ status: "loading" }>
+  | Readonly<{ status: "ready"; accountKey: string; approval: MemoryEmbeddingApproval }>
+  | Readonly<{ status: "error"; message: string }>;
+
+function embeddingProviderLabel(provider: "openai" | "openrouter" | "venice") {
+  if (provider === "openai") return "OpenAI";
+  if (provider === "openrouter") return "OpenRouter";
+  return "Venice";
+}
+
+function MemoryEmbeddingDisclosure({ state, onReload }: Readonly<{
+  state: MemoryEmbeddingApprovalState;
+  onReload: () => void;
+}>) {
+  if (state.status === "inactive") return null;
+  if (state.status === "loading") {
+    return <p className="text-xs text-foreground-muted">Preparing semantic indexing disclosure…</p>;
+  }
+  if (state.status === "error") {
+    return (
+      <div className="flex flex-wrap items-center gap-2 text-xs text-[var(--error)]" role="alert">
+        <span>{state.message}</span>
+        <Button variant="secondary" onClick={onReload}>Reload disclosure</Button>
+      </div>
+    );
+  }
+  const canonical = state.approval.kind === "v2"
+    ? state.approval.embedding.canonicalSpace : state.approval.embedding;
+  const marketplace = state.approval.kind === "v2"
+    && state.approval.embedding.processingRoute.transport === "surplus_marketplace";
+  return (
+    <div className="rounded-md border border-border bg-background-panel px-3 py-2 text-xs text-foreground-muted">
+      <p>
+        Semantic index: {embeddingProviderLabel(canonical.provider)} — {canonical.model}
+        {` (${canonical.dimensions.toLocaleString()} dimensions).`}
+      </p>
+      <p className="mt-1">
+        {marketplace
+          ? "Semantic indexing sends this text through Surplus Intelligence, a marketplace seller, and that seller’s upstream model providers."
+          : `Semantic indexing sends this text directly to ${embeddingProviderLabel(canonical.provider)}.`}
+      </p>
+    </div>
+  );
+}
+
+function embeddingApprovalReady(state: MemoryEmbeddingApprovalState) {
+  return state.status === "inactive" || state.status === "ready";
+}
 import {
   loadAmbience,
   prefersReducedMotion,
@@ -476,6 +537,9 @@ function MemoryListView({
   onRefresh,
   onLoadMore,
   memoryReads,
+  embeddingApproval,
+  onReloadEmbeddingApproval,
+  onEmbeddingFailure,
 }: {
   items: MemoryListItem[];
   memoryMode: MemoryMode;
@@ -493,6 +557,9 @@ function MemoryListView({
   onRefresh: () => void;
   onLoadMore: () => void;
   memoryReads: WorkbenchMemoryReadOperations;
+  embeddingApproval: MemoryEmbeddingApprovalState;
+  onReloadEmbeddingApproval: () => void;
+  onEmbeddingFailure: (error: unknown) => void;
 }) {
   const navigate = useNavigate();
   const [query, setQuery] = useState("");
@@ -597,6 +664,7 @@ function MemoryListView({
       setSearchResults([...(await memoryReads.search({ q, includeArchive: showArchived }))]);
     } catch (e) {
       setError(e instanceof Error ? e.message : String(e));
+      onEmbeddingFailure(e);
     } finally {
       setSearching(false);
     }
@@ -701,6 +769,11 @@ function MemoryListView({
         </header>
       </div>
 
+      <MemoryEmbeddingDisclosure
+        state={embeddingApproval}
+        onReload={onReloadEmbeddingApproval}
+      />
+
       <div className="flex flex-wrap items-center gap-2">
         <div className="min-w-[12rem] flex-1">
           <TextInput
@@ -708,11 +781,13 @@ function MemoryListView({
             onChange={setQuery}
             placeholder="Search memories…"
             ariaLabel="Search memories"
+            disabled={!embeddingApprovalReady(embeddingApproval)}
           />
         </div>
         <Button
           variant="secondary"
           loading={searching}
+          disabled={!embeddingApprovalReady(embeddingApproval)}
           onClick={() => void runSearch()}
         >
           Search
@@ -913,6 +988,9 @@ function MemoryEditorView({
   operations,
   actions,
   ordinaryAccess,
+  embeddingApproval,
+  onReloadEmbeddingApproval,
+  onEmbeddingFailure,
 }: {
   initial: MemoryDetail;
   memoryMode: MemoryMode;
@@ -924,6 +1002,9 @@ function MemoryEditorView({
   operations: WorkbenchMemoryReadOperations;
   actions: MemoryActionPresentation;
   ordinaryAccess?: { context: MemoryDetailResponse["accessContext"] | null; onChanged: () => void; onAccessLost: (message: string) => void };
+  embeddingApproval: MemoryEmbeddingApprovalState;
+  onReloadEmbeddingApproval: () => void;
+  onEmbeddingFailure: (error: unknown) => void;
 }) {
   const navigate = useNavigate();
   const kind = rowKind(initial, memoryMode);
@@ -972,6 +1053,7 @@ function MemoryEditorView({
       onSaved();
     } catch (e) {
       setError(e instanceof Error ? e.message : String(e));
+      onEmbeddingFailure(e);
     } finally {
       setSaving(false);
     }
@@ -1303,6 +1385,13 @@ function MemoryEditorView({
           </p>
         ) : null}
 
+        {canEdit && !readOnly ? (
+          <MemoryEmbeddingDisclosure
+            state={embeddingApproval}
+            onReload={onReloadEmbeddingApproval}
+          />
+        ) : null}
+
         <div className="flex flex-wrap justify-end gap-2">
           {canEdit && affordances.canArchive ? (
             <Button variant="secondary" loading={busy} onClick={() => void archive()}>
@@ -1346,7 +1435,9 @@ function MemoryEditorView({
             </Button>
           ) : null}
           {canEdit && !readOnly ? (
-            <Button variant="primary" loading={saving} onClick={() => void submit()}>
+            <Button variant="primary" loading={saving}
+              disabled={!embeddingApprovalReady(embeddingApproval)}
+              onClick={() => void submit()}>
               Save
             </Button>
           ) : null}
@@ -1375,6 +1466,63 @@ export function MemoryPage() {
   const memoryId = params.id;
 
   const canEdit = auth.viewer.isVerified && can("manage_memories");
+  const accountKey = `${auth.viewer.sessionUserId ?? ""}:${auth.viewer.sessionActorId ?? ""}`;
+  const requiresEmbeddingApproval = encryptionPolicyMode !== "plaintext_only";
+  const [embeddingApproval, setEmbeddingApproval] = useState<MemoryEmbeddingApprovalState>(
+    requiresEmbeddingApproval ? { status: "loading" } : { status: "inactive" },
+  );
+  const [embeddingApprovalReload, setEmbeddingApprovalReload] = useState(0);
+  const embeddingApprovalRef = useRef<MemoryEmbeddingApproval | null>(null);
+  const activeEmbeddingApproval: MemoryEmbeddingApprovalState =
+    embeddingApproval.status === "ready" && embeddingApproval.accountKey !== accountKey
+      ? { status: "loading" } : embeddingApproval;
+  embeddingApprovalRef.current = activeEmbeddingApproval.status === "ready"
+    ? activeEmbeddingApproval.approval : null;
+  const reloadEmbeddingApproval = useCallback(() => {
+    setEmbeddingApprovalReload((value) => value + 1);
+  }, []);
+  const noteEmbeddingFailure = useCallback((failure: unknown) => {
+    const message = failure instanceof Error ? failure.message : String(failure);
+    if (!/embedding disclosure changed|embedding policy changed|prepare.*again/iu.test(message)) {
+      return;
+    }
+    setEmbeddingApproval({ status: "error",
+      message: "The semantic indexing route changed. Reload the disclosure before trying again." });
+  }, []);
+
+  useEffect(() => {
+    if (!requiresEmbeddingApproval || !auth.viewer.isVerified) {
+      setEmbeddingApproval({ status: "inactive" });
+      return;
+    }
+    let cancelled = false;
+    setEmbeddingApproval({ status: "loading" });
+    void (async () => {
+      try {
+        let approval: MemoryEmbeddingApproval;
+        try {
+          const recipient = await apiClient.getMemoryProcessorRecipientV2();
+          if (recipient.embedding === undefined) {
+            throw new Error("Semantic indexing is unavailable");
+          }
+          approval = Object.freeze({ kind: "v2", embedding: recipient.embedding });
+        } catch (error) {
+          if (!(error instanceof ApiError) || error.status !== 404) throw error;
+          const recipient = await apiClient.getMemoryProcessorRecipient();
+          if (recipient.embedding === undefined) {
+            throw new Error("Semantic indexing is unavailable");
+          }
+          approval = Object.freeze({ kind: "v1", embedding: recipient.embedding });
+        }
+        if (!cancelled) setEmbeddingApproval({ status: "ready", accountKey, approval });
+      } catch (failure) {
+        if (!cancelled) setEmbeddingApproval({ status: "error",
+          message: failure instanceof Error ? failure.message : String(failure) });
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [auth.viewer.isVerified, accountKey, embeddingApprovalReload,
+    requiresEmbeddingApproval]);
   const dataOperationOwner = useMemo(() => createWorkbenchDataOperationOwner(), []);
   const protectedComposition = useMemo(() => {
     let controller: WorkbenchProtectedHumanMemoryController | undefined;
@@ -1419,6 +1567,10 @@ export function MemoryPage() {
         humanActorId: auth.viewer.sessionActorId,
         installationId,
         resolveDeviceAdmissionStatus: () => apiClient.deviceAdmission.status(),
+        resolveEmbeddingDisclosure: () => {
+          const approval = embeddingApprovalRef.current;
+          return approval?.kind === "v2" ? approval.embedding : undefined;
+        },
       }),
     );
     return controller;
@@ -1451,12 +1603,11 @@ export function MemoryPage() {
     },
     protected: protectedComposition.get,
     disposeProtected: protectedComposition.dispose,
-    resolveEmbedding: async () => {
-      const recipient = await apiClient.getMemoryProcessorRecipient();
-      if (recipient.embedding === undefined) {
-        throw new Error("Memory embedding is unavailable");
-      }
-      return recipient.embedding;
+    resolveEmbedding: () => {
+      const current = embeddingApprovalRef.current;
+      return current === null
+        ? Promise.reject(new Error("Reload the semantic indexing disclosure before trying again"))
+        : Promise.resolve(current.embedding);
     },
   }), [dataOperationOwner, protectedComposition]);
 
@@ -1480,7 +1631,6 @@ export function MemoryPage() {
   const [personFilter, setPersonFilter] = useState<string | null>(null);
   const [privateFilter, setPrivateFilter] = useState(false);
   const [total, setTotal] = useState<number | null>(null);
-  const accountKey = `${auth.viewer.sessionUserId ?? ""}:${auth.viewer.sessionActorId ?? ""}`;
   const contextAdmissionKey = `${accountKey}:${auth.viewerGeneration}:${memoryId ?? ""}`;
   const contextAdmissionKeyRef = useRef(contextAdmissionKey);
   contextAdmissionKeyRef.current = contextAdmissionKey;
@@ -1639,6 +1789,9 @@ export function MemoryPage() {
         onDeleted={() => void refreshList()}
         operations={memoryReads}
         actions={detailActions}
+        embeddingApproval={activeEmbeddingApproval}
+        onReloadEmbeddingApproval={reloadEmbeddingApproval}
+        onEmbeddingFailure={noteEmbeddingFailure}
         {...(encryptionPolicyMode === "plaintext_only"
           ? { ordinaryAccess: { context: detailAccessContext?.admissionKey === contextAdmissionKey
               && detailAccessContext.memoryId === detail.id ? detailAccessContext.context : null, onChanged: () => {
@@ -1676,6 +1829,9 @@ export function MemoryPage() {
       onRefresh={() => void refreshList()}
       onLoadMore={() => void refreshList(nextCursor ?? undefined)}
       memoryReads={memoryReads}
+      embeddingApproval={activeEmbeddingApproval}
+      onReloadEmbeddingApproval={reloadEmbeddingApproval}
+      onEmbeddingFailure={noteEmbeddingFailure}
     />
   );
 }
diff --git a/apps/workbench/tests/unit-isolated/genie-customization/workbench-onboarding-api.test.ts b/apps/workbench/tests/unit-isolated/genie-customization/workbench-onboarding-api.test.ts
index 94fde7fe2..f07cc2ab2 100644
--- a/apps/workbench/tests/unit-isolated/genie-customization/workbench-onboarding-api.test.ts
+++ b/apps/workbench/tests/unit-isolated/genie-customization/workbench-onboarding-api.test.ts
@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, mock, test } from "bun:test";
-import type { AgentProfileResponse } from "@nautilo/types";
+import type { AgentProfileResponse, AvatarRef } from "@nautilo/types";
 import { VoiceFundingApiError } from "@nautilo/api-client/browser";
 
 const profileWrite = {
@@ -50,6 +50,8 @@ mock.module("../../../src/lib/api", () => ({ apiClient }));
 const { createWorkbenchOnboardingApi } = await import("../../../src/genie-customization/workbench-onboarding-api");
 
 const originalFetch = globalThis.fetch;
+const originalCreateObjectURL = URL.createObjectURL;
+const originalRevokeObjectURL = URL.revokeObjectURL;
 
 function adapterOptions(overrides: Partial<Parameters<typeof createWorkbenchOnboardingApi>[0]> = {}) {
   return {
@@ -65,10 +67,52 @@ function adapterOptions(overrides: Partial<Parameters<typeof createWorkbenchOnbo
 
 afterEach(() => {
   globalThis.fetch = originalFetch;
+  URL.createObjectURL = originalCreateObjectURL;
+  URL.revokeObjectURL = originalRevokeObjectURL;
   for (const operation of Object.values(apiClient)) operation.mockClear();
 });
 
 describe("Workbench onboarding adapter", () => {
+  test.each<AvatarRef>([
+    { kind: "preset", id: "shell" },
+    { kind: "uploaded", blobId: "uploaded-photo" },
+    { kind: "generated", blobId: "generated-photo" },
+  ])("loads the current %j avatar through authenticated media and preserves it on save", async (avatar) => {
+    const image = '<svg xmlns="http://www.w3.org/2000/svg"></svg>';
+    const fetchStub = mock(async () => new Response(image, {
+      headers: { "Content-Type": "image/svg+xml" },
+    }));
+    globalThis.fetch = fetchStub as typeof fetch;
+    const createUrl = mock((_blob: Blob) => "blob:current-avatar");
+    const revokeUrl = mock(() => {});
+    URL.createObjectURL = createUrl;
+    URL.revokeObjectURL = revokeUrl;
+    const adapter = createWorkbenchOnboardingApi(adapterOptions({
+      getCanonicalProfile: () => ({
+        ok: true,
+        data: { ...PROFILE_RESPONSE, agent: { ...PROFILE_RESPONSE.agent, avatar } },
+      }),
+    }));
+
+    await expect(adapter.api.loadExistingProfile()).resolves.toEqual({
+      ok: true,
+      data: expect.objectContaining({ avatar, avatarUrl: "blob:current-avatar" }),
+    });
+    expect(fetchStub).toHaveBeenCalledTimes(1);
+    expect(fetchStub).toHaveBeenCalledWith("/api/profile/avatar", {
+      headers: { Authorization: "Bearer token" },
+    });
+    expect(createUrl).toHaveBeenCalledTimes(1);
+    const loadedImage = createUrl.mock.calls[0]![0];
+    expect(await loadedImage.text()).toBe(image);
+
+    await expect(adapter.api.putProfile(profileWrite)).resolves.toEqual({ ok: true, data: { ok: true } });
+    expect(apiClient.selectAgentPhotoLibraryEntry).toHaveBeenCalledTimes(0);
+    expect(revokeUrl).toHaveBeenCalledTimes(0);
+    adapter.dispose();
+    expect(revokeUrl).toHaveBeenCalledWith("blob:current-avatar");
+  });
+
   test("hydrates safe voice data and relays the browser soul stream", async () => {
     globalThis.fetch = mock(async (input: RequestInfo | URL) => {
       if (String(input).endsWith("setup-flags")) {
diff --git a/apps/workbench/tests/unit-isolated/reveal-soul-persistence.test.tsx b/apps/workbench/tests/unit-isolated/reveal-soul-persistence.test.tsx
new file mode 100644
index 000000000..edb34089a
--- /dev/null
+++ b/apps/workbench/tests/unit-isolated/reveal-soul-persistence.test.tsx
@@ -0,0 +1,238 @@
+import "../bun-dom-preload";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { act, cleanup, fireEvent, render, waitFor } from "@testing-library/react";
+import { StrictMode, useEffect, useReducer, type Dispatch } from "react";
+import type { OnboardingAPI, ProfileWrite } from "@nautilo/genie-customization-ui";
+import {
+  wizardReducerForTests,
+  type WizardState,
+} from "../../../../packages/genie-customization-ui/src/hooks/useWizardState";
+import {
+  RevealScreen,
+  SOUL_NOT_GENERATED_NOTICE,
+} from "../../../../packages/genie-customization-ui/src/screens/RevealScreen";
+
+afterEach(() => cleanup());
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((settle) => {
+    resolve = settle;
+  });
+  return { promise, resolve };
+}
+
+function baseState(overrides: Partial<WizardState> = {}): WizardState {
+  return {
+    screen: 10,
+    viewer: {
+      genieCustomized: false,
+      pinEnrolled: false,
+      handleAutoGenerated: false,
+      displayNameSet: false,
+      recoveryCodesAcknowledged: false,
+    },
+    hydratedSnapshot: null,
+    flags: { avatarGenAvail: false, motherEasterEgg: false },
+    language: "en",
+    privacySlider: 50,
+    workLifeChoice: "both",
+    personalityPrompt: "Calm and precise",
+    motherAnswer: "",
+    compilingPhase: "done",
+    compilingGeneration: 1,
+    soulFile: "# Retained Soul",
+    avatarSource: null,
+    avatarChoice: null,
+    avatarRef: null,
+    avatarTarget: null,
+    name: "Genie",
+    voiceSelection: null,
+    voiceSkipped: true,
+    voiceCapability: "unknown",
+    errors: {},
+    ...overrides,
+  };
+}
+
+function apiHarness(overrides: Partial<OnboardingAPI> = {}) {
+  const complete = mock(async () => {});
+  const generateSoul = mock(async () => ({
+    ok: true as const,
+    data: { soulFile: "# Generated Soul" },
+  }));
+  const putProfile = mock(async (_input: ProfileWrite) => ({
+    ok: true as const,
+    data: { ok: true as const },
+  }));
+  const api: OnboardingAPI = {
+    getServerUrl: async () => "",
+    complete,
+    cancel: async () => {},
+    loadExistingProfile: async () => ({ ok: true, data: null }),
+    getConfigFlags: async () => ({
+      ok: true,
+      data: { avatarGenAvail: false, motherEasterEgg: false },
+    }),
+    getStartAt: async () => null,
+    getVoices: async () => ({
+      ok: true,
+      data: { curated: [], voices: [], elevenLabsConfigured: false },
+    }),
+    previewVoice: async () => ({ ok: true, data: { audioUrl: "blob:preview" } }),
+    listVoiceCatalog: async () => ({
+      ok: true,
+      data: {
+        voices: [],
+        languageGroups: [],
+        page: 0,
+        pageSize: 0,
+        hasMore: false,
+        totalCount: 0,
+        elevenLabsConfigured: false,
+        cachedAt: null,
+      },
+    }),
+    generateSoul,
+    generateAvatar: async () => ({
+      ok: true,
+      data: { target: { kind: "entry", entryId: "avatar" }, avatarUrl: "" },
+    }),
+    putProfile,
+    upsertVoiceAssignment: async () => ({ ok: true, data: { voices: {} } }),
+    ...overrides,
+  };
+  return { api, complete, generateSoul, putProfile };
+}
+
+function RevealHarness({ initialState, api, onDispatch }: {
+  initialState: WizardState;
+  api: OnboardingAPI;
+  onDispatch?: (dispatch: Dispatch<Parameters<typeof wizardReducerForTests>[1]>) => void;
+}) {
+  const [state, dispatch] = useReducer(wizardReducerForTests, initialState);
+  useEffect(() => {
+    onDispatch?.(dispatch);
+  }, [dispatch, onDispatch]);
+  return (
+    <RevealScreen
+      state={state}
+      dispatch={dispatch}
+      serverUrl="http://localhost"
+      api={api}
+    />
+  );
+}
+
+function renderReveal(
+  initialState: WizardState,
+  api: OnboardingAPI,
+  onDispatch?: (dispatch: Dispatch<Parameters<typeof wizardReducerForTests>[1]>) => void,
+) {
+  return render(
+    <StrictMode>
+      <RevealHarness initialState={initialState} api={api} onDispatch={onDispatch} />
+    </StrictMode>,
+  );
+}
+
+describe("Reveal Soul persistence", () => {
+  test("waits for an existing background generation and writes its Soul exactly once", async () => {
+    const harness = apiHarness();
+    let dispatch: Dispatch<Parameters<typeof wizardReducerForTests>[1]> | undefined;
+    const view = renderReveal(baseState({
+      compilingPhase: "background",
+      soulFile: null,
+    }), harness.api, (nextDispatch) => {
+      dispatch = nextDispatch;
+    });
+
+    expect(harness.putProfile).not.toHaveBeenCalled();
+    expect(harness.generateSoul).not.toHaveBeenCalled();
+    expect(view.queryByRole("button", { name: "Done →" })).toBeNull();
+
+    await act(async () => {
+      dispatch?.({ type: "FINISH_COMPILE", generation: 1, soulFile: "# Delayed Soul" });
+    });
+
+    await waitFor(() => expect(harness.putProfile).toHaveBeenCalledTimes(1));
+    expect(harness.putProfile).toHaveBeenCalledWith(
+      expect.objectContaining({ soulFile: "# Delayed Soul" }),
+    );
+    expect(view.getByRole("button", { name: "Done →" })).toBeTruthy();
+    await act(async () => Promise.resolve());
+    expect(harness.putProfile).toHaveBeenCalledTimes(1);
+  });
+
+  test("starts an idle Reveal generation once and saves its reducer-fenced result", async () => {
+    const pending = deferred<Awaited<ReturnType<OnboardingAPI["generateSoul"]>>>();
+    const generateSoul = mock(() => pending.promise);
+    const harness = apiHarness({ generateSoul });
+    const view = renderReveal(baseState({
+      compilingPhase: "idle",
+      compilingGeneration: 4,
+      soulFile: null,
+    }), harness.api);
+
+    await waitFor(() => expect(generateSoul).toHaveBeenCalledTimes(1));
+    expect(harness.putProfile).not.toHaveBeenCalled();
+    expect(view.queryByRole("button", { name: "Done →" })).toBeNull();
+
+    await act(async () => {
+      pending.resolve({ ok: true, data: { soulFile: "# Late-start Soul" } });
+      await pending.promise;
+    });
+
+    await waitFor(() => expect(harness.putProfile).toHaveBeenCalledTimes(1));
+    expect(harness.putProfile).toHaveBeenCalledWith(
+      expect.objectContaining({ soulFile: "# Late-start Soul" }),
+    );
+    expect(generateSoul).toHaveBeenCalledTimes(1);
+    await act(async () => Promise.resolve());
+    expect(harness.putProfile).toHaveBeenCalledTimes(1);
+  });
+
+  test("saves after an idle generation failure without replaying it and explains the missing Soul", async () => {
+    const generateSoul = mock(async () => ({
+      ok: false as const,
+      error: "Soul service unavailable",
+    }));
+    const harness = apiHarness({ generateSoul });
+    const view = renderReveal(baseState({ compilingPhase: "idle", soulFile: null }), harness.api);
+
+    await waitFor(() => expect(harness.putProfile).toHaveBeenCalledTimes(1));
+    expect(generateSoul).toHaveBeenCalledTimes(1);
+    const payload = harness.putProfile.mock.calls[0]?.[0];
+    if (!payload) throw new Error("Expected one profile mutation");
+    expect("soulFile" in payload).toBe(false);
+    expect(view.getByText(SOUL_NOT_GENERATED_NOTICE)).toBeTruthy();
+
+    fireEvent.click(view.getByRole("button", { name: "Done →" }));
+    await waitFor(() => expect(harness.complete).toHaveBeenCalledTimes(1));
+  });
+
+  test("an explicit earlier skip saves once without replay and reports the missing Soul", async () => {
+    const harness = apiHarness();
+    const view = renderReveal(baseState({
+      compilingPhase: "error",
+      soulFile: null,
+      errors: { "compile.soul": "Skipped by the Human" },
+    }), harness.api);
+
+    await waitFor(() => expect(harness.putProfile).toHaveBeenCalledTimes(1));
+    expect(harness.generateSoul).not.toHaveBeenCalled();
+    expect(view.getByText(SOUL_NOT_GENERATED_NOTICE)).toBeTruthy();
+    expect(view.getByRole("button", { name: "Done →" })).toBeTruthy();
+  });
+
+  test("persists a retained Soul without starting another paid generation", async () => {
+    const harness = apiHarness();
+    renderReveal(baseState(), harness.api);
+
+    await waitFor(() => expect(harness.putProfile).toHaveBeenCalledTimes(1));
+    expect(harness.generateSoul).not.toHaveBeenCalled();
+    expect(harness.putProfile).toHaveBeenCalledWith(
+      expect.objectContaining({ soulFile: "# Retained Soul" }),
+    );
+  });
+});
diff --git a/apps/workbench/tests/unit/memory-page-protected-human-memory-contract.test.ts b/apps/workbench/tests/unit/memory-page-protected-human-memory-contract.test.ts
index d1f1aa0b4..8eddce425 100644
--- a/apps/workbench/tests/unit/memory-page-protected-human-memory-contract.test.ts
+++ b/apps/workbench/tests/unit/memory-page-protected-human-memory-contract.test.ts
@@ -32,11 +32,30 @@ describe("Memory page protected Human Memory activation", () => {
     expect(facade).toContain("protectedPort(input.protected).search");
   });
 
-  test("uses server-advertised embedding coordinates for protected edits", () => {
+  test("shows and preserves the server-advertised disclosure for protected actions", () => {
+    expect(source).toContain("await apiClient.getMemoryProcessorRecipientV2()");
+    expect(source).toContain(
+      "Semantic indexing sends this text through Surplus Intelligence, a marketplace seller, and that seller’s upstream model providers.",
+    );
+    expect(source).toContain("const current = embeddingApprovalRef.current");
+    expect(source).toContain("Reload the semantic indexing disclosure before trying again");
+    expect(source).toContain("resolveEmbeddingDisclosure: () => {");
+    expect(source).toContain('message: "The semantic indexing route changed. Reload the disclosure before trying again."');
+    expect(facade).toContain("requestedEmbedding: embedding");
     expect(source).toContain("await apiClient.getMemoryProcessorRecipient()");
     expect(facade).toContain("requestedProvider: embedding.provider");
     expect(facade).toContain("requestedModel: embedding.model");
     expect(source).not.toContain('requestedProvider: "openai"');
+    const list = source.slice(source.indexOf("function MemoryListView("),
+      source.indexOf("function MemoryEditorView("));
+    const editor = source.slice(source.indexOf("function MemoryEditorView("),
+      source.indexOf("export function MemoryPage("));
+    expect(list.indexOf("<MemoryEmbeddingDisclosure")).toBeLessThan(
+      list.indexOf("onClick={() => void runSearch()}"),
+    );
+    expect(editor.indexOf("<MemoryEmbeddingDisclosure")).toBeLessThan(
+      editor.indexOf("onClick={() => void submit()}"),
+    );
   });
 
   test("reports committed updates whose durable follow-up is pending", () => {
diff --git a/apps/workbench/tests/unit/provider-key-coverage.test.tsx b/apps/workbench/tests/unit/provider-key-coverage.test.tsx
index b0557c304..9fcbfd091 100644
--- a/apps/workbench/tests/unit/provider-key-coverage.test.tsx
+++ b/apps/workbench/tests/unit/provider-key-coverage.test.tsx
@@ -66,7 +66,7 @@ describe("ProviderKeyCoverage", () => {
       "TypeSafeOpenRouterVeniceSurplus Intelligence (qualified routes)",
       "VeniceOpenRouterOpenAIAnthropicGooglexAIFireworksTogether AISurplus Intelligence (qualified routes)OpenAI-compatible Gateway",
       "OpenAIAnthropicGoogleOpenRouterVeniceFireworksSurplus Intelligence (qualified models)",
-      "VeniceOpenRouterOpenAI",
+      "VeniceOpenRouterOpenAISurplus Intelligence (Venice 3-large)",
       "ElevenLabs",
       "ElevenLabsGroq",
       "VeniceOpenRouterOpenAIGoogleSurplus Intelligence (generation only; qualified routes)",
@@ -129,6 +129,7 @@ describe("ProviderKeyCoverage", () => {
       "Classification, scoring, and Decisions (Surplus pilot account required)",
       "Chat",
       "Image understanding",
+      "Embeddings",
       "Image generation",
       "Music generation",
       "Video generation",
@@ -138,7 +139,6 @@ describe("ProviderKeyCoverage", () => {
       ).toBeTruthy();
     }
     for (const functionality of [
-      "Embeddings",
       "Text-to-speech",
       "Speech-to-text",
       "Web search",
@@ -150,6 +150,7 @@ describe("ProviderKeyCoverage", () => {
       ).toBeTruthy();
     }
     expect(view.getByText(/Surplus rows require Prefer Surplus/u)).toBeTruthy();
+    expect(view.getByLabelText("Surplus Intelligence (Venice 3-large): API key configured")).toBeTruthy();
   });
 
   test("maps Groq only to speech-to-text", () => {
diff --git a/bin/nautilo-server/src/index.ts b/bin/nautilo-server/src/index.ts
index 1a147010a..abc350056 100644
--- a/bin/nautilo-server/src/index.ts
+++ b/bin/nautilo-server/src/index.ts
@@ -150,6 +150,7 @@ import {
   seedDefaultAgent,
   seedDefaultRoom,
   findDefaultAgentForOwner,
+  getCachedServerModelConfigRow,
 } from "@nautilo/db";
 import {
   createApp,
@@ -171,11 +172,13 @@ import {
 } from "./shutdown-pools";
 import {
   configureRuntimeComputerUseContractCatalogue,
+  hydrateSurplusChatCatalog,
   hydrateModelCapabilitiesCache,
   hydrateRuntimeComputerUseContractCatalogue,
   hydrateRuntimeModelCatalog,
   reconcileComputerUseHostTools,
   registerAllTools,
+  resolveProviderKey,
   setupCheckpointSaver,
   startRuntimeComputerUseContractCatalogueRefreshLoop,
   startRuntimeModelCatalogRefreshLoop,
@@ -696,6 +699,15 @@ async function start() {
     hostname: tlsIdentityHost,
     port,
   });
+  if (getCachedServerModelConfigRow()?.preferSurplus === true
+    && resolveProviderKey("surplus") !== null) {
+    try {
+      await hydrateSurplusChatCatalog();
+      log("[server] Surplus chat discovery hydrated");
+    } catch (err) {
+      warn(`[server] Surplus chat discovery unavailable; routes remain fail-closed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   await app.listen({ port, host });
   markReady("listening");
   const mediaGenerationWorkerAvailable = !TEST_MODE_ONLY && installProductionMediaGenerationWorker();
diff --git a/bun.lock b/bun.lock
index 65b9d73ee..952631af8 100644
--- a/bun.lock
+++ b/bun.lock
@@ -81,6 +81,7 @@
         "@nautilo/genie-customization-ui": "workspace:*",
         "@nautilo/instance-discovery": "workspace:*",
         "@nautilo/lattice-bridge": "workspace:*",
+        "@nautilo/lattice-crypto": "workspace:*",
         "@nautilo/logger": "workspace:*",
         "@nautilo/mcp-client": "workspace:*",
         "@nautilo/relay": "workspace:*",
@@ -279,6 +280,7 @@
         "@nautilo/agent": "workspace:*",
         "@nautilo/computer-use-contracts": "workspace:*",
         "@nautilo/lattice-bridge": "workspace:*",
+        "@nautilo/lattice-crypto": "workspace:*",
         "@tailwindcss/typography": "0.5.19",
         "@tailwindcss/vite": "4.2.2",
         "@testing-library/react": "16.3.2",
@@ -528,6 +530,7 @@
         "@nautilo/db": "workspace:*",
         "@nautilo/fonts": "workspace:*",
         "@nautilo/lattice-bridge": "workspace:*",
+        "@nautilo/lattice-crypto": "workspace:*",
         "@nautilo/loffice": "workspace:*",
         "@nautilo/logger": "workspace:*",
         "@nautilo/message-invariants": "workspace:*",
diff --git a/dev/tests/repo-invariants/lattice-crypto-import.test.ts b/dev/tests/repo-invariants/lattice-crypto-import.test.ts
index 54930cf03..5b9543cee 100644
--- a/dev/tests/repo-invariants/lattice-crypto-import.test.ts
+++ b/dev/tests/repo-invariants/lattice-crypto-import.test.ts
@@ -1684,6 +1684,25 @@ const reviewedCryptoProductConsumerInventory = [
   "packages/server/tests/unit/room-history-shadow-read-composition.test.ts -> @nautilo/lattice-crypto",
   "packages/server/tests/unit/task-content-backfill-authority.test.ts -> @nautilo/lattice-crypto",
   "packages/server/tests/unit/task-content-backfill-scan.test.ts -> @nautilo/lattice-crypto",
+  // Protected Memory carries the exact versioned embedding disclosure from the
+  // Agent producer through Server validation and the Desktop/Workbench consent
+  // surfaces. The package edges own those direct imports; the two Server tests
+  // exercise the same disclosure boundary without admitting a broader crypto
+  // package or internal-module seam.
+  "apps/desktop/electron/foreground-shadow-controller.ts -> @nautilo/lattice-crypto/wire",
+  "apps/desktop/electron/main.ts -> @nautilo/lattice-crypto/wire",
+  "apps/desktop/electron/preload.ts -> @nautilo/lattice-crypto/wire",
+  "apps/desktop/package.json dependency @nautilo/lattice-crypto -> workspace:*",
+  "apps/workbench/package.json dependency @nautilo/lattice-crypto -> workspace:*",
+  "apps/workbench/src/lib/desktop.ts -> @nautilo/lattice-crypto/wire",
+  "apps/workbench/src/pages/memory/memory-page.tsx -> @nautilo/lattice-crypto/wire",
+  "packages/agent/package.json dependency @nautilo/lattice-crypto -> workspace:*",
+  "packages/agent/src/store/embeddings.ts -> @nautilo/lattice-crypto/wire",
+  "packages/server/src/routes/human-memory-embedding-processor.ts -> @nautilo/lattice-crypto/wire",
+  "packages/server/src/routes/memory.ts -> @nautilo/lattice-crypto/wire",
+  "packages/server/src/routes/protected-memory-composition.ts -> @nautilo/lattice-crypto/wire",
+  "packages/server/tests/unit-isolated/human-memory-live-composition-embedding.test.ts -> @nautilo/lattice-crypto/wire",
+  "packages/server/tests/unit-isolated/memory-routes.test.ts -> @nautilo/lattice-crypto/wire",
 ] as const;
 
 const allowedReviewedCryptoProductConsumers = new Set(
@@ -3637,9 +3656,9 @@ describe("Lattice-crypto current package governance", () => {
     );
 
     const mutationTargets = manifest.scopes.flatMap((scope) => scope.mutate);
-    expect(new Set(mutationTargets).size).toBe(142);
+    expect(new Set(mutationTargets).size).toBe(144);
     expect(mutationTargets).toContain("src/message/human-message-edit-v1.ts");
-    expect(eligibleTargets).toHaveLength(142);
+    expect(eligibleTargets).toHaveLength(144);
     // Temporary Task signing adds six eligible modules to the exact inventory.
     expect(mutationTargets).toEqual(expect.arrayContaining([
       "src/background/task-runtime-request-authority.ts",
diff --git a/packages/agent/package.json b/packages/agent/package.json
index 4aa6cd671..689a30727 100644
--- a/packages/agent/package.json
+++ b/packages/agent/package.json
@@ -43,6 +43,7 @@
     "@nautilo/db": "workspace:*",
     "@nautilo/fonts": "workspace:*",
     "@nautilo/lattice-bridge": "workspace:*",
+    "@nautilo/lattice-crypto": "workspace:*",
     "@nautilo/loffice": "workspace:*",
     "@nautilo/logger": "workspace:*",
     "@nautilo/message-invariants": "workspace:*",
diff --git a/packages/agent/src/chat/model-runtime-credentials.ts b/packages/agent/src/chat/model-runtime-credentials.ts
index 15d431418..9392db9db 100644
--- a/packages/agent/src/chat/model-runtime-credentials.ts
+++ b/packages/agent/src/chat/model-runtime-credentials.ts
@@ -29,6 +29,33 @@ const SUPPORTED_CHAT_PROVIDER_PREFIXES = [
 ] as const;
 
 type SupportedChatProviderPrefix = (typeof SUPPORTED_CHAT_PROVIDER_PREFIXES)[number];
+type CredentialBearingProviderPrefix = SupportedChatProviderPrefix | "typesafe";
+
+function credentialProviderForModel(modelId: string): CredentialBearingProviderPrefix | null {
+  const id = String(modelId || "").trim();
+  if (!id) return null;
+  const colon = id.indexOf(":");
+  const prefix = colon >= 0 ? id.slice(0, colon).toLowerCase() : inferLegacyProvider(id);
+  if (prefix === "typesafe" || (SUPPORTED_CHAT_PROVIDER_PREFIXES as readonly string[]).includes(prefix)) {
+    return prefix as CredentialBearingProviderPrefix;
+  }
+  return null;
+}
+
+function credentialEnvNames(provider: CredentialBearingProviderPrefix): readonly string[] {
+  switch (provider) {
+    case "anthropic": return ["ANTHROPIC_API_KEY"];
+    case "openai": return ["OPENAI_API_KEY"];
+    case "openrouter": return ["OPENROUTER_API_KEY"];
+    case "gateway": return ["NAUTILO_GATEWAY_API_KEY", "NAUTILO_GATEWAY_BASE_URL"];
+    case "google": return ["GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY", "GEMINI_API_KEY"];
+    case "xai": return ["XAI_API_KEY"];
+    case "fireworks": return ["FIREWORKS_API_KEY"];
+    case "together": return ["TOGETHER_API_KEY"];
+    case "venice": return ["VENICE_API_KEY"];
+    case "typesafe": return ["TYPESAFE_API_KEY"];
+  }
+}
 
 function providerHasRunnableCredentials(
   provider: SupportedChatProviderPrefix,
@@ -85,11 +112,8 @@ export function modelHasRunnableCredentials(
   modelId: string,
   env: NodeJS.ProcessEnv = process.env,
 ): boolean {
-  const id = String(modelId || "").trim();
-  if (!id) return false;
-
-  const colon = id.indexOf(":");
-  const prefix = colon >= 0 ? id.slice(0, colon).toLowerCase() : inferLegacyProvider(id);
+  const prefix = credentialProviderForModel(modelId);
+  if (!prefix) return false;
 
   switch (prefix) {
     case "typesafe":
@@ -104,8 +128,33 @@ export function modelHasRunnableCredentials(
     case "together":
     case "venice":
       return providerHasRunnableCredentials(prefix, env);
-    default:
-      // Unknown explicit prefixes are not routable until the provider registry knows them.
-      return false;
   }
 }
+
+export interface ModelRunnableCredentialSnapshot {
+  readonly modelId: string;
+  readonly environment: readonly (readonly [string, string | undefined])[];
+}
+
+/** Freeze the exact environment binding used by one currently runnable direct model. */
+export function captureModelRunnableCredentialSnapshot(
+  modelId: string,
+  env: NodeJS.ProcessEnv = process.env,
+): ModelRunnableCredentialSnapshot | null {
+  const provider = credentialProviderForModel(modelId);
+  if (!provider || !modelHasRunnableCredentials(modelId, env)) return null;
+  return Object.freeze({
+    modelId,
+    environment: Object.freeze(credentialEnvNames(provider)
+      .map((name) => Object.freeze([name, env[name]] as const))),
+  });
+}
+
+/** Confirm that no credential or endpoint involved in the captured direct route changed. */
+export function isModelRunnableCredentialSnapshotCurrent(
+  snapshot: ModelRunnableCredentialSnapshot,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  return modelHasRunnableCredentials(snapshot.modelId, env)
+    && snapshot.environment.every(([name, value]) => env[name] === value);
+}
diff --git a/packages/agent/src/config/resolved-catalog.ts b/packages/agent/src/config/resolved-catalog.ts
index d6ec50077..6a3e07665 100644
--- a/packages/agent/src/config/resolved-catalog.ts
+++ b/packages/agent/src/config/resolved-catalog.ts
@@ -545,7 +545,18 @@ export function resolveServerFundedForegroundCatalogModel(
     ...(input.routes === undefined ? {} : { routes: input.routes }),
   });
   if (surplus.status !== "available") return direct;
-  const selectable = { ...direct, availability: "selectable" as const };
+  const selectable = {
+    ...direct,
+    availability: "selectable" as const,
+    contextTokens: surplus.route.maxContextTokens,
+    maxOutputTokens: surplus.route.maxOutputTokens,
+    input: direct.input.filter((modality) => modality !== "image" || surplus.route.supportsVision),
+    features: {
+      ...direct.features,
+      tools: surplus.route.supportsTools,
+      reasoning: surplus.route.supportsReasoning,
+    },
+  };
   delete selectable.unavailableReason;
   return selectable;
 }
diff --git a/packages/agent/src/config/validate-exact-task-model.ts b/packages/agent/src/config/validate-exact-task-model.ts
index b3120cc95..59b723087 100644
--- a/packages/agent/src/config/validate-exact-task-model.ts
+++ b/packages/agent/src/config/validate-exact-task-model.ts
@@ -160,13 +160,7 @@ export function validateExactTaskModelSelection(
         message: `Model "${requestedModelId}" is not qualified for tool-using Tasks through Surplus. Pick a directly configured model or a qualified tool-capable route.`,
       };
     }
-    if (row.maxOutputTokens !== null && surplus.route.maxOutputTokens < row.maxOutputTokens) {
-      return {
-        code: "capability_mismatch",
-        modelId: requestedModelId,
-        message: `Model "${requestedModelId}" requires an output budget above its qualified Surplus route. Configure its original provider or pick another exact model.`,
-      };
-    }
+
   }
   switch (row.availability) {
     case "selectable":
diff --git a/packages/agent/src/index.ts b/packages/agent/src/index.ts
index 330b4741d..19a2f0f45 100644
--- a/packages/agent/src/index.ts
+++ b/packages/agent/src/index.ts
@@ -400,6 +400,7 @@ export { preModelNode } from "./nodes/pre-model";
 export {
   agentNode,
   getDefaultForegroundAgentModelId,
+  hydrateForegroundAgentModelCatalog,
   resolveForegroundAgentModelId,
 } from "./nodes/agent";
 export {
@@ -623,6 +624,7 @@ export {
   getActiveModelCatalogProvenance,
 } from "./config/resolved-catalog";
 export {
+  hydrateSurplusChatCatalog,
   resolveQualifiedSurplusChatRoute,
   resolveSurplusChatServingAvailability,
   type QualifiedSurplusChatRoute,
@@ -1241,6 +1243,7 @@ export {
   type EmbeddingProvider,
   type EmbeddingWithProvenanceV1,
   getProtectedMemoryEmbeddingConfiguration,
+  getMemoryEmbeddingDisclosure,
 } from "./store/embeddings";
 export {
   computeMessageFingerprint,
@@ -1530,6 +1533,11 @@ export { OrdinaryContentAccessRetryRequiredError } from "./runtime/ordinary-cont
 
 export { listSpeechModels, getServerSpeechModel, resolveFundedSpeechModel, estimateSpeechCostUsd, type SpeechModel } from "./config/speech-models";
 export { surplusCredentialFingerprint, fetchSurplusSettlement } from "./providers/surplus-reconciliation";
+export {
+  getQualifiedSurplusEmbeddingRoute,
+  SURPLUS_EMBEDDING_MARKETPLACE_POLICY_VERSION,
+  type QualifiedSurplusEmbeddingRoute,
+} from "./providers/surplus-embedding-route";
 
 export { deriveSurplusMediaModelId, findSurplusMediaModel, type SurplusMediaFamily, type SurplusMediaRequirements } from "./providers/surplus-media-route";
 
diff --git a/packages/agent/src/nodes/agent.ts b/packages/agent/src/nodes/agent.ts
index c26ce0400..23a6fa809 100644
--- a/packages/agent/src/nodes/agent.ts
+++ b/packages/agent/src/nodes/agent.ts
@@ -46,11 +46,8 @@ import {
 import { getActiveModelCatalogSync } from "../config/model-catalog/runtime-catalog";
 import { getModelById } from "../config/assistant-models";
 import { ModelUnavailableError } from "../config/eligible-models";
+import { hydrateSurplusChatCatalog, type QualifiedSurplusChatRoute } from "../providers/surplus-route";
 import { resolveProviderKey } from "../resolve-provider-key";
-import {
-  resolveSurplusChatServingAvailability,
-  type QualifiedSurplusChatRoute,
-} from "../providers/surplus-route";
 import { hasStubModelForTests } from "../providers/stub-model-state";
 import { getCurrentInitiatingClientSurface } from "../runtime/initiating-client-surface-context";
 import { effectiveLiveMiniAppSessionForState } from "../runtime/live-mini-app-execution-context";
@@ -104,24 +101,15 @@ export function resolveForegroundAgentModelId(
   },
 ): string {
   if (input.fundingKind === "personal") return resolvePersonalForegroundModelId(configuredModelId);
-  try {
-    return resolveModelRole("chat", {
-      ...(configuredModelId ? { configuredId: configuredModelId } : {}),
-      ...(input.env === undefined ? {} : { env: input.env }),
-    });
-  } catch (error) {
-    const modelId = configuredModelId?.trim();
-    if (!modelId || !(error instanceof ModelUnavailableError) || error.availability !== "missing-key") throw error;
-    const surplus = resolveSurplusChatServingAvailability({
-      catalogModelId: modelId,
-      policyEnabled: input.policyEnabled ?? getCachedServerModelConfigRow()?.preferSurplus === true,
-      keyConfigured: input.keyConfigured ?? resolveProviderKey("surplus") !== null,
-      fundingKind: "server",
+  return resolveModelRole("chat", {
+    ...(configuredModelId ? { configuredId: configuredModelId } : {}),
+    ...(input.env === undefined ? {} : { env: input.env }),
+    serverSurplus: {
+      ...(input.policyEnabled === undefined ? {} : { policyEnabled: input.policyEnabled }),
+      ...(input.keyConfigured === undefined ? {} : { keyConfigured: input.keyConfigured }),
       ...(input.routes === undefined ? {} : { routes: input.routes }),
-    });
-    if (surplus.status !== "available" || !surplus.route.supportsTools) throw error;
-    return modelId;
-  }
+    },
+  });
 }
 
 /** Foreground executor fallback that honors the server default without widening background roles. */
@@ -141,6 +129,13 @@ export function getDefaultForegroundAgentModelId(
   return resolveForegroundAgentModelId(configured, { fundingKind: "server", ...input });
 }
 
+/** Async owners refresh discovery before entering the synchronous Auto resolver. */
+export async function hydrateForegroundAgentModelCatalog(signal?: AbortSignal): Promise<void> {
+  if (getCachedServerModelConfigRow()?.preferSurplus === true && resolveProviderKey("surplus") !== null) {
+    await hydrateSurplusChatCatalog(signal ? { signal } : {});
+  }
+}
+
 export async function agentNode(
   state: NautiloState,
   invocationConfig?: RunnableConfig,
@@ -154,6 +149,18 @@ export async function agentNode(
   if (isExternalRoomState(state)) state = { ...state, ...await prepareExternalRoomTextContext(state) };
   const config = fromRuntimeConfig();
   const configuredModelId = state.model || config.nautilo_model;
+  const admittedTransport = foregroundChatFundingSession?.admittedTransport
+    ?? (foregroundChatFundingSession?.admission === undefined ? undefined
+      : foregroundChatFundingSession.admission.binding.providerRoute === "surplus" ? "surplus" : "direct");
+  if (!hasStubModelForTests() && foregroundChatFundingSession?.kind !== "personal"
+    && admittedTransport !== "direct"
+    && getCachedServerModelConfigRow()?.preferSurplus === true && resolveProviderKey("surplus") !== null) {
+    await hydrateSurplusChatCatalog({
+      ...(configuredModelId ? { catalogModelIds: [configuredModelId] } : {}),
+      ...(invocationConfig?.signal ? { signal: invocationConfig.signal } : {}),
+    });
+    if (invocationConfig?.signal?.aborted) throw invocationConfig.signal.reason;
+  }
   const isForegroundTurn = (state.subagentDepth ?? 0) === 0;
   const isExactTaskTurn = state.taskRun === true
     && state.trustedExecutionEntrypoint === "background.task"
diff --git a/packages/agent/src/providers/surplus-attempt.ts b/packages/agent/src/providers/surplus-attempt.ts
index 25148d2ae..dc31a5722 100644
--- a/packages/agent/src/providers/surplus-attempt.ts
+++ b/packages/agent/src/providers/surplus-attempt.ts
@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import type { AIMessage, BaseMessage } from "@langchain/core/messages";
+import { AIMessage, type BaseMessage } from "@langchain/core/messages";
 import type { RunnableConfig } from "@langchain/core/runnables";
 import type { StructuredTool } from "@langchain/core/tools";
 import {
@@ -12,8 +12,15 @@ import { warn } from "@nautilo/logger";
 import { getUsageContext, normalizeUsageRoomId, type UsageFundingProvenance } from "../usage/usage-context";
 import { modelRouteProvider } from "./model-route";
 import type { QualifiedSurplusChatRoute } from "./surplus-route";
+import { invalidateSurplusModelCatalog } from "./surplus-catalog";
 import type { ReasoningEffort } from "./types";
 import { surplusAttemptBinding, surplusReceiptTelemetry } from "./surplus-reconciliation";
+import {
+  provenPreRoutingSurplusTrace,
+  safeSurplusErrorDiagnostics,
+  surplusErrorTelemetry,
+  SurplusMarketplaceAttemptError,
+} from "./surplus-error";
 import {
   createSurplusChatModel,
   isSafeSurplusDirectFallback,
@@ -45,11 +52,22 @@ export interface SurplusChatAttemptInput {
   readonly hasDeliveredOutput: () => boolean;
   readonly invokeModel: InvokeModel;
   readonly validateResponse?: (response: AIMessage) => void;
+  /** Optional live authority fence, evaluated after admission and immediately before provider work. */
+  readonly assertStillAuthorized?: () => void | Promise<void>;
+  /** Narrow service callers may retry direct only after a proven pre-service refusal. */
+  readonly directFallbackPolicy?: "pre_service_only";
 }
 
 export type SurplusChatAttemptResult =
   | Readonly<{ kind: "served"; response: AIMessage; requestId?: string }>
-  | Readonly<{ kind: "direct_fallback"; retryUnpinned?: true }>;
+  | Readonly<{
+      kind: "direct_fallback";
+      retryUnpinned?: true;
+      /** Exact-model supply was refused before any marketplace seller attempt. */
+      modelUnavailableBeforeService?: true;
+      /** Content-free typed cause retained when optional recovery is unavailable. */
+      failure?: Error;
+    }>;
 
 export class SurplusProviderRouteMismatchError extends Error {
   readonly code = "surplus_provider_route_mismatch" as const;
@@ -113,20 +131,38 @@ export function canUseQualifiedSurplusChatRoute(input: {
   if (input.needsVision && !route.supportsVision) return false;
   if (input.requiresTools && !route.supportsTools) return false;
   if (input.reasoningRequested && !route.supportsReasoning) return false;
-  if (input.maxOutputTokens > route.maxOutputTokens) return false;
+  if (!Number.isSafeInteger(input.maxOutputTokens) || input.maxOutputTokens < 1
+    || input.maxOutputTokens > route.maxOutputTokens) return false;
   return input.estimatedInputTokens + input.maxOutputTokens <= route.maxContextTokens;
 }
 
-function hasUnsupportedSurplusAdaptation(adaptedParameters: string | undefined): boolean {
+type SurplusAdaptationKind = "none" | "benign" | "output_ceiling" | "unsupported";
+
+function surplusAdaptationKind(adaptedParameters: string | undefined): SurplusAdaptationKind {
   const adapted = adaptedParameters?.trim();
-  // Surplus may choose a cache bucket and overwrite stream_options with
-  // include_usage:true for metering, which our adapter already requests.
-  // Neither changes inference semantics. Reject every other adaptation,
-  // including malformed lists and mixtures with inference-changing settings.
-  return Boolean(adapted && adapted.split(",").some((parameter) => {
-    const name = parameter.trim();
-    return name !== "prompt_cache_key" && name !== "stream_options";
-  }));
+  if (!adapted) return "none";
+  const parameters = adapted.split(",").map((parameter) => parameter.trim());
+  if (parameters.some((parameter) => !parameter)
+    || new Set(parameters).size !== parameters.length) return "unsupported";
+  let outputCeilingAdapted = false;
+  for (const parameter of parameters) {
+    // Surplus may choose a cache bucket and overwrite stream_options with
+    // include_usage:true for metering, which our adapter already requests.
+    if (parameter === "prompt_cache_key" || parameter === "stream_options") continue;
+    // The receipt names the parameter but not how it changed. Defer these two
+    // ceiling aliases until the completed response can prove that the actual
+    // result stayed within the caller's original budget.
+    if (parameter === "max_tokens" || parameter === "max_completion_tokens") {
+      outputCeilingAdapted = true;
+      continue;
+    }
+    return "unsupported";
+  }
+  return outputCeilingAdapted ? "output_ceiling" : "benign";
+}
+
+function hasUnsupportedSurplusAdaptation(adaptedParameters: string | undefined): boolean {
+  return surplusAdaptationKind(adaptedParameters) === "unsupported";
 }
 
 /** A successful marketplace response must preserve the provider and inference settings. */
@@ -157,16 +193,32 @@ const TERMINAL_FINISH_REASONS = new Set([
 /** A complete answer needs both an untruncated receipt and SDK-observed terminal metadata. */
 export function assertCompleteSurplusResponse(
   receipt: SurplusWireReceipt | undefined,
-  response: AIMessage,
+  response: unknown,
+  maxOutputTokens?: number,
 ): void {
-  const finishReason = record(response.response_metadata)?.["finish_reason"];
+  if (!AIMessage.isInstance(response)) throw new SurplusIncompleteResponseError();
+  const message = response;
+  const finishReason = record(message.response_metadata)?.["finish_reason"];
   if (receipt?.truncated || typeof finishReason !== "string" || !TERMINAL_FINISH_REASONS.has(finishReason)) {
     throw new SurplusIncompleteResponseError();
   }
+  const adaptation = surplusAdaptationKind(receipt?.adaptedParameters);
+  if (adaptation === "unsupported") throw new SurplusAdaptedParametersError();
+  if (adaptation === "output_ceiling") {
+    if (typeof maxOutputTokens !== "number" || !Number.isSafeInteger(maxOutputTokens) || maxOutputTokens < 1
+      || finishReason === "length") throw new SurplusAdaptedParametersError();
+    // LangChain can synthesize a normalized zero while merging absent usage
+    // fields. Require the raw terminal completion count emitted by Surplus.
+    const rawUsage = record(record(message.response_metadata)?.["usage"]);
+    const actualOutputTokens = count(rawUsage?.["completion_tokens"]);
+    if (actualOutputTokens === undefined || actualOutputTokens > maxOutputTokens) {
+      throw new SurplusAdaptedParametersError();
+    }
+  }
   // A provider-enforced content filter is a valid terminal answer even when it
   // deliberately carries no text. Every other successful terminal must give
   // Nautilo something useful to deliver or execute.
-  if (finishReason !== "content_filter" && !hasUsableSurplusResponse(response)) {
+  if (finishReason !== "content_filter" && !hasUsableSurplusResponse(message)) {
     throw new SurplusIncompleteResponseError();
   }
 }
@@ -217,7 +269,8 @@ export function classifySurplusFailedAttempt(input: {
     ? "cancelled" as const
     : input.receipt?.truncated === true
       ? "truncated_response" as const
-      : hasUnsupportedSurplusAdaptation(input.receipt?.adaptedParameters) || input.error instanceof SurplusAdaptedParametersError
+      : ["output_ceiling", "unsupported"].includes(surplusAdaptationKind(input.receipt?.adaptedParameters))
+        || input.error instanceof SurplusAdaptedParametersError
         ? "adapted_parameters" as const
         : input.error instanceof SurplusProviderRouteMismatchError
           ? "provider_route_mismatch" as const
@@ -369,10 +422,16 @@ export async function invokeSurplusChatAttempt(input: SurplusChatAttemptInput):
   let receipt: SurplusWireReceipt | undefined;
   let responseStatus: number | undefined;
   let terminalUsage: ReturnType<typeof readSurplusResponseUsage> | undefined;
+  let authorizationGuardEntered = false;
+  let invocationEntered = false;
+  let receiptAttached = false;
   const onResponse = async (next: SurplusWireReceipt, status: number) => {
     receipt = next;
     responseStatus = status;
-    if (next.requestId) {
+    // Successful streamed responses expose a settlement id. Error responses
+    // may expose only a pre-routing trace id, so defer those until the stable
+    // error code and attempt count are available in the catch path.
+    if (next.requestId && status >= 200 && status < 300) {
       try {
         await attachSurplusRequestReceipt({
           attemptId,
@@ -380,6 +439,7 @@ export async function invokeSurplusChatAttempt(input: SurplusChatAttemptInput):
           ...(next.providerFamily ? { servingProvider: next.providerFamily } : {}),
           metadata: surplusReceiptTelemetry(next),
         });
+        receiptAttached = true;
       } catch {
         warn("[nautilo/surplus] request receipt persistence failed", { failureCode: "request_receipt_failed" });
       }
@@ -399,13 +459,19 @@ export async function invokeSurplusChatAttempt(input: SurplusChatAttemptInput):
     });
     const bound = input.tools.length > 0 ? model.bindTools?.([...input.tools], input.toolBindingOptions) : model;
     if (!bound) throw new Error("The selected Surplus route cannot bind tools.");
+    if (input.assertStillAuthorized) {
+      authorizationGuardEntered = true;
+      await input.assertStillAuthorized();
+      input.config.signal?.throwIfAborted();
+    }
+    invocationEntered = true;
     const response = await input.invokeModel(
       bound as { invoke(messages: BaseMessage[], options?: RunnableConfig): Promise<unknown> },
       input.messages,
       input.config,
     );
     terminalUsage = readSurplusResponseUsage(response);
-    assertCompleteSurplusResponse(receipt, response);
+    assertCompleteSurplusResponse(receipt, response, input.maxOutputTokens);
     input.validateResponse?.(response);
     const usage = terminalUsage;
     const costMicro = usage.buyerCostMicro ?? receipt?.buyerCostMicro;
@@ -436,22 +502,61 @@ export async function invokeSurplusChatAttempt(input: SurplusChatAttemptInput):
     };
   } catch (error) {
     const cancelled = input.config.signal?.aborted === true;
-    const disposition = classifySurplusFailedAttempt({
-      error,
-      cancelled,
-      responseStatus,
-      receipt,
-      deliveredOutput: input.hasDeliveredOutput(),
-      ...(terminalUsage === undefined ? {} : { terminalUsage }),
-    });
+    const guardRejectedBeforeInvocation = authorizationGuardEntered && !invocationEntered;
+    const disposition = guardRejectedBeforeInvocation
+      ? {
+          outcome: cancelled ? "cancelled" as const : "failed" as const,
+          costState: "actual" as const,
+          actualCostUsd: 0,
+          failureCode: cancelled ? "cancelled" as const : "authorization_changed" as const,
+          directFallback: false,
+        }
+      : classifySurplusFailedAttempt({
+          error,
+          cancelled,
+          responseStatus,
+          receipt,
+          deliveredOutput: input.hasDeliveredOutput(),
+          ...(terminalUsage === undefined ? {} : { terminalUsage }),
+        });
+    const safeDiagnostics = safeSurplusErrorDiagnostics(error, responseStatus);
+    const trace = provenPreRoutingSurplusTrace({ error, responseStatus, receipt });
+    if (trace?.vendorCode === "no_sellers_for_model" || error instanceof SurplusAdaptedParametersError) {
+      // Refresh metadata for the next admission; this never replays a request
+      // whose output or billing may already have occurred.
+      invalidateSurplusModelCatalog();
+    }
+    const failure = new SurplusMarketplaceAttemptError(trace ?? safeDiagnostics);
+    if (!trace && receipt?.requestId && !receiptAttached) {
+      try {
+        await attachSurplusRequestReceipt({
+          attemptId,
+          providerRequestId: receipt.requestId,
+          ...(receipt.providerFamily ? { servingProvider: receipt.providerFamily } : {}),
+          metadata: {
+            ...surplusReceiptTelemetry(receipt),
+            ...surplusErrorTelemetry(safeDiagnostics),
+          },
+        });
+        receiptAttached = true;
+      } catch {
+        warn("[nautilo/surplus] request receipt persistence failed", { failureCode: "request_receipt_failed" });
+      }
+    }
     try {
       await settleSurplusAttemptWithRetry({
         attemptId,
-        ...(receipt?.requestId ? { providerRequestId: receipt.requestId } : {}),
-        ...(receipt ? { metadata: surplusReceiptTelemetry(receipt) } : {}),
+        ...(!trace && receipt?.requestId ? { providerRequestId: receipt.requestId } : {}),
+        ...(!receipt && Object.keys(safeDiagnostics).length === 0 ? {} : {
+          metadata: {
+            ...(receipt ? surplusReceiptTelemetry(receipt) : {}),
+            ...surplusErrorTelemetry(trace ?? safeDiagnostics),
+          },
+        }),
         outcome: disposition.outcome,
-        costState: disposition.costState,
-        ...(disposition.actualCostUsd === undefined ? {} : { actualCostUsd: disposition.actualCostUsd }),
+        costState: trace ? "actual" : disposition.costState,
+        ...(trace ? { actualCostUsd: 0 }
+          : disposition.actualCostUsd === undefined ? {} : { actualCostUsd: disposition.actualCostUsd }),
         ...(terminalUsage?.inputTokens === undefined ? {} : { inputTokens: terminalUsage.inputTokens }),
         ...(terminalUsage?.outputTokens === undefined ? {} : { outputTokens: terminalUsage.outputTokens }),
         ...(terminalUsage?.totalTokens === undefined ? {} : { totalTokens: terminalUsage.totalTokens }),
@@ -463,13 +568,21 @@ export async function invokeSurplusChatAttempt(input: SurplusChatAttemptInput):
     } catch {
       warn("[nautilo/surplus] attempt settlement failed", { failureCode: "attempt_settlement_failed" });
     }
+    if (guardRejectedBeforeInvocation) throw error;
     if (cancelled) throw input.config.signal?.reason ?? error;
-    if (disposition.directFallback) {
+    if (disposition.directFallback
+      && (input.directFallbackPolicy !== "pre_service_only" || disposition.outcome === "failed")) {
+      const modelUnavailableBeforeService = input.directFallbackPolicy === "pre_service_only"
+        && disposition.outcome === "failed"
+        && receipt?.marketplaceAttempts === 0
+        && (responseStatus === 404 || responseStatus === 503);
       return {
         kind: "direct_fallback",
+        failure,
         ...(input.providerMode !== "any" && disposition.failureCode === "no_sellers_for_model"
           ? { retryUnpinned: true as const }
           : {}),
+        ...(modelUnavailableBeforeService ? { modelUnavailableBeforeService: true as const } : {}),
       };
     }
     throw new SurplusOutcomeUnknownError();
diff --git a/packages/agent/src/providers/surplus-catalog.ts b/packages/agent/src/providers/surplus-catalog.ts
new file mode 100644
index 000000000..7d9e28896
--- /dev/null
+++ b/packages/agent/src/providers/surplus-catalog.ts
@@ -0,0 +1,649 @@
+const SURPLUS_MODELS_URL = "https://api.surplusintelligence.ai/v1/models";
+
+// Surplus documents model discovery as cacheable for one minute. The remaining
+// bounds keep provider failure finite and keep caller-derived alias state small.
+const CATALOG_FRESH_MS = 60_000;
+const CATALOG_MAX_STALE_MS = 5 * 60_000;
+const RETRY_BACKOFF_MS = 10_000;
+const REQUEST_TIMEOUT_MS = 5_000;
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+const MAX_REQUESTED_IDS = 128;
+const MAX_MODEL_ID_LENGTH = 512;
+const DETAIL_CONCURRENCY = 4;
+
+export interface SurplusModelMetadata {
+  readonly id: string;
+  readonly contextTokens: number;
+  readonly maxOutputTokens: number;
+  readonly supportsTools: boolean;
+  readonly supportsVision: boolean;
+  readonly supportsReasoning: boolean;
+  readonly supportsStreaming: boolean;
+  readonly supportedParameters: readonly string[];
+}
+
+interface CatalogSnapshot {
+  readonly version: number;
+  readonly fetchedAt: number;
+  readonly models: ReadonlyMap<string, SurplusModelMetadata>;
+  readonly aliases: ReadonlyMap<string, string>;
+  readonly missingAliases: ReadonlySet<string>;
+}
+
+interface ListCandidate {
+  readonly version: number;
+  readonly fetchedAt: number;
+  readonly models: ReadonlyMap<string, SurplusModelMetadata>;
+}
+
+interface HydrationWait {
+  readonly interrupted: Promise<"deadline" | "cancelled">;
+  readonly reason: () => "deadline" | "cancelled" | null;
+  readonly clear: () => void;
+}
+
+interface DetailJob {
+  readonly version: number;
+  readonly generation: number;
+  readonly controller: AbortController;
+  readonly consumers: Set<symbol>;
+  promise: Promise<AliasResolution>;
+  settled: boolean;
+}
+
+type AliasResolution =
+  | { readonly kind: "found"; readonly canonicalId: string }
+  | { readonly kind: "missing" }
+  | { readonly kind: "transient" };
+
+let configuredFetch: typeof fetch | undefined;
+let configuredNow: (() => number) | undefined;
+let enabled = true;
+let generation = 0;
+let nextSnapshotVersion = 1;
+let snapshot: CatalogSnapshot | null = null;
+let pendingCandidate: ListCandidate | null = null;
+let listRetryAt = 0;
+let refreshRequired = false;
+let listInflight: { readonly generation: number; readonly promise: Promise<ListCandidate | null> } | null = null;
+const detailInflight = new Map<string, DetailJob>();
+const activeDetailJobs = new Set<DetailJob>();
+const detailRetryAt = new Map<string, { readonly version: number; readonly retryAt: number }>();
+const activeControllers = new Set<AbortController>();
+let activeDetailRequests = 0;
+const detailWaiters: Array<{
+  readonly grant: () => void;
+  readonly cancel: () => void;
+}> = [];
+
+function createHydrationWait(callerSignal?: AbortSignal): HydrationWait {
+  let interruption: "deadline" | "cancelled" | null = null;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let finish!: (reason: "deadline" | "cancelled") => void;
+  const interrupted = new Promise<"deadline" | "cancelled">((resolve) => {
+    finish = (reason) => {
+      if (interruption !== null) return;
+      interruption = reason;
+      resolve(reason);
+    };
+    timer = setTimeout(() => {
+      finish("deadline");
+    }, REQUEST_TIMEOUT_MS);
+  });
+  const cancel = () => finish("cancelled");
+  callerSignal?.addEventListener("abort", cancel, { once: true });
+  if (callerSignal?.aborted) cancel();
+  return {
+    interrupted,
+    reason: () => interruption,
+    clear: () => {
+      if (timer !== undefined) clearTimeout(timer);
+      timer = undefined;
+      callerSignal?.removeEventListener("abort", cancel);
+    },
+  };
+}
+
+function now(): number {
+  return (configuredNow ?? Date.now)();
+}
+
+function age(timestamp: number, at: number): number {
+  return Math.max(0, at - timestamp);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function positiveInteger(value: unknown): number | null {
+  return Number.isSafeInteger(value) && (value as number) > 0 ? value as number : null;
+}
+
+function stringList(value: unknown): readonly string[] | null {
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) return null;
+  return value;
+}
+
+function exactModelId(value: unknown): string | null {
+  return typeof value === "string"
+    && value.length > 0
+    && value.length <= MAX_MODEL_ID_LENGTH
+    && value.trim() === value
+    ? value
+    : null;
+}
+
+function parseMetadata(row: Record<string, unknown>): SurplusModelMetadata | null {
+  const id = exactModelId(row["id"]);
+  const architecture = isRecord(row["architecture"]) ? row["architecture"] : null;
+  const inputModalities = architecture ? stringList(architecture["input_modalities"]) : null;
+  const outputModalities = architecture ? stringList(architecture["output_modalities"]) : null;
+  const topProvider = isRecord(row["top_provider"]) ? row["top_provider"] : null;
+  const supportedParameters = stringList(row["supported_parameters"]);
+  const supportedFeatures = stringList(row["supported_features"]);
+  if (!id || !inputModalities?.includes("text") || !outputModalities?.includes("text")
+    || !topProvider || !supportedParameters || !supportedFeatures) return null;
+
+  const contexts = [
+    positiveInteger(row["context_length"]),
+    positiveInteger(topProvider["context_length"]),
+  ].filter((value): value is number => value !== null);
+  const advertisedOutput = positiveInteger(topProvider["max_completion_tokens"]);
+  if (contexts.length === 0 || advertisedOutput === null) return null;
+  const contextTokens = Math.min(...contexts);
+  const maxOutputTokens = Math.min(advertisedOutput, contextTokens);
+  const parameters = Object.freeze([...supportedParameters]);
+
+  return Object.freeze({
+    id,
+    contextTokens,
+    maxOutputTokens,
+    supportsTools: parameters.includes("tools"),
+    supportsVision: inputModalities.includes("image") || supportedFeatures.includes("vision"),
+    // Feature labels describe the model; only these knobs can carry reasoning
+    // intent. Surplus always strips include_reasoning on the chat wire.
+    supportsReasoning: parameters.includes("reasoning") || parameters.includes("reasoning_effort"),
+    supportsStreaming: supportedFeatures.includes("streaming"),
+    supportedParameters: parameters,
+  });
+}
+
+function parseList(payload: unknown, fetchedAt: number): ListCandidate {
+  if (!isRecord(payload) || !Array.isArray(payload["data"])) {
+    throw new Error("Surplus model catalog has an invalid list envelope");
+  }
+  const models = new Map<string, SurplusModelMetadata>();
+  const duplicateIds = new Set<string>();
+  for (const value of payload["data"]) {
+    if (!isRecord(value)) continue;
+    const metadata = parseMetadata(value);
+    if (!metadata) continue;
+    if (models.has(metadata.id)) {
+      duplicateIds.add(metadata.id);
+      models.delete(metadata.id);
+      continue;
+    }
+    if (!duplicateIds.has(metadata.id)) models.set(metadata.id, metadata);
+  }
+  if (models.size === 0) throw new Error("Surplus model catalog has no valid chat models");
+  return Object.freeze({
+    version: nextSnapshotVersion++,
+    fetchedAt,
+    models,
+  });
+}
+
+async function readBoundedJson(response: Response): Promise<unknown> {
+  const declared = response.headers.get("content-length");
+  if (declared !== null && /^\d+$/u.test(declared) && Number(declared) > MAX_RESPONSE_BYTES) {
+    await response.body?.cancel().catch(() => undefined);
+    throw new Error("Surplus model response exceeded its byte limit");
+  }
+  if (!response.body) throw new Error("Surplus model response has no body");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let received = 0;
+  let text = "";
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      if (!(chunk.value instanceof Uint8Array)) throw new Error("Surplus model response is not bytes");
+      received += chunk.value.byteLength;
+      if (received > MAX_RESPONSE_BYTES) throw new Error("Surplus model response exceeded its byte limit");
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    text += decoder.decode();
+    return JSON.parse(text) as unknown;
+  } catch (error) {
+    await reader.cancel().catch(() => undefined);
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+async function fetchJson(
+  url: string,
+  externalSignal?: AbortSignal,
+): Promise<{ readonly status: number; readonly payload?: unknown }> {
+  const controller = new AbortController();
+  activeControllers.add(controller);
+  const abortFromExternal = () => controller.abort();
+  if (externalSignal?.aborted) controller.abort();
+  else externalSignal?.addEventListener("abort", abortFromExternal, { once: true });
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error("Surplus model discovery timed out"));
+    }, REQUEST_TIMEOUT_MS);
+  });
+  const work = async (): Promise<{ readonly status: number; readonly payload?: unknown }> => {
+    const response = await (configuredFetch ?? globalThis.fetch)(url, {
+      method: "GET",
+      redirect: "error",
+      signal: controller.signal,
+      headers: { Accept: "application/json" },
+    });
+    if (response.status === 404) {
+      await response.body?.cancel().catch(() => undefined);
+      return { status: 404 };
+    }
+    if (response.status !== 200 || !response.ok || response.type === "opaqueredirect") {
+      await response.body?.cancel().catch(() => undefined);
+      throw new Error(`Surplus model discovery failed with status ${response.status}`);
+    }
+    return { status: response.status, payload: await readBoundedJson(response) };
+  };
+  const workPromise = work();
+  workPromise.catch(() => undefined);
+  try {
+    return await Promise.race([workPromise, timeout]);
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+    externalSignal?.removeEventListener("abort", abortFromExternal);
+    activeControllers.delete(controller);
+  }
+}
+
+function usableSnapshot(at: number): CatalogSnapshot | null {
+  return snapshot && age(snapshot.fetchedAt, at) <= CATALOG_MAX_STALE_MS ? snapshot : null;
+}
+
+async function fetchList(capturedGeneration: number): Promise<ListCandidate | null> {
+  try {
+    const result = await fetchJson(SURPLUS_MODELS_URL);
+    if (result.status !== 200) throw new Error("Surplus model list was not found");
+    const candidate = parseList(result.payload, now());
+    if (generation !== capturedGeneration || !enabled) return null;
+    pendingCandidate = candidate;
+    refreshRequired = false;
+    listRetryAt = 0;
+    return candidate;
+  } catch {
+    if (generation === capturedGeneration) listRetryAt = now() + RETRY_BACKOFF_MS;
+    return null;
+  }
+}
+
+async function acquireDetailSlot(signal: AbortSignal): Promise<boolean> {
+  if (signal.aborted) return false;
+  if (activeDetailRequests < DETAIL_CONCURRENCY) {
+    activeDetailRequests += 1;
+    return true;
+  }
+  // A release transfers its occupied slot directly to this waiter. Reserving
+  // before wakeup prevents a newly arriving request from overtaking the queue.
+  return new Promise<boolean>((resolve) => {
+    let settled = false;
+    const remove = () => {
+      const index = detailWaiters.indexOf(waiter);
+      if (index >= 0) detailWaiters.splice(index, 1);
+      signal.removeEventListener("abort", waiter.cancel);
+    };
+    const waiter = {
+      grant: () => {
+        if (settled) return;
+        settled = true;
+        remove();
+        resolve(true);
+      },
+      cancel: () => {
+        if (settled) return;
+        settled = true;
+        remove();
+        resolve(false);
+      },
+    };
+    detailWaiters.push(waiter);
+    signal.addEventListener("abort", waiter.cancel, { once: true });
+    if (signal.aborted) waiter.cancel();
+  });
+}
+
+function releaseDetailSlot(): void {
+  const waiter = detailWaiters.shift();
+  if (waiter) waiter.grant();
+  else activeDetailRequests -= 1;
+}
+
+async function resolveAliasUncached(
+  requestedId: string,
+  candidate: ListCandidate,
+  capturedGeneration: number,
+  jobSignal: AbortSignal,
+): Promise<AliasResolution> {
+  const acquired = await acquireDetailSlot(jobSignal);
+  if (!acquired) return { kind: "transient" };
+  try {
+    if (jobSignal.aborted || generation !== capturedGeneration || !enabled) return { kind: "transient" };
+    const result = await fetchJson(
+      `${SURPLUS_MODELS_URL}/${encodeURIComponent(requestedId)}`,
+      jobSignal,
+    );
+    if (result.status === 404) return { kind: "missing" };
+    if (!isRecord(result.payload)) return { kind: "transient" };
+    const canonicalId = exactModelId(result.payload["id"]);
+    if (!canonicalId || !candidate.models.has(canonicalId)) return { kind: "missing" };
+    return { kind: "found", canonicalId };
+  } catch {
+    return { kind: "transient" };
+  } finally {
+    releaseDetailSlot();
+  }
+}
+
+function matchingDetailJob(
+  requestedId: string,
+  candidate: ListCandidate,
+  capturedGeneration: number,
+): DetailJob | null {
+  const inflight = detailInflight.get(requestedId);
+  if (inflight?.version === candidate.version && inflight.generation === capturedGeneration) {
+    return inflight;
+  }
+  return null;
+}
+
+function attachDetailJob(
+  requestedId: string,
+  candidate: ListCandidate,
+  capturedGeneration: number,
+  consumer: symbol,
+): DetailJob {
+  const existing = matchingDetailJob(requestedId, candidate, capturedGeneration);
+  if (existing) {
+    existing.consumers.add(consumer);
+    return existing;
+  }
+  const controller = new AbortController();
+  const job: DetailJob = {
+    version: candidate.version,
+    generation: capturedGeneration,
+    controller,
+    consumers: new Set([consumer]),
+    promise: Promise.resolve({ kind: "transient" }),
+    settled: false,
+  };
+  detailInflight.set(requestedId, job);
+  activeDetailJobs.add(job);
+  const promise = resolveAliasUncached(requestedId, candidate, capturedGeneration, controller.signal);
+  job.promise = promise;
+  promise.finally(() => {
+    job.settled = true;
+    activeDetailJobs.delete(job);
+    if (detailInflight.get(requestedId) === job) detailInflight.delete(requestedId);
+  }).catch(() => undefined);
+  return job;
+}
+
+function detachDetailJob(requestedId: string, job: DetailJob, consumer: symbol): boolean {
+  job.consumers.delete(consumer);
+  if (job.settled || job.consumers.size > 0) return false;
+  job.controller.abort();
+  if (detailInflight.get(requestedId) === job) detailInflight.delete(requestedId);
+  return true;
+}
+
+async function candidateForHydration(force: boolean, capturedGeneration: number): Promise<ListCandidate | null> {
+  const at = now();
+  if (!force) {
+    if (!refreshRequired && pendingCandidate && age(pendingCandidate.fetchedAt, at) < CATALOG_FRESH_MS) {
+      return pendingCandidate;
+    }
+    if (!refreshRequired && snapshot && age(snapshot.fetchedAt, at) < CATALOG_FRESH_MS) {
+      return { version: snapshot.version, fetchedAt: snapshot.fetchedAt, models: snapshot.models };
+    }
+    if (at < listRetryAt) {
+      const stale = usableSnapshot(at);
+      return stale ? { version: stale.version, fetchedAt: stale.fetchedAt, models: stale.models } : null;
+    }
+  }
+  if (listInflight?.generation === capturedGeneration) {
+    const shared = await listInflight.promise;
+    if (shared) return shared;
+    const stale = usableSnapshot(now());
+    return stale ? { version: stale.version, fetchedAt: stale.fetchedAt, models: stale.models } : null;
+  }
+  const promise = fetchList(capturedGeneration);
+  listInflight = { generation: capturedGeneration, promise };
+  const candidate = await promise;
+  if (listInflight?.promise === promise) listInflight = null;
+  if (candidate) return candidate;
+  const stale = usableSnapshot(now());
+  return stale ? { version: stale.version, fetchedAt: stale.fetchedAt, models: stale.models } : null;
+}
+
+function requestedIdsOrThrow(requestedIds: readonly string[]): readonly string[] {
+  const unique = new Set<string>();
+  for (const id of requestedIds) {
+    if (exactModelId(id) === null) throw new TypeError("Surplus model ids must be exact non-empty strings");
+    unique.add(id);
+  }
+  if (unique.size > MAX_REQUESTED_IDS) {
+    throw new RangeError(`Surplus model hydration accepts at most ${MAX_REQUESTED_IDS} unique ids`);
+  }
+  return [...unique];
+}
+
+function trimAliasCaches(
+  aliases: Map<string, string>,
+  missingAliases: Set<string>,
+  requestedIds: readonly string[],
+): void {
+  const priority = new Set(requestedIds);
+  const keys = [...aliases.keys(), ...missingAliases.keys()];
+  let excess = keys.length - MAX_REQUESTED_IDS;
+  if (excess <= 0) return;
+  for (const id of keys) {
+    if (excess <= 0) break;
+    if (priority.has(id)) continue;
+    aliases.delete(id);
+    missingAliases.delete(id);
+    detailRetryAt.delete(id);
+    excess -= 1;
+  }
+  for (const id of keys) {
+    if (excess <= 0) break;
+    if (!aliases.has(id) && !missingAliases.has(id)) continue;
+    aliases.delete(id);
+    missingAliases.delete(id);
+    detailRetryAt.delete(id);
+    excess -= 1;
+  }
+}
+
+function recordDetailRetry(requestedId: string, version: number): void {
+  if (!detailRetryAt.has(requestedId) && detailRetryAt.size >= MAX_REQUESTED_IDS) {
+    const oldest = detailRetryAt.keys().next().value;
+    if (oldest !== undefined) detailRetryAt.delete(oldest);
+  }
+  detailRetryAt.set(requestedId, {
+    version,
+    retryAt: now() + RETRY_BACKOFF_MS,
+  });
+}
+
+/**
+ * Refresh the public Surplus chat-model snapshot and resolve only caller-owned
+ * exact ids. Provider failures are availability misses: a valid bounded-age
+ * snapshot remains readable, while an expired snapshot fails closed.
+ */
+export async function hydrateSurplusModelCatalog(
+  requestedIds: readonly string[] = [],
+  options: { force?: boolean; signal?: AbortSignal } = {},
+): Promise<void> {
+  const exactIds = requestedIdsOrThrow(requestedIds);
+  if (!enabled || options.signal?.aborted) return;
+  const capturedGeneration = generation;
+  const wait = createHydrationWait(options.signal);
+  const consumer = Symbol("surplus-catalog-hydration");
+  const attachedJobs = new Map<string, DetailJob>();
+  let jobsDetached = false;
+  try {
+    const candidate = await Promise.race([
+      candidateForHydration(options.force === true, capturedGeneration),
+      wait.interrupted.then(() => null),
+    ]);
+    if (!candidate || generation !== capturedGeneration || !enabled) return;
+
+    const current = snapshot?.version === candidate.version ? snapshot : null;
+    const aliases = new Map(current?.aliases ?? []);
+    const missingAliases = new Set(current?.missingAliases ?? []);
+    const aliasIds = exactIds.filter((id) => !candidate.models.has(id));
+    const settledIds = new Set<string>();
+    const aliasWork = wait.reason() === null ? Promise.all(aliasIds.map(async (requestedId) => {
+      if (aliases.has(requestedId) || missingAliases.has(requestedId)) {
+        settledIds.add(requestedId);
+        return;
+      }
+      const existing = matchingDetailJob(requestedId, candidate, capturedGeneration);
+      const retry = detailRetryAt.get(requestedId);
+      if (!existing && retry?.version === candidate.version && now() < retry.retryAt) {
+        settledIds.add(requestedId);
+        return;
+      }
+      const job = attachDetailJob(
+        requestedId,
+        candidate,
+        capturedGeneration,
+        consumer,
+      );
+      attachedJobs.set(requestedId, job);
+      const resolution = await job.promise;
+      if (wait.reason() !== null || generation !== capturedGeneration || !enabled) return;
+      settledIds.add(requestedId);
+      if (resolution.kind === "found") {
+        aliases.set(requestedId, resolution.canonicalId);
+        missingAliases.delete(requestedId);
+        detailRetryAt.delete(requestedId);
+      } else if (resolution.kind === "missing") {
+        missingAliases.add(requestedId);
+        aliases.delete(requestedId);
+        detailRetryAt.delete(requestedId);
+      } else {
+        recordDetailRetry(requestedId, candidate.version);
+      }
+    })) : Promise.resolve([]);
+    aliasWork.catch(() => undefined);
+    await Promise.race([aliasWork, wait.interrupted]);
+    const interruption = wait.reason();
+    for (const [requestedId, job] of attachedJobs) {
+      const orphaned = detachDetailJob(requestedId, job, consumer);
+      if (orphaned && interruption === "deadline" && !settledIds.has(requestedId)) {
+        recordDetailRetry(requestedId, candidate.version);
+      }
+    }
+    jobsDetached = true;
+    if (generation !== capturedGeneration || !enabled) return;
+    // A slower hydration from this generation must not roll the catalog back
+    // after a forced refresh has already published a newer list snapshot.
+    if (snapshot && snapshot.version > candidate.version) return;
+
+    // A concurrent hydration may have published other exact aliases for this
+    // same list. Merge them without carrying aliases across list snapshots.
+    if (snapshot?.version === candidate.version) {
+      for (const [id, canonicalId] of snapshot.aliases) if (!missingAliases.has(id)) aliases.set(id, canonicalId);
+      for (const id of snapshot.missingAliases) if (!aliases.has(id)) missingAliases.add(id);
+    }
+    trimAliasCaches(aliases, missingAliases, exactIds);
+    snapshot = Object.freeze({
+      version: candidate.version,
+      fetchedAt: candidate.fetchedAt,
+      models: candidate.models,
+      aliases: new Map(aliases),
+      missingAliases: new Set(missingAliases),
+    });
+    if (pendingCandidate?.version === candidate.version) pendingCandidate = null;
+  } finally {
+    if (!jobsDetached) {
+      for (const [requestedId, job] of attachedJobs) detachDetailJob(requestedId, job, consumer);
+    }
+    wait.clear();
+  }
+}
+
+/** Read one already-hydrated exact canonical id or confirmed exact alias. */
+export function getSurplusModelMetadataSync(requestedId: string): SurplusModelMetadata | null {
+  if (!enabled || exactModelId(requestedId) === null) return null;
+  const current = usableSnapshot(now());
+  if (!current) return null;
+  const direct = current.models.get(requestedId);
+  if (direct) return direct;
+  const canonicalId = current.aliases.get(requestedId);
+  return canonicalId ? current.models.get(canonicalId) ?? null : null;
+}
+
+/** Replace discovery dependencies and clear all state under a new generation. */
+export function configureSurplusModelCatalog(options: {
+  fetchImpl?: typeof fetch;
+  now?: () => number;
+  enabled?: boolean;
+}): void {
+  clearState();
+  configuredFetch = options.fetchImpl;
+  configuredNow = options.now;
+  enabled = options.enabled ?? true;
+}
+
+function clearState(): void {
+  generation += 1;
+  for (const controller of activeControllers) controller.abort();
+  for (const job of activeDetailJobs) job.controller.abort();
+  activeControllers.clear();
+  snapshot = null;
+  pendingCandidate = null;
+  listRetryAt = 0;
+  refreshRequired = false;
+  listInflight = null;
+  detailInflight.clear();
+  detailRetryAt.clear();
+  nextSnapshotVersion = 1;
+}
+
+/** Restore production defaults and fence any in-flight generation. */
+export function resetSurplusModelCatalog(): void {
+  clearState();
+  configuredFetch = undefined;
+  configuredNow = undefined;
+  enabled = true;
+}
+
+/**
+ * Fence current discovery work and require the next hydration to refresh.
+ * The bounded-age last-known-good snapshot remains synchronously readable.
+ */
+export function invalidateSurplusModelCatalog(): void {
+  generation += 1;
+  for (const controller of activeControllers) controller.abort();
+  for (const job of activeDetailJobs) job.controller.abort();
+  activeControllers.clear();
+  pendingCandidate = null;
+  listRetryAt = 0;
+  refreshRequired = true;
+  listInflight = null;
+  detailInflight.clear();
+  detailRetryAt.clear();
+}
diff --git a/packages/agent/src/providers/surplus-embedding-route.ts b/packages/agent/src/providers/surplus-embedding-route.ts
new file mode 100644
index 000000000..bbda91d01
--- /dev/null
+++ b/packages/agent/src/providers/surplus-embedding-route.ts
@@ -0,0 +1,94 @@
+import type { SurplusWireReceipt } from "./surplus-transport";
+
+export const SURPLUS_EMBEDDING_MARKETPLACE_POLICY_VERSION =
+  "surplus-embedding-marketplace-v1" as const;
+
+export const QUALIFIED_SURPLUS_EMBEDDING_CATALOG_MODEL_ID =
+  "venice:text-embedding-3-large" as const;
+const QUALIFIED_MODEL = "text-embedding-3-large";
+const QUALIFIED_DIMENSIONS = 1_536;
+const QUALIFIED_RECEIPT_MODEL = "venice-embed-1";
+const KNOWN_SERVING_PROVIDERS = Object.freeze(["mordiem", "venice"] as const);
+const QUALIFIED_ADAPTED_PARAMETER = "safe_mode";
+
+export interface QualifiedSurplusEmbeddingRoute {
+  readonly catalogModelId: typeof QUALIFIED_SURPLUS_EMBEDDING_CATALOG_MODEL_ID;
+  readonly provider: "venice";
+  readonly model: typeof QUALIFIED_MODEL;
+  readonly dimensions: typeof QUALIFIED_DIMENSIONS;
+  readonly wireModel: typeof QUALIFIED_MODEL;
+  readonly responseModel: typeof QUALIFIED_MODEL;
+  readonly receiptModel: typeof QUALIFIED_RECEIPT_MODEL;
+  readonly servingPolicy: typeof SURPLUS_EMBEDDING_MARKETPLACE_POLICY_VERSION;
+  readonly knownServingProviders: typeof KNOWN_SERVING_PROVIDERS;
+}
+
+const QUALIFIED_ROUTE: QualifiedSurplusEmbeddingRoute = Object.freeze({
+  catalogModelId: QUALIFIED_SURPLUS_EMBEDDING_CATALOG_MODEL_ID,
+  provider: "venice",
+  model: QUALIFIED_MODEL,
+  dimensions: QUALIFIED_DIMENSIONS,
+  wireModel: QUALIFIED_MODEL,
+  responseModel: QUALIFIED_MODEL,
+  receiptModel: QUALIFIED_RECEIPT_MODEL,
+  servingPolicy: SURPLUS_EMBEDDING_MARKETPLACE_POLICY_VERSION,
+  knownServingProviders: KNOWN_SERVING_PROVIDERS,
+});
+
+/** Return the one embedding space qualified for the marketplace transport. */
+export function getQualifiedSurplusEmbeddingRoute(
+  catalogModelId: string,
+  dimensions: number,
+): QualifiedSurplusEmbeddingRoute | null {
+  return catalogModelId === QUALIFIED_ROUTE.catalogModelId
+    && dimensions === QUALIFIED_ROUTE.dimensions
+    ? QUALIFIED_ROUTE
+    : null;
+}
+
+export class SurplusEmbeddingReceiptError extends Error {
+  readonly code = "surplus_embedding_receipt_invalid" as const;
+
+  constructor() {
+    super("Surplus returned an unqualified embedding response.");
+    this.name = "SurplusEmbeddingReceiptError";
+  }
+}
+
+/** Successful embedding responses must identify a qualified processor and preserve parameters. */
+export function assertQualifiedSurplusEmbeddingReceipt(
+  route: QualifiedSurplusEmbeddingRoute,
+  receipt: SurplusWireReceipt,
+  responseStatus: number,
+): void {
+  if (responseStatus < 200 || responseStatus >= 300) return;
+  const servingProvider = receipt.providerFamily?.trim().toLowerCase();
+  if (!servingProvider || !route.knownServingProviders.includes(
+    servingProvider as (typeof route.knownServingProviders)[number],
+  )) {
+    throw new SurplusEmbeddingReceiptError();
+  }
+  // Qualified Mordiem/Venice probes consistently disclose this one adapter change.
+  // Keep the allowance bound to the observed token without inferring its semantics.
+  const adaptedParameters = receipt.adaptedParameters
+    ?.split(",")
+    .map((parameter) => parameter.trim())
+    .filter(Boolean);
+  if (adaptedParameters?.length
+    && (adaptedParameters.length !== 1
+      || adaptedParameters[0] !== QUALIFIED_ADAPTED_PARAMETER)) {
+    throw new SurplusEmbeddingReceiptError();
+  }
+  if (receipt.truncated) throw new SurplusEmbeddingReceiptError();
+}
+
+/** Validate the successful response's model alias before accepting any vectors. */
+export function assertQualifiedSurplusEmbeddingResponseModel(
+  route: QualifiedSurplusEmbeddingRoute,
+  value: unknown,
+): void {
+  const model = value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)["model"]
+    : undefined;
+  if (model !== route.responseModel) throw new SurplusEmbeddingReceiptError();
+}
diff --git a/packages/agent/src/providers/surplus-error.ts b/packages/agent/src/providers/surplus-error.ts
new file mode 100644
index 000000000..da8db3d08
--- /dev/null
+++ b/packages/agent/src/providers/surplus-error.ts
@@ -0,0 +1,138 @@
+import type { SurplusWireReceipt } from "./surplus-transport";
+
+const SAFE_CODE = /^[a-z][a-z0-9_]{0,63}$/;
+const SAFE_REQUEST_ID = /^[a-zA-Z0-9_-]{1,128}$/;
+
+export interface SafeSurplusErrorDiagnostics {
+  readonly vendorCode?: string;
+  readonly responseStatus?: number;
+  readonly traceId?: string;
+}
+
+export class SurplusMarketplaceAttemptError extends Error {
+  readonly code = "surplus_marketplace_attempt_failed" as const;
+  readonly vendorCode?: string;
+  readonly status?: number;
+  readonly traceId?: string;
+
+  constructor(diagnostics: SafeSurplusErrorDiagnostics) {
+    super("The Surplus marketplace attempt did not return a usable completion.");
+    this.name = "SurplusMarketplaceAttemptError";
+    if (diagnostics.vendorCode !== undefined) this.vendorCode = diagnostics.vendorCode;
+    if (diagnostics.responseStatus !== undefined) this.status = diagnostics.responseStatus;
+    if (diagnostics.traceId !== undefined) this.traceId = diagnostics.traceId;
+  }
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function safeSurplusVendorCode(value: unknown): string | undefined {
+  const outer = record(value);
+  const nested = record(outer?.["error"]);
+  const candidate = typeof outer?.["vendorCode"] === "string" ? outer["vendorCode"]
+    : typeof outer?.["code"] === "string" ? outer["code"] : nested?.["code"];
+  if (typeof candidate !== "string") return undefined;
+  const normalized = candidate.trim().toLowerCase();
+  return SAFE_CODE.test(normalized) ? normalized : undefined;
+}
+
+function safeSurplusRequestId(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  return SAFE_REQUEST_ID.test(normalized) ? normalized : undefined;
+}
+
+function safeResponseStatus(value: number | undefined): number | undefined {
+  if (value === undefined || !Number.isSafeInteger(value) || value < 400 || value > 599) return undefined;
+  return value;
+}
+
+export function safeSurplusErrorDiagnostics(
+  error: unknown,
+  responseStatus: number | undefined,
+): SafeSurplusErrorDiagnostics {
+  const vendorCode = safeSurplusVendorCode(error);
+  const status = safeResponseStatus(responseStatus);
+  return {
+    ...(vendorCode === undefined ? {} : { vendorCode }),
+    ...(status === undefined ? {} : { responseStatus: status }),
+  };
+}
+
+/** Affirmative routing refusal evidence distinguishes a trace from a financial request. */
+export function provenPreRoutingSurplusTrace(input: {
+  readonly error: unknown;
+  readonly responseStatus: number | undefined;
+  readonly receipt: SurplusWireReceipt | undefined;
+  readonly requestId?: string;
+}): SafeSurplusErrorDiagnostics | null {
+  const vendorCode = safeSurplusVendorCode(input.error);
+  const responseStatus = safeResponseStatus(input.responseStatus);
+  const traceId = safeSurplusRequestId(input.requestId ?? input.receipt?.requestId);
+  if (!vendorCode || responseStatus === undefined || !traceId
+    || input.receipt?.marketplaceAttempts !== 0
+    || input.receipt.truncated || input.receipt.adaptedParameters?.trim()
+    || (input.receipt.buyerCostMicro ?? 0) !== 0) return null;
+  const proven = (responseStatus === 404 && vendorCode === "no_sellers_for_model")
+    || (responseStatus === 503 && vendorCode === "no_healthy_sellers");
+  return proven ? { vendorCode, responseStatus, traceId } : null;
+}
+
+export function surplusErrorTelemetry(diagnostics: SafeSurplusErrorDiagnostics): Record<string, unknown> {
+  return {
+    ...(diagnostics.vendorCode === undefined ? {} : { surplusErrorCode: diagnostics.vendorCode }),
+    ...(diagnostics.responseStatus === undefined ? {} : { surplusResponseStatus: diagnostics.responseStatus }),
+    ...(diagnostics.traceId === undefined ? {} : { surplusTraceId: diagnostics.traceId }),
+  };
+}
+
+interface BoundedBodyReader {
+  read(): Promise<Readonly<{ done?: boolean; value?: unknown }>>;
+  cancel(): Promise<unknown>;
+  releaseLock(): void;
+}
+
+/** Read only the bounded stable code and request reference from a discarded error body. */
+export async function readBoundedSurplusErrorBody(reader: BoundedBodyReader | undefined): Promise<Readonly<{
+  vendorCode?: string;
+  requestId?: string;
+}>> {
+  if (!reader) return {};
+  const parts: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      if (!(chunk.value instanceof Uint8Array)) return {};
+      size += chunk.value.byteLength;
+      if (size > 65_536) {
+        await reader.cancel();
+        return {};
+      }
+      parts.push(chunk.value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const part of parts) {
+      bytes.set(part, offset);
+      offset += part.byteLength;
+    }
+    const value: unknown = JSON.parse(new TextDecoder().decode(bytes));
+    const row = record(value);
+    const vendorCode = safeSurplusVendorCode(row);
+    const requestId = safeSurplusRequestId(row?.["request_id"]);
+    return {
+      ...(vendorCode === undefined ? {} : { vendorCode }),
+      ...(requestId === undefined ? {} : { requestId }),
+    };
+  } catch {
+    return {};
+  } finally {
+    reader.releaseLock();
+  }
+}
diff --git a/packages/agent/src/providers/surplus-route.ts b/packages/agent/src/providers/surplus-route.ts
index f61f46a6c..7eacd45e4 100644
--- a/packages/agent/src/providers/surplus-route.ts
+++ b/packages/agent/src/providers/surplus-route.ts
@@ -1,5 +1,6 @@
 import type { ModelCatalogEntry } from "@nautilo/types";
 import { getActiveModelCatalogSync } from "../config/model-catalog/runtime-catalog";
+import { getSurplusModelMetadataSync, hydrateSurplusModelCatalog } from "./surplus-catalog";
 
 export type SurplusProviderPin =
   | "anthropic"
@@ -20,6 +21,8 @@ export interface QualifiedSurplusChatRoute {
   readonly supportsReasoning: boolean;
   readonly maxContextTokens: number;
   readonly maxOutputTokens: number;
+  /** Vendor-advertised request knobs; omitted only by the offline route seam. */
+  readonly supportedParameters?: readonly string[];
 }
 
 const SURPLUS_PROVIDER_PINS = Object.freeze({
@@ -55,18 +58,44 @@ function deriveRoute(entry: ModelCatalogEntry): QualifiedSurplusChatRoute | null
   if (!providerPin || !surplusModelId || !isEligibleSignedChatEntry(entry)
     || !Number.isSafeInteger(maxContextTokens) || !Number.isSafeInteger(maxOutputTokens)
     || (maxContextTokens ?? 0) < 1 || (maxOutputTokens ?? 0) < 1) return null;
+  const discovered = getSurplusModelMetadataSync(surplusModelId);
+  if (!discovered?.supportsStreaming) return null;
+  // These signed controls synthesize an effort even without a Human override.
+  // Do not advertise a route that cannot carry that required request intent.
+  if ("controls" in entry && entry.controls?.reasoning && !discovered.supportsReasoning) return null;
   return Object.freeze({
     catalogModelId: entry.id,
-    surplusModelId,
+    surplusModelId: discovered.id,
     providerPin,
-    supportsTools: entry.features?.tools === true,
-    supportsVision: entry.modalities?.input?.includes("image") === true,
-    supportsReasoning: entry.features?.reasoning === true,
-    maxContextTokens: maxContextTokens!,
-    maxOutputTokens: maxOutputTokens!,
+    supportsTools: entry.features?.tools === true && discovered.supportsTools,
+    supportsVision: entry.modalities?.input?.includes("image") === true && discovered.supportsVision,
+    supportsReasoning: entry.features?.reasoning === true && discovered.supportsReasoning,
+    maxContextTokens: Math.min(maxContextTokens!, discovered.contextTokens),
+    maxOutputTokens: Math.min(maxOutputTokens!, discovered.maxOutputTokens, maxContextTokens!),
+    supportedParameters: discovered.supportedParameters,
   });
 }
 
+/** Refresh transport facts only for signed, policy-eligible chat identities. */
+export async function hydrateSurplusChatCatalog(input: {
+  readonly catalogModelIds?: readonly string[];
+  readonly force?: boolean;
+  readonly signal?: AbortSignal;
+} = {}): Promise<void> {
+  input.signal?.throwIfAborted();
+  const selected = input.catalogModelIds === undefined ? null : new Set(input.catalogModelIds);
+  const requestedIds = getActiveModelCatalogSync().catalog.entries
+    .filter((entry) => (!selected || selected.has(entry.id))
+      && isEligibleSignedChatEntry(entry) && providerPinForCatalogEntry(entry) !== null)
+    .map((entry) => entry.id.slice(entry.id.indexOf(":") + 1));
+  if (!requestedIds.length) return;
+  await hydrateSurplusModelCatalog([...new Set(requestedIds)], {
+    ...(input.force === undefined ? {} : { force: input.force }),
+    ...(input.signal === undefined ? {} : { signal: input.signal }),
+  });
+  input.signal?.throwIfAborted();
+}
+
 function validateInjectedRoute(
   entry: ModelCatalogEntry,
   route: QualifiedSurplusChatRoute,
@@ -79,6 +108,9 @@ function validateInjectedRoute(
   if (!route.surplusModelId.trim()) return null;
   if (entry.limits?.contextTokens && route.maxContextTokens > entry.limits.contextTokens) return null;
   if (entry.limits?.outputTokens && route.maxOutputTokens > entry.limits.outputTokens) return null;
+  if (route.supportsTools && entry.features?.tools !== true) return null;
+  if (route.supportsVision && entry.modalities?.input?.includes("image") !== true) return null;
+  if (route.supportsReasoning && entry.features?.reasoning !== true) return null;
   return route;
 }
 
diff --git a/packages/agent/src/providers/surplus-transport.ts b/packages/agent/src/providers/surplus-transport.ts
index e6576cbd4..30dfea583 100644
--- a/packages/agent/src/providers/surplus-transport.ts
+++ b/packages/agent/src/providers/surplus-transport.ts
@@ -1,13 +1,13 @@
 import type { ChatGenerationChunk } from "@langchain/core/outputs";
-import { ChatOpenAI } from "@langchain/openai";
+import {
+  ChatOpenAI,
+  type convertCompletionsDeltaToBaseMessageChunk,
+} from "@langchain/openai";
 import type { ChatModel, ReasoningEffort } from "./types";
 import type { QualifiedSurplusChatRoute } from "./surplus-route";
 import { OpenRouterReasoningCompletions } from "./openrouter-reasoning";
 import { openRouterSessionModelKwargs, surplusReasoningModelKwargs } from "./factory";
-import {
-  VeniceChatOpenAICompletions,
-  wrapVeniceModelForToolSchemas,
-} from "./venice-compat";
+import { wrapVeniceModelForToolSchemas } from "./venice-compat";
 
 const SURPLUS_API_ROOT = "https://api.surplusintelligence.ai/v1";
 const SURPLUS_CHAT_PATH = "/v1/chat/completions";
@@ -178,6 +178,72 @@ export interface CreateSurplusChatModelInput {
   readonly fetchImpl?: typeof fetch;
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Project the factory-reviewed reasoning intent onto the exact spelling the
+ * discovered model advertises. Surplus does not generally translate these two
+ * chat-wire shapes, and include_reasoning is always stripped upstream.
+ */
+function discoveredSurplusReasoningKwargs(
+  route: QualifiedSurplusChatRoute,
+  reviewed: Record<string, unknown>,
+  explicitReasoningEffort: boolean,
+): Record<string, unknown> {
+  const withoutVisibilityHint = { ...reviewed };
+  delete withoutVisibilityHint["include_reasoning"];
+  if (route.supportedParameters === undefined) return withoutVisibilityHint;
+
+  const supported = new Set(route.supportedParameters);
+  const supportsNested = supported.has("reasoning");
+  const supportsFlat = supported.has("reasoning_effort");
+  const nested = isRecord(withoutVisibilityHint["reasoning"])
+    ? withoutVisibilityHint["reasoning"]
+    : undefined;
+  const flat = typeof withoutVisibilityHint["reasoning_effort"] === "string"
+    ? withoutVisibilityHint["reasoning_effort"]
+    : undefined;
+
+  delete withoutVisibilityHint["reasoning"];
+  delete withoutVisibilityHint["reasoning_effort"];
+
+  if (supportsNested && supportsFlat) {
+    return {
+      ...withoutVisibilityHint,
+      ...(nested ? { reasoning: nested } : {}),
+      ...(flat ? { reasoning_effort: flat } : {}),
+    };
+  }
+  if (supportsNested) {
+    return {
+      ...withoutVisibilityHint,
+      ...(nested
+        ? { reasoning: nested }
+        : flat
+          ? { reasoning: { effort: flat } }
+          : {}),
+    };
+  }
+  if (supportsFlat) {
+    const effort = flat
+      ?? (typeof nested?.["effort"] === "string"
+        ? nested["effort"]
+        : nested?.["enabled"] === false
+          ? "none"
+          : undefined);
+    return {
+      ...withoutVisibilityHint,
+      ...(effort ? { reasoning_effort: effort } : {}),
+    };
+  }
+  if (explicitReasoningEffort) {
+    throw new Error("The discovered Surplus model does not advertise a reasoning control.");
+  }
+  return withoutVisibilityHint;
+}
+
 function projectSurplusStreamChunk(
   chunk: ChatGenerationChunk,
   terminalReason: string | undefined,
@@ -210,8 +276,27 @@ function projectSurplusStreamChunk(
   return terminalReason;
 }
 
-/** Preserve terminal metadata for every non-Venice OpenAI-compatible pin. */
+type CompletionDeltaConversion = Parameters<
+  typeof convertCompletionsDeltaToBaseMessageChunk
+>[0];
+
+/** Preserve terminal metadata for every Surplus OpenAI-compatible pin. */
 class SurplusOpenAICompatibleCompletions extends OpenRouterReasoningCompletions {
+  protected override _convertCompletionsDeltaToBaseMessageChunk(
+    delta: CompletionDeltaConversion["delta"],
+    rawResponse: CompletionDeltaConversion["rawResponse"],
+    defaultRole?: CompletionDeltaConversion["defaultRole"],
+  ) {
+    // A chat-completion choice is assistant output, but Surplus sellers may
+    // omit delta.role from every streamed frame. Explicit roles still win in
+    // LangChain's converter; this supplies only its otherwise-missing default.
+    return super._convertCompletionsDeltaToBaseMessageChunk(
+      delta,
+      rawResponse,
+      defaultRole ?? "assistant",
+    );
+  }
+
   override async *_streamResponseChunks(
     ...args: Parameters<OpenRouterReasoningCompletions["_streamResponseChunks"]>
   ) {
@@ -224,7 +309,7 @@ class SurplusOpenAICompatibleCompletions extends OpenRouterReasoningCompletions
 }
 
 /** Surplus may repeat the terminal choice when attaching its final usage receipt. */
-class SurplusOpenRouterCompletions extends OpenRouterReasoningCompletions {
+class SurplusOpenRouterCompletions extends SurplusOpenAICompatibleCompletions {
   override invocationParams(
     ...args: Parameters<OpenRouterReasoningCompletions["invocationParams"]>
   ) {
@@ -237,18 +322,6 @@ class SurplusOpenRouterCompletions extends OpenRouterReasoningCompletions {
     }
     return params;
   }
-
-  override async *_streamResponseChunks(
-    ...args: Parameters<OpenRouterReasoningCompletions["_streamResponseChunks"]>
-  ) {
-    // State belongs to this stream, so concurrent invocations cannot share a
-    // terminal marker. Keep the SDK's final usage chunk and all reasoning.
-    let terminalReason: string | undefined;
-    for await (const chunk of super._streamResponseChunks(...args)) {
-      terminalReason = projectSurplusStreamChunk(chunk, terminalReason);
-      yield chunk;
-    }
-  }
 }
 
 /** Pinned text-chat wire within the admitted payer. Caller owns attempt persistence. */
@@ -262,6 +335,15 @@ export function createSurplusChatModel(input: CreateSurplusChatModelInput): Chat
     throw new Error("Surplus output budget exceeds the qualified route limit.");
   }
   const isVenice = input.providerMode !== "any" && input.route.providerPin === "venice";
+  const reasoningKwargs = discoveredSurplusReasoningKwargs(
+    input.route,
+    surplusReasoningModelKwargs({
+      modelId: input.route.catalogModelId,
+      ...(input.reasoningEffort === undefined ? {} : { reasoningEffort: input.reasoningEffort }),
+      ...(input.reasoningOutput === undefined ? {} : { reasoningOutput: input.reasoningOutput }),
+    }, input.maxOutputTokens),
+    input.reasoningEffort !== undefined,
+  );
   const base = {
     model: input.route.surplusModelId,
     apiKey,
@@ -271,11 +353,7 @@ export function createSurplusChatModel(input: CreateSurplusChatModelInput): Chat
     streamUsage: true,
     modelKwargs: {
       ...(input.providerMode === "any" ? {} : { provider: input.route.providerPin }),
-      ...surplusReasoningModelKwargs({
-        modelId: input.route.catalogModelId,
-        ...(input.reasoningEffort === undefined ? {} : { reasoningEffort: input.reasoningEffort }),
-        ...(input.reasoningOutput === undefined ? {} : { reasoningOutput: input.reasoningOutput }),
-      }, input.maxOutputTokens),
+      ...reasoningKwargs,
       ...(input.route.providerPin === "openrouter"
         ? openRouterSessionModelKwargs(input.openrouterSessionId)
         : {}),
@@ -290,11 +368,9 @@ export function createSurplusChatModel(input: CreateSurplusChatModelInput): Chat
   };
   const model = new ChatOpenAI({
     ...base,
-    ...(isVenice
-      ? { completions: new VeniceChatOpenAICompletions(base) }
-      : input.route.providerPin === "openrouter"
-        ? { completions: new SurplusOpenRouterCompletions(base) }
-        : { completions: new SurplusOpenAICompatibleCompletions(base) }),
+    ...(input.route.providerPin === "openrouter"
+      ? { completions: new SurplusOpenRouterCompletions(base) }
+      : { completions: new SurplusOpenAICompatibleCompletions(base) }),
   }) as unknown as ChatModel;
   return isVenice
     ? wrapVeniceModelForToolSchemas(model)
diff --git a/packages/agent/src/providers/universal.ts b/packages/agent/src/providers/universal.ts
index e46de9cc8..416c1d335 100644
--- a/packages/agent/src/providers/universal.ts
+++ b/packages/agent/src/providers/universal.ts
@@ -418,6 +418,14 @@ async function createUniversalModelInternal(
   const factoryOpts: CreateModelOptions = { modelId: id };
   // The durable personal attempt owner accounts for each retry before the wire.
   if (personalCredential) factoryOpts.maxRetries = 0;
+  if (!personalCredential && cleanOptions["maxRetries"] !== undefined) {
+    const maxRetries = cleanOptions["maxRetries"];
+    if (typeof maxRetries !== "number" || !Number.isSafeInteger(maxRetries) || maxRetries < 0) {
+      throw new Error("Provider retry count must be a nonnegative integer.");
+    }
+    factoryOpts.maxRetries = maxRetries;
+  }
+  delete cleanOptions["maxRetries"];
   if (usageCallbacks) factoryOpts.callbacks = usageCallbacks;
   const apiKey = personalCredential?.apiKey ?? cleanOptions["apiKey"] as string | undefined;
   const baseUrl = (cleanOptions["baseUrl"] ?? cleanOptions["baseURL"]) as string | undefined;
@@ -529,7 +537,7 @@ async function createUniversalModelInternal(
         usageCallbacks,
         personalCredential,
       );
-      if (personalCredential) orOpts.maxRetries = 0;
+      if (factoryOpts.maxRetries !== undefined) orOpts.maxRetries = factoryOpts.maxRetries;
       if (resolvedMaxTokens !== undefined) orOpts.maxTokens = resolvedMaxTokens;
       if (resolvedTimeoutMs !== undefined) orOpts.timeoutMs = resolvedTimeoutMs;
       orOpts.reasoningOutput = reasoningOutput;
@@ -541,6 +549,7 @@ async function createUniversalModelInternal(
     }
     case "gateway": {
       const gateway = buildGatewayCreateModelOptions(id, cleanOptions, usageCallbacks);
+      if (factoryOpts.maxRetries !== undefined) gateway.options.maxRetries = factoryOpts.maxRetries;
       if (resolvedMaxTokens !== undefined) gateway.options.maxTokens = resolvedMaxTokens;
       if (resolvedTimeoutMs !== undefined) gateway.options.timeoutMs = resolvedTimeoutMs;
       gateway.options.reasoningOutput = reasoningOutput;
diff --git a/packages/agent/src/runtime/foreground-chat-funding.ts b/packages/agent/src/runtime/foreground-chat-funding.ts
index 6f510b369..27341ab62 100644
--- a/packages/agent/src/runtime/foreground-chat-funding.ts
+++ b/packages/agent/src/runtime/foreground-chat-funding.ts
@@ -50,6 +50,8 @@ export interface ForegroundFundingSnapshot {
 
 export interface ForegroundChatFundingSession {
   readonly admission?: ForegroundFundingSnapshot;
+  /** Request-local serving fact, never checkpointed or used as funding authority. */
+  readonly admittedTransport?: "direct" | "surplus";
   readonly kind: "personal" | "server";
   /** Trusted request-local diagnostics policy; independent of who pays. Never serialized. */
   readonly contentPrivateDiagnostics?: true;
diff --git a/packages/agent/src/soul/generate-soul-file.ts b/packages/agent/src/soul/generate-soul-file.ts
index 38c8bad60..3bf5467c9 100644
--- a/packages/agent/src/soul/generate-soul-file.ts
+++ b/packages/agent/src/soul/generate-soul-file.ts
@@ -1,12 +1,46 @@
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { fromRuntimeConfig } from "@nautilo/config";
+import {
+  AIMessage,
+  AIMessageChunk,
+  HumanMessage,
+  SystemMessage,
+  type BaseMessage,
+} from "@langchain/core/messages";
+import type { RunnableConfig } from "@langchain/core/runnables";
+import { candidatesForModelRole, fromRuntimeConfig } from "@nautilo/config";
+import { getCachedServerModelConfigRow } from "@nautilo/db";
 import { warn } from "@nautilo/logger";
 import { createUniversalModel } from "../providers/universal";
+import { hasStubModelForTests } from "../providers/stub-model-state";
 import { modelRouteProvider } from "../providers/model-route";
 import { resolveOpenRouterTransport } from "../providers/openrouter-transport";
+import { resolveProviderKey } from "../resolve-provider-key";
 import { runWithUsageContext } from "../usage/usage-context";
+import { runPersonalLlmAttempt } from "../usage/personal-llm-attempt";
 import { normalizeSoulFileInput, type SoulFileInput } from "./types";
 import { resolveModelRole } from "../config/model-role-resolution";
+import {
+  captureModelRunnableCredentialSnapshot,
+  isModelRunnableCredentialSnapshotCurrent,
+  modelHasRunnableCredentials,
+  type ModelRunnableCredentialSnapshot,
+} from "../chat/model-runtime-credentials";
+import {
+  invokeSurplusChatAttempt,
+  type SurplusChatAttemptResult,
+} from "../providers/surplus-attempt";
+import {
+  canBroadenSurplusModelRoute,
+  hydrateSurplusChatCatalog,
+  resolveSurplusChatServingAvailability,
+  SurplusDirectFallbackUnavailableError,
+  type QualifiedSurplusChatRoute,
+} from "../providers/surplus-route";
+import { SurplusOutcomeUnknownError } from "../providers/surplus-transport";
+import type { ChatModel } from "../providers/types";
+import {
+  resolveCompletionBudget,
+  resolveSurplusCompletionBudget,
+} from "../utils/chat-model-invocation";
 import {
   assertCanUseServerFundedOwnSoul,
   assertCanUseServerProviderCredentials,
@@ -273,6 +307,7 @@ function soulUsageProviderRoute(modelId: string): string {
 function soulUsageContext(
   modelId: string,
   authorization: SoulGenerationAuthorization,
+  providerRoute = soulUsageProviderRoute(modelId),
 ) {
   return {
     callType: "soul" as const,
@@ -280,7 +315,7 @@ function soulUsageContext(
     funding: {
       kind: "service" as const,
       humanUserId: authorization.humanUserId,
-      providerRoute: soulUsageProviderRoute(modelId),
+      providerRoute,
     },
     ...(authorization.agentId
       ? { metadata: { agentId: authorization.agentId, service: "soul_generation" } }
@@ -288,6 +323,431 @@ function soulUsageContext(
   };
 }
 
+type SoulMessages = readonly [SystemMessage, HumanMessage];
+
+interface ResolvedSoulInvocation {
+  readonly modelId: string;
+  readonly messages: SoulMessages;
+  /** The selected direct provider's signed limit; marketplace discovery never changes it. */
+  readonly maxOutputTokens: number;
+  /** The discovered marketplace limit after output and context intersection. */
+  readonly surplusMaxOutputTokens: number | null;
+  readonly surplusPolicyEnabled: boolean;
+  readonly surplusKey: string | null;
+  readonly surplusRoute: QualifiedSurplusChatRoute | null;
+  readonly broadeningAuthorityModelId?: string;
+}
+
+async function resolveSoulOutputBudgets(
+  modelId: string,
+  messages: SoulMessages,
+  surplusRoute: QualifiedSurplusChatRoute | null,
+): Promise<Pick<ResolvedSoulInvocation, "maxOutputTokens" | "surplusMaxOutputTokens">> {
+  const maxOutputTokens = await resolveCompletionBudget(modelId, [...messages]);
+  if (!surplusRoute) return { maxOutputTokens, surplusMaxOutputTokens: null };
+  const surplusMaxOutputTokens = resolveSurplusCompletionBudget(
+    surplusRoute,
+    maxOutputTokens,
+    [...messages],
+  );
+  return {
+    maxOutputTokens,
+    surplusMaxOutputTokens: surplusMaxOutputTokens > 0 ? surplusMaxOutputTokens : null,
+  };
+}
+
+function sameSurplusRoute(
+  left: QualifiedSurplusChatRoute | null,
+  right: QualifiedSurplusChatRoute | null,
+): boolean {
+  if (left === null || right === null) return left === right;
+  return left.catalogModelId === right.catalogModelId
+    && left.surplusModelId === right.surplusModelId
+    && left.providerPin === right.providerPin
+    && left.supportsTools === right.supportsTools
+    && left.supportsVision === right.supportsVision
+    && left.supportsReasoning === right.supportsReasoning
+    && left.supportedParameters?.join(",") === right.supportedParameters?.join(",")
+    && left.maxContextTokens === right.maxContextTokens
+    && left.maxOutputTokens === right.maxOutputTokens;
+}
+
+function currentSoulSurplusRoute(
+  modelId: string,
+  policyEnabled: boolean,
+  surplusKey: string | null,
+): QualifiedSurplusChatRoute | null {
+  const availability = resolveSurplusChatServingAvailability({
+    catalogModelId: modelId,
+    policyEnabled,
+    keyConfigured: surplusKey !== null,
+    fundingKind: "server",
+  });
+  return availability.status === "available" ? availability.route : null;
+}
+
+function assertSoulInvocationSnapshotCurrent(invocation: ResolvedSoulInvocation): void {
+  if (invocation.broadeningAuthorityModelId !== undefined
+    && !canBroadenSurplusModelRoute(invocation.broadeningAuthorityModelId)) {
+    throw new Error("Soul generation marketplace eligibility changed before dispatch.");
+  }
+  const policyEnabled = getCachedServerModelConfigRow()?.preferSurplus === true;
+  const surplusKey = resolveProviderKey("surplus");
+  const surplusRoute = currentSoulSurplusRoute(invocation.modelId, policyEnabled, surplusKey);
+  if (policyEnabled !== invocation.surplusPolicyEnabled
+    || surplusKey !== invocation.surplusKey
+    || !sameSurplusRoute(surplusRoute, invocation.surplusRoute)) {
+    throw new Error("Soul generation funding route changed before dispatch.");
+  }
+}
+
+async function resolveSoulInvocation(input: SoulFileInput, signal: AbortSignal): Promise<ResolvedSoulInvocation> {
+  const config = fromRuntimeConfig();
+  const configuredModelId = config.nautilo_soul_generator_model ?? config.nautilo_model;
+  const policyEnabled = getCachedServerModelConfigRow()?.preferSurplus === true;
+  const surplusKey = resolveProviderKey("surplus");
+  if (policyEnabled && surplusKey !== null) {
+    await hydrateSurplusChatCatalog({ signal,
+      ...(configuredModelId ? { catalogModelIds: [configuredModelId] } : {}),
+    });
+  }
+  const modelId = resolveModelRole("systemTasks", {
+    ...(configuredModelId ? { configuredId: configuredModelId } : {}),
+    serverSurplus: {
+      policyEnabled,
+      keyConfigured: surplusKey !== null,
+    },
+  });
+  const surplusRoute = currentSoulSurplusRoute(modelId, policyEnabled, surplusKey);
+  const messages: SoulMessages = [
+    new SystemMessage(SOUL_FILE_SYSTEM_PROMPT),
+    new HumanMessage(buildSoulPrompt(input)),
+  ];
+  const budgets = await resolveSoulOutputBudgets(modelId, messages, surplusRoute);
+  return {
+    modelId,
+    messages,
+    ...budgets,
+    surplusPolicyEnabled: policyEnabled,
+    surplusKey,
+    surplusRoute,
+  };
+}
+
+async function resolveSurplusSoulCandidate(
+  primary: ResolvedSoulInvocation,
+  candidateId: string,
+  signal: AbortSignal,
+): Promise<ResolvedSoulInvocation | null> {
+  try {
+    await hydrateSurplusChatCatalog({ catalogModelIds: [candidateId], signal });
+    const modelId = resolveModelRole("systemTasks", {
+      configuredId: candidateId,
+      serverSurplus: {
+        policyEnabled: primary.surplusPolicyEnabled,
+        keyConfigured: primary.surplusKey !== null,
+      },
+    });
+    const surplusRoute = currentSoulSurplusRoute(
+      modelId,
+      primary.surplusPolicyEnabled,
+      primary.surplusKey,
+    );
+    if (modelId !== candidateId || surplusRoute === null) return null;
+    const budgets = await resolveSoulOutputBudgets(modelId, primary.messages, surplusRoute);
+    return {
+      modelId,
+      messages: primary.messages,
+      ...budgets,
+      surplusPolicyEnabled: primary.surplusPolicyEnabled,
+      surplusKey: primary.surplusKey,
+      surplusRoute,
+      broadeningAuthorityModelId: primary.modelId,
+    };
+  } catch {
+    // A candidate that no longer satisfies the signed role, route, capability,
+    // or context policy is not part of this finite marketplace walk.
+    return null;
+  }
+}
+
+async function runDirectSoulAttempt<T>(
+  modelId: string,
+  signal: AbortSignal,
+  authorization: SoulGenerationAuthorization,
+  invoke: () => Promise<T>,
+  hasObservedProviderWork?: () => boolean,
+  assertStillAuthorized?: () => void | Promise<void>,
+): Promise<T> {
+  const context = soulUsageContext(modelId, authorization);
+  return runWithUsageContext(context, () => hasStubModelForTests()
+    ? invoke()
+    : runPersonalLlmAttempt({
+        modelId,
+        endpoint: "/v1/chat/completions",
+        signal,
+        ...(hasObservedProviderWork ? { hasObservedProviderWork } : {}),
+        ...(assertStillAuthorized ? { assertStillAuthorized } : {}),
+        invoke,
+      }));
+}
+
+function captureDirectSoulCredentialSnapshot(modelId: string): ModelRunnableCredentialSnapshot | null {
+  if (hasStubModelForTests()) return null;
+  const snapshot = captureModelRunnableCredentialSnapshot(modelId, process.env);
+  if (!snapshot) throw new SurplusDirectFallbackUnavailableError();
+  return snapshot;
+}
+
+function assertDirectSoulCredentialSnapshotCurrent(
+  modelId: string,
+  snapshot: ModelRunnableCredentialSnapshot | null,
+): void {
+  if (hasStubModelForTests()) return;
+  if (!snapshot || snapshot.modelId !== modelId
+    || !isModelRunnableCredentialSnapshotCurrent(snapshot, process.env)) {
+    throw new Error("Soul generation direct credential changed before dispatch.");
+  }
+}
+
+async function assertSoulAttemptStillAuthorized(
+  invocation: ResolvedSoulInvocation,
+  signal: AbortSignal,
+  authorization: SoulGenerationAuthorization,
+  directCredentialSnapshot?: ModelRunnableCredentialSnapshot | null,
+): Promise<void> {
+  signal.throwIfAborted();
+  await assertSoulServerFunding(authorization);
+  signal.throwIfAborted();
+  assertSoulInvocationSnapshotCurrent(invocation);
+  if (directCredentialSnapshot !== undefined) {
+    assertDirectSoulCredentialSnapshotCurrent(invocation.modelId, directCredentialSnapshot);
+  }
+  signal.throwIfAborted();
+}
+
+async function invokeDirectSoul(
+  invocation: ResolvedSoulInvocation,
+  signal: AbortSignal,
+  authorization: SoulGenerationAuthorization,
+): Promise<AIMessage> {
+  await assertSoulServerFunding(authorization);
+  assertSoulInvocationSnapshotCurrent(invocation);
+  const credentialBeforeConstruction = captureDirectSoulCredentialSnapshot(invocation.modelId);
+  const model = await createUniversalModel(invocation.modelId, {
+    maxRetries: 0,
+    maxTokens: invocation.maxOutputTokens,
+  });
+  assertDirectSoulCredentialSnapshotCurrent(invocation.modelId, credentialBeforeConstruction);
+  const credentialSnapshot = captureDirectSoulCredentialSnapshot(invocation.modelId);
+  return await runDirectSoulAttempt(
+    invocation.modelId,
+    signal,
+    authorization,
+    async () => (await model.invoke([...invocation.messages], { signal })) as AIMessage,
+    undefined,
+    () => assertSoulAttemptStillAuthorized(invocation, signal, authorization, credentialSnapshot),
+  );
+}
+
+async function invokeSurplusSoul(
+  invocation: ResolvedSoulInvocation & {
+    readonly surplusKey: string;
+    readonly surplusRoute: QualifiedSurplusChatRoute;
+    readonly surplusMaxOutputTokens: number;
+  },
+  signal: AbortSignal,
+  authorization: SoulGenerationAuthorization,
+  hasDeliveredOutput: () => boolean,
+  providerMode?: "any",
+  invokeModel?: (
+    model: ChatModel<BaseMessage, AIMessage>,
+    messages: BaseMessage[],
+    config: RunnableConfig,
+  ) => Promise<AIMessage>,
+): Promise<SurplusChatAttemptResult> {
+  await assertSoulServerFunding(authorization);
+  assertSoulInvocationSnapshotCurrent(invocation);
+  const context = soulUsageContext(invocation.modelId, authorization, "surplus");
+  return await runWithUsageContext(context, () => invokeSurplusChatAttempt({
+    ...(providerMode === undefined ? {} : { providerMode }),
+    route: invocation.surplusRoute,
+    apiKey: invocation.surplusKey,
+    messages: [...invocation.messages],
+    tools: [],
+    config: { signal },
+    maxOutputTokens: invocation.surplusMaxOutputTokens,
+    funding: {
+      kind: "service",
+      humanUserId: authorization.humanUserId,
+      providerRoute: "surplus",
+    },
+    hasDeliveredOutput,
+    assertStillAuthorized: async () => {
+      await assertSoulAttemptStillAuthorized(invocation, signal, authorization);
+      if (providerMode === "any" && !canBroadenSurplusModelRoute(invocation.modelId)) {
+        throw new Error("Soul generation marketplace eligibility changed before dispatch.");
+      }
+    },
+    directFallbackPolicy: "pre_service_only",
+    validateResponse: (response) => {
+      if (!looksLikeSoulFile(extractMessageText(response.content).trim())) {
+        throw new Error("Soul generation returned incomplete markdown.");
+      }
+    },
+    invokeModel: invokeModel
+      ? (model, messages, config) => invokeModel(
+          model as ChatModel<BaseMessage, AIMessage>,
+          messages,
+          config,
+        )
+      : async (model, messages, config) => (await model.invoke(messages, config)) as AIMessage,
+  }));
+}
+
+function hasSurplusRoute(
+  invocation: ResolvedSoulInvocation,
+): invocation is ResolvedSoulInvocation & {
+  readonly surplusKey: string;
+  readonly surplusRoute: QualifiedSurplusChatRoute;
+  readonly surplusMaxOutputTokens: number;
+} {
+  return invocation.surplusKey !== null
+    && invocation.surplusRoute !== null
+    && invocation.surplusMaxOutputTokens !== null;
+}
+
+function assertDirectSoulCredential(modelId: string): void {
+  if (!modelHasRunnableCredentials(modelId, process.env)) {
+    throw new SurplusDirectFallbackUnavailableError();
+  }
+}
+
+interface SoulAttemptExecution {
+  readonly hasDeliveredOutput: () => boolean;
+  readonly hasObservedProviderWork: () => boolean;
+  readonly invokeDirect: (invocation: ResolvedSoulInvocation) => Promise<AIMessage>;
+  readonly invokeSurplusModel?: (
+    model: ChatModel<BaseMessage, AIMessage>,
+    messages: BaseMessage[],
+    config: RunnableConfig,
+  ) => Promise<AIMessage>;
+  readonly onModelSelected?: (modelId: string) => void;
+}
+
+async function refreshRejectedSurplusSoulModel(modelId: string, signal: AbortSignal): Promise<void> {
+  try {
+    await hydrateSurplusChatCatalog({ catalogModelIds: [modelId], force: true, signal });
+  } catch {
+    // Discovery is advisory after a proven pre-service refusal. Preserve the
+    // current result while allowing a later invocation to use refreshed facts.
+  }
+}
+
+async function invokeDirectSoulAfterMarketplaceRefusal(
+  invocation: ResolvedSoulInvocation,
+  execution: SoulAttemptExecution,
+  signal: AbortSignal,
+): Promise<AIMessage> {
+  try {
+    return await execution.invokeDirect(invocation);
+  } finally {
+    await refreshRejectedSurplusSoulModel(invocation.modelId, signal);
+  }
+}
+
+async function invokeSoulWithSupplyFallback(
+  primary: ResolvedSoulInvocation,
+  signal: AbortSignal,
+  authorization: SoulGenerationAuthorization,
+  execution: SoulAttemptExecution,
+): Promise<AIMessage> {
+  execution.onModelSelected?.(primary.modelId);
+  if (!hasSurplusRoute(primary)) return execution.invokeDirect(primary);
+
+  const crossModelAllowed = canBroadenSurplusModelRoute(primary.modelId);
+  const candidateIds = crossModelAllowed
+    ? [...new Set(candidatesForModelRole("systemTasks"))]
+        .filter((candidateId) => candidateId !== primary.modelId)
+    : [];
+  const invocations: Array<ResolvedSoulInvocation | string> = [primary, ...candidateIds];
+
+  for (const candidate of invocations) {
+    if (typeof candidate === "string" && !canBroadenSurplusModelRoute(primary.modelId)) {
+      throw new Error("Soul generation marketplace eligibility changed before dispatch.");
+    }
+    const invocation = typeof candidate === "string"
+      ? await resolveSurplusSoulCandidate(primary, candidate, signal)
+      : candidate;
+    if (!invocation || !hasSurplusRoute(invocation)) continue;
+    execution.onModelSelected?.(invocation.modelId);
+    signal.throwIfAborted();
+
+    // Ordinary aggregator routes can use the marketplace's available seller
+    // pool immediately when there is no matching direct server credential.
+    const providerMode = !modelHasRunnableCredentials(invocation.modelId, process.env)
+      && canBroadenSurplusModelRoute(invocation.modelId) ? "any" : undefined;
+    const first = await invokeSurplusSoul(
+      invocation,
+      signal,
+      authorization,
+      execution.hasDeliveredOutput,
+      providerMode,
+      execution.invokeSurplusModel,
+    );
+    if (first.kind === "served") return first.response;
+    signal.throwIfAborted();
+    if (execution.hasDeliveredOutput() || execution.hasObservedProviderWork()) {
+      throw new SurplusOutcomeUnknownError();
+    }
+
+    if (!first.modelUnavailableBeforeService) {
+      // Preserve the existing admitted same-model direct rail. This result
+      // never authorizes the new unpinned or cross-model marketplace walk.
+      assertDirectSoulCredential(invocation.modelId);
+      return execution.invokeDirect(invocation);
+    }
+
+    // Preserve the established same-model direct fallback whenever its
+    // server credential exists. The marketplace walk fills only the gap where
+    // that direct rail is unavailable.
+    if (modelHasRunnableCredentials(invocation.modelId, process.env)) {
+      return invokeDirectSoulAfterMarketplaceRefusal(invocation, execution, signal);
+    }
+    if (!crossModelAllowed) {
+      await refreshRejectedSurplusSoulModel(invocation.modelId, signal);
+      throw new SurplusDirectFallbackUnavailableError();
+    }
+
+    if (providerMode !== "any" && canBroadenSurplusModelRoute(invocation.modelId)) {
+      signal.throwIfAborted();
+      const unpinned = await invokeSurplusSoul(
+        invocation,
+        signal,
+        authorization,
+        execution.hasDeliveredOutput,
+        "any",
+        execution.invokeSurplusModel,
+      );
+      if (unpinned.kind === "served") return unpinned.response;
+      signal.throwIfAborted();
+      if (execution.hasDeliveredOutput() || execution.hasObservedProviderWork()) {
+        throw new SurplusOutcomeUnknownError();
+      }
+      if (!unpinned.modelUnavailableBeforeService) {
+        assertDirectSoulCredential(invocation.modelId);
+        return execution.invokeDirect(invocation);
+      }
+      if (modelHasRunnableCredentials(invocation.modelId, process.env)) {
+        return invokeDirectSoulAfterMarketplaceRefusal(invocation, execution, signal);
+      }
+    }
+    await refreshRejectedSurplusSoulModel(invocation.modelId, signal);
+  }
+
+  throw new SurplusDirectFallbackUnavailableError();
+}
+
 /**
  * Provider errors may include API credentials, endpoints, or account details.
  * Keep logs useful for operations without ever serializing the provider's
@@ -323,6 +783,7 @@ function extractMessageText(content: unknown): string {
 
 function createGenerationAbortContext(externalSignal?: AbortSignal): {
   readonly signal: AbortSignal;
+  readonly abort: () => void;
   readonly dispose: () => void;
 } {
   const controller = new AbortController();
@@ -339,6 +800,7 @@ function createGenerationAbortContext(externalSignal?: AbortSignal): {
 
   return {
     signal: controller.signal,
+    abort,
     dispose: () => {
       clearTimeout(timeout);
       externalSignal?.removeEventListener("abort", abort);
@@ -346,6 +808,172 @@ function createGenerationAbortContext(externalSignal?: AbortSignal): {
   };
 }
 
+interface SoulStreamRelayItem {
+  readonly text: string;
+  readonly release: () => void;
+}
+
+class SoulStreamRelay {
+  private readonly queued: SoulStreamRelayItem[] = [];
+  private waiter: (() => void) | undefined;
+  private finished = false;
+
+  async emit(text: string): Promise<void> {
+    if (!text) return;
+    await new Promise<void>((resolve) => {
+      this.queued.push({ text, release: resolve });
+      this.waiter?.();
+      this.waiter = undefined;
+    });
+  }
+
+  finish(): void {
+    this.finished = true;
+    this.waiter?.();
+    this.waiter = undefined;
+  }
+
+  cancel(): void {
+    this.finished = true;
+    for (const item of this.queued.splice(0)) item.release();
+    this.waiter?.();
+    this.waiter = undefined;
+  }
+
+  async next(): Promise<SoulStreamRelayItem | null> {
+    for (;;) {
+      const item = this.queued.shift();
+      if (item) return item;
+      if (this.finished) return null;
+      await new Promise<void>((resolve) => {
+        this.waiter = resolve;
+      });
+    }
+  }
+}
+
+function asAIMessageChunk(value: unknown): AIMessageChunk {
+  if (AIMessageChunk.isInstance(value)) return value;
+  const chunk = value && typeof value === "object"
+    ? value as Record<string, unknown>
+    : {};
+  const fields = {
+    content: chunk["content"] ?? "",
+    ...(chunk["additional_kwargs"] && typeof chunk["additional_kwargs"] === "object"
+      ? { additional_kwargs: chunk["additional_kwargs"] }
+      : {}),
+    ...(chunk["response_metadata"] && typeof chunk["response_metadata"] === "object"
+      ? { response_metadata: chunk["response_metadata"] }
+      : {}),
+    ...(chunk["usage_metadata"] && typeof chunk["usage_metadata"] === "object"
+      ? { usage_metadata: chunk["usage_metadata"] }
+      : {}),
+  };
+  return new AIMessageChunk(fields as never);
+}
+
+async function consumeSoulModelStream(
+  model: ChatModel<BaseMessage, unknown>,
+  messages: BaseMessage[],
+  config: RunnableConfig,
+  relay: SoulStreamRelay,
+  observeProviderWork?: () => void,
+): Promise<AIMessage> {
+  if (!model.stream) {
+    return (await model.invoke(messages, config as Record<string, unknown>)) as AIMessage;
+  }
+  const stream = await model.stream(messages, config as Record<string, unknown>);
+  let aggregate: AIMessageChunk | undefined;
+  for await (const rawChunk of stream) {
+    observeProviderWork?.();
+    const chunk = asAIMessageChunk(rawChunk);
+    aggregate = aggregate ? aggregate.concat(chunk) : chunk;
+    await relay.emit(extractMessageText(chunk.content));
+  }
+  return aggregate ?? new AIMessage({ content: "" });
+}
+
+async function* relaySoulAttempt<T>(
+  start: (relay: SoulStreamRelay) => Promise<T>,
+): AsyncGenerator<string, T> {
+  const relay = new SoulStreamRelay();
+  const attempt = start(relay);
+  void attempt.then(
+    () => relay.finish(),
+    () => relay.finish(),
+  );
+  try {
+    for (;;) {
+      const item = await relay.next();
+      if (!item) break;
+      item.release();
+      yield item.text;
+    }
+    return await attempt;
+  } finally {
+    relay.cancel();
+  }
+}
+
+async function invokeDirectSoulStream(
+  invocation: ResolvedSoulInvocation,
+  signal: AbortSignal,
+  authorization: SoulGenerationAuthorization,
+  relay: SoulStreamRelay,
+  fallback: string,
+  observeAttemptProviderWork: () => void,
+): Promise<AIMessage> {
+  await assertSoulServerFunding(authorization);
+  assertSoulInvocationSnapshotCurrent(invocation);
+  const credentialBeforeConstruction = captureDirectSoulCredentialSnapshot(invocation.modelId);
+  const model = await createUniversalModel(invocation.modelId, {
+    maxRetries: 0,
+    maxTokens: invocation.maxOutputTokens,
+  });
+  assertDirectSoulCredentialSnapshotCurrent(invocation.modelId, credentialBeforeConstruction);
+  const credentialSnapshot = captureDirectSoulCredentialSnapshot(invocation.modelId);
+  let providerWorkObserved = false;
+  if (!model.stream) {
+    try {
+      const response = await runDirectSoulAttempt(
+        invocation.modelId,
+        signal,
+        authorization,
+        async () => (await model.invoke([...invocation.messages], { signal })) as AIMessage,
+        undefined,
+        () => assertSoulAttemptStillAuthorized(invocation, signal, authorization, credentialSnapshot),
+      );
+      const content = extractMessageText(response.content).trim();
+      if (looksLikeSoulFile(content)) return response;
+      warn(
+        `[soul] LLM returned short/non-markdown content (${content.length} chars) for model ${invocation.modelId} — using fallback`,
+      );
+      return new AIMessage({ content: fallback });
+    } catch (error) {
+      if (error instanceof ServerProviderCredentialsDeniedError) throw error;
+      warnSoulGenerationFailure(invocation.modelId, signal, false);
+      return new AIMessage({ content: fallback });
+    }
+  }
+  return await runDirectSoulAttempt(
+    invocation.modelId,
+    signal,
+    authorization,
+    () => consumeSoulModelStream(
+      model as ChatModel<BaseMessage, unknown>,
+      [...invocation.messages],
+      { signal },
+      relay,
+      () => {
+        providerWorkObserved = true;
+        observeAttemptProviderWork();
+      },
+    ),
+    () => providerWorkObserved,
+    () => assertSoulAttemptStillAuthorized(invocation, signal, authorization, credentialSnapshot),
+  );
+}
+
 export async function generateSoulFile(
   input: Partial<SoulFileInput>,
   externalSignal: AbortSignal | undefined,
@@ -357,22 +985,25 @@ export async function generateSoulFile(
   let modelId: string | undefined;
 
   try {
-    const config = fromRuntimeConfig();
-    const configuredModelId = config.nautilo_soul_generator_model ?? config.nautilo_model;
-    modelId = resolveModelRole("systemTasks", {
-      ...(configuredModelId ? { configuredId: configuredModelId } : {}),
-    });
-    const model = await createUniversalModel(modelId);
-    await assertSoulServerFunding(authorization);
-    const response = (await runWithUsageContext(soulUsageContext(modelId, authorization), () =>
-      model.invoke(
-        [
-          new SystemMessage(SOUL_FILE_SYSTEM_PROMPT),
-          new HumanMessage(buildSoulPrompt(normalized)),
-        ],
-        { signal: abortContext.signal },
-      ),
-    )) as { content: unknown };
+    const invocation = await resolveSoulInvocation(normalized, abortContext.signal);
+    modelId = invocation.modelId;
+    const response = await invokeSoulWithSupplyFallback(
+      invocation,
+      abortContext.signal,
+      authorization,
+      {
+        hasDeliveredOutput: () => false,
+        hasObservedProviderWork: () => false,
+        invokeDirect: (selected) => invokeDirectSoul(
+          selected,
+          abortContext.signal,
+          authorization,
+        ),
+        onModelSelected: (selectedModelId) => {
+          modelId = selectedModelId;
+        },
+      },
+    );
 
     const content = extractMessageText(response.content).trim();
 
@@ -402,42 +1033,59 @@ export async function* generateSoulFileStream(
   const fallback = generateSoulFileFallback(normalized);
   const abortContext = createGenerationAbortContext(externalSignal);
   let modelId: string | undefined;
+  let activeAttempt: AsyncGenerator<string, unknown> | undefined;
   yield { type: "started" };
 
   try {
-    const config = fromRuntimeConfig();
-    const configuredModelId = config.nautilo_soul_generator_model ?? config.nautilo_model;
-    modelId = resolveModelRole("systemTasks", {
-      ...(configuredModelId ? { configuredId: configuredModelId } : {}),
-    });
-    const model = await createUniversalModel(modelId);
-    if (!model.stream) {
-      const soulFile = await generateSoulFile(normalized, abortContext.signal, authorization);
-      yield { type: "completed", soulFile };
-      return;
-    }
-
+    const invocation = await resolveSoulInvocation(normalized, abortContext.signal);
+    modelId = invocation.modelId;
     let content = "";
-    await assertSoulServerFunding(authorization);
-    const usageContext = soulUsageContext(modelId, authorization);
-    const stream = await runWithUsageContext(usageContext, () => model.stream!(
-      [
-        new SystemMessage(SOUL_FILE_SYSTEM_PROMPT),
-        new HumanMessage(buildSoulPrompt(normalized)),
-      ],
-      { signal: abortContext.signal },
+    let deliveredOutput = false;
+    let providerWorkObserved = false;
+
+    const streamAttempt = relaySoulAttempt((relay) => invokeSoulWithSupplyFallback(
+      invocation,
+      abortContext.signal,
+      authorization,
+      {
+        hasDeliveredOutput: () => deliveredOutput,
+        hasObservedProviderWork: () => providerWorkObserved,
+        invokeDirect: (selected) => invokeDirectSoulStream(
+          selected,
+          abortContext.signal,
+          authorization,
+          relay,
+          fallback,
+          () => {
+            providerWorkObserved = true;
+          },
+        ),
+        invokeSurplusModel: (model, messages, config) =>
+          consumeSoulModelStream(model, messages, config, relay, () => {
+            providerWorkObserved = true;
+          }),
+        onModelSelected: (selectedModelId) => {
+          modelId = selectedModelId;
+        },
+      },
     ));
-    const iterator = stream[Symbol.asyncIterator]();
+    activeAttempt = streamAttempt;
+
+    let response: AIMessage;
     for (;;) {
-      const next = await runWithUsageContext(usageContext, () => iterator.next());
-      if (next.done) break;
-      const chunk = next.value;
-      const delta = extractMessageText((chunk as { content?: unknown }).content);
-      if (!delta) continue;
-      content += delta;
-      yield { type: "delta", text: delta };
+      const next = await streamAttempt.next();
+      if (next.done) {
+        response = next.value;
+        activeAttempt = undefined;
+        break;
+      }
+      deliveredOutput = true;
+      content += next.value;
+      yield { type: "delta", text: next.value };
     }
 
+    if (!content) content = extractMessageText(response.content);
+
     const soulFile = content.trim();
     if (looksLikeSoulFile(soulFile)) {
       yield { type: "completed", soulFile };
@@ -457,6 +1105,8 @@ export async function* generateSoulFileStream(
     warnSoulGenerationFailure(modelId, abortContext.signal, true);
     yield { type: "error", error: SOUL_GENERATION_FAILED_MESSAGE, fallback };
   } finally {
+    abortContext.abort();
+    await activeAttempt?.return(undefined);
     abortContext.dispose();
   }
 }
diff --git a/packages/agent/src/store/embeddings.ts b/packages/agent/src/store/embeddings.ts
index 36863c029..5dc4033b4 100644
--- a/packages/agent/src/store/embeddings.ts
+++ b/packages/agent/src/store/embeddings.ts
@@ -1,5 +1,9 @@
 import { fromRuntimeConfig } from "@nautilo/config";
 import { getCachedServerModelConfigRow } from "@nautilo/db";
+import {
+  sameMemoryEmbeddingDisclosureV2,
+  type MemoryEmbeddingDisclosureV2,
+} from "@nautilo/lattice-crypto/wire";
 import { resolveProviderKey } from "../resolve-provider-key";
 import {
   runServiceEmbeddingAttempt,
@@ -7,6 +11,16 @@ import {
 } from "../usage/service-embedding-attempt";
 import { VENICE_EMBEDDINGS_URL } from "../providers/venice-api";
 import { resolveOpenRouterTransport } from "../providers/openrouter-transport";
+import {
+  assertQualifiedSurplusEmbeddingResponseModel,
+  getQualifiedSurplusEmbeddingRoute,
+  QUALIFIED_SURPLUS_EMBEDDING_CATALOG_MODEL_ID,
+  type QualifiedSurplusEmbeddingRoute,
+} from "../providers/surplus-embedding-route";
+import {
+  invokeSurplusEmbeddingAttempt,
+  SurplusEmbeddingAttemptError,
+} from "../usage/surplus-embedding-attempt";
 
 const OPENAI_EMBEDDINGS_URL = "https://api.openai.com/v1/embeddings";
 const DEFAULT_VENICE_EMBEDDING_MODEL = "text-embedding-qwen3-8b";
@@ -54,8 +68,16 @@ interface ResolvedEmbeddingProvider {
   apiKey: string;
   endpoint: string;
   model: string;
+  transport: "direct" | "surplus_marketplace";
+  surplusRoute?: QualifiedSurplusEmbeddingRoute;
 }
 
+const SURPLUS_EMBEDDING_DATA_RECIPIENT_CLASSES = Object.freeze([
+  "surplus",
+  "marketplace_seller",
+  "seller_upstream_processor",
+] as const);
+
 function getEmbeddingConfig(modelOverride?: string | null) {
   const config = fromRuntimeConfig();
   const serverModel = modelOverride === undefined
@@ -82,11 +104,51 @@ export function getProtectedMemoryEmbeddingConfiguration(
   dimensions: number;
 }> {
   const configured = getEmbeddingConfig(modelOverride);
-  const resolved = resolveEmbeddingProvider(configured.model);
+  const resolved = resolveEmbeddingExecution(configured.model, configured.dims);
   return Object.freeze({ provider: resolved.provider, model: resolved.model,
     dimensions: configured.dims });
 }
 
+function disclosureFor(
+  resolved: ResolvedEmbeddingProvider,
+  dimensions: number,
+): Readonly<MemoryEmbeddingDisclosureV2> {
+  if (dimensions !== 1_536) {
+    throw new EmbeddingProviderError({
+      message: "Protected Memory embeddings require exactly 1,536 dimensions.",
+      code: "unsupported_provider",
+      provider: resolved.provider,
+    });
+  }
+  const canonicalSpace = Object.freeze({
+    provider: resolved.provider,
+    model: resolved.model,
+    dimensions: 1_536 as const,
+  });
+  if (resolved.transport === "direct") {
+    return Object.freeze({
+      contractVersion: 2,
+      canonicalSpace,
+      processingRoute: Object.freeze({ transport: "direct" as const }),
+    });
+  }
+  return Object.freeze({
+    contractVersion: 2,
+    canonicalSpace,
+    processingRoute: Object.freeze({
+      transport: "surplus_marketplace",
+      marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+      dataRecipientClasses: SURPLUS_EMBEDDING_DATA_RECIPIENT_CLASSES,
+    }),
+  });
+}
+
+/** Current protected-Memory processing disclosure, including marketplace recipients. */
+export function getMemoryEmbeddingDisclosure(): Readonly<MemoryEmbeddingDisclosureV2> {
+  const configured = getEmbeddingConfig();
+  return disclosureFor(resolveEmbeddingExecution(configured.model, configured.dims), configured.dims);
+}
+
 function openRouterModelId(model: string): string {
   const trimmed = model.trim();
   if (trimmed.toLowerCase().startsWith("openrouter:")) {
@@ -126,6 +188,7 @@ function resolveEmbeddingProvider(model: string): ResolvedEmbeddingProvider {
       apiKey: veniceKey,
       endpoint: VENICE_EMBEDDINGS_URL,
       model: trimmedModel.slice("venice:".length),
+      transport: "direct",
     };
   }
 
@@ -142,6 +205,7 @@ function resolveEmbeddingProvider(model: string): ResolvedEmbeddingProvider {
       apiKey: openAiKey,
       endpoint: OPENAI_EMBEDDINGS_URL,
       model: trimmedModel.slice("openai:".length),
+      transport: "direct",
     };
   }
 
@@ -160,6 +224,7 @@ function resolveEmbeddingProvider(model: string): ResolvedEmbeddingProvider {
       apiKey: openRouterTransport.apiKey,
       endpoint: `${openRouterTransport.baseUrl}/embeddings`,
       model: openRouterModelId(trimmedModel),
+      transport: "direct",
     };
   }
 
@@ -171,6 +236,7 @@ function resolveEmbeddingProvider(model: string): ResolvedEmbeddingProvider {
       apiKey: veniceKey,
       endpoint: VENICE_EMBEDDINGS_URL,
       model: trimmedModel || DEFAULT_VENICE_EMBEDDING_MODEL,
+      transport: "direct",
     };
   }
 
@@ -180,6 +246,7 @@ function resolveEmbeddingProvider(model: string): ResolvedEmbeddingProvider {
       apiKey: openAiKey,
       endpoint: OPENAI_EMBEDDINGS_URL,
       model: trimmedModel || DEFAULT_OPENAI_EMBEDDING_MODEL,
+      transport: "direct",
     };
   }
 
@@ -195,6 +262,7 @@ function resolveEmbeddingProvider(model: string): ResolvedEmbeddingProvider {
       model: trimmedModel
         ? openRouterModelId(trimmedModel)
         : DEFAULT_OPENROUTER_EMBEDDING_MODEL,
+      transport: "direct",
     };
   }
 
@@ -204,6 +272,7 @@ function resolveEmbeddingProvider(model: string): ResolvedEmbeddingProvider {
       apiKey: openAiKey,
       endpoint: OPENAI_EMBEDDINGS_URL,
       model: trimmedModel || DEFAULT_OPENAI_EMBEDDING_MODEL,
+      transport: "direct",
     };
   }
 
@@ -215,6 +284,52 @@ function resolveEmbeddingProvider(model: string): ResolvedEmbeddingProvider {
   });
 }
 
+function resolveEmbeddingExecution(model: string, dimensions: number): ResolvedEmbeddingProvider {
+  const trimmedModel = model.trim();
+  const route = getQualifiedSurplusEmbeddingRoute(trimmedModel, dimensions);
+  const surplusKey = resolveProviderKey("surplus", {});
+  const preferSurplus = getCachedServerModelConfigRow()?.preferSurplus === true;
+  const surplusExecution = (qualified: QualifiedSurplusEmbeddingRoute, apiKey: string) => ({
+    provider: qualified.provider,
+    model: qualified.model,
+    endpoint: "https://api.surplusintelligence.ai/v1/embeddings",
+    apiKey,
+    transport: "surplus_marketplace" as const,
+    surplusRoute: qualified,
+  });
+  if (route && preferSurplus && surplusKey) {
+    return surplusExecution(route, surplusKey);
+  }
+  if (trimmedModel) return resolveEmbeddingProvider(model);
+  try {
+    // Keep Automatic's established direct vector identity whenever any direct
+    // embedding credential is runnable, even when Surplus is preferred.
+    return resolveEmbeddingProvider(model);
+  } catch (error) {
+    if (!(error instanceof EmbeddingProviderError)
+      || error.code !== "missing_credentials") throw error;
+    const fallbackRoute = getQualifiedSurplusEmbeddingRoute(
+      QUALIFIED_SURPLUS_EMBEDDING_CATALOG_MODEL_ID,
+      dimensions,
+    );
+    if (fallbackRoute && preferSurplus && surplusKey) {
+      return surplusExecution(fallbackRoute, surplusKey);
+    }
+    throw error;
+  }
+}
+
+function disclosuresEqual(
+  left: Readonly<MemoryEmbeddingDisclosureV2>,
+  right: Readonly<MemoryEmbeddingDisclosureV2>,
+): boolean {
+  try {
+    return sameMemoryEmbeddingDisclosureV2(left, right);
+  } catch {
+    return false;
+  }
+}
+
 function providerFailureMessage(provider: EmbeddingProvider, status: number): string {
   const label = embeddingProviderLabel(provider);
   const credentialLabel = `${label} credential`;
@@ -307,7 +422,59 @@ async function embedTextsWithResolvedProvider(
 }>> {
   const config = getEmbeddingConfig();
   const dims = fixed?.dimensions ?? config.dims;
-  const resolved = fixed?.resolved ?? resolveEmbeddingProvider(config.model);
+  const resolved = fixed?.resolved ?? resolveEmbeddingExecution(config.model, dims);
+
+  if (resolved.transport === "surplus_marketplace") {
+    const route = resolved.surplusRoute;
+    if (!route) throw new Error("Qualified Surplus embedding route is missing.");
+    const authorizedDisclosure = disclosureFor(resolved, dims);
+    try {
+      const embeddings = await invokeSurplusEmbeddingAttempt({
+        route,
+        apiKey: resolved.apiKey,
+        texts,
+        ...(signal === undefined ? {} : { signal }),
+        assertStillAuthorized: () => {
+          try {
+            const latest = getEmbeddingConfig();
+            const current = resolveEmbeddingExecution(latest.model, latest.dims);
+            if (current.transport === "surplus_marketplace"
+              && current.apiKey === resolved.apiKey
+              && current.surplusRoute === route
+              && disclosuresEqual(disclosureFor(current, latest.dims), authorizedDisclosure)) {
+              return;
+            }
+          } catch {
+            // Project every selection, policy, or credential drift through the
+            // same stale-approval result without disclosing credential state.
+          }
+          throw new EmbeddingProviderError({
+            message: "The approved embedding configuration changed. Prepare the Memory request again.",
+            code: "unsupported_provider",
+            provider: resolved.provider,
+          });
+        },
+        parseResponse: (value) => {
+          assertQualifiedSurplusEmbeddingResponseModel(route, value);
+          const embeddings = parseEmbeddingResponse(value, texts.length, dims, resolved.provider);
+          return embeddings;
+        },
+      });
+      return { embeddings, resolved, dimensions: dims };
+    } catch (error) {
+      if (error instanceof EmbeddingProviderError) throw error;
+      if (error instanceof SurplusEmbeddingAttemptError) {
+        throw new EmbeddingProviderError({
+          message: error.message,
+          code: error.failureCode === "invalid_response" ? "invalid_response" : "request_failed",
+          provider: resolved.provider,
+          ...(error.status === undefined ? {} : { status: error.status }),
+          retryable: error.retryable,
+        });
+      }
+      throw error;
+    }
+  }
 
   return runServiceEmbeddingAttempt({
     provider: resolved.provider,
@@ -315,6 +482,31 @@ async function embedTextsWithResolvedProvider(
     endpoint: resolved.endpoint,
     dimensions: dims,
     ...(signal === undefined ? {} : { signal }),
+    assertStillAuthorized: () => {
+      try {
+        const latest = getEmbeddingConfig();
+        const current = resolveEmbeddingExecution(latest.model, latest.dims);
+        const disclosureStillMatches = dims !== 1_536
+          || disclosuresEqual(disclosureFor(current, latest.dims), disclosureFor(resolved, dims));
+        if (current.transport === "direct"
+          && latest.dims === dims
+          && current.provider === resolved.provider
+          && current.model === resolved.model
+          && current.endpoint === resolved.endpoint
+          && current.apiKey === resolved.apiKey
+          && disclosureStillMatches) {
+          return;
+        }
+      } catch {
+        // Project every selection, policy, credential, or disclosure drift
+        // through the same stale-approval result without exposing key state.
+      }
+      throw new EmbeddingProviderError({
+        message: "The approved embedding configuration changed. Prepare the Memory request again.",
+        code: "unsupported_provider",
+        provider: resolved.provider,
+      });
+    },
     invoke: async (observeEvidence) => {
       let response: Response;
       try {
@@ -410,10 +602,15 @@ export async function embedText(text: string, signal?: AbortSignal): Promise<num
 export async function embedTextWithProvenance(
   text: string,
   signal?: AbortSignal,
-  expected?: Readonly<{ provider: EmbeddingProvider; model: string; dimensions: number }>,
+  expected?: Readonly<{
+    provider: EmbeddingProvider;
+    model: string;
+    dimensions: number;
+    disclosure?: Readonly<MemoryEmbeddingDisclosureV2>;
+  }>,
 ): Promise<EmbeddingWithProvenanceV1> {
   const configured = getEmbeddingConfig();
-  const resolved = resolveEmbeddingProvider(configured.model);
+  const resolved = resolveEmbeddingExecution(configured.model, configured.dims);
   if (expected !== undefined && (resolved.provider !== expected.provider
     || resolved.model !== expected.model || configured.dims !== expected.dimensions)) {
     throw new EmbeddingProviderError({
@@ -421,6 +618,21 @@ export async function embedTextWithProvenance(
       code: "unsupported_provider", provider: resolved.provider,
     });
   }
+  if (expected !== undefined && resolved.transport === "surplus_marketplace"
+    && (expected.disclosure === undefined
+      || !disclosuresEqual(disclosureFor(resolved, configured.dims), expected.disclosure))) {
+    throw new EmbeddingProviderError({
+      message: "The approved embedding processing route changed. Prepare the Memory request again.",
+      code: "unsupported_provider", provider: resolved.provider,
+    });
+  }
+  if (expected?.disclosure !== undefined
+    && !disclosuresEqual(disclosureFor(resolved, configured.dims), expected.disclosure)) {
+    throw new EmbeddingProviderError({
+      message: "The approved embedding processing route changed. Prepare the Memory request again.",
+      code: "unsupported_provider", provider: resolved.provider,
+    });
+  }
   const result = await embedTextsWithResolvedProvider(
     [text],
     signal,
diff --git a/packages/agent/src/usage/personal-llm-attempt.ts b/packages/agent/src/usage/personal-llm-attempt.ts
index 77d685406..6e2e553f7 100644
--- a/packages/agent/src/usage/personal-llm-attempt.ts
+++ b/packages/agent/src/usage/personal-llm-attempt.ts
@@ -146,14 +146,23 @@ export async function runPersonalLlmAttempt<T>(input: {
   endpoint: string;
   signal?: AbortSignal | undefined;
   hasObservedProviderWork?: (() => boolean) | undefined;
+  /** Optional live authority fence, evaluated immediately before provider work. */
+  assertStillAuthorized?: (() => void | Promise<void>) | undefined;
   invoke: () => Promise<T>;
 }, deps: PersonalAttemptDependencies = defaultDependencies): Promise<T> {
   const context = getUsageContext();
   const funding = context?.funding;
   const isMemoryWork = context && ["memory_review", "room_stenographer", "room_reflection", "room_event_compaction"].includes(context.callType);
   const isServerImageAssistance = context?.callType === "image_assistance" && funding?.kind === "server";
+  const isSoulService = context?.callType === "soul" && funding?.kind === "service";
   if (!context || !funding || funding.providerRoute === "surplus"
-    || (funding.kind !== "personal" && !isMemoryWork && !isServerImageAssistance)) return input.invoke();
+    || (funding.kind !== "personal" && !isMemoryWork && !isServerImageAssistance && !isSoulService)) {
+    if (input.assertStillAuthorized) {
+      await input.assertStillAuthorized();
+      input.signal?.throwIfAborted();
+    }
+    return input.invoke();
+  }
   const nonpersonalBegin = funding.kind === "service" ? deps.beginService : deps.beginServer;
   const persistSettlement = funding.kind === "personal" ? deps.settle
     : funding.kind === "service" ? deps.settleService : deps.settleServer;
@@ -187,13 +196,15 @@ export async function runPersonalLlmAttempt<T>(input: {
   const settle = async (
     outcome: "succeeded" | "cancelled" | "failed" | "unknown",
     preserveOutcome = false,
+    knownUnsent = false,
   ) => {
     const evidence = usage;
     const hasTokenEvidence = evidence !== undefined
       && (evidence.inputTokens > 0 || evidence.outputTokens > 0
         || evidence.totalTokens !== undefined || evidence.reasoningTokens > 0
         || evidence.cachedInputTokens > 0 || evidence.cacheCreationTokens > 0);
-    const costState = evidence?.actualCostUsd != null ? "actual" as const
+    const costState = knownUnsent ? "actual" as const
+      : evidence?.actualCostUsd != null ? "actual" as const
       : hasTokenEvidence ? "estimated" as const : "unknown" as const;
     const providerRequestId = evidence?.providerRequestId ?? terminalProviderRequestId;
     try {
@@ -211,6 +222,7 @@ export async function runPersonalLlmAttempt<T>(input: {
           ...(evidence.actualCostUsd === null ? {} : { actualCostUsd: evidence.actualCostUsd }),
           metadata: { cacheCreationTokens: evidence.cacheCreationTokens },
         } : {}),
+        ...(knownUnsent ? { actualCostUsd: 0 } : {}),
         ...(providerRequestId === undefined ? {} : { providerRequestId }),
         ...(outcome === "succeeded" ? {} : { failureCode: terminalFailureCode
           ?? (outcome === "cancelled" ? "cancelled"
@@ -224,10 +236,10 @@ export async function runPersonalLlmAttempt<T>(input: {
       return false;
     }
   };
-  const finish = async (outcome: NonNullable<typeof terminalOutcome>) => {
+  const finish = async (outcome: NonNullable<typeof terminalOutcome>, knownUnsent = false) => {
     terminalOutcome = outcome;
     const evidenceAtSettlement = usage;
-    initialSettlementSucceeded = await settle(outcome);
+    initialSettlementSucceeded = await settle(outcome, false, knownUnsent);
     initialSettlementDone = true;
     // Usage can arrive while the terminal database write is in flight.
     if (usage && usage !== evidenceAtSettlement && !knownCostSettled
@@ -235,7 +247,15 @@ export async function runPersonalLlmAttempt<T>(input: {
       await settle(outcome, initialSettlementSucceeded);
     }
   };
+  let authorizationGuardEntered = false;
+  let invocationEntered = false;
   try {
+    if (input.assertStillAuthorized) {
+      authorizationGuardEntered = true;
+      await input.assertStillAuthorized();
+      input.signal?.throwIfAborted();
+    }
+    invocationEntered = true;
     const result = await runWithUsageContext({ ...context, trackedAttemptId: id,
       onAttemptUsage: (observed) => {
         usage = observed;
@@ -252,6 +272,12 @@ export async function runPersonalLlmAttempt<T>(input: {
     await finish("succeeded");
     return result;
   } catch (error) {
+    if (authorizationGuardEntered && !invocationEntered) {
+      const cancelled = input.signal?.aborted === true;
+      terminalFailureCode = cancelled ? "cancelled" : "authorization_changed";
+      await finish(cancelled ? "cancelled" : "failed", true);
+      throw error;
+    }
     const failure = classifyPersonalAttemptFailure(
       error,
       input.signal?.aborted === true,
diff --git a/packages/agent/src/usage/service-embedding-attempt.ts b/packages/agent/src/usage/service-embedding-attempt.ts
index 9fef8a17a..38c2b2113 100644
--- a/packages/agent/src/usage/service-embedding-attempt.ts
+++ b/packages/agent/src/usage/service-embedding-attempt.ts
@@ -43,6 +43,8 @@ export interface ServiceEmbeddingAttemptInput<T> {
   endpoint: string;
   dimensions: number;
   signal?: AbortSignal;
+  /** Revalidate the selected route and credential after durable admission. */
+  assertStillAuthorized?: () => void;
   invoke: (
     observeEvidence: (evidence: ServiceEmbeddingAttemptEvidence) => void,
   ) => Promise<T>;
@@ -144,13 +146,16 @@ export async function runServiceEmbeddingAttempt<T>(
     evidence = { ...(evidence ?? {}), ...next };
   };
   const settle = async (
-    outcome: "succeeded" | "cancelled" | "unknown",
+    outcome: "succeeded" | "failed" | "cancelled" | "unknown",
     failureCode?: string,
+    knownPreWireZero = false,
   ): Promise<void> => {
     const hasReportedUsage = evidence?.inputTokens !== undefined
       || evidence?.totalTokens !== undefined;
     const hasActualCost = evidence?.actualCostUsd !== undefined;
-    const costState = hasActualCost
+    const costState = knownPreWireZero
+      ? "actual" as const
+      : hasActualCost
       ? "actual" as const
       : hasReportedUsage
         ? "estimated" as const
@@ -177,9 +182,11 @@ export async function runServiceEmbeddingAttempt<T>(
         ...(estimatedCostUsd === undefined
           ? {}
           : { estimatedCostUsd, pricingVersion: PRICING_VERSION }),
-        ...(evidence?.actualCostUsd === undefined
-          ? {}
-          : { actualCostUsd: evidence.actualCostUsd }),
+        ...(knownPreWireZero
+          ? { actualCostUsd: 0 }
+          : evidence?.actualCostUsd === undefined
+            ? {}
+            : { actualCostUsd: evidence.actualCostUsd }),
         ...(evidence?.providerRequestId === undefined
           ? {}
           : { providerRequestId: evidence.providerRequestId }),
@@ -195,12 +202,19 @@ export async function runServiceEmbeddingAttempt<T>(
     }
   };
 
+  let providerDispatched = false;
   try {
+    input.assertStillAuthorized?.();
+    input.signal?.throwIfAborted();
+    providerDispatched = true;
     const value = await input.invoke(observeEvidence);
     await settle("succeeded");
     return value;
   } catch (error) {
-    if (input.signal?.aborted === true) await settle("cancelled", "cancelled");
+    if (!providerDispatched) {
+      if (input.signal?.aborted === true) await settle("cancelled", "cancelled", true);
+      else await settle("failed", "pre_wire_authorization_changed", true);
+    } else if (input.signal?.aborted === true) await settle("cancelled", "cancelled");
     else await settle("unknown", "outcome_unknown");
     throw error;
   }
diff --git a/packages/agent/src/usage/surplus-embedding-attempt.ts b/packages/agent/src/usage/surplus-embedding-attempt.ts
new file mode 100644
index 000000000..487242076
--- /dev/null
+++ b/packages/agent/src/usage/surplus-embedding-attempt.ts
@@ -0,0 +1,332 @@
+import { randomUUID } from "node:crypto";
+import {
+  attachSurplusRequestReceipt,
+  beginSurplusLlmAttempt,
+  settleSurplusLlmAttempt,
+  type SettleSurplusLlmAttemptInput,
+} from "@nautilo/db";
+import { warn } from "@nautilo/logger";
+import type { QualifiedSurplusEmbeddingRoute } from "../providers/surplus-embedding-route";
+import { assertQualifiedSurplusEmbeddingReceipt } from "../providers/surplus-embedding-route";
+import {
+  surplusCredentialFingerprint,
+  surplusReceiptTelemetry,
+} from "../providers/surplus-reconciliation";
+import { readSurplusWireReceipt, type SurplusWireReceipt } from "../providers/surplus-transport";
+import {
+  provenPreRoutingSurplusTrace,
+  readBoundedSurplusErrorBody,
+  safeSurplusErrorDiagnostics,
+  surplusErrorTelemetry,
+} from "../providers/surplus-error";
+import { getUsageContext, normalizeUsageRoomId } from "./usage-context";
+
+const SURPLUS_EMBEDDINGS_URL = "https://api.surplusintelligence.ai/v1/embeddings";
+
+export interface SurplusEmbeddingUsageEvidence {
+  readonly inputTokens?: number;
+  readonly totalTokens?: number;
+}
+
+export class SurplusEmbeddingAttemptError extends Error {
+  constructor(
+    readonly failureCode:
+      | "attempt_ledger_unavailable"
+      | "provider_unavailable"
+      | "invalid_response"
+      | "outcome_unknown",
+    readonly status?: number,
+    readonly retryable = false,
+    readonly vendorCode?: string,
+  ) {
+    super(failureCode === "provider_unavailable"
+      ? "Surplus is temporarily unavailable for embeddings. Retry shortly."
+      : failureCode === "attempt_ledger_unavailable"
+        ? "Embedding attempt accounting is unavailable. Retry shortly."
+        : failureCode === "invalid_response"
+          ? "Surplus returned an invalid embedding response. Retry shortly."
+          : "The Surplus embedding request may have been processed. Check Costs before trying again.");
+    this.name = "SurplusEmbeddingAttemptError";
+  }
+}
+
+export interface InvokeSurplusEmbeddingAttemptInput<T> {
+  readonly route: QualifiedSurplusEmbeddingRoute;
+  readonly apiKey: string;
+  readonly texts: readonly string[];
+  readonly signal?: AbortSignal;
+  /** Revalidate policy, credential, selection, and disclosure after the durable begin. */
+  readonly assertStillAuthorized: () => void;
+  readonly parseResponse: (value: unknown) => T;
+  readonly fetchImpl?: typeof fetch;
+}
+
+type AttemptDeps = Readonly<{
+  mintAttemptId: () => string;
+  begin: typeof beginSurplusLlmAttempt;
+  attach: typeof attachSurplusRequestReceipt;
+  settle: typeof settleSurplusLlmAttempt;
+}>;
+
+const DEFAULT_DEPS: AttemptDeps = {
+  mintAttemptId: randomUUID,
+  begin: beginSurplusLlmAttempt,
+  attach: attachSurplusRequestReceipt,
+  settle: settleSurplusLlmAttempt,
+};
+
+function count(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+    ? value : undefined;
+}
+
+function usageEvidence(value: unknown): SurplusEmbeddingUsageEvidence {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const usage = (value as Record<string, unknown>)["usage"];
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return {};
+  const record = usage as Record<string, unknown>;
+  const inputTokens = count(record["prompt_tokens"]);
+  const totalTokens = count(record["total_tokens"]);
+  return {
+    ...(inputTokens === undefined ? {} : { inputTokens }),
+    ...(totalTokens === undefined ? {} : { totalTokens }),
+  };
+}
+
+async function settleWithRetry(
+  settle: typeof settleSurplusLlmAttempt,
+  input: SettleSurplusLlmAttemptInput,
+): Promise<void> {
+  const immutable = Object.freeze({ ...input, settledAt: input.settledAt ?? new Date() });
+  try {
+    await settle(immutable);
+  } catch {
+    await settle(immutable);
+  }
+}
+
+function receiptCostUsd(receipt: SurplusWireReceipt | undefined): number | undefined {
+  return receipt?.buyerCostMicro === undefined
+    ? undefined : receipt.buyerCostMicro / 1_000_000;
+}
+
+function receiptMetadata(
+  route: QualifiedSurplusEmbeddingRoute,
+  apiKey: string,
+): Record<string, unknown> {
+  return {
+    catalogModelId: route.catalogModelId,
+    surplusModelId: route.wireModel,
+    surplusEmbeddingPolicy: route.servingPolicy,
+    surplusEmbeddingDimensions: route.dimensions,
+    surplusEmbeddingReceiptModel: route.receiptModel,
+    surplusEmbeddingServingProviders: [...route.knownServingProviders],
+    surplusCredentialFingerprint: surplusCredentialFingerprint(apiKey),
+  };
+}
+
+/** Execute exactly one durable marketplace embedding request. This function never replays provider work. */
+export async function invokeSurplusEmbeddingAttempt<T>(
+  input: InvokeSurplusEmbeddingAttemptInput<T>,
+  deps: Partial<AttemptDeps> = {},
+): Promise<T> {
+  const resolvedDeps = { ...DEFAULT_DEPS, ...deps };
+  const attemptId = resolvedDeps.mintAttemptId();
+  const context = getUsageContext();
+  const binding = receiptMetadata(input.route, input.apiKey);
+  try {
+    await resolvedDeps.begin({
+      id: attemptId,
+      model: input.route.catalogModelId,
+      provider: input.route.provider,
+      endpoint: "/v1/embeddings",
+      fundingKind: "service",
+      callType: "embedding",
+      userId: context?.funding?.humanUserId ?? context?.userId ?? null,
+      roomId: normalizeUsageRoomId(context?.roomId),
+      ...(typeof context?.metadata?.["taskId"] === "string"
+        ? { taskId: context.metadata["taskId"] } : {}),
+      metadata: binding,
+    });
+  } catch {
+    throw new SurplusEmbeddingAttemptError("attempt_ledger_unavailable", undefined, true);
+  }
+
+  let receipt: SurplusWireReceipt | undefined;
+  let responseStatus: number | undefined;
+  let wireDispatched = false;
+  let responseObserved = false;
+  let evidence: SurplusEmbeddingUsageEvidence = {};
+  let receiptAttached = false;
+  let errorBodyRequestId: string | undefined;
+  try {
+    input.assertStillAuthorized();
+    input.signal?.throwIfAborted();
+    let response: Response;
+    try {
+      wireDispatched = true;
+      response = await (input.fetchImpl ?? globalThis.fetch)(SURPLUS_EMBEDDINGS_URL, {
+        method: "POST",
+        redirect: "error",
+        headers: {
+          Authorization: `Bearer ${input.apiKey.trim()}`,
+          "Content-Type": "application/json",
+          "X-Request-Id": attemptId,
+        },
+        body: JSON.stringify({
+          model: input.route.wireModel,
+          input: input.texts,
+          dimensions: input.route.dimensions,
+        }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+      });
+    } catch (error) {
+      if (input.signal?.aborted === true) throw error;
+      throw new SurplusEmbeddingAttemptError("outcome_unknown");
+    }
+    responseObserved = true;
+    responseStatus = response.status;
+    receipt = readSurplusWireReceipt(response.headers);
+    if (receipt.requestId && response.ok) {
+      try {
+        await resolvedDeps.attach({
+          attemptId,
+          providerRequestId: receipt.requestId,
+          ...(receipt.providerFamily ? { servingProvider: receipt.providerFamily.toLowerCase() } : {}),
+          endpoint: "/v1/embeddings",
+          metadata: surplusReceiptTelemetry(receipt),
+        });
+        receiptAttached = true;
+      } catch {
+        warn("[nautilo/surplus] embedding receipt persistence failed", {
+          failureCode: "request_receipt_failed",
+        });
+      }
+    }
+    assertQualifiedSurplusEmbeddingReceipt(input.route, receipt, response.status);
+    if (!response.ok) {
+      let diagnostics: Awaited<ReturnType<typeof readBoundedSurplusErrorBody>> = {};
+      try {
+        // This response is terminal and will not be parsed elsewhere. Reading
+        // it directly avoids tee cancellation waiting on an unread clone.
+        diagnostics = await readBoundedSurplusErrorBody(response.body?.getReader());
+      } catch {
+        // Diagnostics are optional. Preserve the provider failure when the
+        // runtime cannot read the error response.
+      }
+      errorBodyRequestId = diagnostics.requestId;
+      await response.body?.cancel();
+      throw new SurplusEmbeddingAttemptError(
+        "provider_unavailable",
+        response.status,
+        response.status === 429 || response.status >= 500,
+        diagnostics.vendorCode,
+      );
+    }
+    let value: unknown;
+    try {
+      value = await response.json();
+    } catch {
+      throw new SurplusEmbeddingAttemptError("invalid_response", response.status, true);
+    }
+    evidence = usageEvidence(value);
+    let result: T;
+    try {
+      result = input.parseResponse(value);
+    } catch (error) {
+      if (error instanceof SurplusEmbeddingAttemptError) throw error;
+      throw error;
+    }
+    const cost = receiptCostUsd(receipt);
+    try {
+      await settleWithRetry(resolvedDeps.settle, {
+        attemptId,
+        ...(receipt.requestId ? { providerRequestId: receipt.requestId } : {}),
+        metadata: surplusReceiptTelemetry(receipt),
+        outcome: "succeeded",
+        costState: cost === undefined ? (receipt.requestId ? "pending" : "unknown") : "actual",
+        ...(cost === undefined ? {} : { actualCostUsd: cost }),
+        ...(evidence.inputTokens === undefined ? {} : { inputTokens: evidence.inputTokens }),
+        ...(evidence.totalTokens === undefined ? {} : { totalTokens: evidence.totalTokens }),
+        ...(receipt.providerFamily ? { servingProvider: receipt.providerFamily.toLowerCase() } : {}),
+      });
+    } catch {
+      warn("[nautilo/surplus] completed embedding settlement failed", {
+        failureCode: "attempt_settlement_failed",
+      });
+    }
+    return result;
+  } catch (error) {
+    const cancelled = input.signal?.aborted === true;
+    const cost = receiptCostUsd(receipt);
+    const knownPreWireZero = !wireDispatched;
+    const matchingBodyRequestId = errorBodyRequestId !== undefined
+      && (receipt?.requestId === undefined || receipt.requestId === errorBodyRequestId)
+      ? errorBodyRequestId
+      : undefined;
+    const trace = provenPreRoutingSurplusTrace({
+      error,
+      responseStatus,
+      receipt,
+      ...(matchingBodyRequestId === undefined ? {} : { requestId: matchingBodyRequestId }),
+    });
+    const safeDiagnostics = safeSurplusErrorDiagnostics(error, responseStatus);
+    const failureCode = cancelled
+      ? "cancelled"
+      : !wireDispatched
+        ? "pre_wire_authorization_changed"
+      : error instanceof SurplusEmbeddingAttemptError
+        ? error.failureCode
+        : responseObserved
+          ? "invalid_response"
+          : "outcome_unknown";
+    if (!trace && receipt?.requestId && !receiptAttached) {
+      try {
+        await resolvedDeps.attach({
+          attemptId,
+          providerRequestId: receipt.requestId,
+          ...(receipt.providerFamily ? { servingProvider: receipt.providerFamily.toLowerCase() } : {}),
+          endpoint: "/v1/embeddings",
+          metadata: {
+            ...surplusReceiptTelemetry(receipt),
+            ...surplusErrorTelemetry(safeDiagnostics),
+          },
+        });
+        receiptAttached = true;
+      } catch {
+        warn("[nautilo/surplus] embedding receipt persistence failed", {
+          failureCode: "request_receipt_failed",
+        });
+      }
+    }
+    try {
+      await settleWithRetry(resolvedDeps.settle, {
+        attemptId,
+        ...(!trace && receipt?.requestId ? { providerRequestId: receipt.requestId } : {}),
+        ...(!receipt && Object.keys(safeDiagnostics).length === 0 ? {} : {
+          metadata: {
+            ...(receipt ? surplusReceiptTelemetry(receipt) : {}),
+            ...surplusErrorTelemetry(trace ?? safeDiagnostics),
+          },
+        }),
+        outcome: cancelled ? "cancelled" : responseObserved || !wireDispatched ? "failed" : "unknown",
+        costState: knownPreWireZero || trace || cost !== undefined
+          ? "actual" : receipt?.requestId ? "pending" : "unknown",
+        ...(knownPreWireZero || trace ? { actualCostUsd: 0 }
+          : cost === undefined ? {} : { actualCostUsd: cost }),
+        ...(evidence.inputTokens === undefined ? {} : { inputTokens: evidence.inputTokens }),
+        ...(evidence.totalTokens === undefined ? {} : { totalTokens: evidence.totalTokens }),
+        ...(receipt?.providerFamily ? { servingProvider: receipt.providerFamily.toLowerCase() } : {}),
+        failureCode,
+      });
+    } catch {
+      warn("[nautilo/surplus] embedding attempt settlement failed", {
+        failureCode: "attempt_settlement_failed",
+      });
+    }
+    if (cancelled) throw input.signal?.reason ?? error;
+    if (!wireDispatched) throw error;
+    if (error instanceof SurplusEmbeddingAttemptError) throw error;
+    throw new SurplusEmbeddingAttemptError("invalid_response", responseStatus, true);
+  }
+}
diff --git a/packages/agent/src/utils/chat-model-invocation.ts b/packages/agent/src/utils/chat-model-invocation.ts
index 4de21680d..efde868aa 100644
--- a/packages/agent/src/utils/chat-model-invocation.ts
+++ b/packages/agent/src/utils/chat-model-invocation.ts
@@ -25,9 +25,11 @@ import { modelHasRunnableCredentials } from "../chat/model-runtime-credentials";
 import { createUniversalModel } from "../providers/universal";
 import { resolveProviderKey } from "../resolve-provider-key";
 import {
+  hydrateSurplusChatCatalog,
   resolveSurplusChatServingAvailability,
   canBroadenSurplusModelRoute,
   SurplusDirectFallbackUnavailableError,
+  type QualifiedSurplusChatRoute,
 } from "../providers/surplus-route";
 import { canUseQualifiedSurplusChatRoute, invokeSurplusChatAttempt } from "../providers/surplus-attempt";
 import { SurplusOutcomeUnknownError } from "../providers/surplus-transport";
@@ -141,13 +143,14 @@ class ProviderAttemptError extends Error {
   }
 }
 
-class PersonalSurplusDirectFallbackUnavailableError extends SurplusDirectFallbackUnavailableError {
+class SurplusRecoveryUnavailableError extends SurplusDirectFallbackUnavailableError {
   constructor(
     reason: "surplus-unavailable" | "request-not-qualified",
-    readonly personalFundingError: PersonalDirectFundingUnavailableError,
+    readonly marketplaceFailure?: Error,
+    readonly personalFundingError?: PersonalDirectFundingUnavailableError,
   ) {
     super(reason);
-    this.name = "PersonalSurplusDirectFallbackUnavailableError";
+    this.name = "SurplusRecoveryUnavailableError";
   }
 }
 
@@ -156,16 +159,22 @@ async function runAdmittedDirectFallback<T>(
   modelId: string,
   run: (attempt: ForegroundChatFundingAttempt, session: ForegroundChatFundingSession) => Promise<T>,
   reason: "surplus-unavailable" | "request-not-qualified",
+  marketplaceFailure?: Error,
 ): Promise<T> {
   try {
     return await runAdmittedDirectModelRecovery(fundingSession, modelId, run);
   } catch (error) {
     if (error instanceof PersonalDirectFundingUnavailableError) {
-      throw new PersonalSurplusDirectFallbackUnavailableError(reason, error);
+      throw new SurplusRecoveryUnavailableError(reason, marketplaceFailure, error);
     }
     if (error instanceof ProviderAttemptError || error instanceof PersonalAttemptLedgerUnavailableError) {
       throw error;
     }
+    if (marketplaceFailure && typeof error === "object" && error !== null
+      && "code" in error
+      && (error.code === "provider_credentials_missing" || error.code === "personal_credential_missing")) {
+      throw new SurplusRecoveryUnavailableError(reason, marketplaceFailure);
+    }
     // Direct/recovery admission runs inside the marketplace callback, but
     // policy, permission and custody failures remain session failures.
     throw new ForegroundFundingRecheckError(error);
@@ -424,6 +433,17 @@ export async function resolveCompletionBudget(modelId: string, messages: BaseMes
   return resolved;
 }
 
+/** The same marketplace context/output intersection serves chat and Soul. */
+export function resolveSurplusCompletionBudget(
+  route: QualifiedSurplusChatRoute,
+  maxOutputTokens: number,
+  messages: BaseMessage[],
+  tools: readonly StructuredTool[] = [],
+): number {
+  return Math.min(maxOutputTokens, route.maxOutputTokens,
+    preparedMessageBudget(route.maxContextTokens, tools) - estimateTokenCount(messages));
+}
+
 /** One Agent-owned supervisor guards this actual provider invocation. */
 async function invokeModelWithAttemptSupervisor(
   model: { invoke(messages: BaseMessage[], options?: RunnableConfig): Promise<unknown> },
@@ -1081,12 +1101,26 @@ export async function invokeChatModelWithFallback(
             kickServerModelConfigRefresh();
             const surplusKey = usageFunding.kind === "personal"
               ? personalCredential?.apiKey ?? null : resolveProviderKey("surplus");
+            const surplusPolicyEnabled = attemptFundingSession
+              ? usageFunding.providerRoute === "surplus"
+              : getCachedServerModelConfigRow()?.preferSurplus === true;
+            if (surplusPolicyEnabled && surplusKey !== null) {
+              await hydrateSurplusChatCatalog({ catalogModelIds: [currentModelId],
+                ...(llmCallConfig.signal ? { signal: llmCallConfig.signal } : {}),
+              });
+              assertNotCancelled();
+            }
             const surplus = resolveSurplusChatServingAvailability({
               catalogModelId: currentModelId,
-              policyEnabled: attemptFundingSession ? usageFunding.providerRoute === "surplus" : getCachedServerModelConfigRow()?.preferSurplus === true,
+              policyEnabled: surplusPolicyEnabled,
               keyConfigured: surplusKey !== null,
             });
-            const catalogEntry = getActiveModelCatalogSync().catalog.entries.find((entry) => entry.id === currentModelId);
+            // Provider-specific ceilings only lower this marketplace attempt;
+            // direct recovery retains the selected model's signed budget.
+            const estimatedSurplusInput = estimateTokenCount(attemptMessages) + estimateBoundToolTokens(tools);
+            const surplusMaxTokens = surplus.route
+              ? resolveSurplusCompletionBudget(surplus.route, maxTokens, attemptMessages, tools)
+              : maxTokens;
             if (surplus.status === "available" && surplusKey !== null
               && canUseQualifiedSurplusChatRoute({
                 route: surplus.route,
@@ -1095,15 +1129,28 @@ export async function invokeChatModelWithFallback(
                 hasSurplusCredential: true,
                 needsVision,
                 requiresTools,
-                reasoningRequested: requestedReasoningEffort !== undefined
-                  || (catalogEntry?.features?.reasoning === true && reasoningOutput),
+                // Visibility alone is not an effort override. Models without
+                // an advertised knob may retain their provider default; the
+                // transport omits unsupported implicit settings.
+                reasoningRequested: requestedReasoningEffort !== undefined,
                 hasRequestChangingServingProfile: serving !== undefined
                   && (serving.effectiveModelId !== serving.canonicalModelId || serving.requestModelKwargs !== undefined),
-                estimatedInputTokens: estimateTokenCount(attemptMessages) + estimateBoundToolTokens(tools),
-                maxOutputTokens: maxTokens,
+                estimatedInputTokens: estimatedSurplusInput,
+                maxOutputTokens: surplusMaxTokens,
               })) {
               surplusAttemptedForModel = true;
               const surplusFunding = { ...usageFunding, providerRoute: "surplus" };
+              const allowsSellerBroadening = () =>
+                (attemptFundingSession?.allowUnpinnedSurplusRetry === true
+                  || (!attemptFundingSession && invokeOptions?.allowUnpinnedSurplusRetry === true))
+                && canBroadenSurplusModelRoute(initialModelId)
+                && canBroadenSurplusModelRoute(currentModelId);
+              // A server-only setup has no preferred direct rail to preserve.
+              // Personal payer credentials remain owned by their admission.
+              const firstProviderMode = usageFunding.kind === "server"
+                && allowsSellerBroadening()
+                && !modelHasRunnableCredentials(currentModelId, process.env)
+                ? "any" as const : undefined;
               const invokeMarketplace = (providerMode?: "any") => invokeSurplusChatAttempt({
                 ...(providerMode ? { providerMode } : {}),
                 route: surplus.route,
@@ -1112,12 +1159,25 @@ export async function invokeChatModelWithFallback(
                 tools,
                 ...(invokeOptions?.toolBindingOptions ? { toolBindingOptions: invokeOptions.toolBindingOptions } : {}),
                 config: llmCallConfig,
-                maxOutputTokens: maxTokens,
+                maxOutputTokens: surplusMaxTokens,
                 ...(requestedReasoningEffort === undefined ? {} : { reasoningEffort: requestedReasoningEffort }),
                 reasoningOutput,
                 ...(openRouterSessionId === undefined ? {} : { openrouterSessionId: openRouterSessionId }),
                 funding: surplusFunding,
                 hasDeliveredOutput: attemptVisibility.hasVisibleOutput,
+                ...(providerMode === "any" ? {
+                  assertStillAuthorized: async () => {
+                    assertNotCancelled();
+                    if (!allowsSellerBroadening()) {
+                      throw new ForegroundFundingRecheckError(new Error("Surplus seller broadening is no longer authorized."));
+                    }
+                    try {
+                      if (attemptFundingSession) await attemptFundingSession.recheckAttempt(currentModelId, "surplus");
+                      else await assertModelFunding(invokeOptions?.fundingHumanUserId, invokeOptions?.serverFundedService);
+                    } catch (error) { throw new ForegroundFundingRecheckError(error); }
+                    assertNotCancelled();
+                  },
+                } : {}),
                 ...(invokeOptions?.validateResponse ? { validateResponse: invokeOptions.validateResponse } : {}),
                 invokeModel: (model, selectedMessages, selectedConfig) => invokeForegroundAttemptWithUsageContext(
                   model,
@@ -1142,11 +1202,9 @@ export async function invokeChatModelWithFallback(
                   "/v1/chat/completions",
                 ),
               });
-              let result = await invokeMarketplace();
-              if (result.kind === "direct_fallback" && result.retryUnpinned
-                && (attemptFundingSession?.allowUnpinnedSurplusRetry === true
-                  || (!attemptFundingSession && invokeOptions?.allowUnpinnedSurplusRetry === true))
-                && canBroadenSurplusModelRoute(currentModelId)
+              let result = await invokeMarketplace(firstProviderMode);
+              if (firstProviderMode !== "any" && result.kind === "direct_fallback" && result.retryUnpinned
+                && allowsSellerBroadening()
                 && !attemptVisibility.hasVisibleOutput() && !hasAssistantVisibleOutputForCurrentTurn(agentId)) {
                 assertNotCancelled();
                 try {
@@ -1168,13 +1226,16 @@ export async function invokeChatModelWithFallback(
                   currentModelId,
                   runProviderAttempt,
                   "surplus-unavailable",
+                  result.failure,
                 );
               }
               // A definitive pre-service refusal can switch transports.
               // Its cost stays unknown until a receipt confirms it. Recheck
               // live funding before the original provider receives the prompt.
               if (!modelHasRunnableCredentials(currentModelId, process.env)) {
-                throw new SurplusDirectFallbackUnavailableError();
+                throw result.failure
+                  ? new SurplusRecoveryUnavailableError("surplus-unavailable", result.failure)
+                  : new SurplusDirectFallbackUnavailableError();
               }
               try {
                 await assertModelFunding(invokeOptions?.fundingHumanUserId, invokeOptions?.serverFundedService);
@@ -1350,10 +1411,11 @@ export async function invokeChatModelWithFallback(
         return invokeChatModelWithFallback(messages, tools, currentModelId, userId, agentId,
           laneKey, invocationConfig, { ...invokeOptions, fundingSession: recovery, modelFallbackMode: "none" });
       }
-      const terminalProviderError = (personalFunding || personalRecoveryAttemptedForModel)
+      const recoveryUnavailable = providerFailure instanceof SurplusRecoveryUnavailableError ? providerFailure : undefined;
+      const terminalProviderError = recoveryUnavailable?.marketplaceFailure ?? ((personalFunding || personalRecoveryAttemptedForModel)
         && !(providerFailure instanceof SurplusDirectFallbackUnavailableError)
         ? new PersonalProviderInvocationError(classified.category)
-        : providerFailure;
+        : providerFailure);
       // Recovery uses a separate personal attempt, without granting another
       // server/model-chain retry or logging the personal provider response.
       if (personalRecoveryAttemptedForModel) throw terminalProviderError;
@@ -1401,9 +1463,7 @@ export async function invokeChatModelWithFallback(
       disableReasoningOutput = false;
 
       const surplusDirectUnavailable = providerFailure instanceof SurplusDirectFallbackUnavailableError;
-      const personalDirectUnavailable = providerFailure instanceof PersonalSurplusDirectFallbackUnavailableError
-        ? providerFailure.personalFundingError
-        : undefined;
+      const personalDirectUnavailable = recoveryUnavailable?.marketplaceFailure ?? recoveryUnavailable?.personalFundingError;
       // A missing original credential after a safe Surplus refusal does not
       // exhaust the configured chain. A rejected original credential likewise
       // leaves other provider routes usable; personal funding stays separate.
diff --git a/packages/agent/tests/helpers/surplus-catalog-fixture.ts b/packages/agent/tests/helpers/surplus-catalog-fixture.ts
new file mode 100644
index 000000000..dcc62ce89
--- /dev/null
+++ b/packages/agent/tests/helpers/surplus-catalog-fixture.ts
@@ -0,0 +1,40 @@
+import {
+  configureSurplusModelCatalog,
+  hydrateSurplusModelCatalog,
+} from "../../src/providers/surplus-catalog";
+
+/** Content-free vendor-shaped discovery, separate from the signed catalogue. */
+const SURPLUS_CHAT_FIXTURES = [
+  { id: "claude-sonnet-4.6", aliases: ["claude-sonnet-4-6", "anthropic/claude-sonnet-4.6"], context: 1_000_000, output: 64_000 },
+  { id: "kimi-k3", aliases: ["moonshotai/kimi-k3", "accounts/fireworks/models/kimi-k3"], context: 1_000_000, output: 131_072 },
+  { id: "kimi-k2.6", aliases: ["moonshotai/kimi-k2.6"], context: 262_142, output: 131_072 },
+  { id: "minimax-m3-preview", aliases: [], context: 524_288, output: 65_536 },
+  { id: "gpt-5.6-sol", aliases: ["openai/gpt-5.6-sol"], context: 1_050_000, output: 128_000 },
+  { id: "gpt-5.5-2026-04-23", aliases: [], context: 1_050_000, output: 128_000 },
+  { id: "gemini-2.5-pro", aliases: [], context: 1_048_576, output: 65_536 },
+  { id: "gemini-3.1-pro-preview", aliases: [], context: 1_048_576, output: 65_536 },
+] as const;
+
+export async function installSurplusCatalogFixture(): Promise<void> {
+  const rows = SURPLUS_CHAT_FIXTURES.map((model) => ({
+    id: model.id,
+    context_length: model.context,
+    top_provider: { context_length: model.context, max_completion_tokens: model.output },
+    architecture: { input_modalities: ["text", "image"], output_modalities: ["text"] },
+    supported_parameters: ["max_tokens", "tools", "tool_choice", "reasoning", "reasoning_effort"],
+    supported_features: ["tools", "reasoning", "streaming", "vision"],
+  }));
+  configureSurplusModelCatalog({
+    fetchImpl: ((input: Parameters<typeof fetch>[0]) => {
+      const url = new URL(input instanceof Request ? input.url : String(input));
+      if (url.pathname === "/v1/models") return Promise.resolve(Response.json({ data: rows }));
+      const requested = decodeURIComponent(url.pathname.slice("/v1/models/".length));
+      const model = SURPLUS_CHAT_FIXTURES.find((candidate) => candidate.id === requested
+        || (candidate.aliases as readonly string[]).includes(requested));
+      return Promise.resolve(model
+        ? Response.json(rows.find((row) => row.id === model.id))
+        : Response.json({ error: { code: "model_not_found" } }, { status: 404 }));
+    }) as unknown as typeof fetch,
+  });
+  await hydrateSurplusModelCatalog(SURPLUS_CHAT_FIXTURES.flatMap((model) => [model.id, ...model.aliases]));
+}
diff --git a/packages/agent/tests/unit-isolated/agent-admitted-direct-hydration.test.ts b/packages/agent/tests/unit-isolated/agent-admitted-direct-hydration.test.ts
new file mode 100644
index 000000000..8c4297f88
--- /dev/null
+++ b/packages/agent/tests/unit-isolated/agent-admitted-direct-hydration.test.ts
@@ -0,0 +1,119 @@
+/** Isolated so funding, provider-route, and database mocks cannot leak into other suites. */
+import { afterAll, beforeEach, expect, mock, test } from "bun:test";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { ToolCatalog, clearToolCatalog, initToolCatalog } from "@nautilo/catalog";
+import type { NautiloState } from "../../src/agent/state";
+import type { ForegroundChatFundingSession } from "../../src/runtime/foreground-chat-funding";
+
+const MODEL_ID = "openrouter:openai/gpt-5.6-sol";
+const actualDb = await import("@nautilo/db");
+mock.module("@nautilo/db", () => ({
+  ...actualDb,
+  getCachedServerModelConfigRow: () => ({ preferSurplus: true }),
+  kickServerModelConfigRefresh: () => {},
+}));
+
+const actualSurplusRoute = await import("../../src/providers/surplus-route");
+const hydrateSurplusChatCatalog = mock(async () => {
+  throw new Error("unexpected Surplus catalogue discovery");
+});
+mock.module("../../src/providers/surplus-route", () => ({
+  ...actualSurplusRoute,
+  hydrateSurplusChatCatalog,
+}));
+
+const invocation = mock(async (..._args: unknown[]) => ({
+  response: new AIMessage("Direct provider completed the request."),
+  modelUsed: MODEL_ID,
+}));
+mock.module("../../src/utils/chat-model-invocation", () => ({
+  invokeChatModelWithFallback: invocation,
+  resolvePreparedMessageBudget: async () => 4_096,
+  estimateBoundToolTokens: () => 0,
+}));
+
+const { agentNode } = await import("../../src/nodes/agent");
+const previousOpenRouterKey = process.env["OPENROUTER_API_KEY"];
+const previousSurplusKey = process.env["SURPLUS_API_KEY"];
+
+beforeEach(() => {
+  hydrateSurplusChatCatalog.mockClear();
+  invocation.mockClear();
+  process.env["OPENROUTER_API_KEY"] = "synthetic-direct-key";
+  process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+  initToolCatalog(new ToolCatalog());
+});
+
+afterAll(() => {
+  clearToolCatalog();
+  if (previousOpenRouterKey === undefined) delete process.env["OPENROUTER_API_KEY"];
+  else process.env["OPENROUTER_API_KEY"] = previousOpenRouterKey;
+  if (previousSurplusKey === undefined) delete process.env["SURPLUS_API_KEY"];
+  else process.env["SURPLUS_API_KEY"] = previousSurplusKey;
+});
+
+function state(): NautiloState {
+  const prompt = new HumanMessage("Complete this admitted direct-provider task.");
+  return {
+    model: MODEL_ID,
+    subagentDepth: 1,
+    taskRun: true,
+    trustedExecutionEntrypoint: "background.task",
+    modelFallbackMode: "none",
+    preparedMessages: [prompt],
+    messages: [prompt],
+    userId: "task-owner",
+    causalHumanUserId: "task-owner",
+    agentId: "task-agent",
+    roomId: null,
+    turnId: "direct-admission-turn",
+    actorRole: "owner",
+    memoryAccessEnvelope: null,
+    toolWhitelist: [],
+    activatedToolNames: [],
+    activatedToolLeases: [],
+    currentThreadId: "direct-admission-thread",
+    currentFolder: "",
+    workspacePath: "",
+  } as unknown as NautiloState;
+}
+
+function fundingSession(providerRoute?: string): ForegroundChatFundingSession {
+  return {
+    kind: "server",
+    ...(providerRoute === undefined
+      ? {}
+      : { admission: { modelId: MODEL_ID, binding: { kind: "server", providerRoute } } }),
+    runAttempt: async () => { throw new Error("Provider boundary is mocked"); },
+    recheckAttempt: async () => {},
+  };
+}
+
+test("an admitted direct-provider attempt skips unrelated Surplus catalogue discovery", async () => {
+  const session = fundingSession("openrouter");
+
+  const result = await agentNode(
+    state(), undefined, undefined, false, undefined, undefined, session,
+  );
+
+  expect(result.model).toBe(MODEL_ID);
+  expect(hydrateSurplusChatCatalog).not.toHaveBeenCalled();
+  expect(invocation).toHaveBeenCalledTimes(1);
+  expect(invocation.mock.calls[0]?.[7]).toMatchObject({
+    fundingSession: session,
+    modelFallbackMode: "none",
+  });
+});
+
+test.each([
+  ["an unbound attempt", undefined],
+  ["an admitted Surplus attempt", "surplus"],
+] as const)("%s still hydrates the Surplus catalogue", async (_label, providerRoute) => {
+  const thrown = await agentNode(
+    state(), undefined, undefined, false, undefined, undefined, fundingSession(providerRoute),
+  ).catch((error: unknown) => error);
+
+  expect(thrown).toEqual(new Error("unexpected Surplus catalogue discovery"));
+  expect(hydrateSurplusChatCatalog).toHaveBeenCalledTimes(1);
+  expect(invocation).not.toHaveBeenCalled();
+});
diff --git a/packages/agent/tests/unit-isolated/chat-model-fallback.test.ts b/packages/agent/tests/unit-isolated/chat-model-fallback.test.ts
index 90a1283d6..d3862605d 100644
--- a/packages/agent/tests/unit-isolated/chat-model-fallback.test.ts
+++ b/packages/agent/tests/unit-isolated/chat-model-fallback.test.ts
@@ -25,6 +25,8 @@ import {
 } from "../../src/runtime/foreground-chat-funding";
 import type { RecoverPreparedContext } from "../../src/utils/chat-model-invocation";
 import type { ResolvedFallbackPolicy } from "../../src/utils/resolve-fallback-policy";
+import { installSurplusCatalogFixture } from "../helpers/surplus-catalog-fixture";
+import { resetSurplusModelCatalog } from "../../src/providers/surplus-catalog";
 import { setAgentEventSink } from "../../src/runtime-hooks";
 import { getOrCreateAgentTurnContextByKey, turnContextKey, _resetAgentTurnContextsForTests } from "../../src/runtime/turn-context";
 import { ProviderTimeoutError } from "../../src/providers/errors";
@@ -124,6 +126,7 @@ const priorProviderKeys = Object.fromEntries(
     .map((key) => [key, process.env[key]]),
 );
 const priorFetch = globalThis.fetch;
+beforeEach(installSurplusCatalogFixture);
 
 test("resolves each candidate's policy with explicit temporary or caller provenance", () => {
   const legacy = resolveModelAttemptPolicy(A);
@@ -246,6 +249,7 @@ beforeAll(async () => {
 });
 
 afterAll(() => {
+  resetSurplusModelCatalog();
   uninstallPersonalAttemptOwner?.();
   resetRuntimeModelCatalog();
   setAgentEventSink(null);
diff --git a/packages/agent/tests/unit-isolated/image-assistance-invocation.test.ts b/packages/agent/tests/unit-isolated/image-assistance-invocation.test.ts
index d7d27323b..70ec4587f 100644
--- a/packages/agent/tests/unit-isolated/image-assistance-invocation.test.ts
+++ b/packages/agent/tests/unit-isolated/image-assistance-invocation.test.ts
@@ -6,10 +6,12 @@
 import { AIMessage, HumanMessage, type BaseMessage } from "@langchain/core/messages";
 import type { RunnableConfig } from "@langchain/core/runnables";
 import type { StructuredTool } from "@langchain/core/tools";
-import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
 import type { ForegroundChatFundingSession } from "../../src/runtime/foreground-chat-funding";
 import type { UsageFundingProvenance } from "../../src/usage/usage-context";
 import type { ChatModel } from "../../src/providers/types";
+import { resetSurplusModelCatalog } from "../../src/providers/surplus-catalog";
+import { installSurplusCatalogFixture } from "../helpers/surplus-catalog-fixture";
 
 const VISION_MODEL = "anthropic:claude-sonnet-4-6";
 const CHAIN_MODEL = "openai:gpt-5.5-2026-04-23";
@@ -171,7 +173,8 @@ afterAll(() => {
   }
 });
 
-beforeEach(() => {
+beforeEach(async () => {
+  await installSurplusCatalogFixture();
   preferSurplus = false;
   providerResponse = new AIMessage("image-a / invoice.png: total 123.45");
   directInvocations = 0;
@@ -192,6 +195,8 @@ beforeEach(() => {
   policy = { enabled: true, chain: [CHAIN_MODEL] };
 });
 
+afterEach(resetSurplusModelCatalog);
+
 function personalSession(initialRoute: "direct" | "surplus" = "direct"): ForegroundChatFundingSession {
   return {
     kind: "personal",
diff --git a/packages/agent/tests/unit-isolated/memory-store-junction-m076.test.ts b/packages/agent/tests/unit-isolated/memory-store-junction-m076.test.ts
index 456eb2ad0..238457159 100644
--- a/packages/agent/tests/unit-isolated/memory-store-junction-m076.test.ts
+++ b/packages/agent/tests/unit-isolated/memory-store-junction-m076.test.ts
@@ -204,6 +204,9 @@ function mockDbModule(opts: {
     memoryEmbeddingCompatibilityCondition,
     beginServiceLlmAttempt: async () => { throw new Error("service attempt must not run in memory-store isolation"); },
     settleServiceLlmAttempt: async () => { throw new Error("service settlement must not run in memory-store isolation"); },
+    beginSurplusLlmAttempt: async () => { throw new Error("Surplus attempt must not run in memory-store isolation"); },
+    attachSurplusRequestReceipt: async () => { throw new Error("Surplus receipt must not run in memory-store isolation"); },
+    settleSurplusLlmAttempt: async () => { throw new Error("Surplus settlement must not run in memory-store isolation"); },
   }));
   return dbHandle;
 }
diff --git a/packages/agent/tests/unit-isolated/projection-force-create-idempotency.test.ts b/packages/agent/tests/unit-isolated/projection-force-create-idempotency.test.ts
index 77ce97292..805cb5afc 100644
--- a/packages/agent/tests/unit-isolated/projection-force-create-idempotency.test.ts
+++ b/packages/agent/tests/unit-isolated/projection-force-create-idempotency.test.ts
@@ -65,6 +65,9 @@ function mockRuntime(execute: (query: unknown) => Promise<{ rows: unknown[] }>):
     normalizeUsageRoomId: (roomId: string | null | undefined) =>
       typeof roomId === "string" && roomId.trim().length > 0 ? roomId : null,
   }));
+  mock.module("../../src/store/embeddings", () => ({
+    embedTextWithProvenance: async () => embedding,
+  }));
   mock.module("@nautilo/db", () => ({
     agentDb: handle,
     getCachedServerModelConfigRow: () => null,
diff --git a/packages/agent/tests/unit-isolated/surplus-output-ceiling.test.ts b/packages/agent/tests/unit-isolated/surplus-output-ceiling.test.ts
new file mode 100644
index 000000000..50043275e
--- /dev/null
+++ b/packages/agent/tests/unit-isolated/surplus-output-ceiling.test.ts
@@ -0,0 +1,180 @@
+/**
+ * Isolated because the Surplus attempt boundary imports durable DB functions;
+ * this suite replaces them with content-free receipts and must not leak those
+ * module mocks into the shared unit-test process.
+ */
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+type ObservedResponse = (
+  receipt: {
+    requestId: string;
+    providerFamily?: string;
+    marketplaceAttempts?: number;
+    truncated: boolean;
+    adaptedParameters?: string;
+    buyerCostMicro?: number;
+  },
+  status: number,
+) => Promise<void>;
+
+const createModelInputs: Record<string, unknown>[] = [];
+let observedResponse: ObservedResponse | undefined;
+const beginAttempt = mock(async (_input: Record<string, unknown>) => {});
+const attachReceipt = mock(async (_input: Record<string, unknown>) => {});
+const settleAttempt = mock(async (_input: Record<string, unknown>) => {});
+
+mock.module("@nautilo/db", () => ({
+  attachSurplusRequestReceipt: attachReceipt,
+  beginSurplusLlmAttempt: beginAttempt,
+  settleSurplusLlmAttempt: settleAttempt,
+}));
+
+class MockSurplusOutcomeUnknownError extends Error {}
+
+mock.module("../../src/providers/surplus-transport", () => ({
+  createSurplusChatModel: (input: Record<string, unknown>) => {
+    createModelInputs.push(input);
+    observedResponse = input["onResponse"] as ObservedResponse;
+    return { invoke: async () => new AIMessage("unused") };
+  },
+  isSafeSurplusDirectFallback: () => false,
+  SurplusOutcomeUnknownError: MockSurplusOutcomeUnknownError,
+}));
+
+mock.module("../../src/providers/surplus-catalog", () => ({
+  invalidateSurplusModelCatalog: mock(() => {}),
+}));
+
+const { invokeSurplusChatAttempt } = await import("../../src/providers/surplus-attempt");
+
+const MAX_OUTPUT_TOKENS = 131_072;
+const ROUTE = {
+  catalogModelId: "openrouter:moonshotai/kimi-k3",
+  surplusModelId: "kimi-k3",
+  providerPin: "openrouter" as const,
+  supportsTools: true,
+  supportsVision: true,
+  supportsReasoning: true,
+  maxContextTokens: 1_000_000,
+  maxOutputTokens: MAX_OUTPUT_TOKENS,
+};
+
+beforeEach(() => {
+  createModelInputs.length = 0;
+  observedResponse = undefined;
+  beginAttempt.mockClear();
+  attachReceipt.mockClear();
+  settleAttempt.mockClear();
+});
+
+function completedResponse(completionTokens: number): AIMessage {
+  return new AIMessage({
+    content: "Complete",
+    response_metadata: {
+      finish_reason: "stop",
+      usage: {
+        prompt_tokens: 37,
+        completion_tokens: completionTokens,
+        total_tokens: 37 + completionTokens,
+        buyer_cost_micro: 62,
+      },
+    },
+  });
+}
+
+describe("Surplus output-ceiling attempt boundary", () => {
+  test("threads the production output cap through final validation and settles one completed attempt", async () => {
+    let inferenceCalls = 0;
+    const response = completedResponse(5);
+    const result = await invokeSurplusChatAttempt({
+      route: ROUTE,
+      apiKey: "synthetic-surplus-key",
+      providerMode: "any",
+      messages: [new HumanMessage("Complete the probe")],
+      tools: [],
+      config: {},
+      maxOutputTokens: MAX_OUTPUT_TOKENS,
+      funding: { kind: "server", providerRoute: "surplus", humanUserId: "user-1" },
+      hasDeliveredOutput: () => false,
+      invokeModel: async () => {
+        inferenceCalls++;
+        await observedResponse!({
+          requestId: "request-kimi-ceiling",
+          providerFamily: "openai",
+          marketplaceAttempts: 1,
+          adaptedParameters: "max_tokens",
+          truncated: false,
+        }, 200);
+        return response;
+      },
+    });
+
+    expect(result).toEqual({ kind: "served", response, requestId: "request-kimi-ceiling" });
+    expect(inferenceCalls).toBe(1);
+    expect(createModelInputs).toHaveLength(1);
+    expect(createModelInputs[0]).toMatchObject({
+      route: ROUTE,
+      providerMode: "any",
+      maxOutputTokens: MAX_OUTPUT_TOKENS,
+    });
+    expect(beginAttempt).toHaveBeenCalledTimes(1);
+    expect(attachReceipt).toHaveBeenCalledTimes(1);
+    expect(settleAttempt).toHaveBeenCalledTimes(1);
+    expect(settleAttempt.mock.calls[0]?.[0]).toMatchObject({
+      providerRequestId: "request-kimi-ceiling",
+      servingProvider: "openai",
+      outcome: "succeeded",
+      costState: "actual",
+      actualCostUsd: 0.000062,
+      inputTokens: 37,
+      outputTokens: 5,
+      totalTokens: 42,
+      metadata: { surplusAdaptedParameters: ["max_tokens"] },
+    });
+    expect(settleAttempt.mock.calls[0]?.[0]).not.toHaveProperty("failureCode");
+  });
+
+  test("preserves cost and refuses replay when delivered output exceeds the original cap", async () => {
+    let inferenceCalls = 0;
+    const response = completedResponse(MAX_OUTPUT_TOKENS + 1);
+    const error = await invokeSurplusChatAttempt({
+      route: ROUTE,
+      apiKey: "synthetic-surplus-key",
+      providerMode: "any",
+      messages: [new HumanMessage("Complete the probe")],
+      tools: [],
+      config: {},
+      maxOutputTokens: MAX_OUTPUT_TOKENS,
+      funding: { kind: "server", providerRoute: "surplus", humanUserId: "user-1" },
+      hasDeliveredOutput: () => true,
+      invokeModel: async () => {
+        inferenceCalls++;
+        await observedResponse!({
+          requestId: "request-kimi-over-cap",
+          providerFamily: "openai",
+          marketplaceAttempts: 1,
+          adaptedParameters: "max_tokens",
+          truncated: false,
+        }, 200);
+        return response;
+      },
+    }).catch((caught: unknown) => caught);
+
+    expect(error).toBeInstanceOf(MockSurplusOutcomeUnknownError);
+    expect(inferenceCalls).toBe(1);
+    expect(settleAttempt).toHaveBeenCalledTimes(1);
+    expect(settleAttempt.mock.calls[0]?.[0]).toMatchObject({
+      providerRequestId: "request-kimi-over-cap",
+      servingProvider: "openai",
+      outcome: "unknown",
+      costState: "actual",
+      actualCostUsd: 0.000062,
+      inputTokens: 37,
+      outputTokens: MAX_OUTPUT_TOKENS + 1,
+      totalTokens: MAX_OUTPUT_TOKENS + 38,
+      failureCode: "adapted_parameters",
+      metadata: { surplusAdaptedParameters: ["max_tokens"] },
+    });
+  });
+});
diff --git a/packages/agent/tests/unit-isolated/surplus-reasoning-parity.test.ts b/packages/agent/tests/unit-isolated/surplus-reasoning-parity.test.ts
index fe5b6cdcd..8998df744 100644
--- a/packages/agent/tests/unit-isolated/surplus-reasoning-parity.test.ts
+++ b/packages/agent/tests/unit-isolated/surplus-reasoning-parity.test.ts
@@ -3,7 +3,7 @@
  * this suite replaces them with content-free receipts and must not leak those
  * module mocks into the shared unit-test process.
  */
-import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { AIMessage, AIMessageChunk, HumanMessage } from "@langchain/core/messages";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const createModelInputs: Record<string, unknown>[] = [];
@@ -42,9 +42,11 @@ const {
   surplusReasoningModelKwargs,
 } = await import("../../src/providers/factory");
 const {
+  assertCompleteSurplusResponse,
   canUseQualifiedSurplusChatRoute,
   invokeSurplusChatAttempt,
 } = await import("../../src/providers/surplus-attempt");
+const { SurplusMarketplaceAttemptError } = await import("../../src/providers/surplus-error");
 const { runWithUsageContext } = await import("../../src/usage/usage-context");
 
 const MODEL_ID = "openrouter:openai/gpt-5.6-sol";
@@ -68,6 +70,22 @@ beforeEach(() => {
 });
 
 describe("Surplus reasoning parity", () => {
+  test("requires an actual AI message even when a generic value carries terminal text", () => {
+    const receipt = { truncated: false };
+    for (const generic of [
+      null,
+      undefined,
+      { content: "plausible text", response_metadata: { finish_reason: "stop" } },
+      new HumanMessage({ content: "plausible text" }),
+    ]) {
+      expect(() => assertCompleteSurplusResponse(receipt, generic)).toThrow();
+    }
+    expect(() => assertCompleteSurplusResponse(receipt, new AIMessageChunk({
+      content: "real streamed text",
+      response_metadata: { finish_reason: "stop" },
+    }))).not.toThrow();
+  });
+
   test("forwards only trimmed opaque UUID session state", () => {
     expect(openRouterSessionModelKwargs(
       " 22222222-2222-4222-8222-222222222222 ",
@@ -390,7 +408,13 @@ describe("Surplus reasoning parity", () => {
       },
     });
 
-    expect(await attempt).toEqual({ kind: "direct_fallback" });
+    const result = await attempt;
+    expect(result).toMatchObject({
+      kind: "direct_fallback",
+      failure: { code: "surplus_marketplace_attempt_failed" },
+    });
+    if (result.kind !== "direct_fallback") throw new Error("expected direct fallback");
+    expect(result.failure).toBeInstanceOf(SurplusMarketplaceAttemptError);
     expect(inferenceCalls).toBe(1);
     expect(beginAttempt).toHaveBeenCalledTimes(1);
     expect(settleAttempt).toHaveBeenCalledTimes(2);
@@ -423,7 +447,12 @@ describe("Surplus reasoning parity", () => {
       },
     });
 
-    expect(result).toEqual({ kind: "direct_fallback" });
+    expect(result).toMatchObject({
+      kind: "direct_fallback",
+      failure: { code: "surplus_marketplace_attempt_failed" },
+    });
+    if (result.kind !== "direct_fallback") throw new Error("expected direct fallback");
+    expect(result.failure).toBeInstanceOf(SurplusMarketplaceAttemptError);
     expect(settleAttempt.mock.calls[0]?.[0]).toMatchObject({
       outcome: "unknown",
       costState: "actual",
@@ -469,14 +498,35 @@ describe("Surplus reasoning parity", () => {
     };
 
     expect(await run({ status: 404, code: "no_sellers_for_model", marketplaceAttempts: 0 }))
-      .toEqual({ kind: "direct_fallback", retryUnpinned: true });
+      .toMatchObject({
+        kind: "direct_fallback",
+        retryUnpinned: true,
+        failure: {
+          code: "surplus_marketplace_attempt_failed",
+          vendorCode: "no_sellers_for_model",
+          status: 404,
+          traceId: "refusal-request",
+        },
+      });
     expect(await run({ providerMode: "any", status: 404, code: "no_sellers_for_model", marketplaceAttempts: 0 }))
-      .toEqual({ kind: "direct_fallback" });
+      .toMatchObject({
+        kind: "direct_fallback",
+        failure: { code: "surplus_marketplace_attempt_failed", traceId: "refusal-request" },
+      });
     expect(await run({ status: 404, code: "no_sellers_for_model", marketplaceAttempts: 1 }))
-      .toEqual({ kind: "direct_fallback" });
+      .toMatchObject({
+        kind: "direct_fallback",
+        failure: { code: "surplus_marketplace_attempt_failed", vendorCode: "no_sellers_for_model", status: 404 },
+      });
     expect(await run({ status: 401, code: "invalid_api_key" }))
-      .toEqual({ kind: "direct_fallback" });
-    expect(await run({ code: "timeout" })).toEqual({ kind: "direct_fallback" });
+      .toMatchObject({
+        kind: "direct_fallback",
+        failure: { code: "surplus_marketplace_attempt_failed", vendorCode: "invalid_api_key", status: 401 },
+      });
+    expect(await run({ code: "timeout" })).toMatchObject({
+      kind: "direct_fallback",
+      failure: { code: "surplus_marketplace_attempt_failed", vendorCode: "timeout" },
+    });
     const delivered = await run({
       status: 404,
       code: "no_sellers_for_model",
@@ -588,3 +638,68 @@ test("personal marketplace attempts retain exact credential provenance and actua
   expect(settleAttempt.mock.calls.at(-1)?.[0]).toMatchObject({ outcome: "succeeded", costState: "actual", actualCostUsd: 0.000047 });
   expect(JSON.stringify(beginAttempt.mock.calls.at(-1))).not.toContain("personal-surplus-only");
 });
+
+describe("strict service fallback policy", () => {
+  test("keeps a charged uncertain attempt unresolved instead of admitting direct replay", async () => {
+    await Promise.resolve(expect(invokeSurplusChatAttempt({
+      route: ROUTE, apiKey: "synthetic-service-key", messages: [new HumanMessage("Synthetic Soul")],
+      tools: [], config: {}, maxOutputTokens: 256,
+      funding: { kind: "service", providerRoute: "surplus", humanUserId: "user-1" },
+      directFallbackPolicy: "pre_service_only", hasDeliveredOutput: () => false,
+      invokeModel: async () => {
+        await observedResponse!({ requestId: "uncertain-soul", providerFamily: "openrouter",
+          buyerCostMicro: 17, truncated: false }, 200);
+        throw new Error("synthetic connection loss");
+      },
+    })).rejects.toBeInstanceOf(MockSurplusOutcomeUnknownError));
+    expect(beginAttempt).toHaveBeenCalledTimes(1);
+    expect(settleAttempt).toHaveBeenCalledTimes(1);
+    expect(settleAttempt.mock.calls[0]?.[0]).toMatchObject({
+      outcome: "unknown", costState: "actual", actualCostUsd: 0.000017,
+    });
+  });
+
+  test("retains same-model direct eligibility after a proven zero-attempt refusal", async () => {
+    const result = await invokeSurplusChatAttempt({
+      route: ROUTE, apiKey: "synthetic-service-key", messages: [new HumanMessage("Synthetic Soul")],
+      tools: [], config: {}, maxOutputTokens: 256,
+      funding: { kind: "service", providerRoute: "surplus", humanUserId: "user-1" },
+      directFallbackPolicy: "pre_service_only", hasDeliveredOutput: () => false,
+      invokeModel: async () => {
+        await observedResponse!({ requestId: "refused-soul", marketplaceAttempts: 0, truncated: false }, 404);
+        throw Object.assign(new Error("Synthetic no-seller refusal"), { code: "no_sellers_for_model" });
+      },
+    });
+    expect(result).toMatchObject({
+      kind: "direct_fallback",
+      retryUnpinned: true,
+      modelUnavailableBeforeService: true,
+      failure: {
+        code: "surplus_marketplace_attempt_failed",
+        vendorCode: "no_sellers_for_model",
+        status: 404,
+        traceId: "refused-soul",
+      },
+    });
+    expect(settleAttempt.mock.calls[0]?.[0]).toMatchObject({
+      outcome: "failed", costState: "actual", actualCostUsd: 0, failureCode: "no_sellers_for_model",
+    });
+    expect(settleAttempt.mock.calls[0]?.[0]).not.toHaveProperty("providerRequestId");
+  });
+
+  test("does not admit direct replay for an incomplete successful envelope", async () => {
+    await Promise.resolve(expect(invokeSurplusChatAttempt({
+      route: ROUTE, apiKey: "synthetic-service-key", messages: [new HumanMessage("Synthetic Soul")],
+      tools: [], config: {}, maxOutputTokens: 256,
+      funding: { kind: "service", providerRoute: "surplus", humanUserId: "user-1" },
+      directFallbackPolicy: "pre_service_only", hasDeliveredOutput: () => false,
+      invokeModel: async () => {
+        await observedResponse!({ requestId: "incomplete-soul", providerFamily: "openrouter", truncated: false }, 200);
+        return new AIMessage("Soul without terminal metadata");
+      },
+    })).rejects.toBeInstanceOf(MockSurplusOutcomeUnknownError));
+    expect(settleAttempt.mock.calls[0]?.[0]).toMatchObject({
+      outcome: "interrupted", costState: "pending", failureCode: "incomplete_response",
+    });
+  });
+});
diff --git a/packages/agent/tests/unit/embeddings.test.ts b/packages/agent/tests/unit/embeddings.test.ts
index 54a071279..2e50133d3 100644
--- a/packages/agent/tests/unit/embeddings.test.ts
+++ b/packages/agent/tests/unit/embeddings.test.ts
@@ -2,11 +2,13 @@ import { afterEach, beforeEach, describe, expect, type Mock, spyOn, test } from
 import { setConfigOverrides } from "@nautilo/config";
 import * as db from "@nautilo/db";
 import * as serviceAttempt from "../../src/usage/service-embedding-attempt";
+import * as surplusEmbeddingAttempt from "../../src/usage/surplus-embedding-attempt";
 import {
   EmbeddingProviderError,
   embedTextWithProvenance,
   embedTexts,
   getProtectedMemoryEmbeddingConfiguration,
+  getMemoryEmbeddingDisclosure,
 } from "../../src/store/embeddings";
 
 const ORIGINAL_FETCH = globalThis.fetch;
@@ -15,13 +17,16 @@ const ORIGINAL_OPENROUTER_KEY = process.env["OPENROUTER_API_KEY"];
 const ORIGINAL_VENICE_KEY = process.env["VENICE_API_KEY"];
 const ORIGINAL_MANAGED_GATEWAY_KEY = process.env["NAUTILO_MANAGED_GATEWAY_API_KEY"];
 const ORIGINAL_MANAGED_GATEWAY_BASE_URL = process.env["NAUTILO_MANAGED_GATEWAY_BASE_URL"];
+const ORIGINAL_SURPLUS_KEY = process.env["SURPLUS_API_KEY"];
 type ServerModelConfigRow = NonNullable<ReturnType<typeof db.getCachedServerModelConfigRow>>;
 
 let serverEmbeddingModel: string | null | undefined;
+let serverPreferSurplus: boolean;
 let serverConfigSpy: Mock<typeof db.getCachedServerModelConfigRow>;
 let serviceAttemptSpy: Mock<typeof serviceAttempt.runServiceEmbeddingAttempt>;
+let surplusAttemptSpy: Mock<typeof surplusEmbeddingAttempt.invokeSurplusEmbeddingAttempt>;
 
-function restoreEnv(name: "OPENAI_API_KEY" | "OPENROUTER_API_KEY" | "VENICE_API_KEY" | "NAUTILO_MANAGED_GATEWAY_API_KEY" | "NAUTILO_MANAGED_GATEWAY_BASE_URL", value: string | undefined) {
+function restoreEnv(name: "OPENAI_API_KEY" | "OPENROUTER_API_KEY" | "VENICE_API_KEY" | "SURPLUS_API_KEY" | "NAUTILO_MANAGED_GATEWAY_API_KEY" | "NAUTILO_MANAGED_GATEWAY_BASE_URL", value: string | undefined) {
   if (value === undefined) delete process.env[name];
   else process.env[name] = value;
 }
@@ -51,17 +56,31 @@ describe("memory embedding providers", () => {
     delete process.env["VENICE_API_KEY"];
     delete process.env["NAUTILO_MANAGED_GATEWAY_API_KEY"];
     delete process.env["NAUTILO_MANAGED_GATEWAY_BASE_URL"];
+    delete process.env["SURPLUS_API_KEY"];
     setConfigOverrides({
       nautilo_embedding_model: "text-embedding-3-small",
       nautilo_embedding_dims: 3,
     });
     serverEmbeddingModel = undefined;
+    serverPreferSurplus = false;
     serverConfigSpy = spyOn(db, "getCachedServerModelConfigRow").mockImplementation(() =>
       serverEmbeddingModel === undefined
         ? null
-        : ({ embeddingModel: serverEmbeddingModel } as ServerModelConfigRow));
+        : ({ embeddingModel: serverEmbeddingModel, preferSurplus: serverPreferSurplus } as ServerModelConfigRow));
     serviceAttemptSpy = spyOn(serviceAttempt, "runServiceEmbeddingAttempt")
-      .mockImplementation(async (input) => input.invoke(() => {}));
+      .mockImplementation(async (input) => {
+        input.assertStillAuthorized?.();
+        return input.invoke(() => {});
+      });
+    surplusAttemptSpy = spyOn(surplusEmbeddingAttempt, "invokeSurplusEmbeddingAttempt")
+      .mockImplementation(async (input) => {
+        input.assertStillAuthorized();
+        return input.parseResponse({
+          model: "text-embedding-3-large",
+          data: [{ index: 0, embedding: Array.from({ length: 1_536 }, (_, index) => index) }],
+          usage: { prompt_tokens: 1, total_tokens: 1 },
+        });
+      });
   });
 
   afterEach(() => {
@@ -71,11 +90,301 @@ describe("memory embedding providers", () => {
     restoreEnv("VENICE_API_KEY", ORIGINAL_VENICE_KEY);
     restoreEnv("NAUTILO_MANAGED_GATEWAY_API_KEY", ORIGINAL_MANAGED_GATEWAY_KEY);
     restoreEnv("NAUTILO_MANAGED_GATEWAY_BASE_URL", ORIGINAL_MANAGED_GATEWAY_BASE_URL);
+    restoreEnv("SURPLUS_API_KEY", ORIGINAL_SURPLUS_KEY);
     serverConfigSpy.mockRestore();
     serviceAttemptSpy.mockRestore();
+    surplusAttemptSpy.mockRestore();
     setConfigOverrides({});
   });
 
+  test("uses Surplus only for the explicit qualified large space and discloses its recipients", async () => {
+    serverEmbeddingModel = "venice:text-embedding-3-large";
+    serverPreferSurplus = true;
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+
+    const canonical = getProtectedMemoryEmbeddingConfiguration();
+    expect(canonical).toEqual({
+      provider: "venice", model: "text-embedding-3-large", dimensions: 1_536,
+    });
+    const disclosure = getMemoryEmbeddingDisclosure();
+    expect(disclosure).toEqual({
+      contractVersion: 2,
+      canonicalSpace: {
+        provider: "venice", model: "text-embedding-3-large", dimensions: 1_536,
+      },
+      processingRoute: {
+        transport: "surplus_marketplace",
+        marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+        dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"],
+      },
+    });
+    expect(Object.isFrozen(disclosure)).toBe(true);
+
+    const legacyError = await embedTextWithProvenance("memory", undefined, canonical)
+      .catch((error: unknown) => error);
+    expect(legacyError).toMatchObject({
+      code: "unsupported_provider",
+    });
+    expect(surplusAttemptSpy).not.toHaveBeenCalled();
+
+    const embedded = await embedTextWithProvenance("memory", undefined, {
+      ...canonical, disclosure,
+    });
+    expect(embedded).toMatchObject({
+      provider: "venice",
+      canonicalModel: "text-embedding-3-large",
+      dimensions: 1_536,
+    });
+    expect(embedded.vector).toHaveLength(1_536);
+    expect(surplusAttemptSpy).toHaveBeenCalledTimes(1);
+    expect(serviceAttemptSpy).not.toHaveBeenCalled();
+  });
+
+  test("rechecks marketplace policy after durable admission and before dispatch", async () => {
+    serverEmbeddingModel = "venice:text-embedding-3-large";
+    serverPreferSurplus = true;
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+    const canonical = getProtectedMemoryEmbeddingConfiguration();
+    const disclosure = getMemoryEmbeddingDisclosure();
+    surplusAttemptSpy.mockImplementationOnce(async (input) => {
+      serverPreferSurplus = false;
+      input.assertStillAuthorized();
+      throw new Error("must not dispatch");
+    });
+    const error = await embedTextWithProvenance("memory", undefined, {
+      ...canonical, disclosure,
+    }).catch((caught: unknown) => caught);
+    expect(error).toMatchObject({
+      code: "unsupported_provider",
+      message: "The approved embedding configuration changed. Prepare the Memory request again.",
+    });
+    expect(serviceAttemptSpy).not.toHaveBeenCalled();
+  });
+
+  test("rejects a marketplace response that names a different embedding model", async () => {
+    serverEmbeddingModel = "venice:text-embedding-3-large";
+    serverPreferSurplus = true;
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+    surplusAttemptSpy.mockImplementationOnce(async (input) => {
+      try {
+        return input.parseResponse({
+          model: "text-embedding-3-small",
+          data: [{ index: 0, embedding: Array.from({ length: 1_536 }, () => 0) }],
+        });
+      } catch {
+        throw new surplusEmbeddingAttempt.SurplusEmbeddingAttemptError(
+          "invalid_response", 200, true,
+        );
+      }
+    });
+    const error = await embedTexts(["memory"]).catch((caught: unknown) => caught);
+    expect(error).toMatchObject({ code: "invalid_response", provider: "venice" });
+  });
+
+  test("uses qualified Surplus as Auto's fallback when no direct credential is runnable", async () => {
+    serverPreferSurplus = true;
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+    serverEmbeddingModel = "";
+
+    expect(getProtectedMemoryEmbeddingConfiguration()).toEqual({
+      provider: "venice", model: "text-embedding-3-large", dimensions: 1_536,
+    });
+    expect(getMemoryEmbeddingDisclosure()).toMatchObject({
+      canonicalSpace: {
+        provider: "venice", model: "text-embedding-3-large", dimensions: 1_536,
+      },
+      processingRoute: { transport: "surplus_marketplace" },
+    });
+    expect((await embedTexts(["memory"]))[0]).toHaveLength(1_536);
+    expect(surplusAttemptSpy).toHaveBeenCalledTimes(1);
+    expect(serviceAttemptSpy).not.toHaveBeenCalled();
+  });
+
+  test("never rewrites explicit small or Qwen selections to the large marketplace space", async () => {
+    serverPreferSurplus = true;
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+    for (const selection of [
+      "venice:text-embedding-3-small",
+      "openrouter:qwen/qwen3-embedding-8b",
+    ]) {
+      serverEmbeddingModel = selection;
+      const error = await embedTexts(["memory"]).catch((caught: unknown) => caught);
+      expect(error).toMatchObject({ code: "missing_credentials" });
+    }
+    expect(surplusAttemptSpy).not.toHaveBeenCalled();
+  });
+
+  test("distinguishes inherited explicit configuration from an explicit Auto override", async () => {
+    serverPreferSurplus = true;
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    setConfigOverrides({
+      nautilo_embedding_model: "openrouter:qwen/qwen3-embedding-8b",
+      nautilo_embedding_dims: 1_536,
+    });
+
+    serverEmbeddingModel = null;
+    expect(await embedTexts(["memory"]).catch((caught: unknown) => caught))
+      .toMatchObject({ code: "missing_credentials", provider: "openrouter" });
+    expect(surplusAttemptSpy).not.toHaveBeenCalled();
+
+    serverEmbeddingModel = "";
+    expect(getProtectedMemoryEmbeddingConfiguration()).toEqual({
+      provider: "venice", model: "text-embedding-3-large", dimensions: 1_536,
+    });
+    expect((await embedTexts(["memory"]))[0]).toHaveLength(1_536);
+    expect(surplusAttemptSpy).toHaveBeenCalledTimes(1);
+  });
+
+  test("Auto refuses Surplus without the complete policy, credential, and dimension admission", async () => {
+    serverEmbeddingModel = "";
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+    for (const configure of [
+      () => { serverPreferSurplus = false; process.env["SURPLUS_API_KEY"] = "surplus-secret"; },
+      () => { serverPreferSurplus = true; delete process.env["SURPLUS_API_KEY"]; },
+      () => {
+        serverPreferSurplus = true;
+        process.env["SURPLUS_API_KEY"] = "surplus-secret";
+        setConfigOverrides({ nautilo_embedding_dims: 3 });
+      },
+    ]) {
+      configure();
+      expect(await embedTexts(["memory"]).catch((caught: unknown) => caught))
+        .toMatchObject({ code: "missing_credentials" });
+    }
+    expect(surplusAttemptSpy).not.toHaveBeenCalled();
+  });
+
+  test("Auto does not retry a Surplus provider 503", async () => {
+    serverEmbeddingModel = "";
+    serverPreferSurplus = true;
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+    surplusAttemptSpy.mockRejectedValueOnce(new surplusEmbeddingAttempt.SurplusEmbeddingAttemptError(
+      "provider_unavailable", 503, true,
+    ));
+
+    expect(await embedTexts(["memory"]).catch((caught: unknown) => caught))
+      .toMatchObject({ code: "request_failed", status: 503, retryable: true });
+    expect(surplusAttemptSpy).toHaveBeenCalledTimes(1);
+    expect(serviceAttemptSpy).not.toHaveBeenCalled();
+  });
+
+  test("Auto rechecks its marketplace binding before dispatch", async () => {
+    serverEmbeddingModel = "";
+    serverPreferSurplus = true;
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+    let dispatches = 0;
+    surplusAttemptSpy.mockImplementationOnce(async (input) => {
+      delete process.env["SURPLUS_API_KEY"];
+      input.assertStillAuthorized();
+      dispatches += 1;
+      throw new Error("must not dispatch");
+    });
+
+    expect(await embedTexts(["memory"]).catch((caught: unknown) => caught)).toMatchObject({
+      code: "unsupported_provider",
+      message: "The approved embedding configuration changed. Prepare the Memory request again.",
+    });
+    expect(dispatches).toBe(0);
+    expect(serviceAttemptSpy).not.toHaveBeenCalled();
+  });
+
+  test("policy-off large remains an exact direct Venice request with dimensions", async () => {
+    serverEmbeddingModel = "venice:text-embedding-3-large";
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
+    process.env["VENICE_API_KEY"] = "venice-secret";
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+    let body: unknown;
+    globalThis.fetch = (async (_input, init) => {
+      body = parseRequestBody(init?.body);
+      return Response.json({
+        data: [{ index: 0, embedding: Array.from({ length: 1_536 }, () => 0) }],
+        usage: { prompt_tokens: 1, total_tokens: 1 },
+      });
+    }) as typeof fetch;
+    const result = await embedTexts(["memory"]);
+    expect(result[0]).toHaveLength(1_536);
+    expect(body).toEqual({
+      model: "text-embedding-3-large", input: ["memory"], dimensions: 1_536,
+    });
+    expect(serviceAttemptSpy).toHaveBeenCalledTimes(1);
+    expect(surplusAttemptSpy).not.toHaveBeenCalled();
+    expect(getMemoryEmbeddingDisclosure().processingRoute).toEqual({ transport: "direct" });
+  });
+
+  test("rechecks direct route, key, model, and disclosure after durable admission", async () => {
+    setConfigOverrides({ nautilo_embedding_dims: 1_536 });
+    process.env["VENICE_API_KEY"] = "venice-original";
+    let fetches = 0;
+    globalThis.fetch = (async () => {
+      fetches++;
+      return embeddingResponse([{
+        index: 0,
+        embedding: Array.from({ length: 1_536 }, (_, index) => index / 1_536),
+      }]);
+    }) as unknown as typeof fetch;
+
+    const cases: Array<{
+      configure: () => void;
+      drift: () => void;
+    }> = [
+      {
+        configure: () => {
+          serverEmbeddingModel = "venice:text-embedding-3-large";
+          serverPreferSurplus = false;
+          process.env["SURPLUS_API_KEY"] = "surplus-secret";
+          process.env["VENICE_API_KEY"] = "venice-original";
+        },
+        drift: () => { serverPreferSurplus = true; },
+      },
+      {
+        configure: () => {
+          serverEmbeddingModel = "venice:text-embedding-3-large";
+          serverPreferSurplus = false;
+          delete process.env["SURPLUS_API_KEY"];
+          process.env["VENICE_API_KEY"] = "venice-original";
+        },
+        drift: () => { process.env["VENICE_API_KEY"] = "venice-replaced"; },
+      },
+      {
+        configure: () => {
+          serverEmbeddingModel = "venice:text-embedding-3-large";
+          serverPreferSurplus = false;
+          delete process.env["SURPLUS_API_KEY"];
+          process.env["VENICE_API_KEY"] = "venice-original";
+        },
+        drift: () => { serverEmbeddingModel = "venice:text-embedding-3-small"; },
+      },
+    ];
+
+    for (const scenario of cases) {
+      scenario.configure();
+      const canonical = getProtectedMemoryEmbeddingConfiguration();
+      const disclosure = getMemoryEmbeddingDisclosure();
+      serviceAttemptSpy.mockImplementationOnce(async (input) => {
+        scenario.drift();
+        input.assertStillAuthorized?.();
+        return input.invoke(() => {});
+      });
+      const error = await embedTextWithProvenance("private memory", undefined, {
+        ...canonical,
+        disclosure,
+      }).catch((caught: unknown) => caught);
+      expect(error).toMatchObject({
+        code: "unsupported_provider",
+        message: "The approved embedding configuration changed. Prepare the Memory request again.",
+      });
+    }
+    expect(fetches).toBe(0);
+  });
+
   test("publishes only configured disclosure metadata and rejects stale consent before fetch", async () => {
     process.env["OPENROUTER_API_KEY"] = "openrouter-secret";
     const approved = getProtectedMemoryEmbeddingConfiguration();
@@ -195,6 +504,9 @@ describe("memory embedding providers", () => {
   });
 
   test("automatic selection uses Qwen3 8B on Venice and OpenRouter, then OpenAI small", () => {
+    serverEmbeddingModel = "";
+    serverPreferSurplus = true;
+    process.env["SURPLUS_API_KEY"] = "surplus-secret";
     setConfigOverrides({
       nautilo_embedding_model: "",
       nautilo_embedding_dims: 1536,
@@ -220,6 +532,7 @@ describe("memory embedding providers", () => {
       model: "text-embedding-qwen3-8b",
       dimensions: 1536,
     });
+    expect(surplusAttemptSpy).not.toHaveBeenCalled();
   });
 
   test("automatic OpenRouter dispatch requests Qwen3 8B at 1,536 dimensions", async () => {
diff --git a/packages/agent/tests/unit/personal-llm-attempt.test.ts b/packages/agent/tests/unit/personal-llm-attempt.test.ts
index 1864c22d7..c7327aabc 100644
--- a/packages/agent/tests/unit/personal-llm-attempt.test.ts
+++ b/packages/agent/tests/unit/personal-llm-attempt.test.ts
@@ -255,6 +255,174 @@ describe("explicit nonpersonal Memory model attempts", () => {
   });
 });
 
+describe("Soul service direct attempts", () => {
+  const soulScope = <T>(fn: () => T, providerRoute = "openai") => runWithUsageContext({
+    callType: "soul", userId: funding.humanUserId,
+    funding: { kind: "service", humanUserId: funding.humanUserId, providerRoute },
+    metadata: { agentId: "synthetic-agent", service: "soul_generation" },
+  }, fn);
+
+  test("opens a service row before dispatch and retains actual zero without personal provenance", async () => {
+    const ordinary = harness();
+    const begun: BeginServiceLlmAttemptInput[] = [];
+    const settled: SettlePersonalLlmAttemptInput[] = [];
+    await soulScope(() => runPersonalLlmAttempt({ modelId, endpoint: "/v1/chat/completions", invoke: async () => {
+      expect(begun).toHaveLength(1);
+      expect(getUsageContext()?.trackedAttemptId).toBe(begun[0]!.id);
+      getUsageContext()?.onAttemptUsage?.({ inputTokens: 10, outputTokens: 4,
+        reasoningTokens: 0, cachedInputTokens: 0, cacheCreationTokens: 0, actualCostUsd: 0 });
+      return "generated Soul";
+    } }, { ...ordinary.deps,
+      beginService: async (row) => { begun.push(row); },
+      settleService: async (row) => { settled.push(row); },
+    }));
+    expect(ordinary.begun).toHaveLength(0);
+    expect(begun[0]).toMatchObject({ callType: "soul", userId: funding.humanUserId,
+      model: modelId, providerRoute: "openai", metadata: { agentId: "synthetic-agent" } });
+    expect(begun[0]).not.toHaveProperty("credentialId");
+    expect(settled).toHaveLength(1);
+    expect(settled[0]).toMatchObject({ outcome: "succeeded", costState: "actual", actualCostUsd: 0 });
+  });
+
+  test("settles a post-admission authorization denial as known-unsent and preserves the original 403", async () => {
+    const ordinary = harness();
+    const begun: BeginServiceLlmAttemptInput[] = [];
+    const settled: SettlePersonalLlmAttemptInput[] = [];
+    const denial = Object.assign(new Error("Soul funding authorization changed"), { status: 403 });
+    let authorized = true;
+    let invokes = 0;
+
+    const thrown = await soulScope(() => runPersonalLlmAttempt({
+      modelId,
+      endpoint: "/v1/chat/completions",
+      assertStillAuthorized: () => { if (!authorized) throw denial; },
+      invoke: async () => { invokes++; return "must not dispatch"; },
+    }, {
+      ...ordinary.deps,
+      beginService: async (row) => { begun.push(row); authorized = false; },
+      settleService: async (row) => { settled.push(row); },
+    })).then(() => null, (error: unknown) => error);
+
+    expect(thrown).toBe(denial);
+    expect(thrown).toMatchObject({ status: 403 });
+    expect(invokes).toBe(0);
+    expect(begun).toHaveLength(1);
+    expect(settled).toHaveLength(1);
+    expect(settled[0]).toMatchObject({
+      outcome: "failed",
+      costState: "actual",
+      actualCostUsd: 0,
+      failureCode: "authorization_changed",
+    });
+  });
+
+  test.each(["policy", "key"] as const)(
+    "settles a %s mutation during durable admission without invoking direct Soul",
+    async (mutation) => {
+      const ordinary = harness();
+      const settled: SettlePersonalLlmAttemptInput[] = [];
+      let policyEnabled = true;
+      let credential = "original-key";
+      let invokes = 0;
+      const changed = new Error(`Soul ${mutation} changed during admission`);
+      const thrown = await soulScope(() => runPersonalLlmAttempt({
+        modelId,
+        endpoint: "/v1/chat/completions",
+        assertStillAuthorized: () => {
+          if (!policyEnabled || credential !== "original-key") throw changed;
+        },
+        invoke: async () => { invokes++; return "must not dispatch"; },
+      }, {
+        ...ordinary.deps,
+        beginService: async () => {
+          if (mutation === "policy") policyEnabled = false;
+          else credential = "replacement-key";
+        },
+        settleService: async (row) => { settled.push(row); },
+      })).then(() => null, (error: unknown) => error);
+
+      expect(thrown).toBe(changed);
+      expect(invokes).toBe(0);
+      expect(settled).toHaveLength(1);
+      expect(settled[0]).toMatchObject({
+        outcome: "failed",
+        costState: "actual",
+        actualCostUsd: 0,
+        failureCode: "authorization_changed",
+      });
+    },
+  );
+
+  test("settles an abort that arrives during durable admission without invoking direct Soul", async () => {
+    const ordinary = harness();
+    const settled: SettlePersonalLlmAttemptInput[] = [];
+    const abort = new AbortController();
+    const cancellation = new Error("Soul request cancelled during admission");
+    let invokes = 0;
+
+    const thrown = await soulScope(() => runPersonalLlmAttempt({
+      modelId,
+      endpoint: "/v1/chat/completions",
+      signal: abort.signal,
+      assertStillAuthorized: () => abort.signal.throwIfAborted(),
+      invoke: async () => { invokes++; return "must not dispatch"; },
+    }, {
+      ...ordinary.deps,
+      beginService: async () => { abort.abort(cancellation); },
+      settleService: async (row) => { settled.push(row); },
+    })).then(() => null, (error: unknown) => error);
+
+    expect(thrown).toBe(cancellation);
+    expect(invokes).toBe(0);
+    expect(settled).toHaveLength(1);
+    expect(settled[0]).toMatchObject({
+      outcome: "cancelled",
+      costState: "actual",
+      actualCostUsd: 0,
+      failureCode: "cancelled",
+    });
+  });
+
+  test("cannot dispatch without its durable service owner", async () => {
+    const h = harness();
+    let calls = 0;
+    await Promise.resolve(expect(soulScope(() => runPersonalLlmAttempt({ modelId, endpoint: "/v1/chat/completions",
+      invoke: async () => { calls++; },
+    }, { ...h.deps, owner: () => null, beginService: async () => {}, settleService: async () => {} })))
+      .rejects.toBeInstanceOf(PersonalAttemptLedgerUnavailableError));
+    expect(calls).toBe(0);
+  });
+
+  test("retains cancellation with unknown cost without replaying a streamed direct call", async () => {
+    const h = harness();
+    const settled: SettlePersonalLlmAttemptInput[] = [];
+    const abort = new AbortController();
+    let calls = 0;
+    await Promise.resolve(expect(soulScope(() => runPersonalLlmAttempt({ modelId, endpoint: "/v1/chat/completions",
+      signal: abort.signal, hasObservedProviderWork: () => true, invoke: async () => {
+        calls++;
+        abort.abort();
+        throw new Error("synthetic stream closed");
+      },
+    }, { ...h.deps, beginService: async () => {}, settleService: async (row) => { settled.push(row); } })))
+      .rejects.toBeInstanceOf(PersonalAttemptInvocationError));
+    expect(calls).toBe(1);
+    expect(settled).toHaveLength(1);
+    expect(settled[0]).toMatchObject({ outcome: "cancelled", costState: "unknown" });
+    expect(settled[0]).not.toHaveProperty("actualCostUsd");
+  });
+
+  test("leaves Surplus Soul attempts to the existing marketplace ledger", async () => {
+    const h = harness();
+    let calls = 0;
+    await soulScope(() => runPersonalLlmAttempt({ modelId, endpoint: "/v1/chat/completions",
+      invoke: async () => { calls++; return "marketplace Soul"; },
+    }, { ...h.deps, owner: () => null }), "surplus");
+    expect(calls).toBe(1);
+    expect(h.begun).toHaveLength(0);
+  });
+});
+
 describe("server-funded image assistance attempts", () => {
   function imageHarness() {
     const begun: BeginServiceLlmAttemptInput[] = [];
diff --git a/packages/agent/tests/unit/service-embedding-attempt.test.ts b/packages/agent/tests/unit/service-embedding-attempt.test.ts
index 7d528b171..458d2888c 100644
--- a/packages/agent/tests/unit/service-embedding-attempt.test.ts
+++ b/packages/agent/tests/unit/service-embedding-attempt.test.ts
@@ -154,7 +154,8 @@ describe("service embedding durable attempts", () => {
     expect(aborted.settlements[0]).toMatchObject({
       outcome: "cancelled",
       failureCode: "cancelled",
-      costState: "unknown",
+      costState: "actual",
+      actualCostUsd: 0,
     });
   });
 
@@ -170,6 +171,41 @@ describe("service embedding durable attempts", () => {
     expect(calls).toBe(0);
   });
 
+  test("settles a rejected post-begin authorization and pre-dispatch cancellation as zero cost", async () => {
+    for (const cancelled of [false, true]) {
+      const h = harness();
+      const controller = new AbortController();
+      if (cancelled) controller.abort(new Error("cancelled before dispatch"));
+      let wires = 0;
+      const authorizationError = new Error("embedding binding changed");
+      const input = {
+        ...attempt(async () => { wires++; }, controller.signal),
+        assertStillAuthorized: () => {
+          if (!cancelled) throw authorizationError;
+        },
+      };
+      const error = await runServiceEmbeddingAttempt(input, h.deps)
+        .catch((caught: unknown) => caught);
+      expect(error).toBe(cancelled ? controller.signal.reason : authorizationError);
+      expect(wires).toBe(0);
+      expect(h.settlements).toHaveLength(1);
+      expect(h.settlements[0]).toMatchObject(cancelled
+        ? {
+            outcome: "cancelled",
+            costState: "actual",
+            actualCostUsd: 0,
+            failureCode: "cancelled",
+          }
+        : {
+            outcome: "failed",
+            costState: "actual",
+            actualCostUsd: 0,
+            failureCode: "pre_wire_authorization_changed",
+          });
+      expect(h.settlements[0]).not.toHaveProperty("providerRequestId");
+    }
+  });
+
   test("retries only the exact settlement and never repeats embedding work", async () => {
     let wireCalls = 0;
     let settlementCalls = 0;
diff --git a/packages/agent/tests/unit/soul-file.test.ts b/packages/agent/tests/unit/soul-file.test.ts
index d0884829d..df58076c0 100644
--- a/packages/agent/tests/unit/soul-file.test.ts
+++ b/packages/agent/tests/unit/soul-file.test.ts
@@ -1,12 +1,30 @@
 import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { AIMessage, AIMessageChunk } from "@langchain/core/messages";
 import { setLogOutput } from "@nautilo/logger";
-import { setConfigOverrides } from "@nautilo/config";
+import { candidatesForModelRole, setConfigOverrides } from "@nautilo/config";
+import { ModelCatalogSchema } from "@nautilo/types";
+import * as db from "@nautilo/db";
 import { generateSoulFileFallback, normalizeSoulFileInput } from "../../src/index";
 import * as soulModule from "../../src/soul/generate-soul-file";
 import { __setStubModelForTests } from "../../src/providers/universal";
+import * as universalProvider from "../../src/providers/universal";
 import type { ChatModel } from "../../src/providers/types";
 import { ServerProviderCredentialsDeniedError } from "@nautilo/trust";
 import { getUsageContext } from "../../src/usage/usage-context";
+import * as surplusAttempt from "../../src/providers/surplus-attempt";
+import * as personalAttempt from "../../src/usage/personal-llm-attempt";
+import {
+  configureRuntimeModelCatalog,
+  getActiveModelCatalogSync,
+  hydrateRuntimeModelCatalog,
+  resetRuntimeModelCatalog,
+} from "../../src/config/model-catalog/runtime-catalog";
+import {
+  configureSurplusModelCatalog,
+  resetSurplusModelCatalog,
+} from "../../src/providers/surplus-catalog";
+
+type RuntimeModelCatalog = ReturnType<typeof getActiveModelCatalogSync>["catalog"];
 
 const SOUL_AUTHORIZATION = {
   humanUserId: "user-1",
@@ -14,13 +32,116 @@ const SOUL_AUTHORIZATION = {
 } as const;
 
 let originalOpenRouterKey: string | undefined;
+let originalSurplusKey: string | undefined;
+const DIRECT_PROVIDER_ENV_KEYS = [
+  "OPENAI_API_KEY",
+  "OPENROUTER_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "GOOGLE_API_KEY",
+  "VENICE_API_KEY",
+  "TYPESAFE_API_KEY",
+] as const;
+let originalDirectProviderKeys: Partial<Record<(typeof DIRECT_PROVIDER_ENV_KEYS)[number], string>>;
+
+function useSurplusOnlyCredentials(): void {
+  for (const key of DIRECT_PROVIDER_ENV_KEYS) delete process.env[key];
+  process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+}
+
+function activeSurplusTestRows(): Array<Record<string, unknown>> {
+  const rows = new Map<string, Record<string, unknown>>();
+  for (const entry of getActiveModelCatalogSync().catalog.entries) {
+    const separator = entry.id.indexOf(":");
+    const id = separator < 1 ? "" : entry.id.slice(separator + 1);
+    const contextTokens = entry.limits?.contextTokens;
+    const outputTokens = entry.limits?.outputTokens;
+    if (!id || !contextTokens || !outputTokens || rows.has(id)) continue;
+    const supportsTools = entry.features?.tools === true;
+    const supportsVision = entry.modalities?.input?.includes("image") === true;
+    const supportsReasoning = entry.features?.reasoning === true;
+    rows.set(id, {
+      id,
+      context_length: contextTokens,
+      architecture: {
+        input_modalities: supportsVision ? ["text", "image"] : ["text"],
+        output_modalities: ["text"],
+      },
+      top_provider: {
+        context_length: contextTokens,
+        max_completion_tokens: outputTokens,
+      },
+      supported_parameters: supportsTools ? ["max_tokens", "tools"] : ["max_tokens"],
+      supported_features: [
+        "streaming",
+        ...(supportsTools ? ["tools"] : []),
+        ...(supportsVision ? ["vision"] : []),
+        ...(supportsReasoning ? ["reasoning"] : []),
+      ],
+    });
+  }
+  return [...rows.values()];
+}
+
+function installSurplusDiscoveryFixture(
+  rowsForRequest: () => Array<Record<string, unknown>> = activeSurplusTestRows,
+  observeRequest?: (url: string) => void,
+): void {
+  configureSurplusModelCatalog({
+    fetchImpl: (async (input) => {
+      const url = typeof input === "string"
+        ? input
+        : input instanceof URL
+          ? input.href
+          : input.url;
+      observeRequest?.(url);
+      const rows = rowsForRequest();
+      if (url === "https://api.surplusintelligence.ai/v1/models") {
+        return new Response(JSON.stringify({ data: rows }), { status: 200 });
+      }
+      const requestedId = decodeURIComponent(url.slice(url.lastIndexOf("/") + 1));
+      const row = rows.find((candidate) => candidate["id"] === requestedId);
+      return row
+        ? new Response(JSON.stringify(row), { status: 200 })
+        : new Response("", { status: 404 });
+    }) as typeof fetch,
+  });
+}
+
+async function installSoulTestCatalog(catalog: RuntimeModelCatalog): Promise<void> {
+  configureRuntimeModelCatalog({
+    loader: {
+      get: async () => ({
+        catalog,
+        source: "remote-fresh",
+        stale: false,
+        fetchedAt: "2026-10-21T00:00:00.000Z",
+        originUrl: "https://catalog.invalid/soul-recovery.json",
+        reason: "",
+        catalogVersion: catalog.catalogVersion,
+      }),
+      refresh: async () => {},
+      clearCache: () => {},
+    },
+  });
+  await hydrateRuntimeModelCatalog();
+}
 
 beforeEach(() => {
+  installSurplusDiscoveryFixture();
+  originalDirectProviderKeys = {};
+  for (const key of DIRECT_PROVIDER_ENV_KEYS) {
+    const value = process.env[key];
+    if (value !== undefined) originalDirectProviderKeys[key] = value;
+  }
   originalOpenRouterKey = process.env["OPENROUTER_API_KEY"];
+  originalSurplusKey = process.env["SURPLUS_API_KEY"];
   process.env["OPENROUTER_API_KEY"] = "test-openrouter-key";
+  delete process.env["SURPLUS_API_KEY"];
 });
 
 afterEach(() => {
+  resetSurplusModelCatalog();
+  resetRuntimeModelCatalog();
   setConfigOverrides({});
   if (process.env["NAUTILO_TEST_MODE"] === "stub") {
     __setStubModelForTests(null);
@@ -28,6 +149,13 @@ afterEach(() => {
   delete process.env["NAUTILO_TEST_MODE"];
   if (originalOpenRouterKey === undefined) delete process.env["OPENROUTER_API_KEY"];
   else process.env["OPENROUTER_API_KEY"] = originalOpenRouterKey;
+  for (const key of DIRECT_PROVIDER_ENV_KEYS) {
+    const value = originalDirectProviderKeys[key];
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  if (originalSurplusKey === undefined) delete process.env["SURPLUS_API_KEY"];
+  else process.env["SURPLUS_API_KEY"] = originalSurplusKey;
   setLogOutput("stderr");
 });
 
@@ -417,3 +545,1171 @@ describe("streaming soul generation safety", () => {
     expect(streamed).toBeFalse();
   });
 });
+
+describe("Surplus-funded soul generation", () => {
+  const modelId = "openrouter:openai/gpt-5.6-sol";
+  const broadenableModelId = "openrouter:minimax/minimax-m3";
+  const generatedSoul = [
+    "## Essence",
+    "A precise and distinctive generated identity with enough detail to be useful.",
+    "",
+    "## Tone",
+    "Warm, exact, and candid without becoming performative.",
+  ].join("\n");
+
+  function preferSurplus(enabled: boolean) {
+    return spyOn(db, "getCachedServerModelConfigRow").mockReturnValue({
+      preferSurplus: enabled,
+    } as NonNullable<ReturnType<typeof db.getCachedServerModelConfigRow>>);
+  }
+
+  test("hydrates marketplace routes before automatic Soul model resolution", async () => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({
+      nautilo_soul_generator_model: null,
+      nautilo_model: "",
+    });
+    const configSpy = preferSurplus(true);
+    const requests: string[] = [];
+    installSurplusDiscoveryFixture(activeSurplusTestRows, (url) => requests.push(url));
+    let selectedModelId: string | undefined;
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        selectedModelId = input.route.catalogModelId;
+        return {
+          kind: "served",
+          response: new AIMessage({
+            content: generatedSoul,
+            response_metadata: { finish_reason: "stop" },
+          }),
+        };
+      });
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toBe(generatedSoul);
+      expect(requests[0]).toBe("https://api.surplusintelligence.ai/v1/models");
+      expect(selectedModelId).toBe(candidatesForModelRole("systemTasks")[0]);
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("uses discovered marketplace output limits without lowering direct fallback limits", async () => {
+    process.env["NAUTILO_TEST_MODE"] = "stub";
+    process.env["OPENROUTER_API_KEY"] = "synthetic-openrouter-key";
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(true);
+    installSurplusDiscoveryFixture(() => activeSurplusTestRows().map((row) => row["id"] === "openai/gpt-5.6-sol"
+      ? {
+          ...row,
+          context_length: 1_000_000,
+          top_provider: { context_length: 1_000_000, max_completion_tokens: 321 },
+        }
+      : row));
+    let marketplaceBudget: number | undefined;
+    __setStubModelForTests({
+      async invoke() {
+        return new AIMessage({ content: generatedSoul });
+      },
+    });
+    const directSpy = spyOn(universalProvider, "createUniversalModel");
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        marketplaceBudget = input.maxOutputTokens;
+        return { kind: "direct_fallback", modelUnavailableBeforeService: true };
+      });
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toBe(generatedSoul);
+      expect(marketplaceBudget).toBe(321);
+      const directOptions = directSpy.mock.calls[0]?.[1];
+      expect(directOptions?.["maxTokens"]).toBeGreaterThan(321);
+    } finally {
+      attemptSpy.mockRestore();
+      directSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("rejects a Soul request that cannot fit the discovered marketplace context", async () => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(true);
+    installSurplusDiscoveryFixture(() => activeSurplusTestRows().map((row) => row["id"] === "openai/gpt-5.6-sol"
+      ? {
+          ...row,
+          context_length: 1,
+          top_provider: { context_length: 1, max_completion_tokens: 1 },
+        }
+      : row));
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt");
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toContain("# Vex — Soul File");
+      expect(attemptSpy).not.toHaveBeenCalled();
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("uses the original direct budget when the discovered marketplace context cannot fit Soul", async () => {
+    process.env["NAUTILO_TEST_MODE"] = "stub";
+    process.env["OPENROUTER_API_KEY"] = "synthetic-openrouter-key";
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(true);
+    installSurplusDiscoveryFixture(() => activeSurplusTestRows().map((row) => row["id"] === "openai/gpt-5.6-sol"
+      ? {
+          ...row,
+          context_length: 1,
+          top_provider: { context_length: 1, max_completion_tokens: 1 },
+        }
+      : row));
+    __setStubModelForTests({
+      async invoke() {
+        return new AIMessage({ content: generatedSoul });
+      },
+    });
+    const directSpy = spyOn(universalProvider, "createUniversalModel");
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt");
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toBe(generatedSoul);
+      expect(attemptSpy).not.toHaveBeenCalled();
+      expect(directSpy.mock.calls[0]?.[1]?.["maxTokens"]).toBeGreaterThan(1);
+    } finally {
+      attemptSpy.mockRestore();
+      directSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("force-refreshes discovery after a proven model refusal without replaying that model", async () => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const listRequests: string[] = [];
+    installSurplusDiscoveryFixture(activeSurplusTestRows, (url) => {
+      if (url === "https://api.surplusintelligence.ai/v1/models") listRequests.push(url);
+    });
+    const wires: string[] = [];
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        wires.push(input.route.catalogModelId);
+        if (wires.length === 1) {
+          return { kind: "direct_fallback", modelUnavailableBeforeService: true };
+        }
+        return {
+          kind: "served",
+          response: new AIMessage({
+            content: generatedSoul,
+            response_metadata: { finish_reason: "stop" },
+          }),
+        };
+      });
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toBe(generatedSoul);
+      expect(wires[0]).toBe(broadenableModelId);
+      expect(wires[1]).not.toBe(broadenableModelId);
+      expect(listRequests).toHaveLength(2);
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("does not refresh discovery after an unproven marketplace refusal", async () => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const listRequests: string[] = [];
+    installSurplusDiscoveryFixture(activeSurplusTestRows, (url) => {
+      if (url === "https://api.surplusintelligence.ai/v1/models") listRequests.push(url);
+    });
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockResolvedValue({ kind: "direct_fallback" });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toContain("# Vex — Soul File");
+      expect(attemptSpy).toHaveBeenCalledTimes(1);
+      expect(listRequests).toHaveLength(1);
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("recovers a Surplus-only Soul on the same model without a provider pin", async () => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const directSpy = spyOn(universalProvider, "createUniversalModel");
+    const wires: Array<{ modelId: string; providerMode: "any" | undefined }> = [];
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        wires.push({
+          modelId: input.route.catalogModelId,
+          providerMode: input.providerMode,
+        });
+        return {
+          kind: "served",
+          response: new AIMessage({
+            content: generatedSoul,
+            response_metadata: { finish_reason: "stop" },
+          }),
+        };
+      });
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toBe(generatedSoul);
+      expect(wires).toEqual([
+        { modelId: broadenableModelId, providerMode: "any" },
+      ]);
+      expect(directSpy).not.toHaveBeenCalled();
+    } finally {
+      attemptSpy.mockRestore();
+      directSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("retains a provider pin for a privacy-bound Surplus-only Soul model", async () => {
+    useSurplusOnlyCredentials();
+    const privacyBoundModelId = "venice:minimax-m3-preview";
+    setConfigOverrides({ nautilo_soul_generator_model: privacyBoundModelId });
+    const configSpy = preferSurplus(true);
+    const directSpy = spyOn(universalProvider, "createUniversalModel");
+    const wires: Array<{ modelId: string; providerMode: "any" | undefined }> = [];
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        wires.push({ modelId: input.route.catalogModelId, providerMode: input.providerMode });
+        return {
+          kind: "direct_fallback",
+          modelUnavailableBeforeService: true,
+        };
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toContain("# Vex — Soul File");
+      expect(wires).toEqual([{ modelId: privacyBoundModelId, providerMode: undefined }]);
+      expect(directSpy).not.toHaveBeenCalled();
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      directSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("keeps a matching direct server credential on the pinned-first fallback path", async () => {
+    process.env["OPENROUTER_API_KEY"] = "synthetic-openrouter-key";
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    process.env["NAUTILO_TEST_MODE"] = "stub";
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    let directInvokes = 0;
+    __setStubModelForTests({
+      async invoke() {
+        directInvokes++;
+        return new AIMessage({ content: generatedSoul });
+      },
+    });
+    const modes: Array<"any" | undefined> = [];
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        modes.push(input.providerMode);
+        return {
+          kind: "direct_fallback",
+          retryUnpinned: true,
+          modelUnavailableBeforeService: true,
+        };
+      });
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toBe(generatedSoul);
+      expect(modes).toEqual([undefined]);
+      expect(directInvokes).toBe(1);
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("blocks an unpinned wire when the signed privacy label tightens after admission", async () => {
+    const current = getActiveModelCatalogSync().catalog;
+    const primary = current.entries.find((entry) => entry.id === broadenableModelId);
+    if (!primary) throw new Error("Soul primary catalog fixture is missing");
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    let providerInvokes = 0;
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        expect(input.providerMode).toBe("any");
+        await installSoulTestCatalog(ModelCatalogSchema.parse({
+          ...current,
+          catalogVersion: "2026.10.21.1",
+          entries: [{
+            ...primary,
+            privacy: { ...primary.privacy, label: "anonymized" },
+          }],
+        }));
+        await input.assertStillAuthorized?.();
+        providerInvokes++;
+        return { kind: "served", response: new AIMessage({ content: generatedSoul }) };
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toContain("# Vex — Soul File");
+      expect(attemptSpy).toHaveBeenCalledTimes(1);
+      expect(providerInvokes).toBe(0);
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("stops before resolving another Soul candidate when the original primary privacy tightens", async () => {
+    const current = getActiveModelCatalogSync().catalog;
+    const primary = current.entries.find((entry) => entry.id === broadenableModelId);
+    if (!primary) throw new Error("Soul primary catalog fixture is missing");
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const wires: string[] = [];
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        wires.push(`${input.route.catalogModelId}|${input.providerMode ?? "pinned"}`);
+        await installSoulTestCatalog(ModelCatalogSchema.parse({
+          ...current,
+          catalogVersion: "2026.10.21.2",
+          entries: current.entries.map((entry) => entry.id === primary.id
+            ? { ...entry, privacy: { ...entry.privacy, label: "anonymized" as const } }
+            : entry),
+        }));
+        return {
+          kind: "direct_fallback",
+          modelUnavailableBeforeService: true,
+        };
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toContain("# Vex — Soul File");
+      expect(wires).toEqual([`${broadenableModelId}|any`]);
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("blocks a pinned candidate wire when the original primary privacy tightens during admission", async () => {
+    const current = getActiveModelCatalogSync().catalog;
+    const primary = current.entries.find((entry) => entry.id === broadenableModelId);
+    if (!primary) throw new Error("Soul primary catalog fixture is missing");
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const wires: string[] = [];
+    let candidateProviderInvokes = 0;
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        wires.push(`${input.route.catalogModelId}|${input.providerMode ?? "pinned"}`);
+        if (input.route.catalogModelId === broadenableModelId) {
+          return {
+            kind: "direct_fallback",
+            modelUnavailableBeforeService: true,
+          };
+        }
+        expect(input.route.catalogModelId).toBe("venice:minimax-m3-preview");
+        expect(input.providerMode).toBeUndefined();
+        await installSoulTestCatalog(ModelCatalogSchema.parse({
+          ...current,
+          catalogVersion: "2026.10.21.3",
+          entries: current.entries.map((entry) => entry.id === primary.id
+            ? { ...entry, privacy: { ...entry.privacy, label: "anonymized" as const } }
+            : entry),
+        }));
+        await input.assertStillAuthorized?.();
+        candidateProviderInvokes++;
+        return { kind: "served", response: new AIMessage({ content: generatedSoul }) };
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toContain("# Vex — Soul File");
+      expect(wires).toEqual([
+        `${broadenableModelId}|any`,
+        "venice:minimax-m3-preview|pinned",
+      ]);
+      expect(candidateProviderInvokes).toBe(0);
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("streams from the next eligible Soul model after marketplace-first supply refusals", async () => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const directSpy = spyOn(universalProvider, "createUniversalModel");
+    const wires: Array<{ modelId: string; providerMode: "any" | undefined }> = [];
+    const first = "## Essence\nA precise and distinctive generated identity ";
+    const second = "with enough detail to be useful.\n\n## Tone\nWarm and candid.";
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        wires.push({ modelId: input.route.catalogModelId, providerMode: input.providerMode });
+        if (wires.length <= 2) {
+          return {
+            kind: "direct_fallback",
+            ...(input.providerMode === undefined ? { retryUnpinned: true as const } : {}),
+            modelUnavailableBeforeService: true,
+          };
+        }
+        const response = await input.invokeModel({
+          async invoke() {
+            throw new Error("streaming path must not call invoke");
+          },
+          async stream() {
+            return {
+              async *[Symbol.asyncIterator]() {
+                yield new AIMessageChunk({ content: first });
+                yield new AIMessageChunk({
+                  content: second,
+                  response_metadata: { finish_reason: "stop" },
+                });
+              },
+            };
+          },
+        } as never, input.messages, input.config);
+        return { kind: "served", response };
+      });
+
+    try {
+      const events = [];
+      for await (const event of soulModule.generateSoulFileStream(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )) events.push(event);
+      expect(wires.slice(0, 2)).toEqual([
+        { modelId: broadenableModelId, providerMode: "any" },
+        { modelId: "venice:minimax-m3-preview", providerMode: undefined },
+      ]);
+      expect(wires[2]).toEqual({
+        modelId: "openrouter:openai/gpt-5.6-luna",
+        providerMode: "any",
+      });
+      expect(events).toEqual([
+        { type: "started" },
+        { type: "delta", text: first },
+        { type: "delta", text: second },
+        { type: "completed", soulFile: first + second },
+      ]);
+      expect(directSpy).not.toHaveBeenCalled();
+    } finally {
+      attemptSpy.mockRestore();
+      directSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("exhausts the finite deduplicated Soul candidate walk without using direct credentials", async () => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const directSpy = spyOn(universalProvider, "createUniversalModel");
+    const wires: string[] = [];
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        wires.push(`${input.route.catalogModelId}|${input.providerMode ?? "pinned"}`);
+        return {
+          kind: "direct_fallback",
+          ...(input.providerMode === undefined ? { retryUnpinned: true as const } : {}),
+          modelUnavailableBeforeService: true,
+        };
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const result = await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      );
+      expect(result).toContain("# Vex — Soul File");
+      expect(wires.length).toBeGreaterThan(2);
+      expect(new Set(wires).size).toBe(wires.length);
+      const finiteModelBound = new Set([
+        broadenableModelId,
+        ...candidatesForModelRole("systemTasks"),
+      ]).size;
+      expect(wires.length).toBeLessThanOrEqual(finiteModelBound * 2);
+      expect(directSpy).not.toHaveBeenCalled();
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      directSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("skips disabled and unsupported signed-catalog Soul candidates", async () => {
+    const current = getActiveModelCatalogSync().catalog;
+    const primary = current.entries.find((entry) => entry.id === broadenableModelId);
+    const disabledSource = current.entries.find((entry) => entry.id === "venice:minimax-m3-preview");
+    const unsupportedSource = current.entries.find((entry) => entry.id === "openrouter:openai/gpt-5.6-luna");
+    const later = current.entries.find((entry) => entry.id === "venice:openai-gpt-56-luna");
+    if (!primary || !disabledSource || !unsupportedSource || !later) {
+      throw new Error("Soul candidate catalog fixtures are missing");
+    }
+    const disabled = { ...disabledSource, defaultEnabled: false };
+    const unsupported = {
+      ...unsupportedSource,
+      provider: "typesafe",
+      routing: "typesafe" as const,
+    };
+    await installSoulTestCatalog({
+      ...current,
+      catalogVersion: "2026.10.21.soul-recovery",
+      entries: [primary, disabled, unsupported, later],
+    } as RuntimeModelCatalog);
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const wires: Array<{ modelId: string; providerMode: "any" | undefined }> = [];
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        wires.push({ modelId: input.route.catalogModelId, providerMode: input.providerMode });
+        if (input.route.catalogModelId === later.id) {
+          return { kind: "served", response: new AIMessage({ content: generatedSoul }) };
+        }
+        return {
+          kind: "direct_fallback",
+          ...(input.providerMode === undefined ? { retryUnpinned: true as const } : {}),
+          modelUnavailableBeforeService: true,
+        };
+      });
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toBe(generatedSoul);
+      expect(wires).toEqual([
+        { modelId: broadenableModelId, providerMode: "any" },
+        { modelId: later.id, providerMode: undefined },
+      ]);
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test.each([
+    ["auth refusal", { kind: "direct_fallback" } as const],
+    ["payment refusal", { kind: "direct_fallback" } as const],
+    ["attempt-ledger refusal", { kind: "direct_fallback" } as const],
+    ["unknown outcome", new Error("synthetic unknown marketplace outcome")],
+  ])("does not walk to another Soul model after %s", async (_label, outcome) => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const directSpy = spyOn(universalProvider, "createUniversalModel");
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        expect(input.providerMode).toBe("any");
+        if (outcome instanceof Error) throw outcome;
+        return outcome;
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toContain("# Vex — Soul File");
+      expect(attemptSpy).toHaveBeenCalledTimes(1);
+      expect(directSpy).not.toHaveBeenCalled();
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      directSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("does not walk after malformed served output", async () => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockResolvedValue({
+        kind: "served",
+        response: new AIMessage({ content: "not a soul file" }),
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toContain("# Vex — Soul File");
+      expect(attemptSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("does not walk after a stream observed metadata without visible text", async () => {
+    useSurplusOnlyCredentials();
+    setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+    const configSpy = preferSurplus(true);
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        await input.invokeModel({
+          async invoke() {
+            throw new Error("streaming path must not call invoke");
+          },
+          async stream() {
+            return {
+              async *[Symbol.asyncIterator]() {
+                yield new AIMessageChunk({
+                  content: "",
+                  response_metadata: { usage: { prompt_tokens: 7 } },
+                });
+              },
+            };
+          },
+        } as never, input.messages, input.config);
+        return {
+          kind: "direct_fallback",
+          retryUnpinned: true,
+          modelUnavailableBeforeService: true,
+        };
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const events = [];
+      for await (const event of soulModule.generateSoulFileStream(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )) events.push(event);
+      expect(events).toHaveLength(2);
+      expect(events[1]).toMatchObject({
+        type: "error",
+        error: soulModule.SOUL_GENERATION_FAILED_MESSAGE,
+      });
+      expect(attemptSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test.each(["policy", "key", "rbac"] as const)(
+    "stops before the next Soul wire when %s authority drifts between supply retries",
+    async (drift) => {
+      useSurplusOnlyCredentials();
+      setConfigOverrides({ nautilo_soul_generator_model: broadenableModelId });
+      let policyEnabled = true;
+      let deny = false;
+      const configSpy = spyOn(db, "getCachedServerModelConfigRow").mockImplementation(() => ({
+        preferSurplus: policyEnabled,
+      } as NonNullable<ReturnType<typeof db.getCachedServerModelConfigRow>>));
+      const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+        .mockImplementation(async () => {
+          if (drift === "policy") policyEnabled = false;
+          if (drift === "key") process.env["SURPLUS_API_KEY"] = "replacement-surplus-key";
+          if (drift === "rbac") deny = true;
+          return {
+            kind: "direct_fallback",
+            retryUnpinned: true,
+            modelUnavailableBeforeService: true,
+          };
+        });
+      const authorization = {
+        humanUserId: "user-1",
+        assertServerProviderCredentials: async (humanUserId: string, origin?: string) => {
+          if (deny) throw new ServerProviderCredentialsDeniedError(humanUserId, origin);
+        },
+      };
+      const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+      try {
+        const result = soulModule.generateSoulFile({ name: "Vex" }, undefined, authorization);
+        if (drift === "rbac") {
+          await Promise.resolve(expect(result).rejects.toBeInstanceOf(ServerProviderCredentialsDeniedError));
+        } else {
+          expect(await result).toContain("# Vex — Soul File");
+        }
+        expect(attemptSpy).toHaveBeenCalledTimes(1);
+      } finally {
+        stderr.mockRestore();
+        attemptSpy.mockRestore();
+        configSpy.mockRestore();
+      }
+    },
+  );
+
+  test("uses the selected Surplus-only system-task model in non-streaming mode", async () => {
+    delete process.env["OPENROUTER_API_KEY"];
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(true);
+    let observedContext: unknown;
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        observedContext = getUsageContext();
+        expect(input).toMatchObject({
+          route: { catalogModelId: modelId },
+          apiKey: "synthetic-surplus-key",
+          funding: { kind: "service", humanUserId: "user-1", providerRoute: "surplus" },
+          directFallbackPolicy: "pre_service_only",
+        });
+        const response = new AIMessage({
+          content: generatedSoul,
+          response_metadata: { finish_reason: "stop" },
+        });
+        expect(() => input.validateResponse?.(response)).not.toThrow();
+        return { kind: "served", response };
+      });
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toBe(generatedSoul);
+      expect(attemptSpy).toHaveBeenCalledTimes(1);
+      expect(observedContext).toMatchObject({
+        callType: "soul",
+        userId: "user-1",
+        funding: { kind: "service", humanUserId: "user-1", providerRoute: "surplus" },
+      });
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("rejects malformed Surplus output inside the paid attempt boundary", async () => {
+    delete process.env["OPENROUTER_API_KEY"];
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(true);
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        const malformed = new AIMessage({
+          content: "This is not a structured soul file.",
+          response_metadata: { finish_reason: "stop" },
+        });
+        input.validateResponse?.(malformed);
+        return { kind: "served", response: malformed };
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const result = await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      );
+      expect(result).toContain("# Vex — Soul File");
+      expect(attemptSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("stops before dispatch when the Surplus policy or credential changes during authorization", async () => {
+    delete process.env["OPENROUTER_API_KEY"];
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    let policyEnabled = true;
+    const configSpy = spyOn(db, "getCachedServerModelConfigRow").mockImplementation(() => ({
+      preferSurplus: policyEnabled,
+    } as NonNullable<ReturnType<typeof db.getCachedServerModelConfigRow>>));
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt");
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const policyChanged = await soulModule.generateSoulFile({ name: "Vex" }, undefined, {
+        humanUserId: "user-1",
+        assertServerProviderCredentials: async () => {
+          policyEnabled = false;
+        },
+      });
+      expect(policyChanged).toContain("# Vex — Soul File");
+      expect(attemptSpy).not.toHaveBeenCalled();
+
+      policyEnabled = true;
+      process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+      const credentialChanged = await soulModule.generateSoulFile({ name: "Vex" }, undefined, {
+        humanUserId: "user-1",
+        assertServerProviderCredentials: async () => {
+          process.env["SURPLUS_API_KEY"] = "replacement-surplus-key";
+        },
+      });
+      expect(credentialChanged).toContain("# Vex — Soul File");
+      expect(attemptSpy).not.toHaveBeenCalled();
+    } finally {
+      stderr.mockRestore();
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("streams Surplus deltas while retaining terminal metadata on the aggregate", async () => {
+    delete process.env["OPENROUTER_API_KEY"];
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(true);
+    let aggregate: AIMessage | undefined;
+    const first = "## Essence\nA precise and distinctive generated identity ";
+    const second = "with enough detail to be useful.\n\n## Tone\nWarm, exact, and candid.";
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        aggregate = await input.invokeModel({
+          async invoke() {
+            throw new Error("streaming path must not call invoke");
+          },
+          async stream() {
+            return {
+              async *[Symbol.asyncIterator]() {
+                yield new AIMessageChunk({ content: first });
+                yield new AIMessageChunk({
+                  content: second,
+                  response_metadata: {
+                    finish_reason: "stop",
+                    usage: { prompt_tokens: 17, completion_tokens: 23, buyer_cost_micro: 41 },
+                  },
+                  usage_metadata: { input_tokens: 17, output_tokens: 23, total_tokens: 40 },
+                } as never);
+              },
+            };
+          },
+        } as never, input.messages, input.config);
+        return { kind: "served", response: aggregate };
+      });
+
+    try {
+      const events = [];
+      for await (const event of soulModule.generateSoulFileStream(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )) events.push(event);
+
+      expect(events).toEqual([
+        { type: "started" },
+        { type: "delta", text: first },
+        { type: "delta", text: second },
+        { type: "completed", soulFile: first + second },
+      ]);
+      expect(aggregate?.response_metadata).toMatchObject({
+        finish_reason: "stop",
+        usage: { buyer_cost_micro: 41 },
+      });
+      expect(aggregate?.usage_metadata).toMatchObject({
+        input_tokens: 17,
+        output_tokens: 23,
+        total_tokens: 40,
+      });
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("keeps policy-off Soul generation on the direct service-funded path", async () => {
+    process.env["NAUTILO_TEST_MODE"] = "stub";
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(false);
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt");
+    let observedContext: unknown;
+    __setStubModelForTests({
+      async invoke() {
+        observedContext = getUsageContext();
+        return new AIMessage({ content: generatedSoul });
+      },
+    });
+
+    try {
+      expect(await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )).toBe(generatedSoul);
+      expect(attemptSpy).not.toHaveBeenCalled();
+      expect(observedContext).toMatchObject({
+        callType: "soul",
+        funding: { kind: "service", providerRoute: "openrouter" },
+      });
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("does not dispatch direct Soul after its captured credential changes during model construction", async () => {
+    process.env["OPENROUTER_API_KEY"] = "captured-openrouter-key";
+    delete process.env["SURPLUS_API_KEY"];
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(false);
+    let providerInvokes = 0;
+    const modelSpy = spyOn(universalProvider, "createUniversalModel")
+      .mockImplementation(async () => {
+        process.env["OPENROUTER_API_KEY"] = "replacement-openrouter-key";
+        return {
+          async invoke() {
+            providerInvokes++;
+            return new AIMessage({ content: generatedSoul });
+          },
+        };
+      });
+    const ownerSpy = spyOn(personalAttempt, "runPersonalLlmAttempt");
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const result = await soulModule.generateSoulFile(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      );
+      expect(result).toContain("# Vex — Soul File");
+      expect(modelSpy).toHaveBeenCalledTimes(1);
+      expect(ownerSpy).not.toHaveBeenCalled();
+      expect(providerInvokes).toBe(0);
+    } finally {
+      stderr.mockRestore();
+      ownerSpy.mockRestore();
+      modelSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("marks provider work observed when a direct stream emits before a 429", async () => {
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(false);
+    const partial = "## Essence\nVisible direct-provider output.";
+    const providerError = Object.assign(new Error("late rate-limit response"), { status: 429 });
+    const modelSpy = spyOn(universalProvider, "createUniversalModel").mockResolvedValue({
+      async invoke() {
+        throw new Error("streaming path must not call invoke");
+      },
+      async stream() {
+        return {
+          async *[Symbol.asyncIterator]() {
+            yield new AIMessageChunk({ content: partial });
+            throw providerError;
+          },
+        };
+      },
+    });
+    let observedAtFailure = false;
+    let failureClassification: ReturnType<typeof personalAttempt.classifyPersonalAttemptFailure> | undefined;
+    const personalAttemptSpy = spyOn(personalAttempt, "runPersonalLlmAttempt")
+      .mockImplementation(async (input) => {
+        try {
+          return await input.invoke();
+        } catch (error) {
+          observedAtFailure = input.hasObservedProviderWork?.() === true;
+          failureClassification = personalAttempt.classifyPersonalAttemptFailure(
+            error,
+            false,
+            observedAtFailure,
+          );
+          throw error;
+        }
+      });
+    const stderr = spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const events = [];
+      for await (const event of soulModule.generateSoulFileStream(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )) events.push(event);
+      expect(events[0]).toEqual({ type: "started" });
+      expect(events[1]).toEqual({ type: "delta", text: partial });
+      expect(events[2]).toMatchObject({
+        type: "error",
+        error: soulModule.SOUL_GENERATION_FAILED_MESSAGE,
+      });
+      expect(observedAtFailure).toBeTrue();
+      expect(failureClassification).toEqual({
+        outcome: "unknown",
+        failureCode: "outcome_unknown",
+        disposition: "terminal_unknown",
+      });
+      expect(personalAttemptSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      stderr.mockRestore();
+      personalAttemptSpy.mockRestore();
+      modelSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("rechecks live authorization before a safe direct fallback", async () => {
+    process.env["NAUTILO_TEST_MODE"] = "stub";
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(true);
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockResolvedValue({ kind: "direct_fallback" });
+    let directInvoked = false;
+    __setStubModelForTests({
+      async invoke() {
+        directInvoked = true;
+        return new AIMessage({ content: generatedSoul });
+      },
+    });
+    let checks = 0;
+
+    try {
+      await Promise.resolve(expect(soulModule.generateSoulFile({ name: "Vex" }, undefined, {
+        humanUserId: "user-1",
+        assertServerProviderCredentials: async (humanUserId, origin) => {
+          checks++;
+          if (checks > 1) throw new ServerProviderCredentialsDeniedError(humanUserId, origin);
+        },
+      })).rejects.toBeInstanceOf(ServerProviderCredentialsDeniedError));
+      expect(checks).toBe(2);
+      expect(directInvoked).toBeFalse();
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("does not replay a streaming attempt after it delivered visible output", async () => {
+    process.env["NAUTILO_TEST_MODE"] = "stub";
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(true);
+    let directInvoked = false;
+    __setStubModelForTests({
+      async invoke() {
+        directInvoked = true;
+        return new AIMessage({ content: generatedSoul });
+      },
+    });
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        await input.invokeModel({
+          async invoke() {
+            throw new Error("streaming path must not call invoke");
+          },
+          async stream() {
+            return {
+              async *[Symbol.asyncIterator]() {
+                yield new AIMessageChunk({ content: "## Essence\nVisible partial output." });
+              },
+            };
+          },
+        } as never, input.messages, input.config);
+        return { kind: "direct_fallback" };
+      });
+
+    try {
+      const events = [];
+      for await (const event of soulModule.generateSoulFileStream(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      )) events.push(event);
+      expect(events[0]).toEqual({ type: "started" });
+      expect(events[1]).toEqual({ type: "delta", text: "## Essence\nVisible partial output." });
+      expect(events[2]).toMatchObject({
+        type: "error",
+        error: soulModule.SOUL_GENERATION_FAILED_MESSAGE,
+      });
+      expect(directInvoked).toBeFalse();
+      expect(attemptSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+
+  test("aborts a Surplus stream when its consumer closes after visible output", async () => {
+    process.env["NAUTILO_TEST_MODE"] = "stub";
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    setConfigOverrides({ nautilo_soul_generator_model: modelId });
+    const configSpy = preferSurplus(true);
+    let directInvoked = false;
+    let providerSignal: AbortSignal | undefined;
+    __setStubModelForTests({
+      async invoke() {
+        directInvoked = true;
+        return new AIMessage({ content: generatedSoul });
+      },
+    });
+    const attemptSpy = spyOn(surplusAttempt, "invokeSurplusChatAttempt")
+      .mockImplementation(async (input) => {
+        providerSignal = input.config.signal;
+        await input.invokeModel({
+          async invoke() {
+            throw new Error("streaming path must not call invoke");
+          },
+          async stream() {
+            return {
+              async *[Symbol.asyncIterator]() {
+                yield new AIMessageChunk({ content: "## Essence\nVisible before close." });
+                await new Promise<void>((resolve) => {
+                  if (providerSignal?.aborted) resolve();
+                  else providerSignal?.addEventListener("abort", () => resolve(), { once: true });
+                });
+                throw new Error("cancelled provider stream");
+              },
+            };
+          },
+        } as never, input.messages, input.config);
+        throw new Error("expected cancellation");
+      });
+
+    try {
+      const stream = soulModule.generateSoulFileStream(
+        { name: "Vex" }, undefined, SOUL_AUTHORIZATION,
+      );
+      expect((await stream.next()).value).toEqual({ type: "started" });
+      expect((await stream.next()).value).toEqual({
+        type: "delta",
+        text: "## Essence\nVisible before close.",
+      });
+      await stream.return(undefined);
+      expect(providerSignal?.aborted).toBeTrue();
+      expect(directInvoked).toBeFalse();
+      expect(attemptSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      attemptSpy.mockRestore();
+      configSpy.mockRestore();
+    }
+  });
+});
diff --git a/packages/agent/tests/unit/surplus-catalog-routes.test.ts b/packages/agent/tests/unit/surplus-catalog-routes.test.ts
index b3c73a89e..53daa6ea3 100644
--- a/packages/agent/tests/unit/surplus-catalog-routes.test.ts
+++ b/packages/agent/tests/unit/surplus-catalog-routes.test.ts
@@ -1,5 +1,5 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import type { ModelCatalog } from "@nautilo/types";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { ModelCatalogSchema, type ModelCatalog } from "@nautilo/types";
 import {
   configureRuntimeModelCatalog,
   getActiveModelCatalogSync,
@@ -8,9 +8,13 @@ import {
 } from "../../src/config/model-catalog/runtime-catalog";
 import {
   canBroadenSurplusModelRoute,
+  hydrateSurplusChatCatalog,
   resolveQualifiedSurplusChatRoute,
   resolveSurplusChatServingAvailability,
 } from "../../src/providers/surplus-route";
+import { configureSurplusModelCatalog, resetSurplusModelCatalog } from "../../src/providers/surplus-catalog";
+import { installSurplusCatalogFixture } from "../helpers/surplus-catalog-fixture";
+import { resolveModelRole } from "../../src/config/model-role-resolution";
 
 async function installCatalog(catalog: ModelCatalog): Promise<void> {
   configureRuntimeModelCatalog({
@@ -31,10 +35,110 @@ async function installCatalog(catalog: ModelCatalog): Promise<void> {
   await hydrateRuntimeModelCatalog();
 }
 
-afterEach(() => resetRuntimeModelCatalog());
+beforeEach(installSurplusCatalogFixture);
+afterEach(() => { resetRuntimeModelCatalog(); resetSurplusModelCatalog(); });
 
 describe("catalog-derived Surplus chat routes", () => {
-  test("a newly signed supported-provider row is immediately routable with catalog capabilities", async () => {
+  test("uses discovered Claude limits across verified aliases without changing signed direct limits", () => {
+    const catalog = getActiveModelCatalogSync().catalog;
+    const catalogModelId = "openrouter:anthropic/claude-sonnet-4.6";
+    const signedSonnet = catalog.entries.find((entry) => entry.id === catalogModelId);
+    const unrelated = catalog.entries.find((entry) => entry.id === "openrouter:minimax/minimax-m3");
+    if (!signedSonnet?.limits || !unrelated?.limits) throw new Error("Surplus route fixtures are missing limits");
+
+    expect(signedSonnet.limits.outputTokens).toBe(128_000);
+    expect(resolveQualifiedSurplusChatRoute(catalogModelId)?.maxOutputTokens).toBe(64_000);
+    expect(resolveQualifiedSurplusChatRoute(catalogModelId)?.surplusModelId).toBe("claude-sonnet-4.6");
+    expect(resolveQualifiedSurplusChatRoute(unrelated.id)).toBeNull();
+    expect(resolveQualifiedSurplusChatRoute("anthropic:claude-sonnet-4-6")?.maxOutputTokens)
+      .toBe(64_000);
+    expect(resolveQualifiedSurplusChatRoute("venice:claude-sonnet-4-6")?.maxOutputTokens)
+      .toBe(64_000);
+  });
+
+  test("the explicit offline route seam remains bounded by signed capabilities and limits", () => {
+    const catalogModelId = "openrouter:anthropic/claude-sonnet-4.6";
+    const route = resolveQualifiedSurplusChatRoute(catalogModelId);
+    if (!route) throw new Error("Qualified Sonnet route fixture is missing");
+
+    expect(resolveQualifiedSurplusChatRoute(catalogModelId, [{
+      ...route,
+      maxOutputTokens: 256_000,
+    }])).toBeNull();
+    expect(resolveQualifiedSurplusChatRoute(catalogModelId, [{
+      ...route,
+      surplusModelId: "offline-fixture",
+      maxOutputTokens: 32_000,
+    }])?.maxOutputTokens).toBe(32_000);
+  });
+
+  test("qualifies Kimi limits and skips the nonexistent MiniMax alias in Auto", () => {
+    const route = resolveQualifiedSurplusChatRoute("openrouter:moonshotai/kimi-k3");
+    expect(route).toMatchObject({ surplusModelId: "kimi-k3", maxOutputTokens: 131_072, maxContextTokens: 1_000_000 });
+    expect(resolveQualifiedSurplusChatRoute("openrouter:minimax/minimax-m3")).toBeNull();
+    expect(resolveModelRole("chat", {
+      env: {}, serverSurplus: { policyEnabled: true, keyConfigured: true },
+    })).toBe("venice:minimax-m3-preview");
+  });
+
+  test("an empty discovery cache never assumes signed models have a Surplus route", () => {
+    resetSurplusModelCatalog();
+    expect(resolveQualifiedSurplusChatRoute("openrouter:moonshotai/kimi-k3")).toBeNull();
+    expect(resolveSurplusChatServingAvailability({ policyEnabled: true, keyConfigured: true }).status)
+      .toBe("not-qualified");
+  });
+
+  test("a changed vendor limit replaces the old Claude exception", async () => {
+    configureSurplusModelCatalog({ fetchImpl: (async () => Response.json({ data: [{
+      id: "claude-sonnet-4-6", context_length: 200_000,
+      top_provider: { max_completion_tokens: 48_000 },
+      architecture: { input_modalities: ["text"], output_modalities: ["text"] },
+      supported_parameters: ["max_tokens", "reasoning"], supported_features: ["streaming"],
+    }] })) as unknown as typeof fetch });
+    await hydrateSurplusChatCatalog({ catalogModelIds: ["anthropic:claude-sonnet-4-6"] });
+    expect(resolveQualifiedSurplusChatRoute("anthropic:claude-sonnet-4-6")).toMatchObject({
+      maxOutputTokens: 48_000, maxContextTokens: 200_000, supportsTools: false,
+      supportsReasoning: true, supportsVision: false,
+    });
+  });
+
+  test("does not advertise signed reasoning controls that the marketplace cannot carry", async () => {
+    const id = "openai:gpt-6-sol";
+    const signed = getActiveModelCatalogSync().catalog.entries.find((entry) => entry.id === id);
+    expect(signed && "controls" in signed && signed.controls?.reasoning).toBeDefined();
+    configureSurplusModelCatalog({ fetchImpl: (async () => Response.json({ data: [{
+      id: "gpt-6-sol", context_length: 200_000,
+      top_provider: { max_completion_tokens: 32_000 },
+      architecture: { input_modalities: ["text"], output_modalities: ["text"] },
+      supported_parameters: ["max_tokens", "tools", "include_reasoning"],
+      supported_features: ["streaming", "tools", "reasoning"],
+    }] })) as unknown as typeof fetch });
+    await hydrateSurplusChatCatalog({ catalogModelIds: [id] });
+    expect(resolveQualifiedSurplusChatRoute(id)).toBeNull();
+    expect(() => resolveModelRole("chat", { configuredId: id, env: {},
+      serverSurplus: { policyEnabled: true, keyConfigured: true },
+    })).toThrow();
+    expect(resolveSurplusChatServingAvailability({ policyEnabled: true, keyConfigured: true }).status)
+      .toBe("not-qualified");
+  });
+
+  test("a signed Sonnet limit below the qualified Surplus ceiling stays authoritative", async () => {
+    const current = getActiveModelCatalogSync().catalog;
+    const catalogModelId = "openrouter:anthropic/claude-sonnet-4.6";
+    const source = current.entries.find((entry) => entry.id === catalogModelId);
+    if (!source) throw new Error("OpenRouter Sonnet fixture is missing");
+    const narrowed = { ...source, limits: { ...source.limits, outputTokens: 32_000 } };
+    await installCatalog(ModelCatalogSchema.parse({
+      ...current,
+      catalogVersion: "2026.10.22.1",
+      entries: [narrowed],
+    }));
+
+    expect(getActiveModelCatalogSync().catalog.entries[0]?.limits?.outputTokens).toBe(32_000);
+    expect(resolveQualifiedSurplusChatRoute(catalogModelId)?.maxOutputTokens).toBe(32_000);
+  });
+
+  test("a newly signed row requires vendor confirmation and never gains vendor-only capabilities", async () => {
     const current = getActiveModelCatalogSync().catalog;
     const source = current.entries.find((entry) => entry.id === "openai:gpt-5.6-sol");
     if (!source) throw new Error("OpenAI chat fixture is missing");
@@ -50,8 +154,16 @@ describe("catalog-derived Surplus chat routes", () => {
       limits: { contextTokens: 234_567, outputTokens: 12_345 },
     };
     await installCatalog({ ...current, catalogVersion: "2026.10.03.1", entries: [future] } as ModelCatalog);
-
-    expect(resolveQualifiedSurplusChatRoute(id)).toEqual({
+    expect(resolveQualifiedSurplusChatRoute(id)).toBeNull();
+    configureSurplusModelCatalog({ fetchImpl: (async () => Response.json({ data: [{
+      id: "meta-llama/future-signed-chat", context_length: 234_567,
+      top_provider: { max_completion_tokens: 12_345 },
+      architecture: { input_modalities: ["text", "image"], output_modalities: ["text"] },
+      supported_parameters: ["max_tokens", "tools", "reasoning"],
+      supported_features: ["streaming", "reasoning", "vision", "tools"],
+    }] })) as unknown as typeof fetch });
+    await hydrateSurplusChatCatalog();
+    expect(resolveQualifiedSurplusChatRoute(id)).toMatchObject({
       catalogModelId: id,
       surplusModelId: "meta-llama/future-signed-chat",
       providerPin: "together",
@@ -63,7 +175,7 @@ describe("catalog-derived Surplus chat routes", () => {
     });
   });
 
-  test("Google catalog rows pin google-ai-studio while preserving the exact model suffix", () => {
+  test("vendor-confirmed canonical names retain the signed provider pin", () => {
     const googleRoute = resolveQualifiedSurplusChatRoute("google:gemini-3.1-pro-preview");
     expect(googleRoute).toMatchObject({
       surplusModelId: "gemini-3.1-pro-preview",
@@ -74,11 +186,11 @@ describe("catalog-derived Surplus chat routes", () => {
       providerPin: "google" as never,
     }])).toBeNull();
     expect(resolveQualifiedSurplusChatRoute("fireworks:accounts/fireworks/models/kimi-k3")).toMatchObject({
-      surplusModelId: "accounts/fireworks/models/kimi-k3",
+      surplusModelId: "kimi-k3",
       providerPin: "fireworks",
     });
     expect(resolveQualifiedSurplusChatRoute("openrouter:openai/gpt-5.6-sol")).toMatchObject({
-      surplusModelId: "openai/gpt-5.6-sol",
+      surplusModelId: "gpt-5.6-sol",
       providerPin: "openrouter",
     });
   });
@@ -102,6 +214,13 @@ describe("catalog-derived Surplus chat routes", () => {
     if (!source) throw new Error("Anthropic chat fixture is missing");
     const only = { ...source, id: "anthropic:aggregate-new-row" };
     await installCatalog({ ...current, catalogVersion: "2026.10.03.2", entries: [only] } as ModelCatalog);
+    configureSurplusModelCatalog({ fetchImpl: (async () => Response.json({ data: [{
+      id: "aggregate-new-row", context_length: 200_000,
+      top_provider: { max_completion_tokens: 32_000 },
+      architecture: { input_modalities: ["text"], output_modalities: ["text"] },
+      supported_parameters: ["max_tokens"], supported_features: ["streaming"],
+    }] })) as unknown as typeof fetch });
+    await hydrateSurplusChatCatalog();
     expect(resolveSurplusChatServingAvailability({ policyEnabled: true, keyConfigured: true }))
       .toMatchObject({ status: "available", route: { catalogModelId: "anthropic:aggregate-new-row" } });
   });
@@ -130,11 +249,13 @@ describe("catalog-derived Surplus chat routes", () => {
 
 describe("marketplace provider broadening", () => {
   test("ordinary aggregator rows allow exact-model seller recovery", () => {
+    expect(canBroadenSurplusModelRoute("openrouter:anthropic/claude-sonnet-4.6")).toBe(true);
     expect(canBroadenSurplusModelRoute("openrouter:minimax/minimax-m3")).toBe(true);
     expect(canBroadenSurplusModelRoute("openrouter:typesafe/jev-1.13")).toBe(true);
     expect(canBroadenSurplusModelRoute("fireworks:accounts/fireworks/models/kimi-k3")).toBe(true);
   });
   test("provider-bound privacy routes and unknown models retain their pin", () => {
+    expect(canBroadenSurplusModelRoute("venice:claude-sonnet-4-6")).toBe(false);
     for (const row of getActiveModelCatalogSync().catalog.entries.filter(row => row.provider === "venice")) {
       expect(canBroadenSurplusModelRoute(row.id)).toBe(false);
     }
diff --git a/packages/agent/tests/unit/surplus-catalog.test.ts b/packages/agent/tests/unit/surplus-catalog.test.ts
new file mode 100644
index 000000000..d0a3fbe71
--- /dev/null
+++ b/packages/agent/tests/unit/surplus-catalog.test.ts
@@ -0,0 +1,562 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+  configureSurplusModelCatalog,
+  getSurplusModelMetadataSync,
+  hydrateSurplusModelCatalog,
+  invalidateSurplusModelCatalog,
+  resetSurplusModelCatalog,
+} from "../../src/providers/surplus-catalog";
+
+const LIST_URL = "https://api.surplusintelligence.ai/v1/models";
+
+function modelRow(
+  id: string,
+  overrides: Record<string, unknown> = {},
+): Record<string, unknown> {
+  return {
+    id,
+    context_length: 200_000,
+    architecture: {
+      input_modalities: ["text"],
+      output_modalities: ["text"],
+    },
+    top_provider: {
+      context_length: 180_000,
+      max_completion_tokens: 32_000,
+    },
+    supported_parameters: ["max_tokens"],
+    supported_features: ["streaming"],
+    ...overrides,
+  };
+}
+
+function json(payload: unknown, status = 200): Response {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function fakeFetch(
+  implementation: (url: string, init: RequestInit | undefined) => Response | Promise<Response>,
+): typeof fetch {
+  return (async (input: string | URL | Request, init?: RequestInit) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    return implementation(url, init);
+  }) as typeof fetch;
+}
+
+afterEach(() => resetSurplusModelCatalog());
+
+describe("Surplus model catalog", () => {
+  test("sync reads never initiate discovery", () => {
+    let calls = 0;
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(() => {
+        calls += 1;
+        return json({ data: [modelRow("canonical")] });
+      }),
+    });
+
+    expect(getSurplusModelMetadataSync("canonical")).toBeNull();
+    expect(calls).toBe(0);
+  });
+
+  test("publishes conservative token limits and canonical capability fields", async () => {
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(() => json({
+        data: [modelRow("capable", {
+          context_length: 190_000,
+          architecture: {
+            input_modalities: ["text", "image"],
+            output_modalities: ["text"],
+          },
+          top_provider: {
+            context_length: 180_000,
+            max_completion_tokens: 220_000,
+          },
+          supported_parameters: ["max_tokens", "tools", "reasoning"],
+          supported_features: ["streaming"],
+        })],
+      })),
+    });
+
+    await hydrateSurplusModelCatalog(["capable"]);
+
+    expect(getSurplusModelMetadataSync("capable")).toEqual({
+      id: "capable",
+      contextTokens: 180_000,
+      maxOutputTokens: 180_000,
+      supportsTools: true,
+      supportsVision: true,
+      supportsReasoning: true,
+      supportsStreaming: true,
+      supportedParameters: ["max_tokens", "tools", "reasoning"],
+    });
+  });
+
+  test("accepts an exact alias only when its detail canonical id is in the same list", async () => {
+    const urls: string[] = [];
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch((url, init) => {
+        urls.push(url);
+        expect(init?.method).toBe("GET");
+        expect(init?.redirect).toBe("error");
+        expect(new Headers(init?.headers).get("authorization")).toBeNull();
+        return url === LIST_URL
+          ? json({ data: [modelRow("claude-sonnet-4.6")] })
+          : json(modelRow("claude-sonnet-4.6"));
+      }),
+    });
+
+    await hydrateSurplusModelCatalog(["anthropic/claude-sonnet-4.6"]);
+
+    expect(urls).toEqual([
+      LIST_URL,
+      `${LIST_URL}/anthropic%2Fclaude-sonnet-4.6`,
+    ]);
+    expect(getSurplusModelMetadataSync("anthropic/claude-sonnet-4.6")?.id)
+      .toBe("claude-sonnet-4.6");
+  });
+
+  test("rejects a detail canonical id missing from the validated list", async () => {
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch((url) => url === LIST_URL
+        ? json({ data: [modelRow("listed")] })
+        : json(modelRow("unlisted"))),
+    });
+
+    await hydrateSurplusModelCatalog(["vendor/requested"]);
+
+    expect(getSurplusModelMetadataSync("vendor/requested")).toBeNull();
+    expect(getSurplusModelMetadataSync("unlisted")).toBeNull();
+  });
+
+  test("caches 404 aliases for a snapshot but resolves a new requested alias against a fresh list", async () => {
+    let listCalls = 0;
+    const detailCalls = new Map<string, number>();
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch((url) => {
+        if (url === LIST_URL) {
+          listCalls += 1;
+          return json({ data: [modelRow("canonical")] });
+        }
+        detailCalls.set(url, (detailCalls.get(url) ?? 0) + 1);
+        if (url.endsWith("missing")) return json({ error: "missing" }, 404);
+        return json(modelRow("canonical"));
+      }),
+    });
+
+    await hydrateSurplusModelCatalog(["missing"]);
+    await hydrateSurplusModelCatalog(["missing"]);
+    await hydrateSurplusModelCatalog(["new/alias"]);
+
+    expect(listCalls).toBe(1);
+    expect(detailCalls.get(`${LIST_URL}/missing`)).toBe(1);
+    expect(detailCalls.get(`${LIST_URL}/new%2Falias`)).toBe(1);
+    expect(getSurplusModelMetadataSync("new/alias")?.id).toBe("canonical");
+  });
+
+  test("deduplicates list and exact detail work across concurrent hydrations", async () => {
+    let listCalls = 0;
+    let detailCalls = 0;
+    let releaseList!: () => void;
+    const listGate = new Promise<void>((resolve) => { releaseList = resolve; });
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(async (url) => {
+        if (url === LIST_URL) {
+          listCalls += 1;
+          await listGate;
+          return json({ data: [modelRow("canonical")] });
+        }
+        detailCalls += 1;
+        return json(modelRow("canonical"));
+      }),
+    });
+
+    const first = hydrateSurplusModelCatalog(["vendor/alias"]);
+    const second = hydrateSurplusModelCatalog(["vendor/alias"]);
+    releaseList();
+    await Promise.all([first, second]);
+
+    expect(listCalls).toBe(1);
+    expect(detailCalls).toBe(1);
+    expect(getSurplusModelMetadataSync("vendor/alias")?.id).toBe("canonical");
+  });
+
+  test("cancelling one caller returns promptly without aborting its shared exact lookup", async () => {
+    let detailCalls = 0;
+    let detailSignal: AbortSignal | undefined;
+    let detailStarted!: () => void;
+    const started = new Promise<void>((resolve) => { detailStarted = resolve; });
+    let releaseDetail!: () => void;
+    const detailGate = new Promise<void>((resolve) => { releaseDetail = resolve; });
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(async (url, init) => {
+        if (url === LIST_URL) return json({ data: [modelRow("canonical")] });
+        detailCalls += 1;
+        detailSignal = init?.signal ?? undefined;
+        detailStarted();
+        await detailGate;
+        return json(modelRow("canonical"));
+      }),
+    });
+    await hydrateSurplusModelCatalog();
+
+    const first = hydrateSurplusModelCatalog(["vendor/shared"]);
+    await started;
+    const controller = new AbortController();
+    const cancelled = hydrateSurplusModelCatalog(["vendor/shared"], { signal: controller.signal });
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    controller.abort();
+    await Promise.race([
+      cancelled,
+      new Promise<never>((_resolve, reject) => {
+        setTimeout(() => reject(new Error("cancelled hydration did not return promptly")), 250);
+      }),
+    ]);
+
+    expect(detailCalls).toBe(1);
+    expect(detailSignal?.aborted).toBe(false);
+    releaseDetail();
+    await first;
+    expect(getSurplusModelMetadataSync("vendor/shared")?.id).toBe("canonical");
+  });
+
+  test("caller cancellation removes zero-consumer queued work without network or backoff", async () => {
+    const blockerReleases: Array<() => void> = [];
+    let blockersStarted = 0;
+    let fourStarted!: () => void;
+    const started = new Promise<void>((resolve) => { fourStarted = resolve; });
+    let cancelledAliasCalls = 0;
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(async (url) => {
+        if (url === LIST_URL) return json({ data: [modelRow("canonical")] });
+        if (url.endsWith("cancelled")) {
+          cancelledAliasCalls += 1;
+          return json(modelRow("canonical"));
+        }
+        blockersStarted += 1;
+        if (blockersStarted === 4) fourStarted();
+        await new Promise<void>((resolve) => blockerReleases.push(resolve));
+        return json({ error: "missing" }, 404);
+      }),
+    });
+    await hydrateSurplusModelCatalog();
+
+    const blockers = hydrateSurplusModelCatalog(
+      Array.from({ length: 4 }, (_, index) => `vendor/blocker-${index}`),
+    );
+    await started;
+    const controller = new AbortController();
+    const cancelled = hydrateSurplusModelCatalog(["vendor/cancelled"], { signal: controller.signal });
+    await new Promise<void>((resolve) => setTimeout(resolve, 0));
+    controller.abort();
+    await cancelled;
+    expect(cancelledAliasCalls).toBe(0);
+
+    for (const release of blockerReleases) release();
+    await blockers;
+    await hydrateSurplusModelCatalog(["vendor/cancelled"]);
+    expect(cancelledAliasCalls).toBe(1);
+    expect(getSurplusModelMetadataSync("vendor/cancelled")?.id).toBe("canonical");
+  });
+
+  test("an exact waiter survives the broad hydration deadline on a shared queued job", async () => {
+    const target = "vendor/exact-target";
+    let detailStarts = 0;
+    let firstFourStarted!: () => void;
+    const started = new Promise<void>((resolve) => { firstFourStarted = resolve; });
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch((url, init) => {
+        if (url === LIST_URL) return json({ data: [modelRow("canonical")] });
+        detailStarts += 1;
+        if (url.endsWith(encodeURIComponent(target))) return json(modelRow("canonical"));
+        if (detailStarts === 4) firstFourStarted();
+        return new Promise<Response>((_resolve, reject) => {
+          init?.signal?.addEventListener("abort", () => {
+            reject(new DOMException("aborted", "AbortError"));
+          }, { once: true });
+        });
+      }),
+    });
+
+    const broadIds = [
+      "vendor/broad-0", "vendor/broad-1", "vendor/broad-2", "vendor/broad-3",
+      "vendor/broad-4", "vendor/broad-5", target,
+    ];
+    const broad = hydrateSurplusModelCatalog(broadIds);
+    await started;
+    await new Promise<void>((resolve) => setTimeout(resolve, 4_000));
+    const exact = hydrateSurplusModelCatalog([target]);
+
+    await Promise.all([broad, exact]);
+    expect(detailStarts).toBe(5);
+    expect(getSurplusModelMetadataSync(target)?.id).toBe("canonical");
+  }, 10_000);
+
+  test("ignores bad and non-chat rows and removes ambiguous duplicate ids", async () => {
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(() => json({
+        data: [
+          modelRow("duplicate"),
+          modelRow("duplicate", { context_length: 90_000 }),
+          modelRow("media", {
+            architecture: { input_modalities: ["text"], output_modalities: ["image"] },
+          }),
+          modelRow("bad-token", {
+            top_provider: { context_length: 180_000, max_completion_tokens: 0 },
+          }),
+          modelRow("usable", { supported_features: ["vision", "reasoning"] }),
+          null,
+        ],
+      })),
+    });
+
+    await hydrateSurplusModelCatalog();
+
+    expect(getSurplusModelMetadataSync("duplicate")).toBeNull();
+    expect(getSurplusModelMetadataSync("media")).toBeNull();
+    expect(getSurplusModelMetadataSync("bad-token")).toBeNull();
+    expect(getSurplusModelMetadataSync("usable")).toMatchObject({
+      supportsVision: true,
+      supportsReasoning: false,
+    });
+  });
+
+  test.each([
+    ["reasoning", true], ["reasoning_effort", true], ["include_reasoning", false],
+  ] as const)("reasoning capability requires an actionable %s parameter", async (parameter, expected) => {
+    configureSurplusModelCatalog({ fetchImpl: fakeFetch(() => json({ data: [modelRow("reasoning-model", {
+      supported_parameters: ["max_tokens", parameter],
+      supported_features: ["streaming", "reasoning"],
+    })] })) });
+    await hydrateSurplusModelCatalog();
+    expect(getSurplusModelMetadataSync("reasoning-model")?.supportsReasoning).toBe(expected);
+  });
+
+  test("retains a valid last-known-good snapshot on invalid refresh and fails closed after max stale", async () => {
+    let clock = 0;
+    let calls = 0;
+    configureSurplusModelCatalog({
+      now: () => clock,
+      fetchImpl: fakeFetch(() => {
+        calls += 1;
+        return calls === 1
+          ? json({ data: [modelRow("known")] })
+          : json({ data: [] });
+      }),
+    });
+    await hydrateSurplusModelCatalog();
+
+    clock = 60_000;
+    await hydrateSurplusModelCatalog();
+    expect(getSurplusModelMetadataSync("known")?.id).toBe("known");
+    expect(calls).toBe(2);
+
+    clock = 65_000;
+    await hydrateSurplusModelCatalog();
+    expect(calls).toBe(2);
+
+    clock = 300_001;
+    expect(getSurplusModelMetadataSync("known")).toBeNull();
+  });
+
+  test("transient detail errors are retryable after backoff and never become negative aliases", async () => {
+    let clock = 0;
+    let detailCalls = 0;
+    configureSurplusModelCatalog({
+      now: () => clock,
+      fetchImpl: fakeFetch((url) => {
+        if (url === LIST_URL) return json({ data: [modelRow("canonical")] });
+        detailCalls += 1;
+        if (detailCalls === 1) throw new Error("network unavailable");
+        return json(modelRow("canonical"));
+      }),
+    });
+
+    await hydrateSurplusModelCatalog(["vendor/alias"]);
+    expect(getSurplusModelMetadataSync("vendor/alias")).toBeNull();
+    clock = 9_999;
+    await hydrateSurplusModelCatalog(["vendor/alias"]);
+    expect(detailCalls).toBe(1);
+    clock = 10_000;
+    await hydrateSurplusModelCatalog(["vendor/alias"]);
+    expect(detailCalls).toBe(2);
+    expect(getSurplusModelMetadataSync("vendor/alias")?.id).toBe("canonical");
+  });
+
+  test("invalidate keeps the bounded LKG and makes the next hydration refresh", async () => {
+    let calls = 0;
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(() => {
+        calls += 1;
+        return json({ data: [modelRow(calls === 1 ? "first" : "second")] });
+      }),
+    });
+    await hydrateSurplusModelCatalog();
+
+    invalidateSurplusModelCatalog();
+    expect(calls).toBe(1);
+    expect(getSurplusModelMetadataSync("first")?.id).toBe("first");
+
+    await hydrateSurplusModelCatalog();
+    expect(calls).toBe(2);
+    expect(getSurplusModelMetadataSync("first")).toBeNull();
+    expect(getSurplusModelMetadataSync("second")?.id).toBe("second");
+  });
+
+  test("reset fences an in-flight response from later publication", async () => {
+    let release!: (response: Response) => void;
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(() => new Promise<Response>((resolve) => { release = resolve; })),
+    });
+
+    const hydration = hydrateSurplusModelCatalog();
+    resetSurplusModelCatalog();
+    configureSurplusModelCatalog({ enabled: false });
+    release(json({ data: [modelRow("late")] }));
+    await hydration;
+
+    expect(getSurplusModelMetadataSync("late")).toBeNull();
+  });
+
+  test("reset aborts active details and drains queued work without starting it", async () => {
+    let detailStarts = 0;
+    let fourStarted!: () => void;
+    const started = new Promise<void>((resolve) => { fourStarted = resolve; });
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch((url, init) => {
+        if (url === LIST_URL) return json({ data: [modelRow("canonical")] });
+        detailStarts += 1;
+        if (detailStarts === 4) fourStarted();
+        return new Promise<Response>((_resolve, reject) => {
+          init?.signal?.addEventListener("abort", () => {
+            reject(new DOMException("aborted", "AbortError"));
+          }, { once: true });
+        });
+      }),
+    });
+
+    const hydration = hydrateSurplusModelCatalog(
+      Array.from({ length: 7 }, (_, index) => `vendor/queued-${index}`),
+    );
+    await started;
+    resetSurplusModelCatalog();
+    await Promise.race([
+      hydration,
+      new Promise<never>((_resolve, reject) => {
+        setTimeout(() => reject(new Error("reset did not drain detail waiters")), 250);
+      }),
+    ]);
+
+    expect(detailStarts).toBe(4);
+    expect(getSurplusModelMetadataSync("canonical")).toBeNull();
+  });
+
+  test("a slow older alias lookup cannot roll back a newer forced snapshot", async () => {
+    let listCalls = 0;
+    let aliasStarted!: () => void;
+    const started = new Promise<void>((resolve) => { aliasStarted = resolve; });
+    let releaseAlias!: () => void;
+    const aliasGate = new Promise<void>((resolve) => { releaseAlias = resolve; });
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(async (url) => {
+        if (url === LIST_URL) {
+          listCalls += 1;
+          return json({ data: [modelRow(listCalls === 1 ? "old" : "new")] });
+        }
+        aliasStarted();
+        await aliasGate;
+        return json(modelRow("old"));
+      }),
+    });
+
+    const older = hydrateSurplusModelCatalog(["vendor/alias"]);
+    await started;
+    await hydrateSurplusModelCatalog([], { force: true });
+    releaseAlias();
+    await older;
+
+    expect(getSurplusModelMetadataSync("old")).toBeNull();
+    expect(getSurplusModelMetadataSync("vendor/alias")).toBeNull();
+    expect(getSurplusModelMetadataSync("new")?.id).toBe("new");
+  });
+
+  test("network failure resolves without publishing and disabled discovery makes no request", async () => {
+    let calls = 0;
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(() => {
+        calls += 1;
+        throw new Error("offline");
+      }),
+    });
+    await hydrateSurplusModelCatalog(["model"]);
+    expect(getSurplusModelMetadataSync("model")).toBeNull();
+
+    configureSurplusModelCatalog({
+      enabled: false,
+      fetchImpl: fakeFetch(() => {
+        calls += 1;
+        return json({ data: [modelRow("model")] });
+      }),
+    });
+    await hydrateSurplusModelCatalog(["model"]);
+    expect(calls).toBe(1);
+  });
+
+  test("one hydration deadline drops queued aliases, publishes canonical LKG, and backs off repeats", async () => {
+    let listCalls = 0;
+    let detailStarts = 0;
+    const detailSignals: AbortSignal[] = [];
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch((url, init) => {
+        if (url === LIST_URL) {
+          listCalls += 1;
+          return json({ data: [modelRow(listCalls === 1 ? "old" : "current")] });
+        }
+        detailStarts += 1;
+        if (init?.signal) detailSignals.push(init.signal);
+        // Deliberately ignore abort to prove the aggregate hydration race is
+        // bounded independently from provider fetch compliance.
+        return new Promise<Response>(() => undefined);
+      }),
+    });
+    await hydrateSurplusModelCatalog();
+
+    const aliases = Array.from({ length: 7 }, (_, index) => `vendor/alias-${index}`);
+    await hydrateSurplusModelCatalog(aliases, { force: true });
+
+    expect(listCalls).toBe(2);
+    expect(detailStarts).toBe(4);
+    expect(detailSignals).toHaveLength(4);
+    expect(detailSignals.every((signal) => signal.aborted)).toBe(true);
+    expect(getSurplusModelMetadataSync("old")).toBeNull();
+    expect(getSurplusModelMetadataSync("current")?.id).toBe("current");
+    for (const alias of aliases) expect(getSurplusModelMetadataSync(alias)).toBeNull();
+
+    await hydrateSurplusModelCatalog(aliases);
+    expect(detailStarts).toBe(4);
+  }, 7_000);
+
+  test("fails closed explicitly when the caller exceeds the requested-id bound", async () => {
+    let calls = 0;
+    configureSurplusModelCatalog({
+      fetchImpl: fakeFetch(() => {
+        calls += 1;
+        return json({ data: [modelRow("model")] });
+      }),
+    });
+
+    let failure: unknown;
+    try {
+      await hydrateSurplusModelCatalog(
+        Array.from({ length: 129 }, (_, index) => `model-${index}`),
+      );
+    } catch (error) {
+      failure = error;
+    }
+    expect(failure).toBeInstanceOf(RangeError);
+    expect(calls).toBe(0);
+  });
+});
diff --git a/packages/agent/tests/unit/surplus-chat-routing.test.ts b/packages/agent/tests/unit/surplus-chat-routing.test.ts
new file mode 100644
index 000000000..85323f9fb
--- /dev/null
+++ b/packages/agent/tests/unit/surplus-chat-routing.test.ts
@@ -0,0 +1,277 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { AIMessage, HumanMessage, type BaseMessage } from "@langchain/core/messages";
+import { DynamicStructuredTool, type StructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+import * as db from "@nautilo/db";
+import * as credentials from "../../src/chat/model-runtime-credentials";
+import * as eligible from "../../src/config/eligible-models";
+import * as keys from "../../src/resolve-provider-key";
+import * as surplusAttempt from "../../src/providers/surplus-attempt";
+import * as surplusRoutes from "../../src/providers/surplus-route";
+import * as universal from "../../src/providers/universal";
+import { getActiveModelCatalogSync } from "../../src/config/model-catalog/runtime-catalog";
+import { PersonalDirectFundingUnavailableError, type ForegroundChatFundingSession } from "../../src/runtime/foreground-chat-funding";
+import {
+  estimateBoundToolTokens,
+  invokeChatModelWithFallback,
+} from "../../src/utils/chat-model-invocation";
+import { estimateTokenCount } from "../../src/utils/history-manager";
+import {
+  configureSurplusModelCatalog,
+  resetSurplusModelCatalog,
+} from "../../src/providers/surplus-catalog";
+import { installSurplusCatalogFixture } from "../helpers/surplus-catalog-fixture";
+
+const MODEL = "openrouter:anthropic/claude-sonnet-4.6";
+const KIMI_MODEL = "openrouter:moonshotai/kimi-k3";
+const reply = new AIMessage({ content: "Synthetic answer", response_metadata: { finish_reason: "stop" } });
+const restore: (() => void)[] = [];
+beforeEach(async () => installSurplusCatalogFixture());
+afterEach(() => {
+  for (const undo of restore.splice(0).reverse()) undo();
+  resetSurplusModelCatalog();
+});
+
+async function installKimiDiscovery(contextTokens: number, maxOutputTokens: number, reasoningKnob = true): Promise<void> {
+  const row = {
+    id: "kimi-k3",
+    context_length: contextTokens,
+    top_provider: { context_length: contextTokens, max_completion_tokens: maxOutputTokens },
+    architecture: { input_modalities: ["text", "image"], output_modalities: ["text"] },
+    supported_parameters: ["max_tokens", "tools", "tool_choice", ...(reasoningKnob ? ["reasoning"] : [])],
+    supported_features: ["tools", "reasoning", "streaming", "vision"],
+  };
+  configureSurplusModelCatalog({
+    fetchImpl: (async (input: Parameters<typeof fetch>[0]) => {
+      const url = new URL(input instanceof Request ? input.url : String(input));
+      if (url.pathname === "/v1/models") return Response.json({ data: [row] });
+      return decodeURIComponent(url.pathname.slice("/v1/models/".length)) === "moonshotai/kimi-k3"
+        ? Response.json(row)
+        : Response.json({ error: { code: "model_not_found" } }, { status: 404 });
+    }) as unknown as typeof fetch,
+  });
+  await surplusRoutes.hydrateSurplusChatCatalog({ catalogModelIds: [KIMI_MODEL] });
+}
+
+function harness(options: {
+  directKey?: boolean;
+  personal?: boolean;
+  allowBroadening?: boolean;
+  failure?: Error;
+  recheckError?: Error;
+  recoveryError?: Error;
+  noPersonalRecovery?: boolean;
+  retryUnpinned?: boolean;
+} = {}) {
+  const retain = eligible.resolveRetainedModels;
+  const retained = spyOn(eligible, "resolveRetainedModels").mockImplementation((ids, opts) => retain(ids, { ...opts, env: {} }));
+  const refresh = spyOn(db, "kickServerModelConfigRefresh").mockImplementation(() => {});
+  const config = spyOn(db, "getCachedServerModelConfigRow").mockReturnValue({ preferSurplus: true } as ReturnType<typeof db.getCachedServerModelConfigRow>);
+  const key = spyOn(keys, "resolveProviderKey").mockImplementation(provider => provider === "surplus" ? "synthetic-server-surplus" : null);
+  const runnable = spyOn(credentials, "modelHasRunnableCredentials").mockReturnValue(options.directKey === true);
+  const attempts: surplusAttempt.SurplusChatAttemptInput[] = [];
+  const marketplace = spyOn(surplusAttempt, "invokeSurplusChatAttempt").mockImplementation(async input => {
+    attempts.push(input);
+    await input.assertStillAuthorized?.();
+    return options.failure
+      ? { kind: "direct_fallback", failure: options.failure, ...(options.retryUnpinned ? { retryUnpinned: true } : {}) }
+      : { kind: "served", response: reply };
+  });
+  const direct = spyOn(universal, "createUniversalModel").mockImplementation(async () => {
+    const bound = { invoke: async () => reply };
+    return { ...bound, bindTools: () => bound } as Awaited<ReturnType<typeof universal.createUniversalModel>>;
+  });
+  restore.push(...[retained, refresh, config, key, runnable, marketplace, direct].map(mock => () => mock.mockRestore()));
+  const rechecks: (string | undefined)[] = [];
+  const admissions: (string | undefined)[] = [];
+  const session: ForegroundChatFundingSession = {
+    kind: options.personal ? "personal" : "server",
+    ...(options.allowBroadening !== false ? { allowUnpinnedSurplusRetry: true as const } : {}),
+    async recheckAttempt(_model, transport) {
+      rechecks.push(transport);
+      if (options.recheckError) throw options.recheckError;
+    },
+    async runAttempt(_model, run, transport) {
+      admissions.push(transport);
+      if (transport === "direct" && !options.directKey) {
+        throw Object.assign(new Error("No direct credential"), { code: "provider_credentials_missing" });
+      }
+      return run(options.personal ? {
+        usageFunding: { kind: "personal", providerRoute: "surplus", humanUserId: "human", payerHumanId: "human", credentialId: "credential", credentialRevision: 1 },
+        personalCredential: { apiKey: "synthetic-personal-surplus" },
+      } : { usageFunding: { kind: "server", humanUserId: "human", providerRoute: transport === "direct" ? "openrouter" : "surplus" } });
+    },
+    ...(!options.noPersonalRecovery ? {
+      async openPersonalRecovery() { throw options.recoveryError ?? new PersonalDirectFundingUnavailableError(); },
+    } : {}),
+  };
+  const invoke = (
+    model = MODEL,
+    maxOutputTokens?: number,
+    messages: BaseMessage[] = [new HumanMessage("Synthetic routing check")],
+    tools: StructuredTool[] = [],
+  ) => invokeChatModelWithFallback(
+    messages, tools, model, "", null, "synthetic-route", {},
+    { fundingSession: session, modelFallbackMode: "none", sameModelRetryMode: "none", ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }) },
+  );
+  return { attempts, direct, invoke, rechecks, admissions };
+}
+
+describe("Surplus chat request envelope and recovery", () => {
+  test("ordinary Surplus-only server chat starts with any seller and the qualified output budget", async () => {
+    const h = harness();
+    expect((await h.invoke()).response).toBe(reply);
+    expect(h.attempts).toHaveLength(1);
+    expect(h.attempts[0]).toMatchObject({ providerMode: "any", maxOutputTokens: 64_000, funding: { kind: "server", providerRoute: "surplus" } });
+    expect(h.rechecks).toEqual(["surplus"]);
+    expect(h.direct).not.toHaveBeenCalled();
+  });
+
+  test("an explicit smaller request budget remains smaller", async () => {
+    const h = harness();
+    await h.invoke(MODEL, 1_024);
+    expect(h.attempts[0]?.maxOutputTokens).toBe(1_024);
+  });
+
+  test("uses Kimi's discovered marketplace output limit instead of its signed direct limit", async () => {
+    const signed = getActiveModelCatalogSync().catalog.entries.find((entry) => entry.id === KIMI_MODEL);
+    expect(signed?.limits?.outputTokens).toBe(1_048_576);
+    const h = harness();
+    await h.invoke(KIMI_MODEL);
+    expect(h.attempts[0]?.route).toMatchObject({
+      catalogModelId: KIMI_MODEL,
+      maxOutputTokens: 131_072,
+    });
+    expect(h.attempts[0]?.maxOutputTokens).toBe(131_072);
+  });
+
+  test("clamps marketplace output to discovered context after messages, tools, and safety margin", async () => {
+    const contextTokens = 6_000;
+    await installKimiDiscovery(contextTokens, 131_072);
+    const messages = [new HumanMessage("Context-sensitive marketplace request")];
+    const tool = new DynamicStructuredTool({
+      name: "catalog_probe",
+      description: "Read a bounded catalog record. ".repeat(40),
+      schema: z.object({ recordId: z.string(), includeDetails: z.boolean().optional() }),
+      func: async () => "unused",
+    });
+    const h = harness();
+    await h.invoke(KIMI_MODEL, undefined, messages, [tool]);
+    const attempt = h.attempts[0];
+    if (!attempt) throw new Error("expected a marketplace attempt");
+    const estimatedInput = estimateTokenCount(attempt.messages) + estimateBoundToolTokens([tool]);
+    expect(attempt.route.maxContextTokens).toBe(contextTokens);
+    expect(attempt.maxOutputTokens).toBe(contextTokens - estimatedInput - 4_096);
+  });
+
+  test.each([0, -1])("rejects a marketplace request with %d remaining output tokens before the wire", async (remaining) => {
+    const messages = [new HumanMessage("abcd")];
+    const estimatedInput = estimateTokenCount(messages);
+    await installKimiDiscovery(estimatedInput + 4_096 + remaining, 131_072);
+    const h = harness();
+    await Promise.resolve(expect(h.invoke(KIMI_MODEL, undefined, messages)).rejects.toBeInstanceOf(Error));
+    expect(h.attempts).toHaveLength(0);
+  });
+
+  test("implicit reasoning visibility does not require an unadvertised effort knob", async () => {
+    const signed = getActiveModelCatalogSync().catalog.entries.find((entry) => entry.id === KIMI_MODEL);
+    expect(signed && "controls" in signed && signed.controls?.reasoning).toBeFalsy();
+    await installKimiDiscovery(1_000_000, 131_072, false);
+    const h = harness();
+    expect((await h.invoke(KIMI_MODEL)).response).toBe(reply);
+    expect(h.attempts).toHaveLength(1);
+    expect(h.attempts[0]?.route.supportsReasoning).toBe(false);
+    expect(h.attempts[0]?.reasoningEffort).toBeUndefined();
+    expect(h.direct).not.toHaveBeenCalled();
+  });
+
+  test("a matching server direct credential retains the pinned first attempt", async () => {
+    const h = harness({ directKey: true });
+    await h.invoke();
+    expect(h.attempts[0]?.providerMode).toBeUndefined();
+    expect(h.rechecks).toEqual([]);
+  });
+
+  test("a protected operation cannot broaden its seller selection", async () => {
+    const h = harness({ allowBroadening: false });
+    await h.invoke();
+    expect(h.attempts[0]?.providerMode).toBeUndefined();
+  });
+
+  test("provider-bound privacy models retain their seller pin", async () => {
+    const h = harness();
+    await h.invoke("venice:claude-sonnet-4-6");
+    expect(h.attempts[0]?.providerMode).toBeUndefined();
+    expect(h.attempts[0]?.route.providerPin).toBe("venice");
+  });
+
+  test("personal routing does not infer the payer's direct keys from the server environment", async () => {
+    const h = harness({ personal: true });
+    await h.invoke();
+    expect(h.attempts[0]).toMatchObject({ apiKey: "synthetic-personal-surplus", funding: { kind: "personal" } });
+    expect(h.attempts[0]?.providerMode).toBeUndefined();
+  });
+
+  test.each([false, true])("unavailable optional recovery preserves the original failure (no personal recovery=%s)", async noPersonalRecovery => {
+    const original = Object.assign(new Error("Surplus could not serve the model"), { code: "no_healthy_sellers", status: 503 });
+    const h = harness({ failure: original, noPersonalRecovery, retryUnpinned: true });
+    expect(await h.invoke().catch((error: unknown) => error)).toBe(original);
+    expect(h.attempts).toHaveLength(1);
+    expect(h.direct).not.toHaveBeenCalled();
+    expect(h.admissions).toEqual([undefined, "direct"]);
+  });
+
+  test.each([
+    "personal_credentials_disabled", "personal_credentials_forbidden", "server_credentials_forbidden",
+    "funding_source_changed", "personal_credential_stale", "personal_credential_unavailable", "credential_custody_unavailable",
+  ])("%s during recovery remains terminal", async code => {
+    const denied = Object.assign(new Error(code), { code });
+    const h = harness({ failure: new Error("Marketplace unavailable"), recoveryError: denied });
+    expect(await h.invoke().catch((error: unknown) => error)).toBe(denied);
+    expect(h.direct).not.toHaveBeenCalled();
+  });
+
+  test("an absent server-first personal recovery key retains the marketplace failure", async () => {
+    const original = Object.assign(new Error("Surplus unavailable"), { status: 503 });
+    const missing = Object.assign(new Error("No personal credential"), { code: "personal_credential_missing" });
+    const h = harness({ failure: original, recoveryError: missing });
+    expect(await h.invoke().catch((error: unknown) => error)).toBe(original);
+    expect(h.direct).not.toHaveBeenCalled();
+  });
+
+  test("post-admission funding recheck failure prevents provider dispatch and recovery", async () => {
+    const denied = new Error("Funding permission changed");
+    const h = harness({ recheckError: denied });
+    expect(await h.invoke().catch((error: unknown) => error)).toBe(denied);
+    expect(h.admissions).toEqual([undefined]);
+    expect(h.direct).not.toHaveBeenCalled();
+  });
+
+  test("revoked seller-broadening authority prevents provider dispatch and recovery", async () => {
+    const h = harness();
+    let checks = 0;
+    const broadening = spyOn(surplusRoutes, "canBroadenSurplusModelRoute").mockImplementation(() => ++checks <= 2);
+    restore.push(() => broadening.mockRestore());
+    const error = await h.invoke().catch((error: unknown) => error);
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toContain("seller broadening is no longer authorized");
+    expect(h.direct).not.toHaveBeenCalled();
+  });
+
+  test("Surplus-specific output limits do not lower a direct recovery budget", async () => {
+    const h = harness({ directKey: true, allowBroadening: false, failure: new Error("Surplus unavailable") });
+    expect((await h.invoke()).response).toBe(reply);
+    expect(h.attempts[0]?.maxOutputTokens).toBe(64_000);
+    expect(h.direct).toHaveBeenCalledWith(MODEL, expect.objectContaining({ maxTokens: 128_000 }));
+  });
+
+  test("a direct provider failure cannot masquerade as an absent recovery key", async () => {
+    const h = harness({ directKey: true, failure: new Error("Marketplace failed") });
+    const providerFailure = Object.assign(new Error("Direct provider rejected the request"), { code: "personal_credential_missing" });
+    h.direct.mockImplementation(async () => {
+      const bound = { invoke: async () => { throw providerFailure; } };
+      return { ...bound, bindTools: () => bound } as Awaited<ReturnType<typeof universal.createUniversalModel>>;
+    });
+    expect(await h.invoke().catch((error: unknown) => error)).toBe(providerFailure);
+  });
+});
diff --git a/packages/agent/tests/unit/surplus-discovered-parameters.test.ts b/packages/agent/tests/unit/surplus-discovered-parameters.test.ts
new file mode 100644
index 000000000..8f37e8439
--- /dev/null
+++ b/packages/agent/tests/unit/surplus-discovered-parameters.test.ts
@@ -0,0 +1,214 @@
+import { describe, expect, test } from "bun:test";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import type { ReasoningEffort } from "../../src/providers/types";
+import type { QualifiedSurplusChatRoute } from "../../src/providers/surplus-route";
+import { createSurplusChatModel } from "../../src/providers/surplus-transport";
+
+interface CapturedRequest {
+  readonly body: Record<string, unknown>;
+  readonly calls: number;
+}
+
+function route(input: {
+  catalogModelId: string;
+  surplusModelId: string;
+  providerPin: QualifiedSurplusChatRoute["providerPin"];
+  supportedParameters?: readonly string[];
+}): QualifiedSurplusChatRoute {
+  return {
+    ...input,
+    supportsTools: true,
+    supportsVision: false,
+    supportsReasoning: true,
+    maxContextTokens: 100_000,
+    maxOutputTokens: 8_000,
+  };
+}
+
+async function captureRequest(input: {
+  route: QualifiedSurplusChatRoute;
+  reasoningEffort?: ReasoningEffort;
+  reasoningOutput?: boolean;
+  maxOutputTokens?: number;
+}): Promise<CapturedRequest> {
+  let calls = 0;
+  let body: Record<string, unknown> | undefined;
+  const fetchImpl = (async (request: string | URL | Request, init?: RequestInit) => {
+    calls += 1;
+    const rawBody = init?.body
+      ?? (request instanceof Request ? await request.clone().text() : undefined);
+    if (typeof rawBody !== "string") throw new Error("Missing Surplus request body");
+    body = JSON.parse(rawBody) as Record<string, unknown>;
+    const chunk = {
+      id: "chatcmpl-surplus-parameters",
+      object: "chat.completion.chunk",
+      created: 1,
+      model: input.route.surplusModelId,
+      choices: [{
+        index: 0,
+        delta: { role: "assistant", content: "OK" },
+        finish_reason: "stop",
+      }],
+    };
+    return new Response(`data: ${JSON.stringify(chunk)}\n\ndata: [DONE]\n\n`, {
+      headers: { "content-type": "text/event-stream" },
+    });
+  }) as typeof fetch;
+  const model = createSurplusChatModel({
+    route: input.route,
+    apiKey: "synthetic-key",
+    maxOutputTokens: input.maxOutputTokens ?? 321,
+    ...(input.reasoningEffort === undefined
+      ? {}
+      : { reasoningEffort: input.reasoningEffort }),
+    ...(input.reasoningOutput === undefined
+      ? {}
+      : { reasoningOutput: input.reasoningOutput }),
+    onResponse: () => {},
+    fetchImpl,
+  });
+
+  const response = await model.invoke([new HumanMessage("Reply OK")]) as AIMessage;
+  expect(response.content).toBe("OK");
+  if (!body) throw new Error("Surplus request was not captured");
+  return { body, calls };
+}
+
+describe("Surplus discovered parameter projection", () => {
+  test("converts Venice's reviewed flat effort to the discovered nested spelling", async () => {
+    const qualifiedRoute = route({
+      catalogModelId: "venice:minimax-m3-preview",
+      surplusModelId: "minimax-m3-preview",
+      providerPin: "venice",
+      supportedParameters: ["max_tokens", "reasoning"],
+    });
+
+    const captured = await captureRequest({
+      route: qualifiedRoute,
+      reasoningEffort: "medium",
+    });
+
+    expect(captured.calls).toBe(1);
+    expect(captured.body["model"]).toBe("minimax-m3-preview");
+    expect(captured.body["reasoning"]).toEqual({ effort: "medium" });
+    expect(captured.body).not.toHaveProperty("reasoning_effort");
+    expect(captured.body).not.toHaveProperty("include_reasoning");
+  });
+
+  test("converts reviewed nested effort to the discovered flat spelling", async () => {
+    const qualifiedRoute = route({
+      catalogModelId: "openrouter:openai/gpt-6-sol",
+      surplusModelId: "openai/gpt-6-sol",
+      providerPin: "openrouter",
+      supportedParameters: ["max_tokens", "reasoning_effort"],
+    });
+
+    const captured = await captureRequest({
+      route: qualifiedRoute,
+      reasoningEffort: "high",
+    });
+
+    expect(captured.body["model"]).toBe("openai/gpt-6-sol");
+    expect(captured.body["max_tokens"]).toBe(321);
+    expect(captured.body["reasoning_effort"]).toBe("high");
+    expect(captured.body).not.toHaveProperty("max_completion_tokens");
+    expect(captured.body).not.toHaveProperty("reasoning");
+    expect(captured.body).not.toHaveProperty("include_reasoning");
+  });
+
+  test("converts reviewed nested disabled reasoning to flat none", async () => {
+    const qualifiedRoute = route({
+      catalogModelId: "openrouter:openai/gpt-6-sol",
+      surplusModelId: "openai/gpt-6-sol",
+      providerPin: "openrouter",
+      supportedParameters: ["max_tokens", "reasoning_effort"],
+    });
+
+    const captured = await captureRequest({
+      route: qualifiedRoute,
+      reasoningEffort: "off",
+    });
+
+    expect(captured.body["reasoning_effort"]).toBe("none");
+    expect(captured.body).not.toHaveProperty("reasoning");
+  });
+
+  test("preserves the factory-reviewed spelling when both knobs are advertised", async () => {
+    const openRouter = await captureRequest({
+      route: route({
+        catalogModelId: "openrouter:openai/gpt-6-sol",
+        surplusModelId: "openai/gpt-6-sol",
+        providerPin: "openrouter",
+        supportedParameters: ["max_tokens", "reasoning", "reasoning_effort"],
+      }),
+      reasoningEffort: "high",
+    });
+    const venice = await captureRequest({
+      route: route({
+        catalogModelId: "venice:minimax-m3-preview",
+        surplusModelId: "minimax-m3-preview",
+        providerPin: "venice",
+        supportedParameters: ["max_tokens", "reasoning", "reasoning_effort"],
+      }),
+      reasoningEffort: "medium",
+    });
+
+    expect(openRouter.body["reasoning"]).toEqual({ effort: "high", exclude: false });
+    expect(openRouter.body).not.toHaveProperty("reasoning_effort");
+    expect(venice.body["reasoning_effort"]).toBe("medium");
+    expect(venice.body).not.toHaveProperty("reasoning");
+  });
+
+  test("rejects an explicit effort before the wire when no reasoning knob is advertised", () => {
+    let calls = 0;
+    expect(() => createSurplusChatModel({
+      route: route({
+        catalogModelId: "venice:minimax-m3-preview",
+        surplusModelId: "minimax-m3-preview",
+        providerPin: "venice",
+        supportedParameters: ["max_tokens", "include_reasoning"],
+      }),
+      apiKey: "synthetic-key",
+      maxOutputTokens: 321,
+      reasoningEffort: "medium",
+      onResponse: () => {},
+      fetchImpl: (async () => {
+        calls += 1;
+        throw new Error("fetch must not run");
+      }) as unknown as typeof fetch,
+    })).toThrow("does not advertise a reasoning control");
+    expect(calls).toBe(0);
+  });
+
+  test("omits an implicit default when no reasoning knob is advertised", async () => {
+    const captured = await captureRequest({
+      route: route({
+        catalogModelId: "openrouter:openai/gpt-6-sol",
+        surplusModelId: "openai/gpt-6-sol",
+        providerPin: "openrouter",
+        supportedParameters: ["max_tokens", "include_reasoning"],
+      }),
+      reasoningOutput: true,
+      maxOutputTokens: 4_096,
+    });
+
+    expect(captured.body["max_tokens"]).toBe(4_096);
+    expect(captured.body).not.toHaveProperty("reasoning");
+    expect(captured.body).not.toHaveProperty("reasoning_effort");
+    expect(captured.body).not.toHaveProperty("include_reasoning");
+  });
+
+  test("preserves the offline injected-route reasoning seam when discovery is absent", async () => {
+    const captured = await captureRequest({
+      route: route({
+        catalogModelId: "venice:minimax-m3-preview",
+        surplusModelId: "minimax-m3-preview",
+        providerPin: "venice",
+      }),
+      reasoningEffort: "medium",
+    });
+
+    expect(captured.body["reasoning_effort"]).toBe("medium");
+    expect(captured.body).not.toHaveProperty("reasoning");
+  });
+});
diff --git a/packages/agent/tests/unit/surplus-embedding-attempt.test.ts b/packages/agent/tests/unit/surplus-embedding-attempt.test.ts
new file mode 100644
index 000000000..61151a7b0
--- /dev/null
+++ b/packages/agent/tests/unit/surplus-embedding-attempt.test.ts
@@ -0,0 +1,284 @@
+import { describe, expect, test } from "bun:test";
+import { getQualifiedSurplusEmbeddingRoute } from "../../src/providers/surplus-embedding-route";
+import {
+  invokeSurplusEmbeddingAttempt,
+  SurplusEmbeddingAttemptError,
+} from "../../src/usage/surplus-embedding-attempt";
+
+const route = getQualifiedSurplusEmbeddingRoute("venice:text-embedding-3-large", 1_536)!;
+
+function response(options: {
+  status?: number;
+  cost?: number;
+  requestId?: string;
+  provider?: string;
+  adapted?: string;
+  data?: Array<{ index: number; embedding: number[] }>;
+} = {}): Response {
+  const headers = new Headers();
+  headers.set("x-request-id", options.requestId ?? "embedding-request-1");
+  headers.set("x-si-provider-family", options.provider ?? "mordiem");
+  if (options.cost !== undefined) headers.set("x-si-buyer-cost-micro", String(options.cost));
+  if (options.adapted !== undefined) headers.set("x-si-adapted-params", options.adapted);
+  return Response.json({
+    model: "text-embedding-3-large",
+    data: options.data ?? [{ index: 0, embedding: [1, 2, 3] }],
+    usage: { prompt_tokens: 4, total_tokens: 4 },
+  }, { status: options.status ?? 200, headers });
+}
+
+function deps(events: string[], settlements: unknown[]) {
+  return {
+    mintAttemptId: () => "11111111-1111-4111-8111-111111111111",
+    begin: async (input: unknown) => { events.push("begin"); expect(input).toMatchObject({
+      model: "venice:text-embedding-3-large",
+      provider: "venice",
+      endpoint: "/v1/embeddings",
+      fundingKind: "service",
+      callType: "embedding",
+      metadata: {
+        surplusEmbeddingPolicy: "surplus-embedding-marketplace-v1",
+        surplusEmbeddingReceiptModel: "venice-embed-1",
+        surplusEmbeddingServingProviders: ["mordiem", "venice"],
+      },
+    }); },
+    attach: async (input: unknown) => { events.push("attach"); expect(input).toMatchObject({
+      providerRequestId: "embedding-request-1",
+      servingProvider: "mordiem",
+      endpoint: "/v1/embeddings",
+    }); },
+    settle: async (input: unknown) => { events.push("settle"); settlements.push(input); },
+  };
+}
+
+describe("Surplus embedding durable attempt", () => {
+  test("begins before one wire and persists an explicit zero-cost receipt", async () => {
+    const events: string[] = [];
+    const settlements: unknown[] = [];
+    let requests = 0;
+    const result = await invokeSurplusEmbeddingAttempt({
+      route,
+      apiKey: "surplus-key",
+      texts: ["private memory"],
+      assertStillAuthorized: () => { events.push("authorize"); },
+      fetchImpl: (async (input, init) => {
+        requests++;
+        events.push("fetch");
+        expect(input).toBe("https://api.surplusintelligence.ai/v1/embeddings");
+        expect(init?.redirect).toBe("error");
+        if (typeof init?.body !== "string") throw new Error("Expected JSON request body");
+        expect(JSON.parse(init.body)).toEqual({
+          model: "text-embedding-3-large",
+          input: ["private memory"],
+          dimensions: 1_536,
+        });
+        return response({ cost: 0 });
+      }) as typeof fetch,
+      parseResponse: (value) => value,
+    }, deps(events, settlements));
+    expect(result).toMatchObject({ model: "text-embedding-3-large" });
+    expect(requests).toBe(1);
+    expect(events).toEqual(["begin", "authorize", "fetch", "attach", "settle"]);
+    expect(settlements).toHaveLength(1);
+    expect(settlements[0]).toMatchObject({
+      outcome: "succeeded",
+      costState: "actual",
+      actualCostUsd: 0,
+      inputTokens: 4,
+      totalTokens: 4,
+      servingProvider: "mordiem",
+    });
+  });
+
+  test("accepts the qualified live response shape with the observed safe_mode adaptation", async () => {
+    const vector = Array.from({ length: 1_536 }, (_, index) => index / 1_536);
+    const result = await invokeSurplusEmbeddingAttempt({
+      route,
+      apiKey: "surplus-key",
+      texts: ["first", "second"],
+      assertStillAuthorized: () => {},
+      fetchImpl: (async () => response({
+        provider: "Mordiem",
+        adapted: "safe_mode",
+        cost: 0,
+        data: [
+          { index: 0, embedding: vector },
+          { index: 1, embedding: [...vector] },
+        ],
+      })) as unknown as typeof fetch,
+      parseResponse: (value) => {
+        const fixture = value as {
+          model: unknown;
+          data: Array<{ index: number; embedding: number[] }>;
+        };
+        expect(fixture.model).toBe("text-embedding-3-large");
+        expect(fixture.data.map((entry) => entry.index)).toEqual([0, 1]);
+        expect(fixture.data.every((entry) => entry.embedding.length === 1_536)).toBe(true);
+        return fixture.data.map((entry) => entry.embedding);
+      },
+    }, deps([], []));
+    expect(result).toHaveLength(2);
+  });
+
+  test("leaves an identified receipt pending when the response omits cost", async () => {
+    const settlements: unknown[] = [];
+    await invokeSurplusEmbeddingAttempt({
+      route, apiKey: "surplus-key", texts: ["x"], assertStillAuthorized: () => {},
+      fetchImpl: (async () => response()) as unknown as typeof fetch,
+      parseResponse: () => [1, 2, 3],
+    }, deps([], settlements));
+    expect(settlements[0]).toMatchObject({ costState: "pending", outcome: "succeeded" });
+  });
+
+  test("does not send a wire when durable begin or the current authorization fails", async () => {
+    for (const failure of ["begin", "authorization"] as const) {
+      let requests = 0;
+      const settlements: unknown[] = [];
+      const dependencies = deps([], settlements);
+      if (failure === "begin") dependencies.begin = async () => { throw new Error("db unavailable"); };
+      const error = await invokeSurplusEmbeddingAttempt({
+        route, apiKey: "surplus-key", texts: ["x"],
+        assertStillAuthorized: () => {
+          if (failure === "authorization") throw new Error("policy changed");
+        },
+        fetchImpl: (async () => { requests++; return response(); }) as unknown as typeof fetch,
+        parseResponse: () => [1, 2, 3],
+      }, dependencies).catch((caught: unknown) => caught);
+      expect(requests).toBe(0);
+      if (failure === "begin") expect(error).toBeInstanceOf(SurplusEmbeddingAttemptError);
+      else {
+        expect(error).toMatchObject({ message: "policy changed" });
+        expect(settlements).toHaveLength(1);
+        expect(settlements[0]).toMatchObject({
+          outcome: "failed",
+          costState: "actual",
+          actualCostUsd: 0,
+          failureCode: "pre_wire_authorization_changed",
+        });
+        expect(settlements[0]).not.toHaveProperty("providerRequestId");
+      }
+    }
+  });
+
+  test("never repeats a paid wire when completed settlement fails", async () => {
+    let requests = 0;
+    let settlements = 0;
+    const result = await invokeSurplusEmbeddingAttempt({
+      route, apiKey: "surplus-key", texts: ["x"], assertStillAuthorized: () => {},
+      fetchImpl: (async () => { requests++; return response({ cost: 2 }); }) as unknown as typeof fetch,
+      parseResponse: () => "accepted",
+    }, {
+      ...deps([], []),
+      settle: async () => { settlements++; throw new Error("write lost"); },
+    });
+    expect(result).toBe("accepted");
+    expect(requests).toBe(1);
+    expect(settlements).toBe(2);
+  });
+
+  test("surfaces one intermittent-supply failure and records its zero-cost receipt", async () => {
+    let requests = 0;
+    const settlements: unknown[] = [];
+    const error = await invokeSurplusEmbeddingAttempt({
+      route, apiKey: "surplus-key", texts: ["x"], assertStillAuthorized: () => {},
+      fetchImpl: (async () => { requests++; return response({ status: 503, cost: 0 }); }) as unknown as typeof fetch,
+      parseResponse: () => { throw new Error("must not parse"); },
+    }, deps([], settlements)).catch((caught: unknown) => caught);
+    expect(requests).toBe(1);
+    expect(error).toMatchObject({
+      name: "SurplusEmbeddingAttemptError",
+      failureCode: "provider_unavailable",
+      status: 503,
+      retryable: true,
+    });
+    expect(settlements[0]).toMatchObject({
+      outcome: "failed", costState: "actual", actualCostUsd: 0,
+      failureCode: "provider_unavailable",
+    });
+  });
+
+  test("keeps a documented zero-attempt routing trace out of financial receipt recovery", async () => {
+    const events: string[] = [];
+    const settlements: unknown[] = [];
+    const traceId = "trace-no-healthy-1";
+    const error = await invokeSurplusEmbeddingAttempt({
+      route, apiKey: "surplus-key", texts: ["x"], assertStillAuthorized: () => {},
+      fetchImpl: (async () => Response.json({
+        error: { code: "no_healthy_sellers", message: "discarded" },
+        request_id: traceId,
+      }, {
+        status: 503,
+        headers: {
+          "x-request-id": traceId,
+          "x-si-marketplace-attempts": "0",
+        },
+      })) as unknown as typeof fetch,
+      parseResponse: () => { throw new Error("must not parse"); },
+    }, deps(events, settlements)).catch((caught: unknown) => caught);
+
+    expect(error).toMatchObject({
+      name: "SurplusEmbeddingAttemptError",
+      failureCode: "provider_unavailable",
+      vendorCode: "no_healthy_sellers",
+    });
+    expect(events).not.toContain("attach");
+    expect(settlements[0]).toMatchObject({
+      outcome: "failed",
+      costState: "actual",
+      actualCostUsd: 0,
+      failureCode: "provider_unavailable",
+      metadata: {
+        surplusErrorCode: "no_healthy_sellers",
+        surplusResponseStatus: 503,
+        surplusTraceId: traceId,
+        surplusMarketplaceAttempts: 0,
+      },
+    });
+    expect(settlements[0]).not.toHaveProperty("providerRequestId");
+  });
+
+  test("fails closed on an unqualified response adaptation without replay", async () => {
+    let requests = 0;
+    let parsed = false;
+    const settlements: unknown[] = [];
+    const error = await invokeSurplusEmbeddingAttempt({
+      route, apiKey: "surplus-key", texts: ["x"], assertStillAuthorized: () => {},
+      fetchImpl: (async () => {
+        requests++;
+        return response({ adapted: "safe_mode,dimensions", cost: 0 });
+      }) as unknown as typeof fetch,
+      parseResponse: () => { parsed = true; },
+    }, deps([], settlements)).catch((caught: unknown) => caught);
+    expect(requests).toBe(1);
+    expect(parsed).toBe(false);
+    expect(error).toBeInstanceOf(SurplusEmbeddingAttemptError);
+    expect(settlements[0]).toMatchObject({ outcome: "failed", costState: "actual" });
+  });
+
+  test("classifies cancellation and an uncertain transport failure without replay", async () => {
+    for (const cancelled of [true, false]) {
+      let requests = 0;
+      const settlements: unknown[] = [];
+      const controller = new AbortController();
+      if (cancelled) controller.abort(new Error("cancelled by caller"));
+      const error = await invokeSurplusEmbeddingAttempt({
+        route,
+        apiKey: "surplus-key",
+        texts: ["x"],
+        signal: controller.signal,
+        assertStillAuthorized: () => {},
+        fetchImpl: (async () => {
+          requests++;
+          throw new Error("connection lost");
+        }) as unknown as typeof fetch,
+        parseResponse: () => { throw new Error("must not parse"); },
+      }, deps([], settlements)).catch((caught: unknown) => caught);
+      expect(requests).toBe(cancelled ? 0 : 1);
+      expect(error).toBeInstanceOf(Error);
+      expect(settlements[0]).toMatchObject(cancelled
+        ? { outcome: "cancelled", costState: "actual", actualCostUsd: 0,
+            failureCode: "cancelled" }
+        : { outcome: "unknown", costState: "unknown", failureCode: "outcome_unknown" });
+    }
+  });
+});
diff --git a/packages/agent/tests/unit/surplus-embedding-route.test.ts b/packages/agent/tests/unit/surplus-embedding-route.test.ts
new file mode 100644
index 000000000..4f352c7c2
--- /dev/null
+++ b/packages/agent/tests/unit/surplus-embedding-route.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import {
+  assertQualifiedSurplusEmbeddingReceipt,
+  assertQualifiedSurplusEmbeddingResponseModel,
+  getQualifiedSurplusEmbeddingRoute,
+  QUALIFIED_SURPLUS_EMBEDDING_CATALOG_MODEL_ID,
+  SurplusEmbeddingReceiptError,
+} from "../../src/providers/surplus-embedding-route";
+
+describe("qualified Surplus embedding route", () => {
+  test("admits only the explicit Venice large 1536-dimensional space", () => {
+    expect(QUALIFIED_SURPLUS_EMBEDDING_CATALOG_MODEL_ID)
+      .toBe("venice:text-embedding-3-large");
+    const route = getQualifiedSurplusEmbeddingRoute("venice:text-embedding-3-large", 1_536);
+    expect(route).toMatchObject({
+      provider: "venice",
+      model: "text-embedding-3-large",
+      wireModel: "text-embedding-3-large",
+      responseModel: "text-embedding-3-large",
+      receiptModel: "venice-embed-1",
+      servingPolicy: "surplus-embedding-marketplace-v1",
+      knownServingProviders: ["mordiem", "venice"],
+    });
+    expect(Object.isFrozen(route)).toBe(true);
+    expect(getQualifiedSurplusEmbeddingRoute("venice:text-embedding-3-small", 1_536)).toBeNull();
+    expect(getQualifiedSurplusEmbeddingRoute("openai:text-embedding-3-large", 1_536)).toBeNull();
+    expect(getQualifiedSurplusEmbeddingRoute("venice:text-embedding-3-large", 3_072)).toBeNull();
+  });
+
+  test("accepts only known serving families and the qualified compatibility adaptation", () => {
+    const route = getQualifiedSurplusEmbeddingRoute("venice:text-embedding-3-large", 1_536)!;
+    expect(() => assertQualifiedSurplusEmbeddingReceipt(route, {
+      providerFamily: "Mordiem",
+      buyerCostMicro: 0,
+      truncated: false,
+    }, 200)).not.toThrow();
+    expect(() => assertQualifiedSurplusEmbeddingReceipt(route, {
+      providerFamily: "venice",
+      adaptedParameters: " safe_mode ",
+      truncated: false,
+    }, 200)).not.toThrow();
+    for (const receipt of [
+      { providerFamily: "unknown", truncated: false },
+      { providerFamily: "mordiem", adaptedParameters: "safe_mode,safe_mode", truncated: false },
+      { providerFamily: "mordiem", adaptedParameters: "dimensions", truncated: false },
+      { providerFamily: "mordiem", adaptedParameters: "safe_mode,dimensions", truncated: false },
+      { providerFamily: "venice", truncated: true },
+    ]) {
+      expect(() => assertQualifiedSurplusEmbeddingReceipt(route, receipt, 200))
+        .toThrow(SurplusEmbeddingReceiptError);
+    }
+  });
+
+  test("requires the qualified response model alias", () => {
+    const route = getQualifiedSurplusEmbeddingRoute("venice:text-embedding-3-large", 1_536)!;
+    expect(() => assertQualifiedSurplusEmbeddingResponseModel(route, {
+      model: "text-embedding-3-large",
+    })).not.toThrow();
+    expect(() => assertQualifiedSurplusEmbeddingResponseModel(route, { model: "3-large" }))
+      .toThrow(SurplusEmbeddingReceiptError);
+  });
+});
diff --git a/packages/agent/tests/unit/surplus-foreground-model-selection.test.ts b/packages/agent/tests/unit/surplus-foreground-model-selection.test.ts
index 70b601c4b..8ef747a6e 100644
--- a/packages/agent/tests/unit/surplus-foreground-model-selection.test.ts
+++ b/packages/agent/tests/unit/surplus-foreground-model-selection.test.ts
@@ -1,8 +1,14 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { buildForegroundModelControlPlan } from "../../src/config/foreground-model-controls";
 import { resolveModelRole } from "../../src/config/model-role-resolution";
 import { resolveForegroundAgentModelId } from "../../src/nodes/agent";
 
+import { installSurplusCatalogFixture } from "../helpers/surplus-catalog-fixture";
+import { resetSurplusModelCatalog } from "../../src/providers/surplus-catalog";
+
+beforeEach(installSurplusCatalogFixture);
+afterEach(resetSurplusModelCatalog);
+
 const MODEL_ID = "openrouter:openai/gpt-5.6-sol";
 const ROUTE = {
   catalogModelId: MODEL_ID,
@@ -23,6 +29,25 @@ const surplusOnly = {
 };
 
 describe("foreground agent model selection", () => {
+  test("automatic foreground chat can select a qualified server Surplus route", () => {
+    const automaticRoute = {
+      ...ROUTE,
+      catalogModelId: "openrouter:minimax/minimax-m3",
+      surplusModelId: "minimax/minimax-m3",
+      maxContextTokens: 1_000,
+      maxOutputTokens: 100,
+    };
+    const automatic = { ...surplusOnly, routes: [automaticRoute] };
+    expect(resolveForegroundAgentModelId(undefined, automatic)).toBe(automaticRoute.catalogModelId);
+    expect(() => resolveForegroundAgentModelId(undefined, { ...automatic, policyEnabled: false })).toThrow();
+    expect(() => resolveForegroundAgentModelId(undefined, { ...automatic, keyConfigured: false })).toThrow();
+    expect(() => resolveForegroundAgentModelId(undefined, { ...automatic, routes: [] })).toThrow();
+    expect(() => resolveForegroundAgentModelId(undefined, {
+      ...automatic,
+      routes: [{ ...automaticRoute, supportsTools: false }],
+    })).toThrow();
+  });
+
   test("a selected foreground model reaches the agent node without a direct credential", () => {
     const plan = buildForegroundModelControlPlan(
       { modelId: MODEL_ID },
diff --git a/packages/agent/tests/unit/surplus-reconciliation.test.ts b/packages/agent/tests/unit/surplus-reconciliation.test.ts
index 89cc58569..0b3c31677 100644
--- a/packages/agent/tests/unit/surplus-reconciliation.test.ts
+++ b/packages/agent/tests/unit/surplus-reconciliation.test.ts
@@ -5,6 +5,11 @@ import {
   surplusCredentialFingerprint,
   surplusReceiptTelemetry,
 } from "../../src/providers/surplus-reconciliation";
+import {
+  provenPreRoutingSurplusTrace,
+  readBoundedSurplusErrorBody,
+  safeSurplusErrorDiagnostics,
+} from "../../src/providers/surplus-error";
 
 const binding = { requestId: "request-1", surplusModelId: "gpt-5.5", providerPin: "venice" };
 const receipt = {
@@ -19,6 +24,38 @@ const receipt = {
 };
 
 describe("Surplus financial receipt boundary", () => {
+  test("retains only bounded stable error diagnostics and proves routing traces narrowly", async () => {
+    expect(safeSurplusErrorDiagnostics({ error: { code: " NO_HEALTHY_SELLERS " } }, 503)).toEqual({
+      vendorCode: "no_healthy_sellers",
+      responseStatus: 503,
+    });
+    expect(safeSurplusErrorDiagnostics({ code: "bad-code!", message: "private" }, 700)).toEqual({});
+    expect(provenPreRoutingSurplusTrace({
+      error: { code: "no_healthy_sellers" },
+      responseStatus: 503,
+      receipt: { requestId: "trace-1", marketplaceAttempts: 0, truncated: false },
+    })).toEqual({ vendorCode: "no_healthy_sellers", responseStatus: 503, traceId: "trace-1" });
+    expect(provenPreRoutingSurplusTrace({
+      error: { code: "no_healthy_sellers" },
+      responseStatus: 503,
+      receipt: { requestId: "request-1", marketplaceAttempts: 1, truncated: false },
+    })).toBeNull();
+    for (const conflicting of [
+      { truncated: true }, { adaptedParameters: "reasoning" }, { buyerCostMicro: 1 },
+    ]) {
+      expect(provenPreRoutingSurplusTrace({
+        error: { code: "no_healthy_sellers" }, responseStatus: 503,
+        receipt: { requestId: "trace-1", marketplaceAttempts: 0, truncated: false, ...conflicting },
+      })).toBeNull();
+    }
+
+    expect(await readBoundedSurplusErrorBody(Response.json({
+      error: { code: "no_sellers_for_model", message: "discarded" },
+      request_id: "trace-body-1",
+      extra: "discarded",
+    }).body?.getReader())).toEqual({ vendorCode: "no_sellers_for_model", requestId: "trace-body-1" });
+  });
+
   test("accepts confirmed charge and explicit zero, rejecting absent or unrelated evidence", () => {
     expect(readConfirmedSurplusSettlement(receipt, binding)).toBe(283);
     expect(readConfirmedSurplusSettlement({ ...receipt, buyer_cost_micro: 0 }, binding)).toBe(0);
diff --git a/packages/agent/tests/unit/surplus-refusal-fallback.test.ts b/packages/agent/tests/unit/surplus-refusal-fallback.test.ts
index 4f8836fdc..b02ff0f73 100644
--- a/packages/agent/tests/unit/surplus-refusal-fallback.test.ts
+++ b/packages/agent/tests/unit/surplus-refusal-fallback.test.ts
@@ -1,9 +1,11 @@
 import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
 import { HumanMessage, type AIMessage } from "@langchain/core/messages";
 import type { ChatGeneration, LLMResult } from "@langchain/core/outputs";
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
+import * as db from "@nautilo/db";
 import {
   classifySurplusFailedAttempt,
+  invokeSurplusChatAttempt,
 } from "../../src/providers/surplus-attempt";
 import {
   createSurplusChatModel,
@@ -162,6 +164,30 @@ describe("Surplus definitive refusal fallback", () => {
       failureCode: "pre_service_refusal",
       directFallback: true,
     });
+
+    expect(classifySurplusFailedAttempt({
+      error: { code: "no_healthy_sellers" },
+      cancelled: false,
+      responseStatus: 503,
+      receipt: BASE_RECEIPT,
+      deliveredOutput: false,
+    })).toMatchObject({ outcome: "failed", directFallback: true });
+    expect(classifySurplusFailedAttempt({
+      error: { code: "no_healthy_sellers" },
+      cancelled: false,
+      responseStatus: 503,
+      receipt: { ...BASE_RECEIPT, marketplaceAttempts: 1 },
+      deliveredOutput: false,
+    })).toMatchObject({ outcome: "unknown", directFallback: true });
+    for (const responseStatus of [401, 402]) {
+      expect(classifySurplusFailedAttempt({
+        error: {},
+        cancelled: false,
+        responseStatus,
+        receipt: BASE_RECEIPT,
+        deliveredOutput: false,
+      })).toMatchObject({ outcome: "failed", directFallback: true });
+    }
   });
 
   test("recognizes the SDK error from a fake documented 404 without inventing zero cost", async () => {
@@ -222,6 +248,256 @@ describe("Surplus definitive refusal fallback", () => {
       deliveredOutput: false,
     })).toMatchObject({ costState: "pending", directFallback: true });
   });
+
+  test("recognizes a fake documented 503 only with explicit zero marketplace attempts", async () => {
+    for (const [attempts, expectedUnavailable] of [[0, true], [1, false]] as const) {
+      let receipt: SurplusWireReceipt | undefined;
+      let status: number | undefined;
+      let fetches = 0;
+      const model = createSurplusChatModel({
+        route: {
+          catalogModelId: "openrouter:minimax/minimax-m3",
+          surplusModelId: "minimax/minimax-m3",
+          providerPin: "openrouter",
+          supportsTools: true,
+          supportsVision: false,
+          supportsReasoning: true,
+          maxContextTokens: 204_800,
+          maxOutputTokens: 131_072,
+        },
+        apiKey: "synthetic-key",
+        maxOutputTokens: 32,
+        onResponse: (next, nextStatus) => {
+          receipt = next;
+          status = nextStatus;
+        },
+        fetchImpl: (async () => {
+          fetches++;
+          return new Response(JSON.stringify({
+            error: {
+              message: "No healthy sellers",
+              type: "service_unavailable",
+              code: "no_healthy_sellers",
+            },
+          }), {
+            status: 503,
+            headers: {
+              "content-type": "application/json",
+              "x-request-id": `request-http-503-${attempts}`,
+              "x-si-marketplace-attempts": String(attempts),
+            },
+          });
+        }) as unknown as typeof fetch,
+      });
+
+      let caught: unknown;
+      try {
+        await model.invoke([new HumanMessage("synthetic")]);
+      } catch (error) {
+        caught = error;
+      }
+
+      expect(fetches).toBe(1);
+      expect(status).toBe(503);
+      const disposition = classifySurplusFailedAttempt({
+        error: caught,
+        cancelled: false,
+        responseStatus: status,
+        receipt,
+        deliveredOutput: false,
+      });
+      expect(disposition.directFallback).toBe(true);
+      expect(isSafeSurplusDirectFallback(caught, status, receipt, false)).toBe(expectedUnavailable);
+    }
+  });
+
+  test("exposes model-supply recovery authority only for real zero-attempt 404/503 refusals", async () => {
+    const beginSpy = spyOn(db, "beginSurplusLlmAttempt").mockResolvedValue(undefined);
+    const attachSpy = spyOn(db, "attachSurplusRequestReceipt").mockResolvedValue(undefined);
+    const settleSpy = spyOn(db, "settleSurplusLlmAttempt").mockResolvedValue(undefined);
+    const fetchSpy = spyOn(globalThis, "fetch");
+    const cases = [
+      [404, "no_sellers_for_model", 0, true, true],
+      [503, "no_healthy_sellers", 0, true, true],
+      [503, "no_healthy_sellers", 1, false, false],
+      [401, "invalid_api_key", 0, false, true],
+      [402, "insufficient_balance", 0, false, true],
+    ] as const;
+
+    try {
+      for (const [status, code, attempts, expectedUnavailable, returnsFallback] of cases) {
+        let fetches = 0;
+        fetchSpy.mockImplementation((async () => {
+          fetches++;
+          return new Response(JSON.stringify({
+            error: { message: code, type: "invalid_request_error", code },
+          }), {
+            status,
+            headers: {
+              "content-type": "application/json",
+              "x-request-id": `request-${status}-${attempts}`,
+              "x-si-marketplace-attempts": String(attempts),
+            },
+          });
+        }) as unknown as typeof fetch);
+        const invocation = invokeSurplusChatAttempt({
+          route: {
+            catalogModelId: "openrouter:minimax/minimax-m3",
+            surplusModelId: "minimax/minimax-m3",
+            providerPin: "openrouter",
+            supportsTools: true,
+            supportsVision: false,
+            supportsReasoning: true,
+            maxContextTokens: 204_800,
+            maxOutputTokens: 131_072,
+          },
+          apiKey: "synthetic-key",
+          messages: [new HumanMessage("synthetic")],
+          tools: [],
+          config: { signal: new AbortController().signal },
+          maxOutputTokens: 32,
+          funding: { kind: "service", humanUserId: "user-1", providerRoute: "surplus" },
+          hasDeliveredOutput: () => false,
+          directFallbackPolicy: "pre_service_only",
+          invokeModel: async (model, messages, config) =>
+            await model.invoke(messages, config) as AIMessage,
+        });
+
+        if (!returnsFallback) {
+          await Promise.resolve(expect(invocation).rejects.toThrow());
+          expect(fetches).toBe(1);
+          continue;
+        }
+        const result = await invocation;
+        expect(fetches).toBe(1);
+        expect(result).toMatchObject({ kind: "direct_fallback" });
+        if (expectedUnavailable) {
+          expect(result).toHaveProperty("modelUnavailableBeforeService", true);
+        } else {
+          expect(result).not.toHaveProperty("modelUnavailableBeforeService");
+        }
+      }
+    } finally {
+      fetchSpy.mockRestore();
+      settleSpy.mockRestore();
+      attachSpy.mockRestore();
+      beginSpy.mockRestore();
+    }
+  });
+
+  test("a failed attempt-ledger begin never grants model-supply recovery authority or sends a wire", async () => {
+    const beginSpy = spyOn(db, "beginSurplusLlmAttempt")
+      .mockRejectedValue(new Error("synthetic ledger unavailable"));
+    const fetchSpy = spyOn(globalThis, "fetch").mockImplementation((async () => {
+      throw new Error("unexpected marketplace wire");
+    }) as unknown as typeof fetch);
+
+    try {
+      const result = await invokeSurplusChatAttempt({
+        route: OPENAI_REASONING_ROUTE,
+        apiKey: "synthetic-key",
+        messages: [new HumanMessage("synthetic")],
+        tools: [],
+        config: { signal: new AbortController().signal },
+        maxOutputTokens: 32,
+        funding: { kind: "service", humanUserId: "user-1", providerRoute: "surplus" },
+        hasDeliveredOutput: () => false,
+        directFallbackPolicy: "pre_service_only",
+        invokeModel: async (model, messages, config) =>
+          await model.invoke(messages, config) as AIMessage,
+      });
+
+      expect(result).toEqual({ kind: "direct_fallback" });
+      expect(fetchSpy).not.toHaveBeenCalled();
+    } finally {
+      fetchSpy.mockRestore();
+      beginSpy.mockRestore();
+    }
+  });
+
+  test("post-admission authorization and cancellation settle known-unsent without a Surplus wire", async () => {
+    const abort = new AbortController();
+    const errors = {
+      policy: new Error("Soul Surplus policy changed"),
+      key: new Error("Soul Surplus key changed"),
+      rbac: Object.assign(new Error("Soul Surplus authorization changed"), { status: 403 }),
+    } as const;
+    const cancellation = new Error("Soul Surplus cancelled during admission");
+    let mode: "policy" | "key" | "rbac" | "cancellation" = "policy";
+    let policyEnabled = true;
+    let credential = "synthetic-key";
+    let authorized = true;
+    const settlements: Array<Record<string, unknown>> = [];
+    const beginSpy = spyOn(db, "beginSurplusLlmAttempt").mockImplementation(async () => {
+      if (mode === "policy") policyEnabled = false;
+      else if (mode === "key") credential = "replacement-key";
+      else if (mode === "rbac") authorized = false;
+      else abort.abort(cancellation);
+    });
+    const settleSpy = spyOn(db, "settleSurplusLlmAttempt").mockImplementation(async (input) => {
+      settlements.push(input as unknown as Record<string, unknown>);
+    });
+    const fetchSpy = spyOn(globalThis, "fetch").mockImplementation((async () => {
+      throw new Error("unexpected Surplus wire");
+    }) as unknown as typeof fetch);
+    let providerInvokes = 0;
+
+    try {
+      for (mode of ["policy", "key", "rbac", "cancellation"] as const) {
+        policyEnabled = true;
+        credential = "synthetic-key";
+        authorized = true;
+        const beforeSettlements = settlements.length;
+        const signal = mode === "cancellation" ? abort.signal : new AbortController().signal;
+        const expected = mode === "cancellation" ? cancellation : errors[mode];
+        const thrown = await invokeSurplusChatAttempt({
+          route: OPENAI_REASONING_ROUTE,
+          apiKey: "synthetic-key",
+          messages: [new HumanMessage("synthetic")],
+          tools: [],
+          config: { signal },
+          maxOutputTokens: 32,
+          funding: { kind: "service", humanUserId: "user-1", providerRoute: "surplus" },
+          hasDeliveredOutput: () => false,
+          directFallbackPolicy: "pre_service_only",
+          assertStillAuthorized: () => {
+            signal.throwIfAborted();
+            if (!policyEnabled) throw errors.policy;
+            if (credential !== "synthetic-key") throw errors.key;
+            if (!authorized) throw errors.rbac;
+          },
+          invokeModel: async () => {
+            providerInvokes++;
+            throw new Error("must not dispatch");
+          },
+        }).then(() => null, (error: unknown) => error);
+
+        expect(thrown).toBe(expected);
+        if (mode === "rbac") expect(thrown).toMatchObject({ status: 403 });
+        expect(settlements).toHaveLength(beforeSettlements + 1);
+        expect(settlements.at(-1)).toMatchObject(mode === "cancellation"
+          ? {
+              outcome: "cancelled",
+              costState: "actual",
+              actualCostUsd: 0,
+              failureCode: "cancelled",
+            }
+          : {
+              outcome: "failed",
+              costState: "actual",
+              actualCostUsd: 0,
+              failureCode: "authorization_changed",
+            });
+      }
+      expect(providerInvokes).toBe(0);
+      expect(fetchSpy).not.toHaveBeenCalled();
+      expect(beginSpy).toHaveBeenCalledTimes(4);
+    } finally {
+      fetchSpy.mockRestore();
+      settleSpy.mockRestore();
+      beginSpy.mockRestore();
+    }
+  });
 });
 
 class CaptureLLMEnd extends BaseCallbackHandler {
diff --git a/packages/agent/tests/unit/surplus-roleless-stream.test.ts b/packages/agent/tests/unit/surplus-roleless-stream.test.ts
new file mode 100644
index 000000000..d657a9a21
--- /dev/null
+++ b/packages/agent/tests/unit/surplus-roleless-stream.test.ts
@@ -0,0 +1,248 @@
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import {
+  AIMessage,
+  AIMessageChunk,
+  HumanMessage,
+  SystemMessageChunk,
+} from "@langchain/core/messages";
+import type { ChatGeneration, LLMResult } from "@langchain/core/outputs";
+import { describe, expect, test } from "bun:test";
+import { readSurplusResponseUsage } from "../../src/providers/surplus-attempt";
+import { createSurplusChatModel } from "../../src/providers/surplus-transport";
+import type { QualifiedSurplusChatRoute } from "../../src/providers/surplus-route";
+
+const ROUTES: QualifiedSurplusChatRoute[] = [
+  {
+    catalogModelId: "openrouter:openai/gpt-5.6-sol",
+    surplusModelId: "gpt-5.6-sol",
+    providerPin: "openrouter",
+    supportsTools: true,
+    supportsVision: false,
+    supportsReasoning: true,
+    maxContextTokens: 1_050_000,
+    maxOutputTokens: 128_000,
+  },
+  {
+    catalogModelId: "openai:gpt-5.6-luna",
+    surplusModelId: "gpt-5.6-luna",
+    providerPin: "openai",
+    supportsTools: true,
+    supportsVision: false,
+    supportsReasoning: true,
+    maxContextTokens: 1_050_000,
+    maxOutputTokens: 128_000,
+  },
+];
+
+const ROLELESS_FRAMES = [
+  {
+    id: "chatcmpl-roleless",
+    object: "chat.completion.chunk",
+    created: 1,
+    model: "seller-model",
+    choices: [{
+      index: 0,
+      delta: { content: "Checking ", reasoning: "synthetic reasoning" },
+      finish_reason: null,
+    }],
+  },
+  {
+    id: "chatcmpl-roleless",
+    object: "chat.completion.chunk",
+    created: 1,
+    model: "seller-model",
+    choices: [{
+      index: 0,
+      delta: {
+        content: "the report.",
+        tool_calls: [{
+          index: 0,
+          id: "call-report",
+          type: "function",
+          function: { name: "report_probe", arguments: "{\"stat" },
+        }],
+      },
+      finish_reason: null,
+    }],
+  },
+  {
+    id: "chatcmpl-roleless",
+    object: "chat.completion.chunk",
+    created: 1,
+    model: "seller-model",
+    choices: [{
+      index: 0,
+      delta: {
+        tool_calls: [{ index: 0, function: { arguments: "us\":\"ok\"}" } }],
+      },
+      finish_reason: null,
+    }],
+  },
+  {
+    id: "chatcmpl-roleless",
+    object: "chat.completion.chunk",
+    created: 1,
+    model: "seller-model",
+    choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
+  },
+  {
+    id: "chatcmpl-roleless",
+    object: "chat.completion.chunk",
+    created: 1,
+    model: "seller-model",
+    choices: [],
+    usage: {
+      prompt_tokens: 596,
+      completion_tokens: 64,
+      total_tokens: 660,
+      buyer_cost_micro: 687,
+    },
+  },
+];
+
+const TOOL = {
+  type: "function",
+  function: {
+    name: "report_probe",
+    description: "Report the synthetic probe status.",
+    parameters: {
+      type: "object",
+      properties: { status: { type: "string" } },
+      required: ["status"],
+      additionalProperties: false,
+    },
+  },
+};
+
+class CaptureLLMEnd extends BaseCallbackHandler {
+  name = "capture_surplus_roleless_stream";
+  readonly lc_prefer_streaming = true;
+  output: LLMResult | undefined;
+
+  override handleLLMEnd(output: LLMResult): void {
+    this.output = output;
+  }
+}
+
+function asSse(frames: readonly unknown[]): string {
+  return `${frames.map((frame) => `data: ${JSON.stringify(frame)}\n\n`).join("")}data: [DONE]\n\n`;
+}
+
+function rolelessModel(route: QualifiedSurplusChatRoute, frames = ROLELESS_FRAMES) {
+  const model = createSurplusChatModel({
+    route,
+    apiKey: "synthetic-key",
+    maxOutputTokens: 256,
+    onResponse: () => {},
+    fetchImpl: (async () => new Response(asSse(frames), {
+      status: 200,
+      headers: { "content-type": "text/event-stream" },
+    })) as unknown as typeof fetch,
+  });
+  return model.bindTools!([TOOL as never]);
+}
+
+function expectCompleteRolelessResult(message: AIMessage): void {
+  expect(AIMessage.isInstance(message)).toBe(true);
+  expect(message.content).toBe("Checking the report.");
+  expect(message.tool_calls).toEqual([{
+    id: "call-report",
+    name: "report_probe",
+    args: { status: "ok" },
+    type: "tool_call",
+  }]);
+  expect(message.additional_kwargs["reasoning"]).toBe("synthetic reasoning");
+  expect(message.response_metadata["finish_reason"]).toBe("tool_calls");
+  expect(message.response_metadata["model_name"]).toBe("seller-model");
+  expect(readSurplusResponseUsage(message)).toMatchObject({
+    inputTokens: 596,
+    outputTokens: 64,
+    totalTokens: 660,
+    buyerCostMicro: 687,
+  });
+}
+
+describe("Surplus roleless OpenAI-compatible streams", () => {
+  test.each(ROUTES)("reconstructs fragmented tools through invoke for $providerPin", async (route) => {
+    const result = await rolelessModel(route).invoke([
+      new HumanMessage("Run the report probe."),
+    ]);
+
+    expectCompleteRolelessResult(result as AIMessage);
+  });
+
+  test.each(ROUTES)("preserves all roleless chunks through stream for $providerPin", async (route) => {
+    const chunks: AIMessageChunk[] = [];
+    const model = rolelessModel(route);
+    if (!model.stream) throw new Error("Surplus model does not expose streaming.");
+    for await (const chunk of await model.stream([
+      new HumanMessage("Run the report probe."),
+    ])) {
+      expect(AIMessageChunk.isInstance(chunk)).toBe(true);
+      chunks.push(chunk as AIMessageChunk);
+    }
+
+    expect(chunks.map((chunk) => chunk.text).join("")).toBe("Checking the report.");
+    expect(chunks.flatMap((chunk) => chunk.tool_call_chunks ?? [])).toEqual([
+      {
+        id: "call-report",
+        name: "report_probe",
+        args: "{\"stat",
+        index: 0,
+        type: "tool_call_chunk",
+      },
+      {
+        args: "us\":\"ok\"}",
+        index: 0,
+        type: "tool_call_chunk",
+      },
+    ]);
+    expect(chunks.some((chunk) => chunk.additional_kwargs["reasoning"] === "synthetic reasoning"))
+      .toBe(true);
+    expect(chunks.some((chunk) => chunk.response_metadata["finish_reason"] === "tool_calls"))
+      .toBe(true);
+    expect(chunks.some((chunk) => readSurplusResponseUsage(chunk)?.buyerCostMicro === 687))
+      .toBe(true);
+  });
+
+  test.each(ROUTES)("reconstructs fragmented tools through callback-preferred invoke for $providerPin", async (route) => {
+    const capture = new CaptureLLMEnd();
+    const result = await rolelessModel(route).invoke(
+      [new HumanMessage("Run the report probe.")],
+      { callbacks: [capture] },
+    );
+    const generation = capture.output?.generations[0]?.[0] as ChatGeneration | undefined;
+
+    expectCompleteRolelessResult(result as AIMessage);
+    expect(generation).toBeDefined();
+    expectCompleteRolelessResult(generation?.message as AIMessage);
+    expect(generation?.generationInfo?.["finish_reason"]).toBe("tool_calls");
+    expect(generation?.generationInfo?.["model_name"]).toBe("seller-model");
+  });
+
+  test.each(ROUTES)("preserves an explicit non-assistant role for $providerPin", async (route) => {
+    const frames = [{
+      id: "chatcmpl-explicit-role",
+      object: "chat.completion.chunk",
+      created: 1,
+      model: "seller-model",
+      choices: [{
+        index: 0,
+        delta: { role: "system", content: "provider notice" },
+        finish_reason: "stop",
+      }],
+    }];
+    const chunks: unknown[] = [];
+    const model = rolelessModel(route, frames);
+    if (!model.stream) throw new Error("Surplus model does not expose streaming.");
+    for await (const chunk of await model.stream([
+      new HumanMessage("Return the provider notice."),
+    ])) {
+      chunks.push(chunk);
+    }
+
+    expect(chunks).toHaveLength(1);
+    expect(SystemMessageChunk.isInstance(chunks[0])).toBe(true);
+    expect((chunks[0] as SystemMessageChunk).content).toBe("provider notice");
+  });
+});
diff --git a/packages/agent/tests/unit/surplus-transport.test.ts b/packages/agent/tests/unit/surplus-transport.test.ts
index 23658fb4c..21089488d 100644
--- a/packages/agent/tests/unit/surplus-transport.test.ts
+++ b/packages/agent/tests/unit/surplus-transport.test.ts
@@ -1,5 +1,7 @@
-import { describe, expect, test } from "bun:test";
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import type { ChatGeneration, LLMResult } from "@langchain/core/outputs";
 import {
   createSurplusChatModel,
   createSurplusObservedFetch,
@@ -10,6 +12,7 @@ import {
   resolveQualifiedSurplusChatRoute,
   resolveSurplusChatServingAvailability,
 } from "../../src/providers/surplus-route";
+import { resetSurplusModelCatalog } from "../../src/providers/surplus-catalog";
 import {
   assertCompleteSurplusResponse,
   assertSuccessfulSurplusProviderReceipt,
@@ -21,6 +24,7 @@ import {
   SurplusProviderRouteMismatchError,
 } from "../../src/providers/surplus-attempt";
 import { createManageConnectedWebOperationTool } from "../../src/tools/connected-web-accounts/manage-connected-web-operation";
+import { installSurplusCatalogFixture } from "../helpers/surplus-catalog-fixture";
 
 const VENICE_ROUTE = {
   catalogModelId: "venice:openai-gpt-55",
@@ -44,6 +48,29 @@ const QUALIFIED_OPENROUTER_ROUTE = {
   maxOutputTokens: 128_000,
 };
 
+class CaptureSurplusLLMEnd extends BaseCallbackHandler {
+  name = "capture_surplus_llm_end";
+  readonly lc_prefer_streaming = true;
+  output: LLMResult | undefined;
+
+  override handleLLMEnd(output: LLMResult): void {
+    this.output = output;
+  }
+}
+
+class CaptureSurplusTokens extends BaseCallbackHandler {
+  name = "capture_surplus_tokens";
+  readonly lc_prefer_streaming = true;
+  readonly tokens: string[] = [];
+
+  override handleLLMNewToken(token: string): void {
+    if (token) this.tokens.push(token);
+  }
+}
+
+beforeEach(installSurplusCatalogFixture);
+afterEach(resetSurplusModelCatalog);
+
 describe("Surplus wire boundary", () => {
   test("retains real zero cost and omits absent cost", () => {
     const withZero = readSurplusWireReceipt(new Headers({
@@ -276,6 +303,192 @@ describe("Surplus wire boundary", () => {
     });
   });
 
+  test("Venice callback-preferred invoke preserves text, tools, terminal metadata, and final usage", async () => {
+    const route = resolveQualifiedSurplusChatRoute("venice:minimax-m3-preview");
+    if (!route) throw new Error("Expected the discovered Venice route to remain qualified");
+    const frames = [
+      {
+        id: "chatcmpl-surplus-venice-callback",
+        object: "chat.completion.chunk",
+        created: 1,
+        model: route.surplusModelId,
+        choices: [{ index: 0, delta: { content: "Checking " }, finish_reason: null }],
+      },
+      {
+        id: "chatcmpl-surplus-venice-callback",
+        object: "chat.completion.chunk",
+        created: 1,
+        model: route.surplusModelId,
+        choices: [{
+          index: 0,
+          delta: {
+            content: "now",
+            tool_calls: [{
+              index: 0,
+              id: "call-report",
+              type: "function",
+              function: { name: "report_probe", arguments: "{" },
+            }],
+          },
+          finish_reason: null,
+        }],
+      },
+      ...["\"status\": ", "\"ok", "\"", "}"].map((argumentsFragment) => ({
+        id: "chatcmpl-surplus-venice-callback",
+        object: "chat.completion.chunk",
+        created: 1,
+        model: route.surplusModelId,
+        choices: [{
+          index: 0,
+          delta: {
+            tool_calls: [{
+              index: 0,
+              id: null,
+              type: "function",
+              function: { arguments: argumentsFragment },
+            }],
+          },
+          finish_reason: null,
+        }],
+      })),
+      {
+        id: "chatcmpl-surplus-venice-callback",
+        object: "chat.completion.chunk",
+        created: 1,
+        model: route.surplusModelId,
+        choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
+      },
+      {
+        id: "chatcmpl-surplus-venice-callback",
+        object: "chat.completion.chunk",
+        created: 1,
+        model: route.surplusModelId,
+        choices: [],
+        usage: {
+          prompt_tokens: 379,
+          completion_tokens: 55,
+          total_tokens: 434,
+          prompt_tokens_details: { cached_tokens: 107 },
+          cache_read_input_tokens: 107,
+          completion_tokens_details: { reasoning_tokens: 27 },
+          buyer_cost_micro: 116,
+        },
+      },
+    ];
+    const model = createSurplusChatModel({
+      route,
+      apiKey: "synthetic-key",
+      maxOutputTokens: 256,
+      onResponse: () => {},
+      fetchImpl: (async () => new Response(
+        `${frames.map((frame) => `data: ${JSON.stringify(frame)}\n\n`).join("")}data: [DONE]\n\n`,
+        { headers: { "content-type": "text/event-stream" } },
+      )) as unknown as typeof fetch,
+    }).bindTools!([{
+      type: "function",
+      function: {
+        name: "report_probe",
+        description: "Record the synthetic probe.",
+        parameters: {
+          type: "object",
+          properties: { status: { type: "string" } },
+          required: ["status"],
+          additionalProperties: false,
+        },
+      },
+    } as never]);
+    const capture = new CaptureSurplusLLMEnd();
+
+    const response = await model.invoke(
+      [new HumanMessage("Run the probe")],
+      { callbacks: [capture] },
+    ) as AIMessage;
+    const generation = capture.output?.generations[0]?.[0] as ChatGeneration | undefined;
+
+    expect(response.content).toBe("Checking now");
+    expect(response.tool_calls).toEqual([{
+      id: "call-report",
+      name: "report_probe",
+      args: { status: "ok" },
+      type: "tool_call",
+    }]);
+    expect(response.response_metadata["finish_reason"]).toBe("tool_calls");
+    expect(generation?.generationInfo?.["finish_reason"]).toBe("tool_calls");
+    expect(generation?.message.response_metadata["finish_reason"]).toBe("tool_calls");
+    expect(readSurplusResponseUsage(response)).toMatchObject({
+      inputTokens: 379,
+      outputTokens: 55,
+      totalTokens: 434,
+      reasoningTokens: 27,
+      cachedInputTokens: 107,
+      buyerCostMicro: 116,
+    });
+    expect(() => assertCompleteSurplusResponse(
+      { providerFamily: "venice", truncated: false },
+      response,
+    )).not.toThrow();
+  });
+
+  test("Venice callback-preferred invoke deduplicates its final marker without doubling cost", async () => {
+    const route = resolveQualifiedSurplusChatRoute("venice:minimax-m3-preview");
+    if (!route) throw new Error("Expected the discovered Venice route to remain qualified");
+    const frames = [
+      {
+        id: "chatcmpl-surplus-venice-final",
+        object: "chat.completion.chunk",
+        created: 1,
+        model: route.surplusModelId,
+        choices: [{
+          index: 0,
+          delta: { role: "assistant", content: "Done" },
+          finish_reason: "stop",
+        }],
+      },
+      {
+        id: "chatcmpl-surplus-venice-final",
+        object: "chat.completion.chunk",
+        created: 1,
+        model: route.surplusModelId,
+        choices: [{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: "stop" }],
+        usage: {
+          prompt_tokens: 70,
+          completion_tokens: 42,
+          total_tokens: 112,
+          buyer_cost_micro: 129,
+        },
+      },
+    ];
+    const model = createSurplusChatModel({
+      route,
+      apiKey: "synthetic-key",
+      maxOutputTokens: 256,
+      onResponse: () => {},
+      fetchImpl: (async () => new Response(
+        `${frames.map((frame) => `data: ${JSON.stringify(frame)}\n\n`).join("")}data: [DONE]\n\n`,
+        { headers: { "content-type": "text/event-stream" } },
+      )) as unknown as typeof fetch,
+    });
+    const capture = new CaptureSurplusLLMEnd();
+
+    const response = await model.invoke(
+      [new HumanMessage("Reply Done")],
+      { callbacks: [capture] },
+    ) as AIMessage;
+
+    expect(response.content).toBe("Done");
+    expect(response.response_metadata["finish_reason"]).toBe("stop");
+    expect(readSurplusResponseUsage(response)).toMatchObject({
+      inputTokens: 70,
+      outputTokens: 42,
+      totalTokens: 112,
+      buyerCostMicro: 129,
+    });
+    expect(() => assertCompleteSurplusResponse(
+      { providerFamily: "venice", truncated: false },
+      response,
+    )).not.toThrow();
+  });
+
   test("non-Venice SDK requests omit Venice-only options", async () => {
     const openAIRoute = {
       ...VENICE_ROUTE,
@@ -395,7 +608,7 @@ describe("Surplus wire boundary", () => {
   });
 
   test("qualified OpenRouter vision preserves text and image_url on the SDK wire", async () => {
-    const route = resolveQualifiedSurplusChatRoute("openrouter:google/gemini-3.1-flash-lite-preview");
+    const route = resolveQualifiedSurplusChatRoute(QUALIFIED_OPENROUTER_ROUTE.catalogModelId);
     if (!route) throw new Error("Expected the signed vision route to remain qualified");
     const personalFunding = {
       kind: "personal" as const,
@@ -406,7 +619,7 @@ describe("Surplus wire boundary", () => {
       credentialRevision: 1,
     };
     expect(route).toMatchObject({
-      surplusModelId: "google/gemini-3.1-flash-lite-preview",
+      surplusModelId: "gpt-5.6-sol",
       providerPin: "openrouter",
       supportsVision: true,
     });
@@ -528,7 +741,7 @@ describe("Surplus wire boundary", () => {
         truncated: false,
       },
       200,
-    )).toThrow(SurplusAdaptedParametersError);
+    )).not.toThrow();
     expect(() => assertSuccessfulSurplusProviderReceipt(
       VENICE_ROUTE,
       { truncated: false },
@@ -542,18 +755,23 @@ describe("Surplus wire boundary", () => {
     )).not.toThrow();
   });
 
-  test("accepts cache and stream metering hints while preserving provider and inference guards", () => {
+  test("defers only output-ceiling aliases while preserving provider and inference guards", () => {
     const receipt = { providerFamily: "venice", truncated: false };
-    for (const adaptation of [" prompt_cache_key ", "stream_options", "stream_options, prompt_cache_key"]) {
+    for (const adaptation of [
+      " prompt_cache_key ", "stream_options", "stream_options, prompt_cache_key",
+      "max_tokens", "max_completion_tokens", "prompt_cache_key,max_tokens",
+      "stream_options,max_completion_tokens", "max_tokens,max_completion_tokens",
+    ]) {
       expect(() => assertSuccessfulSurplusProviderReceipt(
         VENICE_ROUTE, { ...receipt, adaptedParameters: adaptation }, 200,
       )).not.toThrow();
     }
     for (const adaptation of [
-      "model", "reasoning_effort", "max_completion_tokens", "response_format",
+      "model", "reasoning_effort", "response_format",
       "prompt_cache_retention", "session_id", "unknown_setting", "PROMPT_CACHE_KEY",
       "prompt_cache_key,reasoning_effort", "prompt_cache_key,", ",prompt_cache_key",
       "stream_options,reasoning_effort", "stream_options,", "STREAM_OPTIONS",
+      "max_tokens,reasoning_effort", "max_tokens,max_tokens",
     ]) {
       expect(() => assertSuccessfulSurplusProviderReceipt(
         VENICE_ROUTE, { ...receipt, adaptedParameters: adaptation }, 200,
@@ -599,7 +817,7 @@ describe("Surplus wire boundary", () => {
       { ...receipt!, marketplaceAttempts: 0 }, false)).toBe(false);
   });
 
-  test("rejects a successful adapted response before the SDK can assemble its output", async () => {
+  test("rejects another semantic adaptation before the SDK can assemble its output", async () => {
     const chunk = {
       id: "chatcmpl-surplus-adapted",
       object: "chat.completion.chunk",
@@ -622,7 +840,7 @@ describe("Surplus wire boundary", () => {
           "content-type": "text/event-stream",
           "x-request-id": "request-adapted",
           "x-si-provider-family": "Venice",
-          "x-si-adapted-params": "max_completion_tokens",
+          "x-si-adapted-params": "reasoning_effort",
         },
       })) as unknown as typeof fetch,
     });
@@ -637,7 +855,202 @@ describe("Surplus wire boundary", () => {
     expect(invokeError).toBeInstanceOf(Error);
     expect(observedReceipt).toMatchObject({
       requestId: "request-adapted",
+      adaptedParameters: "reasoning_effort",
+    });
+  });
+
+  test("accepts a naturally completed full-catalogue Kimi request with max_tokens adaptation and bound tools", async () => {
+    const route = resolveQualifiedSurplusChatRoute("openrouter:moonshotai/kimi-k3");
+    if (!route) throw new Error("Expected the discovered Kimi route to remain qualified");
+    expect(route.maxOutputTokens).toBe(131_072);
+    const frames = [{
+      id: "chatcmpl-surplus-kimi-ceiling", object: "chat.completion.chunk", created: 1,
+      model: route.surplusModelId,
+      choices: [{ index: 0, delta: { role: "assistant", content: "Complete" }, finish_reason: "stop" }],
+    }, {
+      id: "chatcmpl-surplus-kimi-ceiling", object: "chat.completion.chunk", created: 1,
+      model: route.surplusModelId, choices: [],
+      usage: { prompt_tokens: 37, completion_tokens: 19, total_tokens: 56, buyer_cost_micro: 62 },
+    }];
+    let requestBody: Record<string, unknown> | undefined;
+    let receipt: Parameters<typeof assertCompleteSurplusResponse>[0];
+    const model = createSurplusChatModel({
+      route,
+      apiKey: "synthetic-key",
+      providerMode: "any",
+      maxOutputTokens: 131_072,
+      onResponse: (next, status) => {
+        receipt = next;
+        assertSuccessfulSurplusProviderReceipt(route, next, status, "any");
+      },
+      fetchImpl: (async (request: string | URL | Request, init?: RequestInit) => {
+        const rawBody = init?.body ?? (request instanceof Request ? await request.clone().text() : undefined);
+        requestBody = typeof rawBody === "string" ? JSON.parse(rawBody) as Record<string, unknown> : undefined;
+        return new Response(
+          `${frames.map((frame) => `data: ${JSON.stringify(frame)}\n\n`).join("")}data: [DONE]\n\n`,
+          { status: 200, headers: {
+            "content-type": "text/event-stream",
+            "x-request-id": "request-kimi-ceiling",
+            "x-si-provider-family": "openai",
+            "x-si-marketplace-attempts": "1",
+            "x-si-adapted-params": "max_tokens",
+          } },
+        );
+      }) as typeof fetch,
+    }).bindTools!([{
+      type: "function",
+      function: {
+        name: "record_probe",
+        description: "Record a synthetic probe.",
+        parameters: { type: "object", properties: {}, additionalProperties: false },
+      },
+    } as never]);
+
+    const response = await model.invoke([new HumanMessage("Complete the probe")]) as AIMessage;
+
+    expect(requestBody?.["max_tokens"]).toBe(131_072);
+    expect(requestBody).not.toHaveProperty("max_completion_tokens");
+    expect(requestBody?.["provider"]).toBeUndefined();
+    expect(requestBody?.["tools"]).toHaveLength(1);
+    expect(receipt).toMatchObject({
+      requestId: "request-kimi-ceiling",
+      providerFamily: "openai",
+      marketplaceAttempts: 1,
+      adaptedParameters: "max_tokens",
+      truncated: false,
+    });
+    expect(response.content).toBe("Complete");
+    expect(() => assertCompleteSurplusResponse(receipt, response, 131_072)).not.toThrow();
+  });
+
+  test("output-ceiling adaptation requires a natural terminal and authoritative usage within the original cap", () => {
+    const receipt = {
+      requestId: "request-output-ceiling",
+      providerFamily: "venice",
       adaptedParameters: "max_completion_tokens",
+      truncated: false,
+    };
+    const response = (
+      finishReason: string,
+      completionTokens: unknown,
+      fields: string | {
+        content: string;
+        additional_kwargs?: Record<string, unknown>;
+        response_metadata?: Record<string, unknown>;
+        tool_calls?: Array<{
+          id: string;
+          name: string;
+          args: Record<string, unknown>;
+          type: "tool_call";
+        }>;
+      } = "done",
+    ) => new AIMessage(typeof fields === "string" ? {
+      content: fields,
+      response_metadata: {
+        finish_reason: finishReason,
+        usage: { prompt_tokens: 5, completion_tokens: completionTokens, total_tokens: 105 },
+      },
+    } : {
+      ...fields,
+      response_metadata: {
+        ...fields.response_metadata,
+        finish_reason: finishReason,
+        usage: { prompt_tokens: 5, completion_tokens: completionTokens, total_tokens: 105 },
+      },
+    });
+
+    expect(() => assertCompleteSurplusResponse(receipt, response("stop", 100), 100)).not.toThrow();
+    expect(() => assertCompleteSurplusResponse(
+      { ...receipt, adaptedParameters: "max_tokens,prompt_cache_key" },
+      response("tool_calls", 100, {
+        content: "",
+        tool_calls: [{ id: "call-1", name: "record_probe", args: {}, type: "tool_call" }],
+      }),
+      100,
+    )).not.toThrow();
+    expect(() => assertCompleteSurplusResponse(receipt, response("function_call", 1, {
+      content: "",
+      additional_kwargs: { function_call: { name: "record_probe", arguments: "{}" } },
+    }), 100)).not.toThrow();
+    expect(() => assertCompleteSurplusResponse(receipt, response("content_filter", 0, ""), 100)).not.toThrow();
+
+    expect(() => assertCompleteSurplusResponse(receipt, response("stop", 101), 100))
+      .toThrow(SurplusAdaptedParametersError);
+    expect(() => assertCompleteSurplusResponse(receipt, response("length", 100), 100))
+      .toThrow(SurplusAdaptedParametersError);
+    expect(() => assertCompleteSurplusResponse(receipt, response("stop", 100)))
+      .toThrow(SurplusAdaptedParametersError);
+    const normalizedOnlyUsage = new AIMessage({
+      content: "done",
+      response_metadata: { finish_reason: "stop", usage: { prompt_tokens: 5, total_tokens: 5 } },
+    });
+    normalizedOnlyUsage.usage_metadata = {
+      input_tokens: 5,
+      output_tokens: 0,
+      total_tokens: 5,
+    } as never;
+    expect(() => assertCompleteSurplusResponse(receipt, normalizedOnlyUsage, 100))
+      .toThrow(SurplusAdaptedParametersError);
+    for (const malformed of [-1, 1.5, "100", Number.NaN, Number.POSITIVE_INFINITY]) {
+      expect(() => assertCompleteSurplusResponse(receipt, response("stop", malformed), 100))
+        .toThrow(SurplusAdaptedParametersError);
+    }
+    expect(() => assertCompleteSurplusResponse(
+      { ...receipt, adaptedParameters: "max_tokens,reasoning_effort" }, response("stop", 1), 100,
+    )).toThrow(SurplusAdaptedParametersError);
+    expect(() => assertCompleteSurplusResponse(
+      { ...receipt, truncated: true }, response("stop", 1), 100,
+    )).toThrow(SurplusIncompleteResponseError);
+    expect(() => assertCompleteSurplusResponse(receipt, response("stop", 1, "   "), 100))
+      .toThrow(SurplusIncompleteResponseError);
+  });
+
+  test("a rejected ceiling-adapted stream exposes callbacks but cannot replay after delivered text", async () => {
+    const frames = [{
+      id: "chatcmpl-surplus-visible-ceiling", object: "chat.completion.chunk", created: 1, model: "gpt-5.5",
+      choices: [{ index: 0, delta: { role: "assistant", content: "visible" }, finish_reason: "stop" }],
+    }, {
+      id: "chatcmpl-surplus-visible-ceiling", object: "chat.completion.chunk", created: 1, model: "gpt-5.5",
+      choices: [], usage: { prompt_tokens: 3, completion_tokens: 11, total_tokens: 14, buyer_cost_micro: 62 },
+    }];
+    let receipt: Parameters<typeof assertCompleteSurplusResponse>[0];
+    const model = createSurplusChatModel({
+      route: VENICE_ROUTE, apiKey: "test-key", maxOutputTokens: 10,
+      onResponse: (next, status) => {
+        receipt = next;
+        assertSuccessfulSurplusProviderReceipt(VENICE_ROUTE, next, status);
+      },
+      fetchImpl: (async () => new Response(
+        `${frames.map((frame) => `data: ${JSON.stringify(frame)}\n\n`).join("")}data: [DONE]\n\n`,
+        { headers: { "content-type": "text/event-stream", "x-request-id": "request-visible-ceiling",
+          "x-si-provider-family": "venice", "x-si-adapted-params": "max_tokens" } },
+      )) as unknown as typeof fetch,
+    });
+    const capture = new CaptureSurplusTokens();
+
+    const response = await model.invoke([new HumanMessage("Reply")], { callbacks: [capture] }) as AIMessage;
+    let completionError: unknown;
+    try {
+      assertCompleteSurplusResponse(receipt, response, 10);
+    } catch (error) {
+      completionError = error;
+    }
+
+    expect(capture.tokens.join("")).toBe("visible");
+    expect(completionError).toBeInstanceOf(SurplusAdaptedParametersError);
+    expect(classifySurplusFailedAttempt({
+      error: completionError,
+      cancelled: false,
+      responseStatus: 200,
+      receipt,
+      deliveredOutput: capture.tokens.length > 0,
+      terminalUsage: readSurplusResponseUsage(response),
+    })).toEqual({
+      outcome: "unknown",
+      costState: "actual",
+      actualCostUsd: 0.000062,
+      failureCode: "adapted_parameters",
+      directFallback: false,
     });
   });
 
@@ -903,11 +1316,11 @@ describe("qualified Surplus route selection", () => {
     expect(resolveQualifiedSurplusChatRoute(QUALIFIED_OPENROUTER_ROUTE.catalogModelId))
       .toMatchObject({
         catalogModelId: QUALIFIED_OPENROUTER_ROUTE.catalogModelId,
-        surplusModelId: "openai/gpt-5.6-sol",
+        surplusModelId: "gpt-5.6-sol",
         providerPin: "openrouter",
       });
-    expect(resolveQualifiedSurplusChatRoute("venice:openai-gpt-55")).not.toBeNull();
-    expect(resolveQualifiedSurplusChatRoute("openrouter:openai/gpt-5.6-terra")).not.toBeNull();
+    expect(resolveQualifiedSurplusChatRoute("venice:minimax-m3-preview")).not.toBeNull();
+    expect(resolveQualifiedSurplusChatRoute("openrouter:anthropic/claude-sonnet-4.6")).not.toBeNull();
     expect(resolveQualifiedSurplusChatRoute("openai:gpt-5.6-sol")).not.toBeNull();
   });
 
diff --git a/packages/agent/tests/unit/universal-retry-policy.test.ts b/packages/agent/tests/unit/universal-retry-policy.test.ts
new file mode 100644
index 000000000..146aba327
--- /dev/null
+++ b/packages/agent/tests/unit/universal-retry-policy.test.ts
@@ -0,0 +1,41 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createUniversalModel } from "../../src/providers/universal";
+import { resetRuntimeModelCatalog } from "../../src/config/model-catalog/runtime-catalog";
+import { activateModelCatalogForTests } from "../helpers/activate-model-catalog";
+
+const MODEL_ID = "openai:gpt-5.6-luna";
+const OPENROUTER_MODEL_ID = "openrouter:minimax/minimax-m3";
+beforeAll(async () => activateModelCatalogForTests([MODEL_ID, OPENROUTER_MODEL_ID]));
+afterAll(() => resetRuntimeModelCatalog());
+
+describe("explicit provider retry ownership", () => {
+  test("a service-owned attempt can disable SDK retries without changing the wire", async () => {
+    const model = await createUniversalModel(MODEL_ID, { apiKey: "synthetic-service-key", maxRetries: 0 });
+    const sdk = model as unknown as { caller: { maxRetries: number }; modelKwargs?: Record<string, unknown> };
+    expect(sdk.caller.maxRetries).toBe(0);
+    expect(sdk.modelKwargs).not.toHaveProperty("maxRetries");
+  });
+
+  test("invalid retry counts fail before constructing a provider", async () => {
+    for (const maxRetries of [-1, 0.5, Number.NaN, Number.POSITIVE_INFINITY, "0"]) {
+      await Promise.resolve(expect(createUniversalModel(MODEL_ID, { apiKey: "synthetic-service-key", maxRetries }))
+        .rejects.toThrow("Provider retry count must be a nonnegative integer."));
+    }
+  });
+
+  test("OpenRouter preserves explicit retry ownership through its separate factory options", async () => {
+    const model = await createUniversalModel(OPENROUTER_MODEL_ID, {
+      apiKey: "synthetic-service-key", maxRetries: 0,
+    });
+    const sdk = model as unknown as { caller: { maxRetries: number }; modelKwargs?: Record<string, unknown> };
+    expect(sdk.caller.maxRetries).toBe(0);
+    expect(sdk.modelKwargs).not.toHaveProperty("maxRetries");
+  });
+
+  test("a caller cannot restore SDK retries for an admitted personal credential", async () => {
+    const model = await createUniversalModel(MODEL_ID, {
+      personalCredential: { apiKey: "synthetic-personal-key" }, maxRetries: 3,
+    });
+    expect((model as unknown as { caller: { maxRetries: number } }).caller.maxRetries).toBe(0);
+  });
+});
diff --git a/packages/agent/tests/unit/validate-exact-task-model.test.ts b/packages/agent/tests/unit/validate-exact-task-model.test.ts
index bd522d6f6..17afe038a 100644
--- a/packages/agent/tests/unit/validate-exact-task-model.test.ts
+++ b/packages/agent/tests/unit/validate-exact-task-model.test.ts
@@ -17,7 +17,7 @@
  * venice + capabilities caches so the rows are deterministic. The validator
  * is pure / cache-backed — it never awaits a fetch (Phase 0).
  */
-import { beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { resetModelCapabilitiesCacheForTests } from "@nautilo/model-capabilities";
 import {
   validateExactTaskModelSelection,
@@ -28,6 +28,9 @@ import type { QualifiedSurplusChatRoute } from "../../src/providers/surplus-rout
 import { validateTaskModelSelectionForCreate } from "../../src/tools/tasks/selection-validation";
 import { resetVeniceCatalogCacheModuleForTests } from "../../src/config/venice-catalog-cache";
 
+import { installSurplusCatalogFixture } from "../helpers/surplus-catalog-fixture";
+import { resetSurplusModelCatalog } from "../../src/providers/surplus-catalog";
+
 const FULL_ENV: NodeJS.ProcessEnv = {
   ANTHROPIC_API_KEY: "x",
   OPENAI_API_KEY: "x",
@@ -245,6 +248,8 @@ describe("validateExactTaskModelSelection (D429 Phase 3) — strict tool-capabil
 });
 
 describe("validateExactTaskModelSelection — qualified server-funded exact Tasks", () => {
+  beforeEach(installSurplusCatalogFixture);
+  afterEach(resetSurplusModelCatalog);
   test("admits a signed tool-capable default route without an injected route allowlist", () => {
     expect(validateExactTaskModelSelection({
       requestedModelId: "anthropic:claude-sonnet-4-6",
@@ -257,6 +262,18 @@ describe("validateExactTaskModelSelection — qualified server-funded exact Task
     })).toBeNull();
   });
 
+  test("admits the derived Sonnet route at its lower qualified Surplus output budget", () => {
+    expect(validateExactTaskModelSelection({
+      requestedModelId: "openrouter:anthropic/claude-sonnet-4.6",
+      env: NO_ENV,
+      toolsMode: "auto",
+      surplus: {
+        policyEnabled: true,
+        keyConfigured: true,
+      },
+    })).toBeNull();
+  });
+
   test("admits a qualified tool-free exact pin without the original provider credential", () => {
     expect(validateExactTaskModelSelection({
       requestedModelId: SURPLUS_ONLY_MODEL,
@@ -329,7 +346,7 @@ describe("validateExactTaskModelSelection — qualified server-funded exact Task
     })?.code).toBe("capability_mismatch");
   });
 
-  test("rejects a route narrower than the signed Task output budget", () => {
+  test("admits a qualified route narrower than the signed direct output budget", () => {
     expect(validateExactTaskModelSelection({
       requestedModelId: SURPLUS_ONLY_MODEL,
       env: NO_ENV,
@@ -339,7 +356,23 @@ describe("validateExactTaskModelSelection — qualified server-funded exact Task
         keyConfigured: true,
         routes: [{ ...QUALIFIED_SURPLUS_ROUTE, maxOutputTokens: 8_000 }],
       },
-    })?.code).toBe("capability_mismatch");
+    })).toBeNull();
+  });
+
+  test("admits an output maximum equal to context because invocation budgets the remaining context", () => {
+    expect(validateExactTaskModelSelection({
+      requestedModelId: SURPLUS_ONLY_MODEL,
+      env: NO_ENV,
+      toolsMode: "none",
+      surplus: {
+        policyEnabled: true,
+        keyConfigured: true,
+        routes: [{
+          ...QUALIFIED_SURPLUS_ROUTE,
+          maxContextTokens: QUALIFIED_SURPLUS_ROUTE.maxOutputTokens,
+        }],
+      },
+    })).toBeNull();
   });
 
   test.each([
diff --git a/packages/api-client/src/client.ts b/packages/api-client/src/client.ts
index 093db127a..69e834a84 100644
--- a/packages/api-client/src/client.ts
+++ b/packages/api-client/src/client.ts
@@ -60,8 +60,10 @@ import {
   type ProtectedMemoryRepairResponseV1,
 } from "./schemas/protected-memory-repair";
 import {
+  memoryProcessorRecipientV2Schema,
   memoryProcessorRecipientV1Schema,
   memoryProcessorSealedRequestV1Schema,
+  type MemoryProcessorRecipientV2,
   type MemoryProcessorRecipientV1,
   type MemoryProcessorSealedRequestV1,
 } from "./schemas/memory-processor-transport";
@@ -1909,6 +1911,14 @@ export const assistantModelSummarySchema = z
       })
       .strict()
       .optional(),
+    /** Effective request limits after intersecting catalog policy with the serving route. */
+    limits: z
+      .object({
+        contextTokens: z.number().int().positive(),
+        outputTokens: z.number().int().positive(),
+      })
+      .strict()
+      .optional(),
     controls: z
       .object({
         reasoning: z
@@ -10194,6 +10204,15 @@ export class NautiloApiClient {
     });
   }
 
+  async getMemoryProcessorRecipientV2(): Promise<MemoryProcessorRecipientV2> {
+    return this.request({
+      path: "/api/memory/processor-recipient/v2",
+      auth: "session-fresh",
+      schema: memoryProcessorRecipientV2Schema,
+      defaultErrorPrefix: "GET /api/memory/processor-recipient/v2",
+    });
+  }
+
   async searchProtectedMemories(opts: {
     sealedQuery: MemoryProcessorSealedRequestV1;
     mode: "text" | "semantic";
@@ -10219,6 +10238,31 @@ export class NautiloApiClient {
     });
   }
 
+  async searchProtectedMemoriesV2(opts: {
+    sealedQueryV2: MemoryProcessorSealedRequestV1;
+    mode: "text" | "semantic";
+    limit?: number;
+    includeArchive?: boolean;
+  }): Promise<
+    ProtectedMemorySearchResponseV1 | ProtectedMemoryUnavailableResponseV1
+  > {
+    return this.request({
+      method: "POST",
+      path: "/api/memory/search",
+      auth: "session-fresh",
+      body: {
+        sealedQueryV2: memoryProcessorSealedRequestV1Schema.parse(opts.sealedQueryV2),
+        mode: opts.mode,
+        ...(opts.limit === undefined ? {} : { limit: opts.limit }),
+        ...(opts.includeArchive === undefined
+          ? {}
+          : { includeArchive: opts.includeArchive }),
+      },
+      schema: protectedMemorySearchRouteResponseV1Schema,
+      defaultErrorPrefix: "POST /api/memory/search (protected V2)",
+    });
+  }
+
   async getProtectedMemoryBrief(opts?: {
     readonly?: boolean;
   }): Promise<
diff --git a/packages/api-client/src/schemas/memory-processor-transport.ts b/packages/api-client/src/schemas/memory-processor-transport.ts
index 8759aac3b..d239786ec 100644
--- a/packages/api-client/src/schemas/memory-processor-transport.ts
+++ b/packages/api-client/src/schemas/memory-processor-transport.ts
@@ -22,6 +22,51 @@ export const memoryProcessorRecipientV1Schema = z.object({
   }).strict().optional(),
 }).strict();
 
+export const memoryEmbeddingCanonicalSpaceV2Schema = z.object({
+  provider: z.enum(["openai", "openrouter", "venice"]),
+  model: z.string().min(1).regex(/^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/u),
+  dimensions: z.literal(1536),
+}).strict();
+
+export const memoryEmbeddingProcessingRouteV2Schema = z.discriminatedUnion(
+  "transport",
+  [
+    z.object({ transport: z.literal("direct") }).strict(),
+    z.object({
+      transport: z.literal("surplus_marketplace"),
+      marketplacePolicyVersion: z.literal("surplus-embedding-marketplace-v1"),
+      dataRecipientClasses: z.tuple([
+        z.literal("surplus"),
+        z.literal("marketplace_seller"),
+        z.literal("seller_upstream_processor"),
+      ]).readonly(),
+    }).strict(),
+  ],
+);
+
+/** Exact user-visible disclosure authorized by new protected Memory clients. */
+export const memoryEmbeddingDisclosureV2Schema = z.object({
+  contractVersion: z.literal(2),
+  canonicalSpace: memoryEmbeddingCanonicalSpaceV2Schema,
+  processingRoute: memoryEmbeddingProcessingRouteV2Schema,
+}).strict().superRefine((value, context) => {
+  if (value.processingRoute.transport === "surplus_marketplace"
+    && (value.canonicalSpace.provider !== "venice"
+      || value.canonicalSpace.model !== "text-embedding-3-large")) {
+    context.addIssue({ code: "custom",
+      message: "Surplus marketplace embeddings require the admitted Venice 3-large space" });
+  }
+});
+
+/** Versioned separately so strict V1 clients never reinterpret a marketplace route. */
+export const memoryProcessorRecipientV2Schema = z.object({
+  formatVersion: z.literal(2),
+  purpose: z.literal("memory.foreground_embedding"),
+  recipientId: bytes.length(43),
+  publicKeyBase64url: bytes.length(87),
+  embedding: memoryEmbeddingDisclosureV2Schema.optional(),
+}).strict();
+
 /** Request content is opened only inside the foreground embedding boundary. */
 export const memoryProcessorSealedRequestV1Schema = z.object({
   formatVersion: z.literal(1),
@@ -32,6 +77,18 @@ export const memoryProcessorSealedRequestV1Schema = z.object({
 export type MemoryProcessorRecipientV1 = z.infer<
   typeof memoryProcessorRecipientV1Schema
 >;
+export type MemoryEmbeddingCanonicalSpaceV2 = z.infer<
+  typeof memoryEmbeddingCanonicalSpaceV2Schema
+>;
+export type MemoryEmbeddingProcessingRouteV2 = z.infer<
+  typeof memoryEmbeddingProcessingRouteV2Schema
+>;
+export type MemoryEmbeddingDisclosureV2 = z.infer<
+  typeof memoryEmbeddingDisclosureV2Schema
+>;
+export type MemoryProcessorRecipientV2 = z.infer<
+  typeof memoryProcessorRecipientV2Schema
+>;
 export type MemoryProcessorSealedRequestV1 = z.infer<
   typeof memoryProcessorSealedRequestV1Schema
 >;
diff --git a/packages/api-client/tests/unit/client.test.ts b/packages/api-client/tests/unit/client.test.ts
index 9760267a8..2d086fb14 100644
--- a/packages/api-client/tests/unit/client.test.ts
+++ b/packages/api-client/tests/unit/client.test.ts
@@ -148,22 +148,81 @@ describe("NautiloApiClient", () => {
     }
   });
 
-  test("caller-model client accepts only the secret-free effective funding projection", async () => {
+  test("caller-model client accepts Surplus limits while retaining responses without limits", async () => {
     const originalFetch = globalThis.fetch;
-    globalThis.fetch = (async () => Response.json([{
-      id: "openai:gpt-5",
-      displayName: "GPT-5",
-      provider: "openai",
+    globalThis.fetch = (async () => Response.json([
+      {
+        id: "openrouter:moonshotai/kimi-k3",
+        displayName: "Kimi K3",
+        provider: "openrouter",
+        priority: 1,
+        enabled: true,
+        costCoefficient: 1,
+        availability: "selectable",
+        fundingSource: "personal",
+        fundingProviderRoute: "surplus",
+        imageInput: "direct",
+        capabilities: {
+          tools: true,
+          vision: true,
+          reasoning: true,
+          e2ee: false,
+          webSearch: false,
+        },
+        limits: { contextTokens: 1_000_000, outputTokens: 131_072 },
+      },
+      {
+        id: "openai:gpt-5",
+        displayName: "GPT-5",
+        provider: "openai",
+        priority: 2,
+        enabled: true,
+        costCoefficient: 1,
+        availability: "selectable",
+        fundingSource: "server",
+      },
+    ])) as unknown as typeof fetch;
+    try {
+      const [surplusModel, directModel] = await new NautiloApiClient("http://127.0.0.1:3001").getCallerModels();
+      expect(surplusModel).toMatchObject({
+        fundingSource: "personal",
+        fundingProviderRoute: "surplus",
+        limits: { contextTokens: 1_000_000, outputTokens: 131_072 },
+      });
+      expect(directModel?.limits).toBeUndefined();
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("caller-model client rejects malformed limits and unknown fields", async () => {
+    const originalFetch = globalThis.fetch;
+    const baseModel = {
+      id: "openrouter:moonshotai/kimi-k3",
+      displayName: "Kimi K3",
+      provider: "openrouter",
       priority: 1,
       enabled: true,
       costCoefficient: 1,
       availability: "selectable",
       fundingSource: "personal",
       fundingProviderRoute: "surplus",
-    }])) as unknown as typeof fetch;
+    };
+    const invalidModels = [
+      { ...baseModel, limits: { contextTokens: 0, outputTokens: 131_072 } },
+      { ...baseModel, limits: { contextTokens: 1_000_000, outputTokens: 131_072.5 } },
+      { ...baseModel, limits: { contextTokens: 1_000_000 } },
+      { ...baseModel, limits: { contextTokens: 1_000_000, outputTokens: 131_072, providerLimit: true } },
+      { ...baseModel, credentialId: "server-only-authority" },
+    ];
     try {
-      const [model] = await new NautiloApiClient("http://127.0.0.1:3001").getCallerModels();
-      expect(model).toMatchObject({ fundingSource: "personal", fundingProviderRoute: "surplus" });
+      for (const model of invalidModels) {
+        globalThis.fetch = (async () => Response.json([model])) as unknown as typeof fetch;
+        const error = await new NautiloApiClient("http://127.0.0.1:3001")
+          .getCallerModels()
+          .catch((cause: unknown) => cause);
+        expect(error).toBeInstanceOf(Error);
+      }
     } finally {
       globalThis.fetch = originalFetch;
     }
diff --git a/packages/api-client/tests/unit/memory-processor-transport.test.ts b/packages/api-client/tests/unit/memory-processor-transport.test.ts
index 037a87dee..a75beda84 100644
--- a/packages/api-client/tests/unit/memory-processor-transport.test.ts
+++ b/packages/api-client/tests/unit/memory-processor-transport.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
-import { memoryProcessorRecipientV1Schema } from "../../src/schemas/memory-processor-transport";
+import {
+  memoryEmbeddingDisclosureV2Schema,
+  memoryProcessorRecipientV1Schema,
+  memoryProcessorRecipientV2Schema,
+} from "../../src/schemas/memory-processor-transport";
 
 function recipient<const Provider extends string>(provider: Provider) {
   return {
@@ -28,4 +32,57 @@ describe("Memory processor transport schema", () => {
       recipient("unknown-provider"),
     ).success).toBe(false);
   });
+
+  test("accepts the exact Surplus marketplace disclosure without changing canonical space", () => {
+    const embedding = {
+      contractVersion: 2,
+      canonicalSpace: {
+        provider: "venice",
+        model: "text-embedding-3-large",
+        dimensions: 1536,
+      },
+      processingRoute: {
+        transport: "surplus_marketplace",
+        marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+        dataRecipientClasses: [
+          "surplus",
+          "marketplace_seller",
+          "seller_upstream_processor",
+        ],
+      },
+    } as const;
+    expect(memoryEmbeddingDisclosureV2Schema.parse(embedding)).toEqual(embedding);
+    expect(memoryProcessorRecipientV2Schema.parse({
+      formatVersion: 2,
+      purpose: "memory.foreground_embedding",
+      recipientId: "A".repeat(43),
+      publicKeyBase64url: "B".repeat(87),
+      embedding,
+    }).embedding).toEqual(embedding);
+  });
+
+  test("rejects widened or reordered marketplace recipients", () => {
+    const base = {
+      contractVersion: 2,
+      canonicalSpace: { provider: "venice", model: "text-embedding-3-large", dimensions: 1536 },
+      processingRoute: {
+        transport: "surplus_marketplace",
+        marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+      },
+    } as const;
+    expect(memoryEmbeddingDisclosureV2Schema.safeParse({ ...base,
+      processingRoute: { ...base.processingRoute,
+        dataRecipientClasses: ["surplus", "seller_upstream_processor", "marketplace_seller"] },
+    }).success).toBe(false);
+    expect(memoryEmbeddingDisclosureV2Schema.safeParse({ ...base,
+      canonicalSpace: { provider: "openai", model: "text-embedding-3-large",
+        dimensions: 1536 },
+      processingRoute: { ...base.processingRoute,
+        dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] },
+    }).success).toBe(false);
+    expect(memoryEmbeddingDisclosureV2Schema.safeParse({ ...base,
+      processingRoute: { ...base.processingRoute,
+        dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor", "other"] },
+    }).success).toBe(false);
+  });
 });
diff --git a/packages/config/src/model-role-candidates.ts b/packages/config/src/model-role-candidates.ts
index fcb7003de..30b3ae4cc 100644
--- a/packages/config/src/model-role-candidates.ts
+++ b/packages/config/src/model-role-candidates.ts
@@ -185,6 +185,7 @@ export const MODEL_ROLE_CANDIDATES = {
     "venice:text-embedding-3-small",
     "openrouter:openai/text-embedding-3-small",
     "openai:text-embedding-3-small",
+    "venice:text-embedding-3-large",
   ],
   imageGeneration: [
     "openai:gpt-image-2.5-sunburst",
diff --git a/packages/config/tests/unit/model-role-candidates.test.ts b/packages/config/tests/unit/model-role-candidates.test.ts
index b7ba78503..397a67eeb 100644
--- a/packages/config/tests/unit/model-role-candidates.test.ts
+++ b/packages/config/tests/unit/model-role-candidates.test.ts
@@ -80,6 +80,7 @@ describe("model role candidates", () => {
       "venice:text-embedding-3-small",
       "openrouter:openai/text-embedding-3-small",
       "openai:text-embedding-3-small",
+      "venice:text-embedding-3-large",
     ]);
   });
 });
diff --git a/packages/db/src/queries/llm-usage.ts b/packages/db/src/queries/llm-usage.ts
index d5990a00c..1941606aa 100644
--- a/packages/db/src/queries/llm-usage.ts
+++ b/packages/db/src/queries/llm-usage.ts
@@ -897,9 +897,14 @@ export async function classifySurplusLlmAttemptRecovery(input: {
   recoveryState: "pending" | "retryable" | "blocked_repair";
   failureCode: string;
 }): Promise<boolean> {
+  const recoveryFailureCode = assertNonEmpty(input.failureCode, "failureCode");
   const rows = await db().update(llmUsageEvents).set({
     recoveryState: input.recoveryState,
-    failureCode: assertNonEmpty(input.failureCode, "failureCode"),
+    // Receipt recovery is independent of the inference outcome. Preserve the
+    // original failureCode and keep this mutable diagnostic in metadata.
+    metadata: sql`coalesce(${llmUsageEvents.metadata}, '{}'::jsonb) || ${JSON.stringify({
+      surplusReceiptRecoveryFailureCode: recoveryFailureCode,
+    })}::jsonb`,
     updatedAt: new Date(),
   }).where(and(
     eq(llmUsageEvents.id, input.attemptId),
@@ -921,7 +926,7 @@ export async function requeueBlockedPersonalSurplusAttempts(input: {
   }
   const rows = await db().update(llmUsageEvents).set({
     recoveryState: "retryable",
-    failureCode: null,
+    metadata: sql`${llmUsageEvents.metadata} - 'surplusReceiptRecoveryFailureCode'`,
     updatedAt: new Date(),
   }).where(and(
     eq(llmUsageEvents.providerRoute, "surplus"),
@@ -950,19 +955,27 @@ export async function requeueBlockedPersonalSurplusAttempts(input: {
 export async function requeueBlockedServerSurplusAttempts(): Promise<number> {
   const rows = await db().update(llmUsageEvents).set({
     recoveryState: "retryable",
-    failureCode: null,
+    metadata: sql`${llmUsageEvents.metadata} - 'surplusReceiptRecoveryFailureCode'`,
     updatedAt: new Date(),
   }).where(and(
     eq(llmUsageEvents.providerRoute, "surplus"),
     inArray(llmUsageEvents.fundingKind, ["server", "service"]),
     eq(llmUsageEvents.recoveryState, "blocked_repair"),
     inArray(llmUsageEvents.costState, ["pending", "unknown"]),
-    inArray(llmUsageEvents.failureCode, [
-      "credential_missing",
-      "credential_fingerprint_mismatch",
-      "receipt_account_unproven",
-      "receipt_read_unauthorized",
-    ]),
+    or(
+      inArray(llmUsageEvents.failureCode, [
+        "credential_missing",
+        "credential_fingerprint_mismatch",
+        "receipt_account_unproven",
+        "receipt_read_unauthorized",
+      ]),
+      sql`${llmUsageEvents.metadata}->>'surplusReceiptRecoveryFailureCode' in (
+        'credential_missing',
+        'credential_fingerprint_mismatch',
+        'receipt_account_unproven',
+        'receipt_read_unauthorized'
+      )`,
+    ),
   )).returning({ id: llmUsageEvents.id });
   return rows.length;
 }
@@ -974,13 +987,16 @@ export async function requeueBlockedServerSurplusAttempts(): Promise<number> {
 export async function requeueBlockedSurplusDecisionAttempts(): Promise<number> {
   const rows = await db().update(llmUsageEvents).set({
     recoveryState: "retryable",
-    failureCode: null,
+    metadata: sql`${llmUsageEvents.metadata} - 'surplusReceiptRecoveryFailureCode'`,
     updatedAt: new Date(),
   }).where(and(
     eq(llmUsageEvents.providerRoute, "surplus"),
     eq(llmUsageEvents.endpoint, "/v1/decisions"),
     eq(llmUsageEvents.recoveryState, "blocked_repair"),
-    eq(llmUsageEvents.failureCode, "receipt_endpoint_unsupported"),
+    or(
+      eq(llmUsageEvents.failureCode, "receipt_endpoint_unsupported"),
+      sql`${llmUsageEvents.metadata}->>'surplusReceiptRecoveryFailureCode' = 'receipt_endpoint_unsupported'`,
+    ),
     inArray(llmUsageEvents.costState, ["pending", "unknown"]),
   )).returning({ id: llmUsageEvents.id });
   return rows.length;
diff --git a/packages/db/tests/unit/surplus-llm-attempts.test.ts b/packages/db/tests/unit/surplus-llm-attempts.test.ts
index c8a3e3885..d2c035c20 100644
--- a/packages/db/tests/unit/surplus-llm-attempts.test.ts
+++ b/packages/db/tests/unit/surplus-llm-attempts.test.ts
@@ -9,6 +9,7 @@ import {
   beginServiceLlmAttempt,
   beginServerLlmAttempt,
   beginSurplusLlmAttempt,
+  classifySurplusLlmAttemptRecovery,
   interruptExpiredPersonalLlmAttempts,
   interruptPersonalLlmAttemptsByOwner,
   listPendingSurplusAttempts,
@@ -456,6 +457,23 @@ describe("Surplus durable LLM attempts", () => {
     expect(fake.updated[0]?.["attemptOutcome"]).not.toBe("cancelled");
   });
 
+  test("receipt recovery classification preserves the original inference failure", async () => {
+    const fake = mutationDb({ returning: [{ id: ATTEMPT_ID }] });
+    __setLlmUsageDbForTests(fake.handle);
+    expect(await classifySurplusLlmAttemptRecovery({
+      attemptId: ATTEMPT_ID,
+      expectedUpdatedAt: new Date(0),
+      recoveryState: "retryable",
+      failureCode: "receipt_not_found",
+    })).toBe(true);
+    expect(fake.updated[0]).toMatchObject({ recoveryState: "retryable" });
+    expect(fake.updated[0]).not.toHaveProperty("failureCode");
+    const metadata = new PgDialect().sqlToQuery(fake.updated[0]?.["metadata"] as SQL);
+    expect(metadata.params).toContain(JSON.stringify({
+      surplusReceiptRecoveryFailureCode: "receipt_not_found",
+    }));
+  });
+
   test("requeues a payer's old blocked receipts only behind a current-key guard", async () => {
     const fake = mutationDb({ returning: [{ id: ATTEMPT_ID }] });
     __setLlmUsageDbForTests(fake.handle);
@@ -466,8 +484,8 @@ describe("Surplus durable LLM attempts", () => {
     })).toBe(1);
     expect(fake.updated[0]).toMatchObject({
       recoveryState: "retryable",
-      failureCode: null,
     });
+    expect(fake.updated[0]).not.toHaveProperty("failureCode");
     const predicate = new PgDialect().sqlToQuery(fake.updatePredicates[0]!);
     expect(predicate.sql).toContain("exists (select 1 where");
     expect(predicate.sql).toContain('"personal_provider_credentials"."id"');
@@ -480,8 +498,8 @@ describe("Surplus durable LLM attempts", () => {
     expect(await requeueBlockedServerSurplusAttempts()).toBe(1);
     expect(fake.updated[0]).toMatchObject({
       recoveryState: "retryable",
-      failureCode: null,
     });
+    expect(fake.updated[0]).not.toHaveProperty("failureCode");
     const predicate = new PgDialect().sqlToQuery(fake.updatePredicates[0]!);
     expect(predicate.params).toContain("server");
     expect(predicate.params).toContain("service");
@@ -499,8 +517,8 @@ describe("Surplus durable LLM attempts", () => {
     expect(await requeueBlockedSurplusDecisionAttempts()).toBe(1);
     expect(fake.updated[0]).toMatchObject({
       recoveryState: "retryable",
-      failureCode: null,
     });
+    expect(fake.updated[0]).not.toHaveProperty("failureCode");
     const predicate = new PgDialect().sqlToQuery(fake.updatePredicates[0]!);
     expect(predicate.params).toContain("surplus");
     expect(predicate.params).toContain("/v1/decisions");
diff --git a/packages/genie-customization-ui/src/screens/RevealScreen.tsx b/packages/genie-customization-ui/src/screens/RevealScreen.tsx
index 65d38a4b9..60c0791b5 100644
--- a/packages/genie-customization-ui/src/screens/RevealScreen.tsx
+++ b/packages/genie-customization-ui/src/screens/RevealScreen.tsx
@@ -41,6 +41,14 @@ type RevealPhase =
   | "completing"
   | "error";
 
+export const SOUL_NOT_GENERATED_NOTICE =
+  "Your profile was saved without a generated Soul. You can add one later in Settings.";
+
+function combineNotices(...notices: Array<string | null>): string | null {
+  const present = notices.filter((notice): notice is string => notice !== null);
+  return present.length > 0 ? present.join(" ") : null;
+}
+
 function playableAudioUrl(rawUrl: string): { url: string; revoke: boolean } {
   if (!rawUrl.startsWith("data:")) return { url: rawUrl, revoke: false };
   const [meta = "", base64 = ""] = rawUrl.split(",", 2);
@@ -65,8 +73,8 @@ function buildSoulInput(state: ScreenProps["state"]) {
 
 /**
  * Test seam for non-linear flows that reach Reveal without having started soul
- * generation. Reveal may enqueue the work, but final profile persistence never
- * waits for the model request.
+ * generation. Reveal starts the same reducer-fenced generation used by the
+ * ordinary Compiling screen before it starts final profile persistence.
  */
 export function shouldStartSoulGenerationAtReveal(state: ScreenProps["state"]): boolean {
   return state.compilingPhase === "idle" && state.soulFile === null;
@@ -74,6 +82,7 @@ export function shouldStartSoulGenerationAtReveal(state: ScreenProps["state"]):
 
 export function RevealScreen({
   state,
+  dispatch,
   api,
 }: ScreenProps): React.ReactElement {
   const [phase, setPhase] = useState<RevealPhase>("writing");
@@ -91,13 +100,44 @@ export function RevealScreen({
   useEffect(() => {
     if (phase !== "writing") return;
     if (!api) return;
-    // The model request can take a minute or more. Desktop owns it after IPC
-    // dispatch and persists the result when it finishes, even if this window
-    // has already closed. Never turn that background work into a save blocker.
+
+    // A non-linear flow can reach Reveal before Compiling starts. Route that
+    // request through the ordinary reducer generation fence so its result is
+    // part of the one final profile mutation rather than discarded.
     if (shouldStartSoulGenerationAtReveal(state) && !lateSoulStartedRef.current) {
       lateSoulStartedRef.current = true;
-      void api.generateSoul(buildSoulInput(state)).catch(() => undefined);
+      const generation = state.compilingGeneration + 1;
+      dispatch({ type: "START_COMPILE" });
+      void (async () => {
+        try {
+          const result = await api.generateSoul(buildSoulInput(state));
+          if (result.ok) {
+            dispatch({
+              type: "FINISH_COMPILE",
+              generation,
+              soulFile: result.data.soulFile,
+            });
+            return;
+          }
+          dispatch({ type: "ERROR_COMPILE", generation, message: result.error });
+        } catch {
+          dispatch({
+            type: "ERROR_COMPILE",
+            generation,
+            message: "Soul generation failed.",
+          });
+        }
+      })();
+      return;
     }
+
+    // Compiling may have auto-advanced after its seven-second display cap.
+    // Keep later wizard screens non-blocking, but do not commit the final
+    // profile until the already-authorized request settles. This guarantees a
+    // successful Soul is included exactly once and never replays a failure.
+    if (state.compilingPhase === "running" || state.compilingPhase === "background") return;
+    // StrictMode can probe this effect again before START_COMPILE rerenders.
+    if (state.compilingPhase === "idle" && state.soulFile === null) return;
     if (profileWriteStartedRef.current) return;
     if (!state.voiceSelection && !state.voiceSkipped) {
       // A null voice is valid only when the user explicitly skipped voice.
@@ -132,7 +172,10 @@ export function RevealScreen({
         setPhase("error");
         return;
       }
-      setNotice(res.notice);
+      setNotice(combineNotices(
+        res.notice,
+        state.soulFile === null ? SOUL_NOT_GENERATED_NOTICE : null,
+      ));
       if (res.voice === "assigned") {
         setGreetingAudioUrl(res.greetingAudioUrl);
         setPhase("greeting");
@@ -140,7 +183,7 @@ export function RevealScreen({
         setPhase("ready");
       }
     })();
-  }, [phase, api, state, newlyUsableVoice]);
+  }, [phase, api, state, dispatch, newlyUsableVoice]);
 
   // Step 2.5: greeting playback.
   useEffect(() => {
diff --git a/packages/lattice-bridge/src/client/browser/index.ts b/packages/lattice-bridge/src/client/browser/index.ts
index ddbb4b20f..ae8b0621e 100644
--- a/packages/lattice-bridge/src/client/browser/index.ts
+++ b/packages/lattice-bridge/src/client/browser/index.ts
@@ -1329,7 +1329,9 @@ export {
   type AuthorizedHumanMemoryReadResultV1,
   type AuthorizedHumanMemoryTestAuthority,
   type AuthorizedHumanMemoryUnavailableReason,
+  type AuthorizedHumanMemoryWriteIntent,
   type AuthorizedHumanMemoryWriteIntentV1,
+  type AuthorizedHumanMemoryWriteIntentV2,
 } from "../memory/authorized-human-memory-client.ts";
 export {
   createVaultAuthorizedHumanMemoryDeviceContentPort,
diff --git a/packages/lattice-bridge/src/client/electron/index.ts b/packages/lattice-bridge/src/client/electron/index.ts
index e1f958f89..79f558f9c 100644
--- a/packages/lattice-bridge/src/client/electron/index.ts
+++ b/packages/lattice-bridge/src/client/electron/index.ts
@@ -693,7 +693,9 @@ export {
   type AuthorizedHumanMemoryReadResultV1,
   type AuthorizedHumanMemoryTestAuthority,
   type AuthorizedHumanMemoryUnavailableReason,
+  type AuthorizedHumanMemoryWriteIntent,
   type AuthorizedHumanMemoryWriteIntentV1,
+  type AuthorizedHumanMemoryWriteIntentV2,
 } from "../memory/authorized-human-memory-client.ts";
 export {
   createVaultAuthorizedHumanMemoryDeviceContentPort,
diff --git a/packages/lattice-bridge/src/client/memory/authorized-human-memory-client.ts b/packages/lattice-bridge/src/client/memory/authorized-human-memory-client.ts
index 630d37534..740df8de5 100644
--- a/packages/lattice-bridge/src/client/memory/authorized-human-memory-client.ts
+++ b/packages/lattice-bridge/src/client/memory/authorized-human-memory-client.ts
@@ -17,6 +17,11 @@ import type {
   ProtectedMemoryPreparedRepairRequestV1,
   ProtectedMemoryRepairResponseV1,
 } from "@nautilo/api-client/browser";
+import {
+  decodeMemoryEmbeddingDisclosureV2,
+  encodeMemoryEmbeddingDisclosureV2,
+  type MemoryEmbeddingDisclosureV2,
+} from "@nautilo/lattice-crypto/wire";
 
 import {
   decodeMemoryPayloadV1,
@@ -63,6 +68,7 @@ export type ProtectedMemoryApi = ProtectedMemoryApiBase &
         mode: "text" | "semantic";
         limit?: number;
         includeArchive?: boolean;
+        embeddingDisclosure?: MemoryEmbeddingDisclosureV2;
       }>,
     ): ReturnType<NautiloApiClient["searchProtectedMemories"]>;
     createProtectedMemory(
@@ -102,6 +108,16 @@ export type AuthorizedHumanMemoryWriteIntentV1 = Readonly<{
   requestedModel: string;
 }>;
 
+export type AuthorizedHumanMemoryWriteIntentV2 = Readonly<{
+  payload: MemoryPayloadV1;
+  importance?: number;
+  requestedEmbedding: MemoryEmbeddingDisclosureV2;
+}>;
+
+export type AuthorizedHumanMemoryWriteIntent =
+  | AuthorizedHumanMemoryWriteIntentV1
+  | AuthorizedHumanMemoryWriteIntentV2;
+
 export type AuthorizedHumanMemoryOpenedV1 = Readonly<{
   projection: ProtectedMemoryProjectionV1;
   payload: MemoryPayloadV1;
@@ -158,13 +174,13 @@ export interface AuthorizedHumanMemoryDeviceContentPort {
   prepareCreate(
     input: Readonly<{
       plan: Exclude<ProtectedMemoryCreatePlanResponseV1, { status: string }>;
-      intent: AuthorizedHumanMemoryWriteIntentV1;
+      intent: AuthorizedHumanMemoryWriteIntent;
     }>,
   ): Promise<ProtectedMemoryPreparedCreateRequestV1>;
   prepareUpdate(
     input: Readonly<{
       current: ProtectedMemoryDtoV1;
-      intent: AuthorizedHumanMemoryWriteIntentV1;
+      intent: AuthorizedHumanMemoryWriteIntent;
     }>,
   ): Promise<ProtectedMemoryPreparedUpdateRequestV1>;
   prepareOrdinaryFallbackCreate?(
@@ -172,14 +188,14 @@ export interface AuthorizedHumanMemoryDeviceContentPort {
       plan:
         | ProtectedMemoryOrdinaryFallbackCreatePlanV1
         | Exclude<ProtectedMemoryCreatePlanResponseV1, { status: string }>;
-      intent: AuthorizedHumanMemoryWriteIntentV1;
+      intent: AuthorizedHumanMemoryWriteIntent;
     }>,
   ): Promise<ProtectedMemoryOrdinaryFallbackCreateRequestV1>;
   prepareOrdinaryFallbackUpdate?(
     input: Readonly<{
       current: ProtectedMemoryDtoV1;
       policyRevision: number;
-      intent: AuthorizedHumanMemoryWriteIntentV1;
+      intent: AuthorizedHumanMemoryWriteIntent;
     }>,
   ): Promise<ProtectedMemoryOrdinaryFallbackUpdateRequestV1>;
   prepareAccess(
@@ -314,12 +330,12 @@ export interface AuthorizedHumanMemoryClient {
       HumanMemoryObservationDeliveryResult
   >;
   create(
-    intent: AuthorizedHumanMemoryWriteIntentV1,
+    intent: AuthorizedHumanMemoryWriteIntent,
     use: (opened: AuthorizedHumanMemoryOpenedV1) => void | Promise<void>,
   ): Promise<ContentCompletion>;
   update(
     memoryId: string,
-    intent: AuthorizedHumanMemoryWriteIntentV1,
+    intent: AuthorizedHumanMemoryWriteIntent,
     use: (opened: AuthorizedHumanMemoryOpenedV1) => void | Promise<void>,
   ): Promise<ContentCompletion>;
   archive(memoryId: string): Promise<
@@ -429,25 +445,29 @@ function exactStrings(
 }
 
 function normalizeWriteIntent(
-  value: AuthorizedHumanMemoryWriteIntentV1,
-): AuthorizedHumanMemoryWriteIntentV1 {
+  value: AuthorizedHumanMemoryWriteIntent,
+): AuthorizedHumanMemoryWriteIntent {
   const fields = Object.keys(value).sort();
-  const expected =
-    value.importance === undefined
-      ? ["payload", "requestedModel", "requestedProvider"]
+  const v2 = "requestedEmbedding" in value;
+  const expected = value.importance === undefined
+    ? v2 ? ["payload", "requestedEmbedding"]
+      : ["payload", "requestedModel", "requestedProvider"]
+    : v2 ? ["importance", "payload", "requestedEmbedding"]
       : ["importance", "payload", "requestedModel", "requestedProvider"];
   if (
     fields.length !== expected.length ||
     fields.some((field, index) => field !== expected[index])
   )
     throw new TypeError("Protected Human Memory write intent is invalid");
-  if (
-    value.requestedProvider !== "openai" &&
-    value.requestedProvider !== "openrouter" && value.requestedProvider !== "venice"
-  )
-    throw new TypeError("Protected Human Memory provider is invalid");
-  if (!/^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,127}$/u.test(value.requestedModel))
-    throw new TypeError("Protected Human Memory model is invalid");
+  if (!v2) {
+    if (value.requestedProvider !== "openai" && value.requestedProvider !== "openrouter"
+      && value.requestedProvider !== "venice") {
+      throw new TypeError("Protected Human Memory provider is invalid");
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,127}$/u.test(value.requestedModel)) {
+      throw new TypeError("Protected Human Memory model is invalid");
+    }
+  }
   if (
     value.importance !== undefined &&
     (!Number.isFinite(value.importance) ||
@@ -457,14 +477,20 @@ function normalizeWriteIntent(
     throw new TypeError("Protected Human Memory importance is invalid");
   const payloadBytes = encodeMemoryPayloadV1(value.payload);
   try {
-    return Object.freeze({
+    const common = {
       payload: decodeMemoryPayloadV1(payloadBytes),
       ...(value.importance === undefined
         ? {}
         : { importance: value.importance }),
+    };
+    if (!v2) return Object.freeze({ ...common,
       requestedProvider: value.requestedProvider,
-      requestedModel: value.requestedModel,
-    });
+      requestedModel: value.requestedModel });
+    const disclosure = encodeMemoryEmbeddingDisclosureV2(value.requestedEmbedding);
+    try {
+      return Object.freeze({ ...common,
+        requestedEmbedding: decodeMemoryEmbeddingDisclosureV2(disclosure) });
+    } finally { disclosure.fill(0); }
   } finally {
     payloadBytes.fill(0);
   }
diff --git a/packages/lattice-bridge/src/client/memory/human-memory-processor-transport.ts b/packages/lattice-bridge/src/client/memory/human-memory-processor-transport.ts
index 2b16a9da2..8faf31b19 100644
--- a/packages/lattice-bridge/src/client/memory/human-memory-processor-transport.ts
+++ b/packages/lattice-bridge/src/client/memory/human-memory-processor-transport.ts
@@ -1,7 +1,15 @@
-import type { MemoryProcessorRequestPurposeV1, NautiloApiClient } from
+import { ApiError, type MemoryProcessorRequestPurposeV1, type NautiloApiClient } from
   "@nautilo/api-client/browser";
 import type { LatticeCrypto } from "@nautilo/lattice-crypto";
-import { sealForegroundMemoryProcessorRequest } from "../../memory/foreground-memory-processor-transport.ts";
+import {
+  sameMemoryEmbeddingDisclosureV2,
+  type MemoryEmbeddingDisclosureV2,
+} from "@nautilo/lattice-crypto/wire";
+import {
+  sealForegroundMemoryProcessorRequest,
+  sealForegroundMemoryProcessorRequestV2,
+  sealForegroundMemoryProcessorSearchQueryV2,
+} from "../../memory/foreground-memory-processor-transport.ts";
 import type { ProtectedMemoryApi } from "./authorized-human-memory-client.ts";
 
 function requiredString(value: object, field: string): string {
@@ -22,17 +30,44 @@ export function createHumanMemoryProcessorTransport(input: Readonly<{
   crypto: LatticeCrypto;
   subjectId: string;
   now?: () => number;
+  /** Disclosure already shown to and approved by the human for this action. */
+  resolveEmbeddingDisclosure?: () => MemoryEmbeddingDisclosureV2 | undefined;
 }>): ProtectedMemoryApi {
   const { api } = input;
-  const seal = async (purpose: MemoryProcessorRequestPurposeV1, payload: string) =>
-    sealForegroundMemoryProcessorRequest({
+  const recipient = async () => {
+    try {
+      return Object.freeze({ kind: "v2" as const,
+        value: await api.getMemoryProcessorRecipientV2() });
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 404) throw error;
+      return Object.freeze({ kind: "v1" as const,
+        value: await api.getMemoryProcessorRecipient() });
+    }
+  };
+  const seal = async (purpose: MemoryProcessorRequestPurposeV1, payload: string) => {
+    const current = await recipient();
+    const common = {
       crypto: input.crypto,
-      recipient: await api.getMemoryProcessorRecipient(),
       subjectId: input.subjectId,
       purpose,
       payload,
       ...(input.now === undefined ? {} : { now: input.now }),
-    });
+    };
+    if (current.kind === "v1") {
+      return sealForegroundMemoryProcessorRequest({ ...common, recipient: current.value });
+    }
+    if (current.value.embedding === undefined) {
+      throw new TypeError("Memory embedding is unavailable");
+    }
+    const approved = input.resolveEmbeddingDisclosure?.();
+    if (approved !== undefined
+      && !sameMemoryEmbeddingDisclosureV2(approved, current.value.embedding)) {
+      throw new TypeError(
+        "The Memory embedding disclosure changed. Reload it before trying again.",
+      );
+    }
+    return sealForegroundMemoryProcessorRequestV2({ ...common, recipient: current.value });
+  };
   return Object.freeze({
     listProtectedMemories: api.listProtectedMemories.bind(api),
     getProtectedMemory: api.getProtectedMemory.bind(api),
@@ -45,9 +80,43 @@ export function createHumanMemoryProcessorTransport(input: Readonly<{
     commitProtectedMemoryAccess: api.commitProtectedMemoryAccess.bind(api),
     planProtectedMemoryRepair: api.planProtectedMemoryRepair.bind(api),
     commitProtectedMemoryRepair: api.commitProtectedMemoryRepair.bind(api),
-    async searchProtectedMemories({ q, ...options }) {
-      return api.searchProtectedMemories({ ...options,
-        sealedQuery: await seal("memory.query_embedding", q),
+    async searchProtectedMemories({ q, embeddingDisclosure, ...options }) {
+      const current = await recipient();
+      if (current.kind === "v1") {
+        return api.searchProtectedMemories({ ...options,
+          sealedQuery: await sealForegroundMemoryProcessorRequest({
+            crypto: input.crypto,
+            recipient: current.value,
+            subjectId: input.subjectId,
+            purpose: "memory.query_embedding",
+            payload: q,
+            ...(input.now === undefined ? {} : { now: input.now }),
+          }),
+        });
+      }
+      if (current.value.embedding === undefined) {
+        throw new TypeError("Memory embedding is unavailable");
+      }
+      const approved = embeddingDisclosure ?? input.resolveEmbeddingDisclosure?.();
+      if (approved === undefined) {
+        throw new TypeError(
+          "Memory search requires the embedding disclosure shown to the human.",
+        );
+      }
+      if (!sameMemoryEmbeddingDisclosureV2(approved, current.value.embedding)) {
+        throw new TypeError(
+          "The Memory embedding disclosure changed. Reload it before trying again.",
+        );
+      }
+      return api.searchProtectedMemoriesV2({ ...options,
+        sealedQueryV2: await sealForegroundMemoryProcessorSearchQueryV2({
+          crypto: input.crypto,
+          recipient: current.value,
+          subjectId: input.subjectId,
+          query: q,
+          embeddingDisclosure: approved,
+          ...(input.now === undefined ? {} : { now: input.now }),
+        }),
       });
     },
     async createProtectedMemory(prepared) {
diff --git a/packages/lattice-bridge/src/client/memory/vault-human-memory-device-content.ts b/packages/lattice-bridge/src/client/memory/vault-human-memory-device-content.ts
index e6db18106..55c4ef848 100644
--- a/packages/lattice-bridge/src/client/memory/vault-human-memory-device-content.ts
+++ b/packages/lattice-bridge/src/client/memory/vault-human-memory-device-content.ts
@@ -23,6 +23,7 @@ import {
   encodeEncryptedPayloadV2,
   encodeNamespaceObjectEnvelopeV2,
   encodeObjectAccessManifestV5,
+  prepareHumanMemoryContentEmbeddingRequestV3,
 } from "@nautilo/lattice-crypto/wire";
 
 import {
@@ -68,9 +69,11 @@ import {
 } from "../foreground-agent-accepted-execution.ts";
 import { prepareHumanMemoryOrdinaryFallbackRequestV1 } from
   "../../memory/human-memory-ordinary-fallback-request.ts";
+import { prepareHumanMemoryOrdinaryFallbackRequestV2 } from
+  "../../memory/human-memory-ordinary-fallback-request.ts";
 import type {
   AuthorizedHumanMemoryDeviceContentPort,
-  AuthorizedHumanMemoryWriteIntentV1,
+  AuthorizedHumanMemoryWriteIntent,
 } from "./authorized-human-memory-client.ts";
 import type {
   DeviceAdmissionStatus,
@@ -532,7 +535,7 @@ async function prepareOrdinaryFallback(
     nextContentRevision: number; expectedCryptoAccessRevision: number;
     requiredNamespaceIds: readonly string[]; policyRevision: number;
     planIssuedAt: number | null; planDeadlineAt: number | null;
-    issuedAt: number; deadlineAt: number; intent: AuthorizedHumanMemoryWriteIntentV1;
+    issuedAt: number; deadlineAt: number; intent: AuthorizedHumanMemoryWriteIntent;
   }>,
 ) {
   return withProfile(input, async (profile) => {
@@ -541,7 +544,7 @@ async function prepareOrdinaryFallback(
       || admission.deviceId !== input.coordinates.deviceId) {
       throw new AuthorizedHumanMemoryUnavailableError("authorization_required");
     }
-    const prepared = prepareHumanMemoryOrdinaryFallbackRequestV1(input.crypto, {
+    const common = {
       formatVersion: 1, purpose: source.purpose,
       reason: "target_encryption_not_ready", operationId: source.operationId,
       memoryId: source.memoryId,
@@ -553,9 +556,6 @@ async function prepareOrdinaryFallback(
       ...(source.intent.importance === undefined ? {} : {
         importance: source.intent.importance,
       }),
-      requestedProvider: source.intent.requestedProvider,
-      requestedModel: source.intent.requestedModel,
-      dimensions: 1536, processorContractVersion: 1,
       policyRevision: source.policyRevision, subjectHumanId: input.subjectHumanId,
       committerDeviceId: profile.deviceId,
       committerDeviceSigningKeyGeneration: admission.deviceGeneration,
@@ -563,7 +563,21 @@ async function prepareOrdinaryFallback(
       planIssuedAt: source.planIssuedAt, planDeadlineAt: source.planDeadlineAt,
       issuedAt: source.issuedAt, deadlineAt: source.deadlineAt,
       signingPrivateKey: profile.signingPrivateKey,
-    });
+    } as const;
+    const prepared = "requestedEmbedding" in source.intent
+      ? prepareHumanMemoryOrdinaryFallbackRequestV2(input.crypto, {
+          ...common,
+          formatVersion: 2,
+          requestedEmbedding: source.intent.requestedEmbedding,
+          processorContractVersion: 2,
+        })
+      : prepareHumanMemoryOrdinaryFallbackRequestV1(input.crypto, {
+          ...common,
+          requestedProvider: source.intent.requestedProvider,
+          requestedModel: source.intent.requestedModel,
+          dimensions: 1536,
+          processorContractVersion: 1,
+        });
     try { return toBase64url(prepared.bytes); }
     finally {
       prepared.bytes.fill(0);
@@ -862,7 +876,7 @@ async function prepareContentRevision(input: Readonly<{
   namespaceIds: readonly string[];
   authorities: readonly ProtectedMemoryNamespaceAuthorityV1[];
   deadlineAt: number;
-  intent: AuthorizedHumanMemoryWriteIntentV1;
+  intent: AuthorizedHumanMemoryWriteIntent;
 }>): Promise<Readonly<{
   cryptoObjectId: string;
   payloadBytes: Uint8Array;
@@ -917,9 +931,7 @@ async function prepareContentRevision(input: Readonly<{
         payloadBytes = sealed.payloadBytes;
         envelopeBytes = sealed.envelopeBytes;
         manifestBytes = sealed.manifestBytes;
-        const signedRequest = prepareHumanMemoryContentEmbeddingRequest(
-          input.dependencies.crypto,
-          {
+        const common = {
             subjectHumanId: humanId(input.dependencies.subjectHumanId),
             requestId: input.operationId,
             memoryId: input.memoryId,
@@ -938,10 +950,6 @@ async function prepareContentRevision(input: Readonly<{
             content: input.intent.payload.content,
             ...(input.intent.importance === undefined
               ? {} : { importance: input.intent.importance }),
-            requestedProvider: input.intent.requestedProvider,
-            requestedModel: input.intent.requestedModel,
-            dimensions: 1536,
-            processorContractVersion: 1,
             issuedAt: unixTimestamp(now),
             deadlineAt: unixTimestamp(Math.min(
               input.deadlineAt,
@@ -953,8 +961,22 @@ async function prepareContentRevision(input: Readonly<{
             ),
             committerSigningPublicKey: input.profile.signingPublicKey,
             committerSigningPrivateKey: input.profile.signingPrivateKey,
-          },
-        );
+        } as const;
+        const signedRequest = "requestedEmbedding" in input.intent
+          ? prepareHumanMemoryContentEmbeddingRequestV3(
+              input.dependencies.crypto,
+              { ...common,
+                requestedEmbedding: input.intent.requestedEmbedding,
+                processorContractVersion: 2 },
+            )
+          : prepareHumanMemoryContentEmbeddingRequest(
+              input.dependencies.crypto,
+              { ...common,
+                requestedProvider: input.intent.requestedProvider,
+                requestedModel: input.intent.requestedModel,
+                dimensions: 1536,
+                processorContractVersion: 1 },
+            );
         signedRequestBytes = signedRequest.bytes;
         return Object.freeze({
           cryptoObjectId,
@@ -1351,7 +1373,7 @@ export function createVaultAuthorizedHumanMemoryDeviceContentPort(
     },
     prepareCreate: ({ plan: rawPlan, intent }: Readonly<{
       plan: ProtectedMemoryCreatePlanSlotResponseV1;
-      intent: AuthorizedHumanMemoryWriteIntentV1;
+      intent: AuthorizedHumanMemoryWriteIntent;
     }>) =>
       withProfile(dependencies, async (profile) => {
         const plan = exactCreatePlan(rawPlan);
@@ -1428,7 +1450,7 @@ export function createVaultAuthorizedHumanMemoryDeviceContentPort(
     },
     prepareUpdate: async ({ current, intent }: Readonly<{
       current: ProtectedMemoryDtoV1;
-      intent: AuthorizedHumanMemoryWriteIntentV1;
+      intent: AuthorizedHumanMemoryWriteIntent;
     }>) => {
       if (current.protectedPayload.status !== "encrypted") {
         throw new Error("Protected Human Memory ciphertext is unavailable");
diff --git a/packages/lattice-bridge/src/client/message/foreground-shadow-client-composition.ts b/packages/lattice-bridge/src/client/message/foreground-shadow-client-composition.ts
index b7341b7ab..8e2f1acaa 100644
--- a/packages/lattice-bridge/src/client/message/foreground-shadow-client-composition.ts
+++ b/packages/lattice-bridge/src/client/message/foreground-shadow-client-composition.ts
@@ -1,4 +1,5 @@
 import { ApiError, type NautiloApiClient } from "@nautilo/api-client/browser";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/lattice-crypto/wire";
 import { createObservedHumanMemoryDeviceContent } from "../memory/observed-human-memory-device-content.ts";
 import type { DeviceAdmissionStatus } from "@nautilo/api-client/browser";
 import {
@@ -811,6 +812,7 @@ export type ForegroundHumanMemoryClientInput = Readonly<{
   createIdempotencyKey?: () => string;
   resolveDeviceAdmissionStatus: () => Promise<DeviceAdmissionStatus>;
   onProtectedRoomAccessState?: (state: ProtectedRoomAccessStateV2) => void;
+  resolveEmbeddingDisclosure?: () => MemoryEmbeddingDisclosureV2 | undefined;
 }>;
 
 /**
@@ -862,6 +864,9 @@ export function createForegroundHumanMemoryClient(
     owner: input.dataOperationOwner,
     api: createHumanMemoryProcessorTransport({
       api: input.api, crypto, subjectId: input.userId, now,
+      ...(input.resolveEmbeddingDisclosure === undefined ? {} : {
+        resolveEmbeddingDisclosure: input.resolveEmbeddingDisclosure,
+      }),
     }),
     content: createObservedHumanMemoryDeviceContent({
       crypto,
diff --git a/packages/lattice-bridge/src/index.ts b/packages/lattice-bridge/src/index.ts
index 15e12c218..390839c65 100644
--- a/packages/lattice-bridge/src/index.ts
+++ b/packages/lattice-bridge/src/index.ts
@@ -10,7 +10,12 @@ export {
 
 export {
   createForegroundMemoryProcessorRecipient,
+  decodeMemoryProcessorSearchQueryV2,
+  encodeMemoryProcessorSearchQueryV2,
   sealForegroundMemoryProcessorRequest,
+  sealForegroundMemoryProcessorRequestV2,
+  sealForegroundMemoryProcessorSearchQueryV2,
+  type MemoryProcessorSearchQueryV2,
 } from "./memory/foreground-memory-processor-transport.ts";
 export { createHumanMemoryProcessorTransport } from "./client/memory/human-memory-processor-transport.ts";
 export {
@@ -97,7 +102,9 @@ export {
   type AuthorizedHumanMemoryReadResultV1,
   type AuthorizedHumanMemoryTestAuthority,
   type AuthorizedHumanMemoryUnavailableReason,
+  type AuthorizedHumanMemoryWriteIntent,
   type AuthorizedHumanMemoryWriteIntentV1,
+  type AuthorizedHumanMemoryWriteIntentV2,
 } from "./client/memory/authorized-human-memory-client.ts";
 export {
   createVaultAuthorizedHumanMemoryDeviceContentPort,
@@ -1386,5 +1393,20 @@ export {
 export * from "./message/message-backfill-ack.ts";
 export * from "./message/message-backfill-state.ts";
 export { PROTECTED_TOP_LEVEL_ROOM_KINDS, isProtectedTopLevelRoomKind } from "./message/protected-room-topology.ts";
+
+export {
+  createHumanMemoryOrdinaryFallbackReplayAdmissionV2,
+  encodeHumanMemoryOrdinaryFallbackRequestV2,
+  decodeHumanMemoryOrdinaryFallbackRequestV2,
+  digestHumanMemoryOrdinaryFallbackRequestV2,
+  prepareHumanMemoryOrdinaryFallbackRequestV2,
+  verifyHumanMemoryOrdinaryFallbackRequestV2,
+} from "./memory/human-memory-ordinary-fallback-request.ts";
+export type {
+  HumanMemoryOrdinaryFallbackUnsignedRequestV2,
+  HumanMemoryOrdinaryFallbackRequestV2,
+  AuthenticatedHumanMemoryOrdinaryFallbackRequestV2,
+  HumanMemoryOrdinaryFallbackReplayAdmissionV2,
+} from "./memory/human-memory-ordinary-fallback-request.ts";
 export * from "./client/task/device-task-content-backfill-client.ts";
 export * from "./client/task/task-content-backfill-worker.ts";
diff --git a/packages/lattice-bridge/src/memory/foreground-embedding-processor.ts b/packages/lattice-bridge/src/memory/foreground-embedding-processor.ts
index ac23fc010..55d282356 100644
--- a/packages/lattice-bridge/src/memory/foreground-embedding-processor.ts
+++ b/packages/lattice-bridge/src/memory/foreground-embedding-processor.ts
@@ -1,5 +1,11 @@
+import {
+  assertMemoryEmbeddingDisclosureV2,
+  type MemoryEmbeddingDisclosureV2,
+} from "@nautilo/lattice-crypto/wire";
+
 export const MEMORY_EMBEDDING_DIMENSIONS = 1536 as const;
 export const MEMORY_FOREGROUND_PROCESSOR_CONTRACT_VERSION = 1 as const;
+const MEMORY_FOREGROUND_DISCLOSURE_CONTRACT_VERSION = 2 as const;
 export const MEMORY_CONTENT_EMBEDDING_MAX_BYTES = 64 * 1024;
 export const MEMORY_QUERY_EMBEDDING_MAX_BYTES = 4 * 1024;
 export const MEMORY_FOREGROUND_PROCESSOR_MAX_DEADLINE_MS = 30_000;
@@ -9,8 +15,8 @@ export type MemoryEmbeddingPurpose =
   | "memory.query_embedding";
 
 export type MemoryForegroundEmbeddingRequest = Readonly<{
-  readonly contractVersion:
-    typeof MEMORY_FOREGROUND_PROCESSOR_CONTRACT_VERSION;
+  readonly contractVersion: 1 | 2;
+  readonly embeddingDisclosure?: MemoryEmbeddingDisclosureV2;
   readonly purpose: MemoryEmbeddingPurpose;
   readonly subjectId: string;
   readonly requestId: string;
@@ -65,6 +71,7 @@ export interface MemoryEmbeddingProviderPort {
     readonly requestedProvider: "openai" | "openrouter" | "venice";
     readonly requestedModel: string;
     readonly dimensions: typeof MEMORY_EMBEDDING_DIMENSIONS;
+    readonly embeddingDisclosure?: MemoryEmbeddingDisclosureV2;
     readonly signal?: AbortSignal;
   }>): Promise<Readonly<{
     readonly provider: "openai" | "openrouter" | "venice";
@@ -111,7 +118,22 @@ export function validateMemoryForegroundEmbeddingRequest(
 ): MemoryForegroundEmbeddingRequest {
   if (
     request.contractVersion !== MEMORY_FOREGROUND_PROCESSOR_CONTRACT_VERSION
+    && request.contractVersion !== MEMORY_FOREGROUND_DISCLOSURE_CONTRACT_VERSION
   ) invalid("Memory foreground processor contract version is unsupported");
+  if (request.contractVersion === MEMORY_FOREGROUND_DISCLOSURE_CONTRACT_VERSION) {
+    try {
+      assertMemoryEmbeddingDisclosureV2(request.embeddingDisclosure);
+    } catch {
+      invalid("Memory embedding disclosure binding is invalid");
+    }
+    const space = request.embeddingDisclosure.canonicalSpace;
+    if (space.provider !== request.provider || space.model !== request.model
+      || space.dimensions !== request.dimensions) {
+      invalid("Memory embedding disclosure disagrees with its canonical space");
+    }
+  } else if (request.embeddingDisclosure !== undefined) {
+    invalid("Legacy Memory embedding requests cannot carry a new disclosure binding");
+  }
   if (
     request.purpose !== "memory.content_embedding"
     && request.purpose !== "memory.query_embedding"
@@ -245,6 +267,8 @@ export function createMemoryForegroundEmbeddingProcessor(input: Readonly<{
           requestedProvider: request.provider,
           requestedModel: request.model,
           dimensions: request.dimensions,
+          ...(request.embeddingDisclosure === undefined ? {}
+            : { embeddingDisclosure: request.embeddingDisclosure }),
           ...(operation.signal === undefined
             ? {}
             : { signal: operation.signal }),
@@ -267,6 +291,8 @@ export function createMemoryForegroundEmbeddingProcessor(input: Readonly<{
       }
       if (
         embedded.provider !== request.provider
+        || (request.contractVersion === MEMORY_FOREGROUND_DISCLOSURE_CONTRACT_VERSION
+          && embedded.canonicalModel !== request.model)
         || embedded.dimensions !== MEMORY_EMBEDDING_DIMENSIONS
         || !validVector(embedded.vector, MEMORY_EMBEDDING_DIMENSIONS)
       ) return unavailable("incompatible_embedding");
diff --git a/packages/lattice-bridge/src/memory/foreground-memory-processor-transport.ts b/packages/lattice-bridge/src/memory/foreground-memory-processor-transport.ts
index b80943043..3950fc24b 100644
--- a/packages/lattice-bridge/src/memory/foreground-memory-processor-transport.ts
+++ b/packages/lattice-bridge/src/memory/foreground-memory-processor-transport.ts
@@ -1,12 +1,24 @@
 import {
+  memoryEmbeddingDisclosureV2Schema,
   memoryProcessorRecipientV1Schema,
+  memoryProcessorRecipientV2Schema,
   memoryProcessorSealedRequestV1Schema,
+  type MemoryEmbeddingDisclosureV2,
   type MemoryProcessorRecipientV1,
+  type MemoryProcessorRecipientV2,
   type MemoryProcessorRequestPurposeV1,
   type MemoryProcessorSealedRequestV1,
 } from "@nautilo/api-client/browser";
 import { LatticeCrypto } from "@nautilo/lattice-crypto";
-import { MEMORY_FOREGROUND_PROCESSOR_MAX_DEADLINE_MS } from
+import {
+  assertMemoryEmbeddingDisclosureV2,
+  decodeMemoryEmbeddingDisclosureV2,
+  encodeMemoryEmbeddingDisclosureV2,
+} from "@nautilo/lattice-crypto/wire";
+import {
+  MEMORY_FOREGROUND_PROCESSOR_MAX_DEADLINE_MS,
+  MEMORY_QUERY_EMBEDDING_MAX_BYTES,
+} from
   "./foreground-embedding-processor.ts";
 
 function encode(bytes: Uint8Array): string {
@@ -28,22 +40,80 @@ type RequestBinding = Readonly<{
   subjectId: string;
 }>;
 
-/** Seal at send time: a prepared mutation journal never owns a server key. */
-export async function sealForegroundMemoryProcessorRequest(input: RequestBinding & Readonly<{
+export type MemoryProcessorSearchQueryV2 = Readonly<{
+  formatVersion: 2;
+  purpose: "memory.query_embedding";
+  query: string;
+  embeddingDisclosure: MemoryEmbeddingDisclosureV2;
+}>;
+
+export function encodeMemoryProcessorSearchQueryV2(
+  value: MemoryProcessorSearchQueryV2,
+): string {
+  if (value.formatVersion !== 2 || value.purpose !== "memory.query_embedding"
+    || typeof value.query !== "string" || value.query.trim().length === 0
+    || new TextEncoder().encode(value.query).length > MEMORY_QUERY_EMBEDDING_MAX_BYTES) {
+    throw new TypeError("Memory processor search query V2 is invalid");
+  }
+  assertMemoryEmbeddingDisclosureV2(value.embeddingDisclosure);
+  return JSON.stringify({
+    formatVersion: 2,
+    purpose: "memory.query_embedding",
+    query: value.query,
+    embeddingDisclosure: value.embeddingDisclosure,
+  });
+}
+
+export function decodeMemoryProcessorSearchQueryV2(
+  encoded: string,
+): MemoryProcessorSearchQueryV2 {
+  if (typeof encoded !== "string") {
+    throw new TypeError("Memory processor search query V2 is invalid");
+  }
+  const value: unknown = JSON.parse(encoded);
+  if (typeof value !== "object" || value === null || Array.isArray(value)
+    || Object.keys(value).sort().join(",")
+      !== "embeddingDisclosure,formatVersion,purpose,query") {
+    throw new TypeError("Memory processor search query V2 is invalid");
+  }
+  const body = value as Record<string, unknown>;
+  if (body["formatVersion"] !== 2 || body["purpose"] !== "memory.query_embedding"
+    || typeof body["query"] !== "string" || body["query"].trim().length === 0
+    || new TextEncoder().encode(body["query"]).length > MEMORY_QUERY_EMBEDDING_MAX_BYTES) {
+    throw new TypeError("Memory processor search query V2 is invalid");
+  }
+  assertMemoryEmbeddingDisclosureV2(body["embeddingDisclosure"]);
+  const disclosureBytes = encodeMemoryEmbeddingDisclosureV2(
+    memoryEmbeddingDisclosureV2Schema.parse(body["embeddingDisclosure"]),
+  );
+  try {
+    const normalized = Object.freeze({
+      formatVersion: 2 as const,
+      purpose: "memory.query_embedding" as const,
+      query: body["query"],
+      embeddingDisclosure: decodeMemoryEmbeddingDisclosureV2(disclosureBytes),
+    });
+    if (encodeMemoryProcessorSearchQueryV2(normalized) !== encoded) {
+      throw new TypeError("Memory processor search query V2 is noncanonical");
+    }
+    return normalized;
+  } finally { disclosureBytes.fill(0); }
+}
+
+async function sealRequest(input: RequestBinding & Readonly<{
   crypto: LatticeCrypto;
-  recipient: MemoryProcessorRecipientV1;
+  recipient: MemoryProcessorRecipientV1 | MemoryProcessorRecipientV2;
   payload: string;
   now?: () => number;
 }>): Promise<MemoryProcessorSealedRequestV1> {
-  const recipient = memoryProcessorRecipientV1Schema.parse(input.recipient);
-  const publicKey = decode(recipient.publicKeyBase64url);
-  if (encode(input.crypto.hash(publicKey)) !== recipient.recipientId) {
+  const publicKey = decode(input.recipient.publicKeyBase64url);
+  if (encode(input.crypto.hash(publicKey)) !== input.recipient.recipientId) {
     throw new TypeError("Memory processor recipient fingerprint mismatch");
   }
   const issuedAt = (input.now ?? Date.now)();
   const plaintext = new TextEncoder().encode(JSON.stringify({
     formatVersion: 1,
-    recipientId: recipient.recipientId,
+    recipientId: input.recipient.recipientId,
     purpose: input.purpose,
     subjectId: input.subjectId,
     issuedAt,
@@ -53,7 +123,7 @@ export async function sealForegroundMemoryProcessorRequest(input: RequestBinding
   try {
     return Object.freeze({
       formatVersion: 1,
-      recipientId: recipient.recipientId,
+      recipientId: input.recipient.recipientId,
       ciphertextBase64url: encode(await input.crypto.sealTo(publicKey, plaintext)),
     });
   } finally {
@@ -61,6 +131,48 @@ export async function sealForegroundMemoryProcessorRequest(input: RequestBinding
   }
 }
 
+/** Seal at send time: a prepared mutation journal never owns a server key. */
+export async function sealForegroundMemoryProcessorRequest(input: RequestBinding & Readonly<{
+  crypto: LatticeCrypto;
+  recipient: MemoryProcessorRecipientV1;
+  payload: string;
+  now?: () => number;
+}>): Promise<MemoryProcessorSealedRequestV1> {
+  const recipient = memoryProcessorRecipientV1Schema.parse(input.recipient);
+  return sealRequest({ ...input, recipient });
+}
+
+export async function sealForegroundMemoryProcessorRequestV2(
+  input: RequestBinding & Readonly<{
+    crypto: LatticeCrypto;
+    recipient: MemoryProcessorRecipientV2;
+    payload: string;
+    now?: () => number;
+  }>,
+): Promise<MemoryProcessorSealedRequestV1> {
+  const recipient = memoryProcessorRecipientV2Schema.parse(input.recipient);
+  return sealRequest({ ...input, recipient });
+}
+
+export async function sealForegroundMemoryProcessorSearchQueryV2(
+  input: Omit<Parameters<typeof sealForegroundMemoryProcessorRequestV2>[0],
+    "purpose" | "payload"> & Readonly<{
+      query: string;
+      embeddingDisclosure: MemoryEmbeddingDisclosureV2;
+    }>,
+): Promise<MemoryProcessorSealedRequestV1> {
+  return sealForegroundMemoryProcessorRequestV2({
+    ...input,
+    purpose: "memory.query_embedding",
+    payload: encodeMemoryProcessorSearchQueryV2({
+      formatVersion: 2,
+      purpose: "memory.query_embedding",
+      query: input.query,
+      embeddingDisclosure: input.embeddingDisclosure,
+    }),
+  });
+}
+
 /**
  * An ephemeral processor transport key, not a data-decryption grant. No device,
  * Domain, or Memory key is received or retained. Restart invalidates old
diff --git a/packages/lattice-bridge/src/memory/human-memory-ordinary-fallback-request.ts b/packages/lattice-bridge/src/memory/human-memory-ordinary-fallback-request.ts
index 3dd7b972a..7ae6eb322 100644
--- a/packages/lattice-bridge/src/memory/human-memory-ordinary-fallback-request.ts
+++ b/packages/lattice-bridge/src/memory/human-memory-ordinary-fallback-request.ts
@@ -4,6 +4,10 @@ import {
   type LatticeCrypto,
 } from "@nautilo/lattice-crypto";
 import {
+  assertMemoryEmbeddingDisclosureV2,
+  encodeMemoryEmbeddingDisclosureV2,
+  decodeMemoryEmbeddingDisclosureV2,
+  type MemoryEmbeddingDisclosureV2,
   HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_MAX_NAMESPACE_ENVELOPES_V2,
   HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_MAX_TTL_MS_V2,
   MAX_HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_WIRE_BYTES_V2,
@@ -11,6 +15,7 @@ import {
 import { encodeMemoryPayloadV1 } from "./memory-payload-v1.ts";
 
 const DOMAIN = "nautilo/memory/human-ordinary-fallback/v1";
+const DOMAIN_V2 = "nautilo/memory/human-ordinary-fallback/v2";
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 const PORTABLE = /^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/u;
 const encoder = new TextEncoder();
@@ -56,6 +61,26 @@ export type AuthenticatedHumanMemoryOrdinaryFallbackRequestV1 = Readonly<{
   requestDigest: Uint8Array;
 }>;
 
+export interface HumanMemoryOrdinaryFallbackUnsignedRequestV2 extends Omit<
+  HumanMemoryOrdinaryFallbackUnsignedRequestV1,
+  "formatVersion" | "requestedProvider" | "requestedModel" | "dimensions" | "processorContractVersion"
+> {
+  readonly formatVersion: 2;
+  readonly requestedEmbedding: MemoryEmbeddingDisclosureV2;
+  readonly processorContractVersion: 2;
+}
+export interface HumanMemoryOrdinaryFallbackRequestV2 extends HumanMemoryOrdinaryFallbackUnsignedRequestV2 {
+  readonly signature: Uint8Array;
+}
+export type AuthenticatedHumanMemoryOrdinaryFallbackRequestV2 = Readonly<{
+  request: HumanMemoryOrdinaryFallbackRequestV2;
+  requestDigest: Uint8Array;
+}>;
+type FallbackUnsigned = HumanMemoryOrdinaryFallbackUnsignedRequestV1 | HumanMemoryOrdinaryFallbackUnsignedRequestV2;
+type FallbackRequest = HumanMemoryOrdinaryFallbackRequestV1 | HumanMemoryOrdinaryFallbackRequestV2;
+type FallbackAuthenticated = AuthenticatedHumanMemoryOrdinaryFallbackRequestV1 | AuthenticatedHumanMemoryOrdinaryFallbackRequestV2;
+type FallbackVersion = 1 | 2;
+
 declare const replayAdmissionBrand: unique symbol;
 export type HumanMemoryOrdinaryFallbackReplayAdmissionV1 = Readonly<{
   [replayAdmissionBrand]: true;
@@ -79,6 +104,26 @@ export function createHumanMemoryOrdinaryFallbackReplayAdmissionV1(
   return token;
 }
 
+// Durable replay admission binds the exact canonical request digest, including
+// its signing domain and format. Both versions share the same opaque authority.
+export type HumanMemoryOrdinaryFallbackReplayAdmissionV2 = HumanMemoryOrdinaryFallbackReplayAdmissionV1;
+export function createHumanMemoryOrdinaryFallbackReplayAdmissionV2(
+  input: Readonly<{ operationId: string; memoryId: string; requestDigest: Uint8Array }>,
+): HumanMemoryOrdinaryFallbackReplayAdmissionV2 {
+  if (!(input.requestDigest instanceof Uint8Array)) {
+    throw new TypeError("Human Memory ordinary fallback replay admission is invalid");
+  }
+  return createHumanMemoryOrdinaryFallbackReplayAdmissionV1(input);
+}
+
+const FIELDS_V2 = Object.freeze([
+  "formatVersion", "purpose", "reason", "operationId", "memoryId",
+  "expectedContentRevision", "nextContentRevision", "expectedCryptoAccessRevision",
+  "requiredNamespaceIds", "type", "content", "requestedEmbedding", "processorContractVersion",
+  "policyRevision", "subjectHumanId", "committerDeviceId", "committerDeviceSigningKeyGeneration",
+  "hostAuthorizationRevision", "planIssuedAt", "planDeadlineAt", "issuedAt", "deadlineAt", "signature",
+]);
+
 function validCounter(value: unknown): value is number {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
@@ -105,7 +150,15 @@ function fromHex(value: string, length: number): Uint8Array {
     Number.parseInt(value.slice(index * 2, index * 2 + 2), 16));
 }
 
-function assertRequest(value: HumanMemoryOrdinaryFallbackRequestV1): void {
+function assertRequest(value: FallbackRequest, version: FallbackVersion): void {
+  if (version === 2) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)
+      || !FIELDS_V2.every((field) => Object.hasOwn(value, field))
+      || Reflect.ownKeys(value).some((field) => typeof field !== "string" || (field !== "importance" && !FIELDS_V2.includes(field)))) {
+      throw new TypeError("Human Memory ordinary fallback request has an invalid field set");
+    }
+    assertMemoryEmbeddingDisclosureV2((value as HumanMemoryOrdinaryFallbackRequestV2).requestedEmbedding);
+  }
   const create = value.purpose === "memory.ordinary_fallback.create";
   let authoredPayload: Uint8Array;
   try {
@@ -118,7 +171,7 @@ function assertRequest(value: HumanMemoryOrdinaryFallbackRequestV1): void {
     throw new TypeError("Human Memory ordinary fallback authored payload is invalid");
   }
   authoredPayload.fill(0);
-  if (value.formatVersion !== 1
+  if (value.formatVersion !== version
     || (!create && value.purpose !== "memory.ordinary_fallback.update")
     || value.reason !== "target_encryption_not_ready"
     || !validPortable(value.operationId) || !validUuid(value.memoryId)
@@ -135,9 +188,9 @@ function assertRequest(value: HumanMemoryOrdinaryFallbackRequestV1): void {
       || (index > 0 && value.requiredNamespaceIds[index - 1]! >= id))
     || (value.importance !== undefined && (!Number.isFinite(value.importance)
       || value.importance < 0 || value.importance > 1))
-    || (value.requestedProvider !== "openai" && value.requestedProvider !== "openrouter" && value.requestedProvider !== "venice")
-    || !validPortable(value.requestedModel)
-    || value.dimensions !== 1536 || value.processorContractVersion !== 1
+    || (value.formatVersion === 1 && ((value.requestedProvider !== "openai" && value.requestedProvider !== "openrouter" && value.requestedProvider !== "venice")
+      || !validPortable(value.requestedModel) || value.dimensions !== 1536))
+    || value.processorContractVersion !== version
     || !validCounter(value.policyRevision) || value.policyRevision < 1
     || !validPortable(value.subjectHumanId) || !validPortable(value.committerDeviceId)
     || !validCounter(value.committerDeviceSigningKeyGeneration)
@@ -159,28 +212,31 @@ function assertRequest(value: HumanMemoryOrdinaryFallbackRequestV1): void {
   }
 }
 
-function wire(value: HumanMemoryOrdinaryFallbackRequestV1): readonly unknown[] {
-  return [DOMAIN, value.formatVersion, value.purpose, value.reason,
+function wire(value: FallbackRequest): readonly unknown[] {
+  return [value.formatVersion === 1 ? DOMAIN : DOMAIN_V2, value.formatVersion, value.purpose, value.reason,
     value.operationId, value.memoryId, value.expectedContentRevision,
     value.nextContentRevision, value.expectedCryptoAccessRevision,
     value.requiredNamespaceIds, value.type, value.content,
-    value.importance ?? null, value.requestedProvider, value.requestedModel,
-    value.dimensions, value.processorContractVersion, value.policyRevision,
+    value.importance ?? null,
+    ...(value.formatVersion === 1 ? [value.requestedProvider, value.requestedModel, value.dimensions]
+      : [decodeMemoryEmbeddingDisclosureV2(encodeMemoryEmbeddingDisclosureV2(value.requestedEmbedding))]),
+    value.processorContractVersion, value.policyRevision,
     value.subjectHumanId, value.committerDeviceId,
     value.committerDeviceSigningKeyGeneration, value.hostAuthorizationRevision,
     value.planIssuedAt, value.planDeadlineAt, value.issuedAt, value.deadlineAt,
     hex(value.signature)];
 }
 
-function signingBytes(value: HumanMemoryOrdinaryFallbackUnsignedRequestV1): Uint8Array {
+function signingBytes(value: FallbackUnsigned): Uint8Array {
   return encoder.encode(JSON.stringify(wire({ ...value, signature: new Uint8Array(64) })
     .slice(0, -1)));
 }
 
-export function encodeHumanMemoryOrdinaryFallbackRequestV1(
-  value: HumanMemoryOrdinaryFallbackRequestV1,
+function encodeHumanMemoryOrdinaryFallbackRequestForVersion(
+  value: FallbackRequest,
+  version: FallbackVersion,
 ): Uint8Array {
-  assertRequest(value);
+  assertRequest(value, version);
   const bytes = encoder.encode(JSON.stringify(wire(value)));
   if (bytes.length > MAX_HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_WIRE_BYTES_V2) {
     bytes.fill(0);
@@ -189,20 +245,23 @@ export function encodeHumanMemoryOrdinaryFallbackRequestV1(
   return bytes;
 }
 
-export function decodeHumanMemoryOrdinaryFallbackRequestV1(
+function decodeHumanMemoryOrdinaryFallbackRequestForVersion(
   bytes: Uint8Array,
-): HumanMemoryOrdinaryFallbackRequestV1 {
+  version: FallbackVersion,
+): FallbackRequest {
   if (!(bytes instanceof Uint8Array)
     || bytes.length === 0
     || bytes.length > MAX_HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_WIRE_BYTES_V2) {
     throw new TypeError("Human Memory ordinary fallback wire is invalid");
   }
   const raw: unknown = JSON.parse(decoder.decode(bytes));
-  if (!Array.isArray(raw) || raw.length !== 27 || raw[0] !== DOMAIN
-    || !Array.isArray(raw[9]) || typeof raw[26] !== "string") {
+  const length = version === 1 ? 27 : 25;
+  if (!Array.isArray(raw) || raw.length !== length || raw[0] !== (version === 1 ? DOMAIN : DOMAIN_V2)
+    || !Array.isArray(raw[9]) || typeof raw[length - 1] !== "string") {
     throw new TypeError("Human Memory ordinary fallback wire is invalid");
   }
   const fields = raw as readonly unknown[];
+  const offset = version === 1 ? 0 : -2;
   const value = {
     formatVersion: fields[1], purpose: fields[2], reason: fields[3],
     operationId: fields[4], memoryId: fields[5],
@@ -210,50 +269,59 @@ export function decodeHumanMemoryOrdinaryFallbackRequestV1(
     expectedCryptoAccessRevision: fields[8], requiredNamespaceIds: fields[9],
     type: fields[10], content: fields[11],
     ...(fields[12] === null ? {} : { importance: fields[12] }),
-    requestedProvider: fields[13], requestedModel: fields[14],
-    dimensions: fields[15], processorContractVersion: fields[16],
-    policyRevision: fields[17], subjectHumanId: fields[18],
-    committerDeviceId: fields[19],
-    committerDeviceSigningKeyGeneration: fields[20],
-    hostAuthorizationRevision: fields[21], planIssuedAt: fields[22],
-    planDeadlineAt: fields[23], issuedAt: fields[24], deadlineAt: fields[25],
-    signature: fromHex(fields[26] as string, 64),
-  } as HumanMemoryOrdinaryFallbackRequestV1;
-  assertRequest(value);
-  const canonical = encodeHumanMemoryOrdinaryFallbackRequestV1(value);
+    ...(version === 1 ? { requestedProvider: fields[13], requestedModel: fields[14], dimensions: fields[15] }
+      : { requestedEmbedding: fields[13] }),
+    processorContractVersion: fields[16 + offset],
+    policyRevision: fields[17 + offset], subjectHumanId: fields[18 + offset],
+    committerDeviceId: fields[19 + offset],
+    committerDeviceSigningKeyGeneration: fields[20 + offset],
+    hostAuthorizationRevision: fields[21 + offset], planIssuedAt: fields[22 + offset],
+    planDeadlineAt: fields[23 + offset], issuedAt: fields[24 + offset], deadlineAt: fields[25 + offset],
+    signature: fromHex(fields[26 + offset] as string, 64),
+  } as FallbackRequest;
+  assertRequest(value, version);
+  const canonical = encodeHumanMemoryOrdinaryFallbackRequestForVersion(value, version);
   if (canonical.length !== bytes.length
     || canonical.some((entry, index) => entry !== bytes[index])) {
     throw new TypeError("Human Memory ordinary fallback wire is noncanonical");
   }
   return Object.freeze({ ...value,
+    ...(value.formatVersion === 2 ? { requestedEmbedding: decodeMemoryEmbeddingDisclosureV2(encodeMemoryEmbeddingDisclosureV2(value.requestedEmbedding)) } : {}),
     requiredNamespaceIds: Object.freeze([...value.requiredNamespaceIds]),
     signature: value.signature.slice() });
 }
 
-export function digestHumanMemoryOrdinaryFallbackRequestV1(
+function digestHumanMemoryOrdinaryFallbackRequestForVersion(
   bytes: Uint8Array,
+  version: FallbackVersion,
 ): Uint8Array {
-  decodeHumanMemoryOrdinaryFallbackRequestV1(bytes);
+  decodeHumanMemoryOrdinaryFallbackRequestForVersion(bytes, version);
   return sha256(bytes);
 }
 
-export function prepareHumanMemoryOrdinaryFallbackRequestV1(
+function prepareHumanMemoryOrdinaryFallbackRequestForVersion(
   crypto: LatticeCrypto,
-  input: HumanMemoryOrdinaryFallbackUnsignedRequestV1 & Readonly<{
+  input: FallbackUnsigned & Readonly<{
     signingPrivateKey: Uint8Array;
   }>,
-): Readonly<{ request: HumanMemoryOrdinaryFallbackRequestV1; bytes: Uint8Array }> {
+  version: FallbackVersion,
+): Readonly<{ request: FallbackRequest; bytes: Uint8Array }> {
   const { signingPrivateKey, ...unsigned } = input;
+  if (version === 2) {
+    if (Object.hasOwn(unsigned, "signature")) throw new TypeError("Human Memory ordinary fallback preparation has an invalid field set");
+    assertRequest({ ...unsigned, signature: new Uint8Array(64) }, version);
+  }
   const signed = signingBytes(unsigned);
   try {
     const request = Object.freeze({ ...unsigned,
       requiredNamespaceIds: Object.freeze([...unsigned.requiredNamespaceIds]),
       signature: crypto.sign(signingPrivateKey, signed) });
-    return Object.freeze({ request, bytes: encodeHumanMemoryOrdinaryFallbackRequestV1(request) });
+    const bytes = encodeHumanMemoryOrdinaryFallbackRequestForVersion(request, version);
+    return Object.freeze({ request: version === 1 ? request : decodeHumanMemoryOrdinaryFallbackRequestForVersion(bytes, version), bytes });
   } finally { signed.fill(0); }
 }
 
-export function verifyHumanMemoryOrdinaryFallbackRequestV1(
+function verifyHumanMemoryOrdinaryFallbackRequestForVersion(
   crypto: LatticeCrypto,
   input: Readonly<{
     requestBytes: Uint8Array;
@@ -261,8 +329,9 @@ export function verifyHumanMemoryOrdinaryFallbackRequestV1(
     now: number;
     replayAdmission?: HumanMemoryOrdinaryFallbackReplayAdmissionV1;
   }>,
-): AuthenticatedHumanMemoryOrdinaryFallbackRequestV1 {
-  const request = decodeHumanMemoryOrdinaryFallbackRequestV1(input.requestBytes);
+  version: FallbackVersion,
+): FallbackAuthenticated {
+  const request = decodeHumanMemoryOrdinaryFallbackRequestForVersion(input.requestBytes, version);
   const requestDigest = sha256(input.requestBytes);
   const replay = input.replayAdmission === undefined ? undefined
     : replayAdmissions.get(input.replayAdmission);
@@ -282,6 +351,48 @@ export function verifyHumanMemoryOrdinaryFallbackRequestV1(
       || verificationTime >= request.deadlineAt) {
       throw new TypeError("Human Memory ordinary fallback request is not currently valid");
     }
-    return Object.freeze({ request, requestDigest });
+    return Object.freeze({ request, requestDigest }) as FallbackAuthenticated;
   } finally { signed.fill(0); }
 }
+
+export function encodeHumanMemoryOrdinaryFallbackRequestV1(value: HumanMemoryOrdinaryFallbackRequestV1): Uint8Array {
+  return encodeHumanMemoryOrdinaryFallbackRequestForVersion(value, 1);
+}
+export function decodeHumanMemoryOrdinaryFallbackRequestV1(bytes: Uint8Array): HumanMemoryOrdinaryFallbackRequestV1 {
+  return decodeHumanMemoryOrdinaryFallbackRequestForVersion(bytes, 1) as HumanMemoryOrdinaryFallbackRequestV1;
+}
+export function digestHumanMemoryOrdinaryFallbackRequestV1(bytes: Uint8Array): Uint8Array {
+  return digestHumanMemoryOrdinaryFallbackRequestForVersion(bytes, 1);
+}
+export function prepareHumanMemoryOrdinaryFallbackRequestV1(crypto: LatticeCrypto, input: HumanMemoryOrdinaryFallbackUnsignedRequestV1 & Readonly<{
+  signingPrivateKey: Uint8Array;
+}>): Readonly<{ request: HumanMemoryOrdinaryFallbackRequestV1; bytes: Uint8Array }> {
+  return prepareHumanMemoryOrdinaryFallbackRequestForVersion(crypto, input, 1) as Readonly<{ request: HumanMemoryOrdinaryFallbackRequestV1; bytes: Uint8Array }>;
+}
+export function verifyHumanMemoryOrdinaryFallbackRequestV1(crypto: LatticeCrypto, input: Readonly<{
+  requestBytes: Uint8Array; signingPublicKey: Uint8Array; now: number;
+  replayAdmission?: HumanMemoryOrdinaryFallbackReplayAdmissionV1;
+}>): AuthenticatedHumanMemoryOrdinaryFallbackRequestV1 {
+  return verifyHumanMemoryOrdinaryFallbackRequestForVersion(crypto, input, 1) as AuthenticatedHumanMemoryOrdinaryFallbackRequestV1;
+}
+
+export function encodeHumanMemoryOrdinaryFallbackRequestV2(value: HumanMemoryOrdinaryFallbackRequestV2): Uint8Array {
+  return encodeHumanMemoryOrdinaryFallbackRequestForVersion(value, 2);
+}
+export function decodeHumanMemoryOrdinaryFallbackRequestV2(bytes: Uint8Array): HumanMemoryOrdinaryFallbackRequestV2 {
+  return decodeHumanMemoryOrdinaryFallbackRequestForVersion(bytes, 2) as HumanMemoryOrdinaryFallbackRequestV2;
+}
+export function digestHumanMemoryOrdinaryFallbackRequestV2(bytes: Uint8Array): Uint8Array {
+  return digestHumanMemoryOrdinaryFallbackRequestForVersion(bytes, 2);
+}
+export function prepareHumanMemoryOrdinaryFallbackRequestV2(crypto: LatticeCrypto, input: HumanMemoryOrdinaryFallbackUnsignedRequestV2 & Readonly<{
+  signingPrivateKey: Uint8Array;
+}>): Readonly<{ request: HumanMemoryOrdinaryFallbackRequestV2; bytes: Uint8Array }> {
+  return prepareHumanMemoryOrdinaryFallbackRequestForVersion(crypto, input, 2) as Readonly<{ request: HumanMemoryOrdinaryFallbackRequestV2; bytes: Uint8Array }>;
+}
+export function verifyHumanMemoryOrdinaryFallbackRequestV2(crypto: LatticeCrypto, input: Readonly<{
+  requestBytes: Uint8Array; signingPublicKey: Uint8Array; now: number;
+  replayAdmission?: HumanMemoryOrdinaryFallbackReplayAdmissionV2;
+}>): AuthenticatedHumanMemoryOrdinaryFallbackRequestV2 {
+  return verifyHumanMemoryOrdinaryFallbackRequestForVersion(crypto, input, 2) as AuthenticatedHumanMemoryOrdinaryFallbackRequestV2;
+}
diff --git a/packages/lattice-bridge/src/server/memory/human-memory-ordinary-fallback-publication.ts b/packages/lattice-bridge/src/server/memory/human-memory-ordinary-fallback-publication.ts
index e492d8ce7..5419a1b1c 100644
--- a/packages/lattice-bridge/src/server/memory/human-memory-ordinary-fallback-publication.ts
+++ b/packages/lattice-bridge/src/server/memory/human-memory-ordinary-fallback-publication.ts
@@ -8,8 +8,15 @@ import type { LatticeCrypto } from "@nautilo/lattice-crypto";
 
 import {
   decodeHumanMemoryOrdinaryFallbackRequestV1,
+  decodeHumanMemoryOrdinaryFallbackRequestV2,
   digestHumanMemoryOrdinaryFallbackRequestV1,
+  digestHumanMemoryOrdinaryFallbackRequestV2,
   verifyHumanMemoryOrdinaryFallbackRequestV1,
+  verifyHumanMemoryOrdinaryFallbackRequestV2,
+  type HumanMemoryOrdinaryFallbackRequestV1,
+  type HumanMemoryOrdinaryFallbackRequestV2,
+  type AuthenticatedHumanMemoryOrdinaryFallbackRequestV1,
+  type AuthenticatedHumanMemoryOrdinaryFallbackRequestV2,
 } from "../../memory/human-memory-ordinary-fallback-request.ts";
 import {
   MEMORY_FOREGROUND_PROCESSOR_MAX_DEADLINE_MS,
@@ -26,6 +33,18 @@ import type {
 import { humanMemoryPreparedAuthorizationError,
   humanMemoryPreparedIntegrityError } from "./human-memory-prepared-route-error.ts";
 
+type FallbackRequest = HumanMemoryOrdinaryFallbackRequestV1 | HumanMemoryOrdinaryFallbackRequestV2;
+type AuthenticatedFallback = AuthenticatedHumanMemoryOrdinaryFallbackRequestV1 | AuthenticatedHumanMemoryOrdinaryFallbackRequestV2;
+function decodeFallback(bytes: Uint8Array): FallbackRequest {
+  try { return decodeHumanMemoryOrdinaryFallbackRequestV2(bytes); }
+  catch { return decodeHumanMemoryOrdinaryFallbackRequestV1(bytes); }
+}
+function requestedSpace(request: FallbackRequest) {
+  return request.formatVersion === 2 ? request.requestedEmbedding.canonicalSpace
+    : { provider: request.requestedProvider, model: request.requestedModel,
+      dimensions: request.dimensions };
+}
+
 type SubmittedOrdinaryFallback =
   | ProtectedMemoryOrdinaryFallbackCreateRequestV1
   | ProtectedMemoryOrdinaryFallbackUpdateRequestV1;
@@ -61,7 +80,7 @@ function unavailable(): ProtectedMemoryUnavailableResponseV1 {
 
 function exactOuterRequest(
   submitted: SubmittedOrdinaryFallback,
-  request: ReturnType<typeof verifyHumanMemoryOrdinaryFallbackRequestV1>["request"],
+  request: FallbackRequest,
   expectedPurpose: HumanMemoryOrdinaryFallbackPurpose,
 ): boolean {
   return request.purpose === expectedPurpose
@@ -100,10 +119,12 @@ export async function publishHumanMemoryOrdinaryFallbackIntent<
   ));
   try {
   let digest: Uint8Array;
-  let unsigned: ReturnType<typeof decodeHumanMemoryOrdinaryFallbackRequestV1>;
+  let unsigned: FallbackRequest;
   try {
-    unsigned = decodeHumanMemoryOrdinaryFallbackRequestV1(requestBytes);
-    digest = digestHumanMemoryOrdinaryFallbackRequestV1(requestBytes);
+    unsigned = decodeFallback(requestBytes);
+    digest = unsigned.formatVersion === 2
+      ? digestHumanMemoryOrdinaryFallbackRequestV2(requestBytes)
+      : digestHumanMemoryOrdinaryFallbackRequestV1(requestBytes);
   } catch (error) {
     if (!(error instanceof TypeError) && !(error instanceof RangeError)) throw error;
     throw humanMemoryPreparedIntegrityError(
@@ -134,9 +155,11 @@ export async function publishHumanMemoryOrdinaryFallbackIntent<
       "Human Memory ordinary fallback signer is unavailable",
     );
   }
-  let authenticated: ReturnType<typeof verifyHumanMemoryOrdinaryFallbackRequestV1>;
+  let authenticated: AuthenticatedFallback;
   try {
-    authenticated = verifyHumanMemoryOrdinaryFallbackRequestV1(input.crypto, {
+    const verify = unsigned.formatVersion === 2
+      ? verifyHumanMemoryOrdinaryFallbackRequestV2 : verifyHumanMemoryOrdinaryFallbackRequestV1;
+    authenticated = verify(input.crypto, {
       requestBytes,
       signingPublicKey: historical.committerSigningPublicKey,
       now: input.now(),
@@ -167,14 +190,14 @@ export async function publishHumanMemoryOrdinaryFallbackIntent<
   });
   const processorIssuedAt = input.now();
   const embedded = await input.foregroundEmbeddingProcessor.embed({
-    request: Object.freeze({ contractVersion: 1,
+    request: Object.freeze({ contractVersion: authenticated.request.processorContractVersion,
       purpose: "memory.content_embedding",
       subjectId: authenticated.request.subjectHumanId,
       requestId: authenticated.request.operationId,
       plaintext: authenticated.request.content,
-      provider: authenticated.request.requestedProvider,
-      model: authenticated.request.requestedModel,
-      dimensions: authenticated.request.dimensions,
+      ...requestedSpace(authenticated.request),
+      ...(authenticated.request.formatVersion === 2
+        ? { embeddingDisclosure: authenticated.request.requestedEmbedding } : {}),
       issuedAt: processorIssuedAt,
       deadlineAt: processorIssuedAt + MEMORY_FOREGROUND_PROCESSOR_MAX_DEADLINE_MS,
       publication: Object.freeze({ objectId: authenticated.request.memoryId,
diff --git a/packages/lattice-bridge/src/server/memory/human-memory-prepared-update.ts b/packages/lattice-bridge/src/server/memory/human-memory-prepared-update.ts
index 4b33cc7ad..8eefc7231 100644
--- a/packages/lattice-bridge/src/server/memory/human-memory-prepared-update.ts
+++ b/packages/lattice-bridge/src/server/memory/human-memory-prepared-update.ts
@@ -14,7 +14,10 @@ import {
   verifyHumanMemoryContentEmbeddingRequest,
 } from "@nautilo/lattice-crypto";
 import {
+  type HumanMemoryContentEmbeddingRequestV3,
+  verifyHumanMemoryContentEmbeddingRequestV3,
   decodeHumanMemoryContentEmbeddingRequestV2,
+  decodeHumanMemoryContentEmbeddingRequestV3,
   decodeEncryptedPayloadV2,
   decodeNamespaceObjectEnvelopeV2,
   decodeObjectAccessManifestV5,
@@ -36,6 +39,22 @@ import {
   humanMemoryPreparedIntegrityError,
 } from "./human-memory-prepared-route-error.ts";
 
+type SignedContentEmbeddingRequest = HumanMemoryContentEmbeddingRequest | HumanMemoryContentEmbeddingRequestV3;
+
+function decodeContentEmbeddingRequest(bytes: Uint8Array): SignedContentEmbeddingRequest {
+  try {
+    return decodeHumanMemoryContentEmbeddingRequestV3(bytes);
+  } catch {
+    return decodeHumanMemoryContentEmbeddingRequestV2(bytes);
+  }
+}
+
+function requestedEmbeddingSpace(request: SignedContentEmbeddingRequest) {
+  return request.formatVersion === 3 ? request.requestedEmbedding.canonicalSpace
+    : { provider: request.requestedProvider, model: request.requestedModel,
+      dimensions: request.dimensions };
+}
+
 const PORTABLE_ID = /^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/;
 const UUID =
   /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
@@ -114,7 +133,7 @@ export function digestPreparedHumanMemorySignedRequest(
     prepared.signedContentEmbeddingRequestBytesBase64url, 160 * 1024);
   try {
     decodeIntegrity("Signed Human Memory request", () =>
-      decodeHumanMemoryContentEmbeddingRequestV2(bytes));
+      decodeContentEmbeddingRequest(bytes));
     return crypto.hash(bytes);
   } finally {
     bytes.fill(0);
@@ -287,7 +306,7 @@ function decodeIntegrity<Value>(label: string, decode: () => Value): Value {
 }
 
 function requestMatchesOuterPreparedUpdate(input: Readonly<{
-  request: HumanMemoryContentEmbeddingRequest;
+  request: SignedContentEmbeddingRequest;
   expectedHumanId: string;
   memoryId: string;
   prepared:
@@ -403,9 +422,9 @@ async function authenticatePreparedHumanMemory(input: Readonly<{
   let payload: ReturnType<typeof decodeEncryptedPayloadV2> | undefined;
   let genesis: ReturnType<typeof decodeObjectAccessManifestV5> | undefined;
   let decodedSignedRequest:
-    | ReturnType<typeof decodeHumanMemoryContentEmbeddingRequestV2>
+    | SignedContentEmbeddingRequest
     | undefined;
-  let verifiedSignedRequest: HumanMemoryContentEmbeddingRequest | undefined;
+  let verifiedSignedRequest: SignedContentEmbeddingRequest | undefined;
   let payloadHash: Uint8Array | undefined;
   let genesisManifestHash: Uint8Array | undefined;
   let operationRequestDigest: Uint8Array | undefined;
@@ -439,7 +458,7 @@ async function authenticatePreparedHumanMemory(input: Readonly<{
     genesis = decodeIntegrity("Prepared Human Memory access manifest", () =>
       decodeObjectAccessManifestV5(genesisManifestBytes!));
     decodedSignedRequest = decodeIntegrity("Signed Human Memory request", () =>
-      decodeHumanMemoryContentEmbeddingRequestV2(signedRequestBytes!));
+      decodeContentEmbeddingRequest(signedRequestBytes!));
     payloadHash = input.crypto.hash(payloadBytes);
     genesisManifestHash = input.crypto.hash(genesisManifestBytes);
     for (const entry of [...input.prepared.namespaceEnvelopes]
@@ -570,7 +589,9 @@ async function authenticatePreparedHumanMemory(input: Readonly<{
       );
     }
     try {
-      verifiedSignedRequest = verifyHumanMemoryContentEmbeddingRequest(input.crypto, {
+      const verify = decodedSignedRequest.formatVersion === 3
+        ? verifyHumanMemoryContentEmbeddingRequestV3 : verifyHumanMemoryContentEmbeddingRequest;
+      verifiedSignedRequest = verify(input.crypto, {
         requestBytes: signedRequestBytes,
         committerSigningPublicKey: resolverPublicKey,
         // A durable exact reservation proves these signed bytes were admitted
@@ -673,9 +694,9 @@ async function authenticatePreparedHumanMemory(input: Readonly<{
         subjectId: verifiedSignedRequest.subjectHumanId,
         requestId: verifiedSignedRequest.requestId,
         plaintext: verifiedSignedRequest.content,
-        provider: verifiedSignedRequest.requestedProvider,
-        model: verifiedSignedRequest.requestedModel,
-        dimensions: verifiedSignedRequest.dimensions,
+        ...requestedEmbeddingSpace(verifiedSignedRequest),
+        ...(verifiedSignedRequest.formatVersion === 3
+          ? { embeddingDisclosure: verifiedSignedRequest.requestedEmbedding } : {}),
         // An exact durable reservation admits a new, transient processor
         // attempt. It does not renew or rewrite the original signed request.
         // Route composition rechecks current device authority before disclosure.
diff --git a/packages/lattice-bridge/src/server/memory/human-memory-protected-route-ports.ts b/packages/lattice-bridge/src/server/memory/human-memory-protected-route-ports.ts
index 9165f8413..3659245f2 100644
--- a/packages/lattice-bridge/src/server/memory/human-memory-protected-route-ports.ts
+++ b/packages/lattice-bridge/src/server/memory/human-memory-protected-route-ports.ts
@@ -23,6 +23,7 @@ import {
   type MemoryForegroundEmbeddingProcessor,
   type MemoryForegroundEmbeddingResult,
 } from "../../memory/foreground-embedding-processor.ts";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/lattice-crypto/wire";
 import type {
   HumanMemoryPreparedCreateRoutePort,
 } from "./human-memory-prepared-create-composition.ts";
@@ -253,6 +254,7 @@ export interface HumanMemoryProtectedRoutePorts {
     authority: HumanMemoryProtectedRouteAuthority;
     namespaceIds: readonly string[];
     query: string;
+    embeddingDisclosure?: MemoryEmbeddingDisclosureV2;
     limit?: number;
     includeArchive: boolean;
   }>): Promise<ProtectedReadResult<ProtectedMemorySearchResponseV1>>;
@@ -721,7 +723,10 @@ export function createHumanMemoryProtectedRoutePortsFromTrustedPorts(
       const embedded = await input.foregroundEmbeddingProcessor.embed({
         authenticatedSubjectId: productCommon.subjectHumanId,
         request: Object.freeze({
-          contractVersion: MEMORY_FOREGROUND_PROCESSOR_CONTRACT_VERSION,
+          contractVersion: operation.embeddingDisclosure === undefined
+            ? MEMORY_FOREGROUND_PROCESSOR_CONTRACT_VERSION : 2,
+          ...(operation.embeddingDisclosure === undefined ? {}
+            : { embeddingDisclosure: operation.embeddingDisclosure }),
           purpose: "memory.query_embedding" as const,
           subjectId: productCommon.subjectHumanId,
           requestId,
diff --git a/packages/lattice-bridge/src/server/memory/postgres-human-memory-product-update.ts b/packages/lattice-bridge/src/server/memory/postgres-human-memory-product-update.ts
index 302c7b84c..8810605ce 100644
--- a/packages/lattice-bridge/src/server/memory/postgres-human-memory-product-update.ts
+++ b/packages/lattice-bridge/src/server/memory/postgres-human-memory-product-update.ts
@@ -7,6 +7,7 @@ import type {
 import {
   createHumanMemoryOrdinaryFallbackReplayAdmissionV1,
   type AuthenticatedHumanMemoryOrdinaryFallbackRequestV1,
+  type AuthenticatedHumanMemoryOrdinaryFallbackRequestV2,
   type HumanMemoryOrdinaryFallbackReplayAdmissionV1,
 } from "../../memory/human-memory-ordinary-fallback-request.ts";
 import {
@@ -115,7 +116,7 @@ export type HumanMemoryReservationReplay = Readonly<{
 }>;
 
 export type HumanMemoryOrdinaryFallbackAdmission = Readonly<{
-  authenticated: AuthenticatedHumanMemoryOrdinaryFallbackRequestV1;
+  authenticated: AuthenticatedHumanMemoryOrdinaryFallbackRequestV1 | AuthenticatedHumanMemoryOrdinaryFallbackRequestV2;
   expectedAccessRevision: number;
 }>;
 
@@ -136,7 +137,7 @@ export interface HumanMemoryProductUpdatePort {
   }>): Promise<HumanMemoryOrdinaryFallbackReplay | null>;
   admitOrdinaryFallback(input: Readonly<{
     authority: HumanMemoryProductAuthority;
-    authenticated: AuthenticatedHumanMemoryOrdinaryFallbackRequestV1;
+    authenticated: AuthenticatedHumanMemoryOrdinaryFallbackRequestV1 | AuthenticatedHumanMemoryOrdinaryFallbackRequestV2;
   }>): Promise<HumanMemoryOrdinaryFallbackAdmission>;
   publishOrdinaryFallbackIntent(input: Readonly<{
     authority: HumanMemoryProductAuthority;
@@ -213,7 +214,7 @@ export interface HumanMemoryProductCreatePort {
   }>): Promise<HumanMemoryOrdinaryFallbackReplay | null>;
   admitOrdinaryFallback(input: Readonly<{
     authority: HumanMemoryProductCreateAuthority;
-    authenticated: AuthenticatedHumanMemoryOrdinaryFallbackRequestV1;
+    authenticated: AuthenticatedHumanMemoryOrdinaryFallbackRequestV1 | AuthenticatedHumanMemoryOrdinaryFallbackRequestV2;
   }>): Promise<HumanMemoryOrdinaryFallbackAdmission>;
   publishOrdinaryFallbackIntent(input: Readonly<{
     authority: HumanMemoryProductCreateAuthority;
@@ -914,7 +915,7 @@ export class PostgresHumanMemoryProductUpdate
 
   async admitOrdinaryFallback(input: Readonly<{
     authority: HumanMemoryProductAuthority | HumanMemoryProductCreateAuthority;
-    authenticated: AuthenticatedHumanMemoryOrdinaryFallbackRequestV1;
+    authenticated: AuthenticatedHumanMemoryOrdinaryFallbackRequestV1 | AuthenticatedHumanMemoryOrdinaryFallbackRequestV2;
   }>): Promise<HumanMemoryOrdinaryFallbackAdmission> {
     const { request, requestDigest } = input.authenticated;
     const create = request.purpose === "memory.ordinary_fallback.create";
@@ -1802,7 +1803,9 @@ export class PostgresHumanMemoryProductUpdate
           nextContentRevision: request.nextContentRevision,
           expectedAccessRevision: request.expectedCryptoAccessRevision,
           requiredNamespaceIds: request.requiredNamespaceIds,
-          authored: request, embedding: input.embedding, retainOrdinary: true,
+          authored: { formatVersion: 1, type: request.type, content: request.content,
+            ...(request.importance === undefined ? {} : { importance: request.importance }) },
+          embedding: input.embedding, retainOrdinary: true,
           resetAccessRevision: false, priorMapping: "if-present",
           isCreate: request.purpose === "memory.ordinary_fallback.create" });
         const projection = projectProduct(await loadProduct(tx, request.memoryId));
diff --git a/packages/lattice-bridge/tests/integration/postgres-memory-product-crypto.integration.test.ts b/packages/lattice-bridge/tests/integration/postgres-memory-product-crypto.integration.test.ts
index 6bdb4d944..9f52ecbb5 100644
--- a/packages/lattice-bridge/tests/integration/postgres-memory-product-crypto.integration.test.ts
+++ b/packages/lattice-bridge/tests/integration/postgres-memory-product-crypto.integration.test.ts
@@ -55,6 +55,8 @@ import {
   type Rng,
 } from "@nautilo/lattice-crypto";
 import {
+  decodeHumanMemoryContentEmbeddingRequestV2,
+  prepareHumanMemoryContentEmbeddingRequestV3,
   encodeAgentRuntimeSignerPublicationV1,
   encodeLiveShadowMessagePlanV4,
   encodeEncryptedPayloadV2,
@@ -1552,6 +1554,7 @@ async function assertMemoryRepresentationAndCryptoOpaque(
 
 async function createHumanDeletionFixture(
   representation: "ordinary_and_protected" | "protected_only" = "protected_only",
+  marketplace = false,
 ) {
   const memoryId = randomUUID();
   const namespaceValue = randomUUID();
@@ -1613,7 +1616,7 @@ async function createHumanDeletionFixture(
     committerSigningPublicKey: signing.publicKey,
     committerSigningPrivateKey: signing.privateKey,
   });
-  const signedEmbeddingRequest = prepareHumanMemoryContentEmbeddingRequest(
+  const legacySignedEmbeddingRequest = prepareHumanMemoryContentEmbeddingRequest(
     crypto,
     {
       subjectHumanId: humanId(humanValue),
@@ -1642,6 +1645,21 @@ async function createHumanDeletionFixture(
       committerSigningPrivateKey: signing.privateKey,
     },
   );
+  const legacyRequest = decodeHumanMemoryContentEmbeddingRequestV2(legacySignedEmbeddingRequest.bytes);
+  const { formatVersion: _version, purpose: _purpose, signature: _signature,
+    requestedProvider: _provider, requestedModel: _model, dimensions: _dimensions,
+    processorContractVersion: _contract, ...signedCoordinates } = legacyRequest;
+  const requestedEmbedding = { contractVersion: 2, canonicalSpace: {
+    provider: "venice", model: "text-embedding-3-large", dimensions: 1536 },
+    processingRoute: { transport: "surplus_marketplace",
+      marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+      dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] } } as const;
+  const signedEmbeddingRequest = marketplace
+    ? prepareHumanMemoryContentEmbeddingRequestV3(crypto, { ...signedCoordinates,
+      requestedEmbedding, processorContractVersion: 2,
+      committerSigningPublicKey: signing.publicKey,
+      committerSigningPrivateKey: signing.privateKey })
+    : legacySignedEmbeddingRequest;
   const preparedCreateRequest = Object.freeze({
       requestVersion: 1,
       memoryId,
@@ -1794,11 +1812,13 @@ async function createHumanDeletionFixture(
     foregroundEmbeddingProcessor: {
       embed: async ({ request }) => {
         expect(request.plaintext).toBe(plaintext);
+        if (marketplace) expect(request).toMatchObject({ contractVersion: 2,
+          embeddingDisclosure: requestedEmbedding });
         return {
           status: "embedded",
           embedding: {
-            provider: "openai",
-            canonicalModel: "text-embedding-3-small",
+            provider: marketplace ? "venice" : "openai",
+            canonicalModel: marketplace ? "text-embedding-3-large" : "text-embedding-3-small",
             dimensions: 1536,
             vector: new Array<number>(1536).fill(0.5),
             processorContractVersion: 1,
@@ -4343,7 +4363,7 @@ describe("Postgres protected Memory product and crypto adapters", () => {
     }
   });
 
-  test("publishes and replays early ordinary Human create/update with truthful terminal receipts and no crypto allocation", async () => {
+  test.each([false, true])("publishes and replays early ordinary Human create/update with truthful terminal receipts and no crypto allocation (marketplace=%s)", async (marketplace) => {
     const fixture = await createHumanDeletionFixture("ordinary_and_protected");
     const operationId = `human-memory:ordinary-update:${randomUUID()}`;
     const requestDigest = fixture.crypto.hash(new TextEncoder().encode(operationId));
@@ -4363,7 +4383,7 @@ describe("Postgres protected Memory product and crypto adapters", () => {
           withLocks: async (_input, publish) => publish(async () => {}),
           withOrdinaryLocks: async (_input, publish) => publish(async () => {}) },
       });
-      const authenticated = Object.freeze({ requestDigest,
+      const legacyAuthenticated = Object.freeze({ requestDigest,
         request: Object.freeze({ formatVersion: 1 as const,
           purpose: "memory.ordinary_fallback.update" as const,
           reason: "target_encryption_not_ready" as const,
@@ -4380,14 +4400,27 @@ describe("Postgres protected Memory product and crypto adapters", () => {
           hostAuthorizationRevision: 1, planIssuedAt: null,
           planDeadlineAt: null, issuedAt: NOW, deadlineAt: NOW + 30_000,
           signature: new Uint8Array(64) }) });
+      const { formatVersion: _version, requestedProvider: _provider,
+        requestedModel: _model, dimensions: _dimensions,
+        processorContractVersion: _contract, ...coordinates } = legacyAuthenticated.request;
+      const authenticated = marketplace ? Object.freeze({ requestDigest,
+        request: Object.freeze({ ...coordinates, formatVersion: 2 as const,
+          processorContractVersion: 2 as const,
+          requestedEmbedding: { contractVersion: 2 as const,
+            canonicalSpace: { provider: "venice" as const,
+              model: "text-embedding-3-large", dimensions: 1536 as const },
+            processingRoute: { transport: "surplus_marketplace" as const,
+              marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+              dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] as const } } }) })
+        : legacyAuthenticated;
       expect(() => product.admitOrdinaryFallback({
         authority: { ...authority, mutableNamespaceIds: [] }, authenticated,
       })).toThrow("fallback authority is incomplete");
       const admission = await product.admitOrdinaryFallback({ authority,
         authenticated });
       const projection = await product.publishOrdinaryFallbackIntent({
-        authority, admission, embedding: { provider: "openai",
-          canonicalModel: "text-embedding-3-small", dimensions: 1536,
+        authority, admission, embedding: { provider: marketplace ? "venice" : "openai",
+          canonicalModel: marketplace ? "text-embedding-3-large" : "text-embedding-3-small", dimensions: 1536,
           vector: new Array<number>(1536).fill(0.25),
           processorContractVersion: 1 },
       });
@@ -4456,7 +4489,7 @@ describe("Postgres protected Memory product and crypto adapters", () => {
       if (plan.issuedAt === undefined) throw new Error("Missing plan issue time");
       const createDigest = fixture.crypto.hash(
         new TextEncoder().encode(createdOperationId));
-      const createAuthenticated = Object.freeze({ requestDigest: createDigest,
+      const legacyCreateAuthenticated = Object.freeze({ requestDigest: createDigest,
         request: Object.freeze({ formatVersion: 1 as const,
           purpose: "memory.ordinary_fallback.create" as const,
           reason: "target_encryption_not_ready" as const,
@@ -4473,12 +4506,20 @@ describe("Postgres protected Memory product and crypto adapters", () => {
           hostAuthorizationRevision: 1, planIssuedAt: plan.issuedAt,
           planDeadlineAt: plan.deadlineAt, issuedAt: plan.issuedAt,
           deadlineAt: plan.deadlineAt, signature: new Uint8Array(64) }) });
+      const { formatVersion: _createVersion, requestedProvider: _createProvider,
+        requestedModel: _createModel, dimensions: _createDimensions,
+        processorContractVersion: _createContract, ...createCoordinates } = legacyCreateAuthenticated.request;
+      const createAuthenticated = authenticated.request.formatVersion === 2
+        ? { requestDigest: createDigest, request: { ...createCoordinates,
+          formatVersion: 2 as const, processorContractVersion: 2 as const,
+          requestedEmbedding: authenticated.request.requestedEmbedding } }
+        : legacyCreateAuthenticated;
       const createAdmission = await createProduct.admitOrdinaryFallback({
         authority: createAuthority, authenticated: createAuthenticated });
       expect(await createProduct.publishOrdinaryFallbackIntent({
         authority: createAuthority, admission: createAdmission,
-        embedding: { provider: "openai",
-          canonicalModel: "text-embedding-3-small", dimensions: 1536,
+        embedding: { provider: marketplace ? "venice" : "openai",
+          canonicalModel: marketplace ? "text-embedding-3-large" : "text-embedding-3-small", dimensions: 1536,
           vector: new Array<number>(1536).fill(0.5),
           processorContractVersion: 1 },
       })).toMatchObject({ memoryId: createdMemoryId, contentRevision: 1,
@@ -4946,3 +4987,24 @@ describe("Postgres protected Memory product and crypto adapters", () => {
     }
   });
 });
+
+
+test("persists marketplace-bound protected Human content with canonical Venice vectors", async () => {
+  const fixture = await createHumanDeletionFixture("protected_only", true);
+  try {
+    const db = drizzle(admin, { schema });
+    const [stored] = await db.select({ content: memories.content,
+      provider: memories.embeddingProvider, model: memories.embeddingModel,
+      dimensions: memories.embeddingDimensions, contract: memories.embeddingContractVersion,
+      embeddingRevision: memories.embeddingRevision, contentRevision: memories.contentRevision,
+      mapping: memories.cryptoMappingState }).from(memories).where(eq(memories.id, fixture.memoryId));
+    expect(stored).toEqual({ content: null, provider: "venice", model: "text-embedding-3-large",
+      dimensions: 1536, contract: 1, embeddingRevision: 1, contentRevision: 1, mapping: "verified" });
+    const opened = decryptObjectPayload(fixture.crypto, fixture.objectDek, decodeEncryptedPayloadV2(fixture.payloadBytes));
+    if (opened === null) throw new Error("Protected Memory payload failed to decrypt");
+    expect(decodeMemoryPayloadV1(opened).content).toBe(fixture.plaintext);
+  } finally {
+    fixture.objectDek.fill(0); fixture.signingPrivateKey.fill(0);
+    fixture.envelopeBytes.fill(0); fixture.signedEmbeddingRequest.bytes.fill(0);
+  }
+});
diff --git a/packages/lattice-bridge/tests/unit/foreground-memory-processor-transport.test.ts b/packages/lattice-bridge/tests/unit/foreground-memory-processor-transport.test.ts
index 663a45a72..c936c465e 100644
--- a/packages/lattice-bridge/tests/unit/foreground-memory-processor-transport.test.ts
+++ b/packages/lattice-bridge/tests/unit/foreground-memory-processor-transport.test.ts
@@ -2,10 +2,64 @@ import { describe, expect, test } from "bun:test";
 import { LatticeCrypto } from "@nautilo/lattice-crypto";
 import {
   createForegroundMemoryProcessorRecipient,
+  decodeMemoryProcessorSearchQueryV2,
+  encodeMemoryProcessorSearchQueryV2,
   sealForegroundMemoryProcessorRequest,
+  sealForegroundMemoryProcessorSearchQueryV2,
 } from "../../src/memory/foreground-memory-processor-transport.ts";
 
 describe("foreground Memory processor carrier", () => {
+  const marketplace = Object.freeze({
+    contractVersion: 2 as const,
+    canonicalSpace: Object.freeze({ provider: "venice" as const,
+      model: "text-embedding-3-large", dimensions: 1536 as const }),
+    processingRoute: Object.freeze({
+      transport: "surplus_marketplace" as const,
+      marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+      dataRecipientClasses: Object.freeze([
+        "surplus", "marketplace_seller", "seller_upstream_processor",
+      ] as const),
+    }),
+  });
+
+  test("V2 query codec authenticates the full marketplace disclosure", () => {
+    const encoded = encodeMemoryProcessorSearchQueryV2({
+      formatVersion: 2,
+      purpose: "memory.query_embedding",
+      query: "private orchid",
+      embeddingDisclosure: marketplace,
+    });
+    expect(decodeMemoryProcessorSearchQueryV2(encoded)).toEqual({
+      formatVersion: 2,
+      purpose: "memory.query_embedding",
+      query: "private orchid",
+      embeddingDisclosure: marketplace,
+    });
+    expect(() => decodeMemoryProcessorSearchQueryV2(encoded.replace(
+      "surplus-embedding-marketplace-v1", "changed-policy",
+    ))).toThrow();
+  });
+
+  test("V2 query carrier hides text and opens to the exact disclosed payload", async () => {
+    const crypto = new LatticeCrypto();
+    const recipient = await createForegroundMemoryProcessorRecipient({ crypto });
+    try {
+      const descriptor = { ...recipient.descriptor, formatVersion: 2 as const,
+        embedding: marketplace };
+      const sealed = await sealForegroundMemoryProcessorSearchQueryV2({
+        crypto, recipient: descriptor, subjectId: "human-a",
+        query: "private orchid", embeddingDisclosure: marketplace,
+      });
+      expect(JSON.stringify(sealed)).not.toContain("private orchid");
+      const opened = await recipient.open(sealed, {
+        purpose: "memory.query_embedding", subjectId: "human-a",
+      });
+      expect(opened).not.toBeNull();
+      expect(decodeMemoryProcessorSearchQueryV2(opened!)).toMatchObject({
+        query: "private orchid", embeddingDisclosure: marketplace,
+      });
+    } finally { recipient.dispose(); }
+  });
   test("actual wire ciphertext hides query and signed content, opens only for the exact subject/purpose", async () => {
     const crypto = new LatticeCrypto();
     const recipient = await createForegroundMemoryProcessorRecipient({ crypto });
diff --git a/packages/lattice-bridge/tests/unit/human-memory-ordinary-fallback-publication.test.ts b/packages/lattice-bridge/tests/unit/human-memory-ordinary-fallback-publication.test.ts
index 9b09079b2..ffb5a2240 100644
--- a/packages/lattice-bridge/tests/unit/human-memory-ordinary-fallback-publication.test.ts
+++ b/packages/lattice-bridge/tests/unit/human-memory-ordinary-fallback-publication.test.ts
@@ -1,7 +1,8 @@
 import { describe, expect, test } from "bun:test";
 import { LatticeCrypto } from "@nautilo/lattice-crypto";
 
-import { prepareHumanMemoryOrdinaryFallbackRequestV1,
+import { prepareHumanMemoryOrdinaryFallbackRequestV2,
+  prepareHumanMemoryOrdinaryFallbackRequestV1,
   createHumanMemoryOrdinaryFallbackReplayAdmissionV1 } from
   "../../src/memory/human-memory-ordinary-fallback-request.ts";
 import { publishHumanMemoryOrdinaryFallbackIntent } from
@@ -18,10 +19,16 @@ const NAMESPACE = "81000000-0000-4000-8000-000000000010";
 const authority: HumanMemoryProductAuthority = Object.freeze({ userId: "user-1",
   mutableNamespaceIds: [NAMESPACE], writableNamespaceIds: [NAMESPACE] });
 
-function fixture() {
+const marketplaceDisclosure = { contractVersion: 2, canonicalSpace: {
+  provider: "venice", model: "text-embedding-3-large", dimensions: 1536 },
+  processingRoute: { transport: "surplus_marketplace",
+    marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+    dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] } } as const;
+
+function fixture(marketplace = false) {
   const crypto = new LatticeCrypto();
   const signer = crypto.generateSigningKeyPair();
-  const signed = prepareHumanMemoryOrdinaryFallbackRequestV1(crypto, {
+  const legacyInput = {
     formatVersion: 1, purpose: "memory.ordinary_fallback.update",
     reason: "target_encryption_not_ready", operationId: "operation-1",
     memoryId: MEMORY, expectedContentRevision: 2, nextContentRevision: 3,
@@ -33,7 +40,14 @@ function fixture() {
     hostAuthorizationRevision: 3, planIssuedAt: null, planDeadlineAt: null,
     issuedAt: 1_000, deadlineAt: 31_000,
     signingPrivateKey: signer.privateKey,
-  });
+  } as const;
+  const { formatVersion: _version, requestedProvider: _provider,
+    requestedModel: _model, dimensions: _dimensions, processorContractVersion: _contract,
+    ...coordinates } = legacyInput;
+  const signed = marketplace
+    ? prepareHumanMemoryOrdinaryFallbackRequestV2(crypto, { ...coordinates,
+      formatVersion: 2, requestedEmbedding: marketplaceDisclosure, processorContractVersion: 2 })
+    : prepareHumanMemoryOrdinaryFallbackRequestV1(crypto, legacyInput);
   return { crypto, signer, submitted: { requestVersion: 1 as const,
     publicationKind: "ordinary_fallback" as const,
     reason: "target_encryption_not_ready" as const, memoryId: MEMORY,
@@ -164,3 +178,35 @@ describe("Human Memory ordinary fallback publication", () => {
     expect(order).toEqual(["admit", "embed"]);
   });
 });
+
+
+test("ordinary fallback publishes the exact signed marketplace disclosure while retaining result provenance V1", async () => {
+  const value = fixture(true); const order: string[] = [];
+  const result = await publishHumanMemoryOrdinaryFallbackIntent({ ...value,
+    now: () => 2_000, expectedHumanId: "human-1",
+    expectedPurpose: "memory.ordinary_fallback.update", authority,
+    product: { lookupOrdinaryFallback: async () => null,
+      admitOrdinaryFallback: async ({ authenticated }) => {
+        order.push("admit");
+        expect(authenticated.request).toMatchObject({ formatVersion: 2,
+          requestedEmbedding: marketplaceDisclosure });
+        return { authenticated, expectedAccessRevision: 1 }; },
+      publishOrdinaryFallbackIntent: async ({ embedding }) => {
+        order.push("publish");
+        expect(embedding).toMatchObject({ provider: "venice",
+          canonicalModel: "text-embedding-3-large", processorContractVersion: 1 });
+        return projection(); } },
+    resolveHistoricalDeviceAuthority: async () => ({
+      committerSigningPublicKey: value.signer.publicKey }),
+    foregroundEmbeddingProcessor: { embed: async ({ request }) => {
+      order.push("embed");
+      expect(request).toMatchObject({ contractVersion: 2,
+        embeddingDisclosure: marketplaceDisclosure, provider: "venice",
+        model: "text-embedding-3-large", dimensions: 1536 });
+      return { status: "embedded", embedding: { provider: "venice",
+        canonicalModel: "text-embedding-3-large", dimensions: 1536,
+        processorContractVersion: 1, vector: new Array<number>(1536).fill(0.25) } }; } },
+  });
+  expect(result).toMatchObject({ status: "ordinary_fallback", contentRevision: 3 });
+  expect(order).toEqual(["admit", "embed", "publish"]);
+});
diff --git a/packages/lattice-bridge/tests/unit/human-memory-ordinary-fallback-request-v2.test.ts b/packages/lattice-bridge/tests/unit/human-memory-ordinary-fallback-request-v2.test.ts
new file mode 100644
index 000000000..a245b6d4f
--- /dev/null
+++ b/packages/lattice-bridge/tests/unit/human-memory-ordinary-fallback-request-v2.test.ts
@@ -0,0 +1,131 @@
+import { describe, expect, test } from "bun:test";
+import { LatticeCrypto } from "@nautilo/lattice-crypto";
+import {
+  createHumanMemoryOrdinaryFallbackReplayAdmissionV1,
+  createHumanMemoryOrdinaryFallbackReplayAdmissionV2,
+  decodeHumanMemoryOrdinaryFallbackRequestV1,
+  decodeHumanMemoryOrdinaryFallbackRequestV2,
+  encodeHumanMemoryOrdinaryFallbackRequestV2,
+  digestHumanMemoryOrdinaryFallbackRequestV2,
+  prepareHumanMemoryOrdinaryFallbackRequestV1,
+  prepareHumanMemoryOrdinaryFallbackRequestV2,
+  verifyHumanMemoryOrdinaryFallbackRequestV2,
+  type HumanMemoryOrdinaryFallbackUnsignedRequestV2,
+} from "../../src/memory/human-memory-ordinary-fallback-request.ts";
+
+function fixture() {
+  let value = 1;
+  const crypto = new LatticeCrypto({ bytes: (length) => Uint8Array.from({ length }, () => value++ & 0xff) });
+  const signer = crypto.generateSigningKeyPair();
+  const unsigned: HumanMemoryOrdinaryFallbackUnsignedRequestV2 = {
+    formatVersion: 2, purpose: "memory.ordinary_fallback.create", reason: "target_encryption_not_ready",
+    operationId: "create:1", memoryId: "81000000-0000-4000-8000-000000000001",
+    expectedContentRevision: 0, nextContentRevision: 1, expectedCryptoAccessRevision: 0,
+    requiredNamespaceIds: ["81000000-0000-4000-8000-000000000010"],
+    type: "fact", content: "Private memory content", importance: 0.5,
+    requestedEmbedding: { contractVersion: 2,
+      canonicalSpace: { provider: "venice", model: "text-embedding-3-large", dimensions: 1536 },
+      processingRoute: { transport: "surplus_marketplace", marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+        dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] } },
+    processorContractVersion: 2, policyRevision: 7, subjectHumanId: "human:1", committerDeviceId: "device:1",
+    committerDeviceSigningKeyGeneration: 2, hostAuthorizationRevision: 9,
+    planIssuedAt: 1_000, planDeadlineAt: 31_000, issuedAt: 1_100, deadlineAt: 31_000,
+  };
+  return { crypto, signer, unsigned };
+}
+function mutateWire(bytes: Uint8Array, index: number, value: unknown) {
+  const wire = JSON.parse(new TextDecoder().decode(bytes)) as unknown[];
+  wire[index] = value;
+  return new TextEncoder().encode(JSON.stringify(wire));
+}
+
+describe("Human Memory ordinary fallback V2", () => {
+  test.each(["memory.ordinary_fallback.create", "memory.ordinary_fallback.update"] as const)("signs and canonically round-trips %s", (purpose) => {
+    const { crypto, signer, unsigned } = fixture();
+    const created = prepareHumanMemoryOrdinaryFallbackRequestV2(crypto, { ...unsigned, purpose,
+      ...(purpose.endsWith("update") ? { planIssuedAt: null, planDeadlineAt: null } : {}), signingPrivateKey: signer.privateKey });
+    expect(decodeHumanMemoryOrdinaryFallbackRequestV2(created.bytes)).toEqual(created.request);
+    expect(encodeHumanMemoryOrdinaryFallbackRequestV2(created.request)).toEqual(created.bytes);
+    const authenticated = verifyHumanMemoryOrdinaryFallbackRequestV2(crypto, {
+      requestBytes: created.bytes, signingPublicKey: signer.publicKey, now: 2_000 });
+    expect(authenticated.request).toEqual(created.request);
+    expect(authenticated.requestDigest).toEqual(digestHumanMemoryOrdinaryFallbackRequestV2(created.bytes));
+    expect(Object.isFrozen(created.request.requestedEmbedding.processingRoute)).toBeTrue();
+  });
+
+  test("signature commits to transport and every authority/content field", () => {
+    const { crypto, signer, unsigned } = fixture();
+    const created = prepareHumanMemoryOrdinaryFallbackRequestV2(crypto, { ...unsigned, signingPrivateKey: signer.privateKey });
+    const changed = { ...unsigned.requestedEmbedding, processingRoute: { transport: "direct" } };
+    const substitutions: readonly [number, unknown][] = [
+      [4, "create:2"], [5, "81000000-0000-4000-8000-000000000002"],
+      [9, ["81000000-0000-4000-8000-000000000011"]], [10, "preference"], [11, "changed"], [12, 0.9],
+      [13, changed], [15, 8], [16, "human:2"], [17, "device:2"], [18, 3], [19, 10],
+      [20, 999], [21, 30_999], [22, 1_101], [23, 30_999],
+    ];
+    for (const [index, value] of substitutions) expect(() => verifyHumanMemoryOrdinaryFallbackRequestV2(crypto, {
+      requestBytes: mutateWire(created.bytes, index, value), signingPublicKey: signer.publicKey, now: 2_000,
+    })).toThrow();
+    for (const disclosure of [
+      { ...unsigned.requestedEmbedding, canonicalSpace: { ...unsigned.requestedEmbedding.canonicalSpace, provider: "openai" } },
+      { ...unsigned.requestedEmbedding, processingRoute: { ...unsigned.requestedEmbedding.processingRoute, marketplacePolicyVersion: "other" } },
+      { ...unsigned.requestedEmbedding, processingRoute: { ...unsigned.requestedEmbedding.processingRoute, dataRecipientClasses: ["surplus"] } },
+    ]) expect(() => verifyHumanMemoryOrdinaryFallbackRequestV2(crypto, {
+      requestBytes: mutateWire(created.bytes, 13, disclosure), signingPublicKey: signer.publicKey, now: 2_000,
+    })).toThrow();
+  });
+
+  test("rejects extra, missing, invalid, and noncanonical fields before signing", () => {
+    const { crypto, signer, unsigned } = fixture();
+    const sign = crypto.sign.bind(crypto);
+    let signatures = 0;
+    crypto.sign = (...args) => { signatures++; return sign(...args); };
+    for (const patch of [{ formatVersion: 1 }, { processorContractVersion: 1 }, { requestedEmbedding: undefined },
+      { requestedProvider: "venice" }, { extra: true }, { signature: new Uint8Array(64) }, { deadlineAt: 31_101 },
+      { requestedEmbedding: { ...unsigned.requestedEmbedding, extra: true } }]) {
+      expect(() => prepareHumanMemoryOrdinaryFallbackRequestV2(crypto, { ...unsigned, ...patch, signingPrivateKey: signer.privateKey } as never)).toThrow();
+    }
+    expect(signatures).toBe(0);
+    const created = prepareHumanMemoryOrdinaryFallbackRequestV2(crypto, { ...unsigned, signingPrivateKey: signer.privateKey });
+    const whitespace = Uint8Array.from([...created.bytes, 0x20]);
+    expect(() => decodeHumanMemoryOrdinaryFallbackRequestV2(whitespace)).toThrow("noncanonical");
+    const reversedFields = { processingRoute: unsigned.requestedEmbedding.processingRoute,
+      canonicalSpace: unsigned.requestedEmbedding.canonicalSpace, contractVersion: 2 };
+    expect(() => decodeHumanMemoryOrdinaryFallbackRequestV2(mutateWire(created.bytes, 13, reversedFields))).toThrow("noncanonical");
+  });
+
+  test("shares exact durable replay authority across versions without broadening its digest binding", () => {
+    const { crypto, signer, unsigned } = fixture();
+    const created = prepareHumanMemoryOrdinaryFallbackRequestV2(crypto, { ...unsigned, signingPrivateKey: signer.privateKey });
+    const binding = { operationId: unsigned.operationId, memoryId: unsigned.memoryId,
+      requestDigest: digestHumanMemoryOrdinaryFallbackRequestV2(created.bytes) };
+    expect(() => verifyHumanMemoryOrdinaryFallbackRequestV2(crypto, { requestBytes: created.bytes,
+      signingPublicKey: signer.publicKey, now: 31_000 })).toThrow("not currently valid");
+    for (const replayAdmission of [createHumanMemoryOrdinaryFallbackReplayAdmissionV1(binding), createHumanMemoryOrdinaryFallbackReplayAdmissionV2(binding)]) {
+      expect(verifyHumanMemoryOrdinaryFallbackRequestV2(crypto, { requestBytes: created.bytes,
+        signingPublicKey: signer.publicKey, now: 31_000, replayAdmission }).request).toEqual(created.request);
+      const changed = prepareHumanMemoryOrdinaryFallbackRequestV2(crypto, { ...unsigned, content: "different", signingPrivateKey: signer.privateKey });
+      expect(() => verifyHumanMemoryOrdinaryFallbackRequestV2(crypto, { requestBytes: changed.bytes,
+        signingPublicKey: signer.publicKey, now: 31_000, replayAdmission })).toThrow("replay admission disagrees");
+    }
+  });
+
+  test("fences versions and preserves the legacy byte layout and signing domain", () => {
+    const { crypto, signer, unsigned } = fixture();
+    const created = prepareHumanMemoryOrdinaryFallbackRequestV2(crypto, { ...unsigned, signingPrivateKey: signer.privateKey });
+    expect(() => decodeHumanMemoryOrdinaryFallbackRequestV1(created.bytes)).toThrow();
+    const { requestedEmbedding: _, ...common } = unsigned;
+    const legacy = prepareHumanMemoryOrdinaryFallbackRequestV1(crypto, { ...common, formatVersion: 1,
+      requestedProvider: "venice", requestedModel: "text-embedding-3-large", dimensions: 1536,
+      processorContractVersion: 1, signingPrivateKey: signer.privateKey });
+    expect(() => decodeHumanMemoryOrdinaryFallbackRequestV2(legacy.bytes)).toThrow();
+    const legacyFields = ["nautilo/memory/human-ordinary-fallback/v1", 1,
+      "memory.ordinary_fallback.create", "target_encryption_not_ready", "create:1",
+      "81000000-0000-4000-8000-000000000001", 0, 1, 0,
+      ["81000000-0000-4000-8000-000000000010"], "fact", "Private memory content", 0.5,
+      "venice", "text-embedding-3-large", 1536, 1, 7, "human:1", "device:1", 2, 9, 1_000, 31_000, 1_100, 31_000];
+    const encoder = new TextEncoder();
+    const signature = crypto.sign(signer.privateKey, encoder.encode(JSON.stringify(legacyFields)));
+    expect(legacy.bytes).toEqual(encoder.encode(JSON.stringify([...legacyFields, Buffer.from(signature).toString("hex")])));
+  });
+});
diff --git a/packages/lattice-bridge/tests/unit/human-memory-prepared-update.test.ts b/packages/lattice-bridge/tests/unit/human-memory-prepared-update.test.ts
index da29cae22..31f4b099d 100644
--- a/packages/lattice-bridge/tests/unit/human-memory-prepared-update.test.ts
+++ b/packages/lattice-bridge/tests/unit/human-memory-prepared-update.test.ts
@@ -19,6 +19,8 @@ import {
   wrapObjectDekForNamespace,
 } from "@nautilo/lattice-crypto";
 import {
+  decodeHumanMemoryContentEmbeddingRequestV2,
+  prepareHumanMemoryContentEmbeddingRequestV3,
   decodeEncryptedPayloadV2,
   decodeNamespaceObjectEnvelopeV2,
   decodeObjectAccessManifestV5,
@@ -1573,3 +1575,35 @@ describe("Human prepared Memory create", () => {
     expect(completionCalls).toBe(3);
   });
 });
+
+
+test("authenticates a marketplace-bound signed content request without changing vector provenance format", async () => {
+  const state = fixture();
+  const legacy = decodeHumanMemoryContentEmbeddingRequestV2(Buffer.from(
+    state.dto.signedContentEmbeddingRequestBytesBase64url, "base64url"));
+  const { formatVersion: _version, purpose: _purpose, signature: _signature,
+    requestedProvider: _provider, requestedModel: _model, dimensions: _dimensions,
+    processorContractVersion: _contract, ...coordinates } = legacy;
+  const requestedEmbedding = { contractVersion: 2, canonicalSpace: {
+    provider: "venice", model: "text-embedding-3-large", dimensions: 1536 },
+    processingRoute: { transport: "surplus_marketplace",
+      marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+      dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] } } as const;
+  const signed = prepareHumanMemoryContentEmbeddingRequestV3(state.crypto, {
+    ...coordinates, requestedEmbedding, processorContractVersion: 2,
+    committerSigningPublicKey: state.signingPublicKey,
+    committerSigningPrivateKey: state.signingPrivateKey,
+  });
+  const authenticated = await authenticatePreparedHumanMemoryUpdate({
+    crypto: state.crypto, expectedHumanId: "human:1", memoryId: MEMORY_ID,
+    prepared: { ...state.dto, signedContentEmbeddingRequestBytesBase64url:
+      Buffer.from(signed.bytes).toString("base64url") },
+    now: 1_800_000_000_000,
+    resolveHistoricalDeviceAuthority: authorityResolver(state.signingPublicKey),
+  });
+  expect(authenticated.embeddingRequest).toMatchObject({ contractVersion: 2,
+    provider: "venice", model: "text-embedding-3-large", dimensions: 1536,
+    embeddingDisclosure: requestedEmbedding, plaintext: "kept client-side" });
+  expect(authenticated.operationRequestDigest).not.toEqual(
+    digestPreparedHumanMemorySignedRequest(state.crypto, state.dto));
+});
diff --git a/packages/lattice-bridge/tests/unit/human-memory-processor-transport.test.ts b/packages/lattice-bridge/tests/unit/human-memory-processor-transport.test.ts
index 0ddb15eeb..f1e4ccf44 100644
--- a/packages/lattice-bridge/tests/unit/human-memory-processor-transport.test.ts
+++ b/packages/lattice-bridge/tests/unit/human-memory-processor-transport.test.ts
@@ -3,8 +3,125 @@ import { NautiloApiClient } from "@nautilo/api-client/browser";
 import { LatticeCrypto } from "@nautilo/lattice-crypto";
 import { createHumanMemoryProcessorTransport } from "../../src/client/memory/human-memory-processor-transport.ts";
 import { createForegroundMemoryProcessorRecipient } from "../../src/memory/foreground-memory-processor-transport.ts";
+import { decodeMemoryProcessorSearchQueryV2 } from "../../src/memory/foreground-memory-processor-transport.ts";
 
 describe("Human Memory protected HTTP adapter", () => {
+  test("does not reinterpret V2 availability failures as legacy direct consent", async () => {
+    const paths: string[] = [];
+    const api = new NautiloApiClient("https://memory.example", {
+      fetchImpl: (url) => {
+        const path = new URL(typeof url === "string" ? url
+          : url instanceof URL ? url.href : url.url).pathname;
+        paths.push(path);
+        return Promise.resolve(Response.json({ error: "unavailable" }, { status: 503 }));
+      },
+    });
+    api.setToken("test-only-session");
+    let failure: unknown;
+    try {
+      await createHumanMemoryProcessorTransport({ api, crypto: new LatticeCrypto(),
+        subjectId: "human-session" }).searchProtectedMemories({
+        q: "private orchid", mode: "semantic",
+      });
+    } catch (error) { failure = error; }
+    expect(failure).toBeInstanceOf(Error);
+    expect(paths).toEqual(["/api/memory/processor-recipient/v2"]);
+  });
+
+  test("V2 search sends the disclosed marketplace route inside ciphertext", async () => {
+    const crypto = new LatticeCrypto();
+    const recipient = await createForegroundMemoryProcessorRecipient({ crypto });
+    const embedding = {
+      contractVersion: 2 as const,
+      canonicalSpace: { provider: "venice" as const,
+        model: "text-embedding-3-large", dimensions: 1536 as const },
+      processingRoute: {
+        transport: "surplus_marketplace" as const,
+        marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+        dataRecipientClasses: [
+          "surplus", "marketplace_seller", "seller_upstream_processor",
+        ] as const,
+      },
+    };
+    let disclosed: ReturnType<typeof decodeMemoryProcessorSearchQueryV2> | undefined;
+    const api = new NautiloApiClient("https://memory.example", {
+      fetchImpl: async (url, init) => {
+        const path = new URL(typeof url === "string" ? url
+          : url instanceof URL ? url.href : url.url).pathname;
+        if (path === "/api/memory/processor-recipient/v2") {
+          return Response.json({ ...recipient.descriptor, formatVersion: 2, embedding });
+        }
+        if (typeof init?.body !== "string") throw new Error("Expected serialized body");
+        const body = JSON.parse(init.body) as Record<string, unknown>;
+        expect(body).toHaveProperty("sealedQueryV2");
+        expect(body).not.toHaveProperty("sealedQuery");
+        const opened = await recipient.open(body["sealedQueryV2"], {
+          purpose: "memory.query_embedding", subjectId: "human-session",
+        });
+        disclosed = decodeMemoryProcessorSearchQueryV2(opened!);
+        return Response.json({ dtoVersion: 1, status: "unavailable",
+          reason: "embedding_unavailable" });
+      },
+    });
+    api.setToken("test-only-session");
+    try {
+      await createHumanMemoryProcessorTransport({ api, crypto,
+        subjectId: "human-session",
+        resolveEmbeddingDisclosure: () => embedding,
+      }).searchProtectedMemories({
+        q: "private orchid", mode: "semantic",
+      });
+      expect(disclosed).toEqual({ formatVersion: 2,
+        purpose: "memory.query_embedding", query: "private orchid",
+        embeddingDisclosure: embedding });
+    } finally { recipient.dispose(); }
+  });
+
+  test("rejects policy drift instead of replacing the disclosure approved by the human", async () => {
+    const crypto = new LatticeCrypto();
+    const recipient = await createForegroundMemoryProcessorRecipient({ crypto });
+    const approved = {
+      contractVersion: 2 as const,
+      canonicalSpace: { provider: "venice" as const,
+        model: "text-embedding-3-large", dimensions: 1536 as const },
+      processingRoute: { transport: "direct" as const },
+    };
+    const current = { ...approved, processingRoute: {
+      transport: "surplus_marketplace" as const,
+      marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+      dataRecipientClasses: [
+        "surplus", "marketplace_seller", "seller_upstream_processor",
+      ] as const,
+    } };
+    let searches = 0;
+    const api = new NautiloApiClient("https://memory.example", {
+      fetchImpl: async (url) => {
+        const path = new URL(typeof url === "string" ? url
+          : url instanceof URL ? url.href : url.url).pathname;
+        if (path === "/api/memory/processor-recipient/v2") {
+          return Response.json({ ...recipient.descriptor, formatVersion: 2,
+            embedding: current });
+        }
+        searches += 1;
+        return Response.json({ dtoVersion: 1, status: "unavailable",
+          reason: "embedding_unavailable" });
+      },
+    });
+    api.setToken("test-only-session");
+    try {
+      let failure: unknown;
+      try {
+        await createHumanMemoryProcessorTransport({ api, crypto,
+          subjectId: "human-session",
+          resolveEmbeddingDisclosure: () => approved,
+        }).searchProtectedMemories({ q: "private orchid", mode: "semantic" });
+      } catch (error) { failure = error; }
+      expect(failure).toBeInstanceOf(TypeError);
+      expect((failure as TypeError).message).toContain("embedding disclosure changed");
+      expect(searches).toBe(0);
+    } finally { recipient.dispose(); }
+  });
+
   test("real API fetch receives ciphertext only; recipient refresh follows server restart", async () => {
     const crypto = new LatticeCrypto();
     let recipient = await createForegroundMemoryProcessorRecipient({ crypto });
@@ -16,6 +133,9 @@ describe("Human Memory protected HTTP adapter", () => {
         const path = new URL(typeof url === "string" ? url
           : url instanceof URL ? url.href : url.url).pathname;
         paths.push(path);
+        if (path === "/api/memory/processor-recipient/v2") {
+          return Response.json({ error: "unsupported" }, { status: 404 });
+        }
         if (path === "/api/memory/processor-recipient") {
           return Response.json(recipient.descriptor);
         }
@@ -55,8 +175,11 @@ describe("Human Memory protected HTTP adapter", () => {
       expect(disclosed).toEqual(["private orchid query", "private orchid query",
         "cHJpdmF0ZS1vcmRpbmFyeS1pbnRlbnQ"]);
       expect(paths).toEqual([
+        "/api/memory/processor-recipient/v2",
         "/api/memory/processor-recipient", "/api/memory/search",
+        "/api/memory/processor-recipient/v2",
         "/api/memory/processor-recipient", "/api/memory/search",
+        "/api/memory/processor-recipient/v2",
         "/api/memory/processor-recipient", "/api/memory/protected-create",
       ]);
       expect(bodies).toHaveLength(3);
diff --git a/packages/lattice-bridge/tests/unit/memory-foreground-embedding-processor.test.ts b/packages/lattice-bridge/tests/unit/memory-foreground-embedding-processor.test.ts
index ea786e392..107251044 100644
--- a/packages/lattice-bridge/tests/unit/memory-foreground-embedding-processor.test.ts
+++ b/packages/lattice-bridge/tests/unit/memory-foreground-embedding-processor.test.ts
@@ -315,3 +315,39 @@ describe("Human foreground Memory embedding processor contract", () => {
     });
   });
 });
+
+describe("versioned Memory embedding disclosure", () => {
+  const space = { provider: "venice" as const, model: "text-embedding-3-large", dimensions: 1536 as const };
+  const disclosure = { contractVersion: 2 as const, canonicalSpace: space,
+    processingRoute: { transport: "surplus_marketplace" as const,
+      marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+      dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] as const } };
+
+  test("rejects missing, mismatched, and legacy-attached disclosures before the provider", async () => {
+    let calls = 0;
+    const processor = createMemoryForegroundEmbeddingProcessor({ now: () => now,
+      provider: { async embed() { calls++; throw new Error("must not disclose"); } } });
+    for (const value of [request({ ...space, contractVersion: 2 }),
+      request({ contractVersion: 2, embeddingDisclosure: disclosure }),
+      request({ ...space, embeddingDisclosure: disclosure })]) {
+      expect(await processor.embed({ request: value, authenticatedSubjectId: "human-alice" }))
+        .toEqual({ status: "unavailable", reason: "invalid_request" });
+    }
+    expect(calls).toBe(0);
+  });
+
+  test("requires the returned canonical model to match the versioned approved space", async () => {
+    let calls = 0;
+    const processor = createMemoryForegroundEmbeddingProcessor({ now: () => now,
+      provider: { async embed(input) {
+        calls++;
+        expect(input.embeddingDisclosure).toEqual(disclosure);
+        return { provider: "venice", canonicalModel: "text-embedding-qwen3-8b", dimensions: 1536,
+          vector: new Array<number>(1536).fill(0.1) };
+      } } });
+    expect(await processor.embed({ request: request({ ...space, contractVersion: 2,
+      embeddingDisclosure: disclosure }), authenticatedSubjectId: "human-alice" }))
+      .toEqual({ status: "unavailable", reason: "incompatible_embedding" });
+    expect(calls).toBe(1);
+  });
+});
diff --git a/packages/lattice-bridge/tests/unit/vault-human-memory-device-content.test.ts b/packages/lattice-bridge/tests/unit/vault-human-memory-device-content.test.ts
index 177f54209..c03a88e6c 100644
--- a/packages/lattice-bridge/tests/unit/vault-human-memory-device-content.test.ts
+++ b/packages/lattice-bridge/tests/unit/vault-human-memory-device-content.test.ts
@@ -3,6 +3,8 @@ import { sha256 } from "@noble/hashes/sha2.js";
 import { AuthorizedHumanMemoryUnavailableError } from "../../src/client/memory/authorized-human-memory-client.ts";
 import { verifyHumanMemoryOrdinaryFallbackRequestV1 } from
   "../../src/memory/human-memory-ordinary-fallback-request.ts";
+import { verifyHumanMemoryOrdinaryFallbackRequestV2 } from
+  "../../src/memory/human-memory-ordinary-fallback-request.ts";
 
 import {
   LatticeCrypto,
@@ -31,6 +33,7 @@ import {
   decodeLiveShadowMessagePlanV4,
   encodeLiveShadowMessagePlanV4,
   encodeNamespaceObjectEnvelopeV2,
+  verifyHumanMemoryContentEmbeddingRequestV3,
 } from "@nautilo/lattice-crypto/wire";
 
 import {
@@ -59,8 +62,6 @@ import { decodeMemoryPayloadV1, encodeMemoryPayloadV1 } from "../../src/memory/m
 import { MemoryClientProfileVault } from "../../src/testing/client-profile-vault.ts";
 import { decodeHumanMemoryRepairAttestationV1, humanMemoryRepairAttestationSigningDigestV1 } from "../../src/memory/human-memory-repair-attestation.ts";
 import { deriveMemoryCryptoObjectIdV1, fingerprintRequiredMemoryNamespaces } from "../../src/memory/memory-repository.ts";
-import { authenticatePreparedHumanMemoryUpdate } from
-  "../../src/server/memory/human-memory-prepared-update.ts";
 
 const MEMORY_ID = "00000000-0000-4000-8000-000000000248";
 const NAMESPACE_ID = "00000000-0000-4000-8000-000000000249";
@@ -633,6 +634,46 @@ async function revisionThreeFixture() {
 }
 
 describe("vault-backed Human Memory device content", () => {
+  test("signs the full marketplace disclosure in an ordinary fallback V2", async () => {
+    const state = await setup();
+    const requestedEmbedding = {
+      contractVersion: 2 as const,
+      canonicalSpace: { provider: "venice" as const,
+        model: "text-embedding-3-large", dimensions: 1536 as const },
+      processingRoute: {
+        transport: "surplus_marketplace" as const,
+        marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+        dataRecipientClasses: [
+          "surplus", "marketplace_seller", "seller_upstream_processor",
+        ] as const,
+      },
+    };
+    const prepared = await state.content.prepareOrdinaryFallbackCreate!({
+      plan: { dtoVersion: 1, status: "ordinary_fallback_ready",
+        reason: "target_encryption_not_ready", memoryId: MEMORY_ID,
+        operationId: "memory-create:fallback-v2", expectedContentRevision: 0,
+        nextContentRevision: 1, expectedCryptoAccessRevision: 0,
+        productAuthority: { mode: "namespace" },
+        requiredNamespaceIds: [NAMESPACE_ID],
+        ordinaryFallbackAuthorization: { policyRevision: 9 },
+        issuedAt: state.now, deadlineAt: state.now + 30_000 },
+      intent: { payload: { formatVersion: 1, type: "preference",
+        content: "marketplace signed value" }, requestedEmbedding },
+    });
+    const bytes = decodeBase64url(
+      prepared.signedOrdinaryFallbackRequestBytesBase64url,
+    );
+    try {
+      const authenticated = verifyHumanMemoryOrdinaryFallbackRequestV2(
+        state.crypto,
+        { requestBytes: bytes, signingPublicKey: state.signing.publicKey,
+          now: state.now },
+      );
+      expect(authenticated.request.requestedEmbedding).toEqual(requestedEmbedding);
+      expect(authenticated.request.processorContractVersion).toBe(2);
+    } finally { bytes.fill(0); }
+  });
+
   test("signs an ordinary create intent with the admitted device and no Namespace keys", async () => {
     const state = await setup();
     state.unavailableAuthorities.add(NAMESPACE_ID);
@@ -1150,8 +1191,18 @@ describe("vault-backed Human Memory device content", () => {
       current,
       intent: {
         payload: { formatVersion: 1, type: "fact", content: "new" },
-        requestedProvider: "openai",
-        requestedModel: "text-embedding-3-small",
+        requestedEmbedding: {
+          contractVersion: 2,
+          canonicalSpace: { provider: "venice",
+            model: "text-embedding-3-large", dimensions: 1536 },
+          processingRoute: {
+            transport: "surplus_marketplace",
+            marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+            dataRecipientClasses: [
+              "surplus", "marketplace_seller", "seller_upstream_processor",
+            ],
+          },
+        },
       },
     });
     expect(updated).toMatchObject({
@@ -1159,14 +1210,28 @@ describe("vault-backed Human Memory device content", () => {
       nextContentRevision: 2,
       requiredNamespaceIds: [NAMESPACE_ID],
     });
-    const authenticated = await authenticatePreparedHumanMemoryUpdate({
-      crypto, expectedHumanId: COORDINATES.humanActorId, memoryId: MEMORY_ID,
-      prepared: updated, now,
-      resolveHistoricalDeviceAuthority: (authority) => Promise.resolve({
-        ...authority, committerSigningPublicKey: signing.publicKey.slice(),
-      }),
+    const signedBytes = decodeBase64url(
+      updated.signedContentEmbeddingRequestBytesBase64url,
+    );
+    const authenticated = verifyHumanMemoryContentEmbeddingRequestV3(crypto, {
+      requestBytes: signedBytes,
+      committerSigningPublicKey: signing.publicKey,
+      now: unixTimestamp(now),
+    });
+    expect(authenticated.content).toBe("new");
+    expect(authenticated.requestedEmbedding).toEqual({
+      contractVersion: 2,
+      canonicalSpace: { provider: "venice",
+        model: "text-embedding-3-large", dimensions: 1536 },
+      processingRoute: {
+        transport: "surplus_marketplace",
+        marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+        dataRecipientClasses: [
+          "surplus", "marketplace_seller", "seller_upstream_processor",
+        ],
+      },
     });
-    expect(authenticated.authored.content).toBe("new");
+    signedBytes.fill(0);
   });
 
   test("requires exact server-derived Human signer evidence", async () => {
diff --git a/packages/lattice-crypto/scripts/mutation-scopes.json b/packages/lattice-crypto/scripts/mutation-scopes.json
index 814f8ccb4..e4e66a69b 100644
--- a/packages/lattice-crypto/scripts/mutation-scopes.json
+++ b/packages/lattice-crypto/scripts/mutation-scopes.json
@@ -321,10 +321,12 @@
       "tier": "critical",
       "mutate": [
         "src/memory/content-embedding-request-v1.ts",
+        "src/memory/content-embedding-request-v3.ts",
+        "src/memory/embedding-disclosure-v2.ts",
         "src/memory/deletion-v1.ts",
         "src/memory/exact-access-request-v1.ts"
       ],
-      "command": "bun test --bail=1 --timeout 60000 tests/unit/human-memory-content-embedding-request-v1.test.ts tests/unit/human-memory-deletion-v1.test.ts tests/unit/human-memory-exact-access-request-v1.test.ts tests/property/human-memory-content-embedding-request-v1.property.test.ts"
+      "command": "bun test --bail=1 --timeout 60000 tests/unit/human-memory-content-embedding-request-v1.test.ts tests/unit/human-memory-deletion-v1.test.ts tests/unit/human-memory-exact-access-request-v1.test.ts tests/property/human-memory-content-embedding-request-v1.property.test.ts tests/unit/human-memory-content-embedding-request-v3.test.ts tests/unit/memory-embedding-disclosure-v2.test.ts tests/property/human-memory-content-embedding-request-v3.property.test.ts"
     },
     {
       "name": "human-task-publication",
diff --git a/packages/lattice-crypto/src/internal-v2.ts b/packages/lattice-crypto/src/internal-v2.ts
index feacce56d..4cc824bd2 100644
--- a/packages/lattice-crypto/src/internal-v2.ts
+++ b/packages/lattice-crypto/src/internal-v2.ts
@@ -867,3 +867,28 @@ export type {
   RecoveryArchiveWireRecordV2,
   V2Storage,
 } from "./storage/v2-store.ts";
+
+export {
+  assertMemoryEmbeddingDisclosureV2,
+  encodeMemoryEmbeddingDisclosureV2,
+  decodeMemoryEmbeddingDisclosureV2,
+  sameMemoryEmbeddingDisclosureV2,
+  MAX_MEMORY_EMBEDDING_DISCLOSURE_WIRE_BYTES_V2,
+} from "./memory/embedding-disclosure-v2.ts";
+export type { MemoryEmbeddingDisclosureV2 } from "./memory/embedding-disclosure-v2.ts";
+export {
+  HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V3,
+  HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V3,
+  HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V3,
+  humanMemoryContentEmbeddingRequestSigningBytesV3,
+  encodeHumanMemoryContentEmbeddingRequestV3,
+  decodeHumanMemoryContentEmbeddingRequestV3,
+  prepareHumanMemoryContentEmbeddingRequestV3,
+  verifyHumanMemoryContentEmbeddingRequestV3,
+} from "./memory/content-embedding-request-v3.ts";
+export type {
+  HumanMemoryContentEmbeddingRequestUnsignedV3,
+  HumanMemoryContentEmbeddingRequestV3,
+  PrepareHumanMemoryContentEmbeddingRequestInputV3,
+  CreatedHumanMemoryContentEmbeddingRequestV3,
+} from "./memory/content-embedding-request-v3.ts";
diff --git a/packages/lattice-crypto/src/memory/content-embedding-request-v1.ts b/packages/lattice-crypto/src/memory/content-embedding-request-v1.ts
index 431a765ab..05c3dc24e 100644
--- a/packages/lattice-crypto/src/memory/content-embedding-request-v1.ts
+++ b/packages/lattice-crypto/src/memory/content-embedding-request-v1.ts
@@ -1,3 +1,15 @@
+import type {
+  HumanMemoryContentEmbeddingRequestUnsignedV3,
+  HumanMemoryContentEmbeddingRequestV3,
+  PrepareHumanMemoryContentEmbeddingRequestInputV3,
+  CreatedHumanMemoryContentEmbeddingRequestV3,
+} from "./content-embedding-request-v3.ts";
+import {
+  assertMemoryEmbeddingDisclosureV2,
+  encodeMemoryEmbeddingDisclosureV2,
+  decodeMemoryEmbeddingDisclosureV2,
+  MAX_MEMORY_EMBEDDING_DISCLOSURE_WIRE_BYTES_V2,
+} from "./embedding-disclosure-v2.ts";
 import type { LatticeCrypto } from "../crypto/index.ts";
 import { compareUnsignedUtf8 } from "../domain/participants.ts";
 import {
@@ -110,6 +122,17 @@ export interface CreatedHumanMemoryContentEmbeddingRequestV2 {
   readonly bytes: Uint8Array;
 }
 
+type ContentUnsigned = HumanMemoryContentEmbeddingRequestUnsignedV2 | HumanMemoryContentEmbeddingRequestUnsignedV3;
+type ContentRequest = HumanMemoryContentEmbeddingRequestV2 | HumanMemoryContentEmbeddingRequestV3;
+type ContentInput = PrepareHumanMemoryContentEmbeddingRequestInputV2 | PrepareHumanMemoryContentEmbeddingRequestInputV3;
+type ContentCreated = CreatedHumanMemoryContentEmbeddingRequestV2 | CreatedHumanMemoryContentEmbeddingRequestV3;
+type ContentVersion = 2 | 3;
+
+function requestDomain(version: ContentVersion): string {
+  return version === 2 ? HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V2
+    : "nautilo/lattice-crypto/human-memory-content-embedding-request/v3";
+}
+
 const UNSIGNED_FIELDS = Object.freeze([
   "formatVersion",
   "purpose",
@@ -134,7 +157,11 @@ const UNSIGNED_FIELDS = Object.freeze([
   "committerDeviceId",
   "hostAuthorizationRevision",
 ] as const);
-const SIGNED_FIELDS = Object.freeze([...UNSIGNED_FIELDS, "signature"]);
+const UNSIGNED_FIELDS_V3 = Object.freeze([
+  ...UNSIGNED_FIELDS.filter((field) => field !== "requestedProvider"
+    && field !== "requestedModel" && field !== "dimensions"),
+  "requestedEmbedding",
+]);
 const ENVELOPE_FIELDS = Object.freeze(["namespaceId", "envelopeHash"]);
 
 function assertObject(label: string, value: unknown): asserts value is object {
@@ -156,20 +183,28 @@ function assertExactFields(
   ) throw new TypeError(`${label} has an invalid field set`);
 }
 
-function assertUnsignedFields(value: object): void {
+function assertUnsignedFields(value: object, version: ContentVersion): void {
+  const fields = version === 2 ? UNSIGNED_FIELDS : UNSIGNED_FIELDS_V3;
   const actual = Object.keys(value).sort();
-  const withoutImportance = UNSIGNED_FIELDS.filter(
+  if (version === 3 && Reflect.ownKeys(value).length !== actual.length) {
+    throw new TypeError("Human Memory content-embedding request has an invalid field set");
+  }
+  const withoutImportance = fields.filter(
     (field) => field !== "importance",
   ).sort();
-  const withImportance = [...UNSIGNED_FIELDS].sort();
+  const withImportance = [...fields].sort();
   if (![withoutImportance, withImportance].some((expected) =>
     actual.length === expected.length
     && actual.every((field, index) => field === expected[index])
   )) throw new TypeError("Human Memory content-embedding request has an invalid field set");
 }
 
-function assertSignedFields(value: object): void {
+function assertSignedFields(value: object, version: ContentVersion): void {
+  const SIGNED_FIELDS = [...(version === 2 ? UNSIGNED_FIELDS : UNSIGNED_FIELDS_V3), "signature"];
   const actual = Object.keys(value).sort();
+  if (version === 3 && Reflect.ownKeys(value).length !== actual.length) {
+    throw new TypeError("Human Memory content-embedding request has an invalid field set");
+  }
   const withoutImportance = SIGNED_FIELDS.filter(
     (field) => field !== "importance",
   ).sort();
@@ -310,13 +345,13 @@ function assertImportance(value: unknown): asserts value is number | undefined {
 }
 
 function normalizeUnsigned(
-  value: HumanMemoryContentEmbeddingRequestUnsignedV2,
-): HumanMemoryContentEmbeddingRequestUnsignedV2 {
+  value: ContentUnsigned,
+  version: ContentVersion,
+): ContentUnsigned {
   assertObject("Human Memory content-embedding request", value);
-  assertUnsignedFields(value);
+  assertUnsignedFields(value, version);
   if (
-    value.formatVersion
-      !== HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V2
+    value.formatVersion !== version
     || value.purpose !== HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_PURPOSE_V2
   ) throw new TypeError("Human Memory content-embedding request kind is invalid");
   const subjectHumanId = humanId(value.subjectHumanId);
@@ -350,21 +385,19 @@ function normalizeUnsigned(
     assertType(value.type);
     assertContent(value.content);
     assertImportance(value.importance);
-    if (
-      value.requestedProvider !== "openai"
-      && value.requestedProvider !== "openrouter"
-      && value.requestedProvider !== "venice"
-    ) throw new TypeError("Memory content-embedding provider is unsupported");
-    assertPortableId(
-      "Memory content-embedding requested model",
-      value.requestedModel,
-    );
-    if (
-      value.dimensions
-        !== HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DIMENSIONS_V2
-      || value.processorContractVersion
-        !== HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V2
-    ) throw new TypeError("Memory content-embedding processor contract is invalid");
+    if (value.formatVersion === 3) {
+      assertMemoryEmbeddingDisclosureV2(value.requestedEmbedding);
+    } else {
+      if (value.requestedProvider !== "openai" && value.requestedProvider !== "openrouter"
+        && value.requestedProvider !== "venice") throw new TypeError("Memory content-embedding provider is unsupported");
+      assertPortableId("Memory content-embedding requested model", value.requestedModel);
+      if (value.dimensions !== HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DIMENSIONS_V2) {
+        throw new TypeError("Memory content-embedding processor contract is invalid");
+      }
+    }
+    if (value.processorContractVersion !== (version === 2 ? 1 : 2)) {
+      throw new TypeError("Memory content-embedding processor contract is invalid");
+    }
     const issuedAt = unixTimestamp(value.issuedAt);
     const deadlineAt = unixTimestamp(value.deadlineAt);
     if (
@@ -377,8 +410,7 @@ function normalizeUnsigned(
       value.hostAuthorizationRevision,
     );
     return Object.freeze({
-      formatVersion:
-        HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V2,
+      formatVersion: version,
       purpose: HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_PURPOSE_V2,
       subjectHumanId,
       requestId: value.requestId,
@@ -392,16 +424,16 @@ function normalizeUnsigned(
       type: value.type,
       content: value.content,
       ...(value.importance === undefined ? {} : { importance: value.importance }),
-      requestedProvider: value.requestedProvider,
-      requestedModel: value.requestedModel,
-      dimensions: HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DIMENSIONS_V2,
-      processorContractVersion:
-        HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V2,
+      ...(value.formatVersion === 3
+        ? { requestedEmbedding: decodeMemoryEmbeddingDisclosureV2(encodeMemoryEmbeddingDisclosureV2(value.requestedEmbedding)) }
+        : { requestedProvider: value.requestedProvider, requestedModel: value.requestedModel,
+          dimensions: HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DIMENSIONS_V2 }),
+      processorContractVersion: version === 2 ? 1 : 2,
       issuedAt,
       deadlineAt,
       committerDeviceId,
       hostAuthorizationRevision,
-    });
+    }) as ContentUnsigned;
   } catch (error) {
     wipeBytes(
       ciphertextPayloadHash,
@@ -413,12 +445,13 @@ function normalizeUnsigned(
 }
 
 function normalizeRequest(
-  value: HumanMemoryContentEmbeddingRequestV2,
-): HumanMemoryContentEmbeddingRequestV2 {
+  value: ContentRequest,
+  version: ContentVersion,
+): ContentRequest {
   assertObject("Human Memory content-embedding request", value);
-  assertSignedFields(value);
+  assertSignedFields(value, version);
   const { signature: rawSignature, ...rawUnsigned } = value;
-  const unsigned = normalizeUnsigned(rawUnsigned);
+  const unsigned = normalizeUnsigned(rawUnsigned, version);
   try {
     return Object.freeze({
       ...unsigned,
@@ -435,7 +468,7 @@ function normalizeRequest(
 }
 
 function destroyUnsigned(
-  value: HumanMemoryContentEmbeddingRequestUnsignedV2,
+  value: ContentUnsigned,
 ): void {
   wipeBytes(
     value.ciphertextPayloadHash,
@@ -444,17 +477,17 @@ function destroyUnsigned(
   );
 }
 
-function destroyRequest(value: HumanMemoryContentEmbeddingRequestV2): void {
+function destroyRequest(value: ContentRequest): void {
   destroyUnsigned(value);
   wipeBytes(value.signature);
 }
 
 function signingBytesFromNormalized(
-  value: HumanMemoryContentEmbeddingRequestUnsignedV2,
+  value: ContentUnsigned,
 ): Uint8Array {
   return concatV2(
-    frameText(HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V2),
-    encodeU32(HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V2),
+    frameText(requestDomain(value.formatVersion)),
+    encodeU32(value.formatVersion),
     frameText(value.purpose),
     frameText(value.subjectHumanId),
     frameText(value.requestId),
@@ -474,9 +507,9 @@ function signingBytesFromNormalized(
     encodeU32(value.importance === undefined ? 0 : 1),
     ...(value.importance === undefined
       ? [] : [frameText(String(value.importance))]),
-    frameText(value.requestedProvider),
-    frameText(value.requestedModel),
-    encodeU32(value.dimensions),
+    ...(value.formatVersion === 3
+      ? [frame(encodeMemoryEmbeddingDisclosureV2(value.requestedEmbedding))]
+      : [frameText(value.requestedProvider), frameText(value.requestedModel), encodeU32(value.dimensions)]),
     encodeU32(value.processorContractVersion),
     encodeU64(value.issuedAt),
     encodeU64(value.deadlineAt),
@@ -485,10 +518,11 @@ function signingBytesFromNormalized(
   );
 }
 
-export function humanMemoryContentEmbeddingRequestSigningBytesV2(
-  value: HumanMemoryContentEmbeddingRequestUnsignedV2,
+export function humanMemoryContentEmbeddingRequestSigningBytesForVersion(
+  value: ContentUnsigned,
+  version: ContentVersion,
 ): Uint8Array {
-  const normalized = normalizeUnsigned(value);
+  const normalized = normalizeUnsigned(value, version);
   try {
     return signingBytesFromNormalized(normalized);
   } finally {
@@ -496,10 +530,11 @@ export function humanMemoryContentEmbeddingRequestSigningBytesV2(
   }
 }
 
-export function encodeHumanMemoryContentEmbeddingRequestV2(
-  value: HumanMemoryContentEmbeddingRequestV2,
+export function encodeHumanMemoryContentEmbeddingRequestForVersion(
+  value: ContentRequest,
+  version: ContentVersion,
 ): Uint8Array {
-  const normalized = normalizeRequest(value);
+  const normalized = normalizeRequest(value, version);
   try {
     const bytes = concatV2(
       signingBytesFromNormalized(normalized),
@@ -524,9 +559,10 @@ function equalBytes(left: Uint8Array, right: Uint8Array): boolean {
     && left.every((value, index) => value === right[index]);
 }
 
-export function decodeHumanMemoryContentEmbeddingRequestV2(
+export function decodeHumanMemoryContentEmbeddingRequestForVersion(
   bytes: Uint8Array,
-): HumanMemoryContentEmbeddingRequestV2 {
+  version: ContentVersion,
+): ContentRequest {
   if (!(bytes instanceof Uint8Array)) {
     throw new TypeError(
       "Human Memory content-embedding request bytes must be Uint8Array",
@@ -539,18 +575,18 @@ export function decodeHumanMemoryContentEmbeddingRequestV2(
       "Human Memory content-embedding request exceeds its wire limit",
     );
   }
-  const raw = decodeExact(bytes, (reader): HumanMemoryContentEmbeddingRequestV2 => {
+  const raw = decodeExact(bytes, (reader): ContentRequest => {
     const domain = reader.readText(
-      utf8V2(HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V2).length,
+      utf8V2(requestDomain(version)).length,
     );
-    if (domain !== HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V2) {
+    if (domain !== requestDomain(version)) {
       throw new CanonicalDecodingError(
         "Human Memory content-embedding request domain mismatch",
       );
     }
     const formatVersion = reader.readVersion(
-      HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V2,
-    ) as typeof HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V2;
+      version,
+    ) as ContentVersion;
     const purpose = reader.readText(
       utf8V2(HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_PURPOSE_V2).length,
     ) as typeof HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_PURPOSE_V2;
@@ -601,28 +637,24 @@ export function decodeHumanMemoryContentEmbeddingRequestV2(
         );
         return { importance };
       })(),
-      requestedProvider: (
-        reader.readText(V2_LIMITS.idBytes)
-      ) as HumanMemoryContentEmbeddingProviderV2,
-      requestedModel: reader.readText(V2_LIMITS.idBytes),
-      dimensions: (
-        reader.readU32()
-      ) as typeof HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DIMENSIONS_V2,
-      processorContractVersion: (
-        reader.readU32()
-      ) as typeof HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V2,
+      ...(version === 3
+        ? { requestedEmbedding: decodeMemoryEmbeddingDisclosureV2(reader.readFrame(MAX_MEMORY_EMBEDDING_DISCLOSURE_WIRE_BYTES_V2)) }
+        : { requestedProvider: reader.readText(V2_LIMITS.idBytes) as HumanMemoryContentEmbeddingProviderV2,
+          requestedModel: reader.readText(V2_LIMITS.idBytes),
+          dimensions: reader.readU32() as typeof HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DIMENSIONS_V2 }),
+      processorContractVersion: reader.readU32(),
       issuedAt: unixTimestamp(reader.readU64()),
       deadlineAt: unixTimestamp(reader.readU64()),
       committerDeviceId: cryptoDeviceId(reader.readText(V2_LIMITS.idBytes)),
       hostAuthorizationRevision: authorizationRevision(reader.readU64()),
       signature: reader.readFrame(V2_LIMITS.signatureBytes),
-    };
+    } as ContentRequest;
   });
-  let normalized: HumanMemoryContentEmbeddingRequestV2 | undefined;
+  let normalized: ContentRequest | undefined;
   let canonical: Uint8Array | undefined;
   try {
-    normalized = normalizeRequest(raw);
-    canonical = encodeHumanMemoryContentEmbeddingRequestV2(normalized);
+    normalized = normalizeRequest(raw, version);
+    canonical = encodeHumanMemoryContentEmbeddingRequestForVersion(normalized, version);
     if (!equalBytes(canonical, bytes)) {
       throw new CanonicalDecodingError(
         "Human Memory content-embedding request is noncanonical",
@@ -638,20 +670,24 @@ export function decodeHumanMemoryContentEmbeddingRequestV2(
   }
 }
 
-export function prepareHumanMemoryContentEmbeddingRequestV2(
+export function prepareHumanMemoryContentEmbeddingRequestForVersion(
   crypto: LatticeCrypto,
-  input: PrepareHumanMemoryContentEmbeddingRequestInputV2,
-): CreatedHumanMemoryContentEmbeddingRequestV2 {
+  input: ContentInput,
+  version: ContentVersion,
+): ContentCreated {
   const {
     committerSigningPublicKey: rawPublicKey,
     committerSigningPrivateKey: rawPrivateKey,
     ...rawUnsigned
   } = input;
+  if (version === 3 && (Object.hasOwn(rawUnsigned, "formatVersion") || Object.hasOwn(rawUnsigned, "purpose"))) {
+    throw new TypeError("Human Memory content-embedding preparation has an invalid field set");
+  }
   const unsigned = normalizeUnsigned({
     ...rawUnsigned,
-    formatVersion: HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V2,
+    formatVersion: version,
     purpose: HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_PURPOSE_V2,
-  });
+  } as ContentUnsigned, version);
   let publicKey: Uint8Array | undefined;
   let privateKey: Uint8Array | undefined;
   let signingBytes: Uint8Array | undefined;
@@ -678,30 +714,32 @@ export function prepareHumanMemoryContentEmbeddingRequestV2(
         "Human Memory content-embedding signing keys do not match",
       );
     }
-    const bytes = encodeHumanMemoryContentEmbeddingRequestV2({
+    const bytes = encodeHumanMemoryContentEmbeddingRequestForVersion({
       ...unsigned,
       signature,
-    });
+    }, version);
     return Object.freeze({
-      request: decodeHumanMemoryContentEmbeddingRequestV2(bytes),
+      request: decodeHumanMemoryContentEmbeddingRequestForVersion(bytes, version),
       bytes,
-    });
+    }) as ContentCreated;
   } finally {
     destroyUnsigned(unsigned);
     wipeBytes(publicKey, privateKey, signingBytes, signature);
   }
 }
 
-export function verifyHumanMemoryContentEmbeddingRequestV2(
+export function verifyHumanMemoryContentEmbeddingRequestForVersion(
   crypto: LatticeCrypto,
   input: Readonly<{
     readonly requestBytes: Uint8Array;
     readonly committerSigningPublicKey: Uint8Array;
     readonly now: UnixTimestamp;
   }>,
-): HumanMemoryContentEmbeddingRequestV2 {
-  const request = decodeHumanMemoryContentEmbeddingRequestV2(
+  version: ContentVersion,
+): ContentRequest {
+  const request = decodeHumanMemoryContentEmbeddingRequestForVersion(
     input.requestBytes,
+    version,
   );
   let publicKey: Uint8Array | undefined;
   let signingBytes: Uint8Array | undefined;
@@ -731,3 +769,22 @@ export function verifyHumanMemoryContentEmbeddingRequestV2(
     if (!verified) destroyRequest(request);
   }
 }
+
+// Legacy entry points always select V2; a new-version payload is never inferred.
+export function humanMemoryContentEmbeddingRequestSigningBytesV2(value: HumanMemoryContentEmbeddingRequestUnsignedV2): Uint8Array {
+  return humanMemoryContentEmbeddingRequestSigningBytesForVersion(value, 2);
+}
+export function encodeHumanMemoryContentEmbeddingRequestV2(value: HumanMemoryContentEmbeddingRequestV2): Uint8Array {
+  return encodeHumanMemoryContentEmbeddingRequestForVersion(value, 2);
+}
+export function decodeHumanMemoryContentEmbeddingRequestV2(bytes: Uint8Array): HumanMemoryContentEmbeddingRequestV2 {
+  return decodeHumanMemoryContentEmbeddingRequestForVersion(bytes, 2) as HumanMemoryContentEmbeddingRequestV2;
+}
+export function prepareHumanMemoryContentEmbeddingRequestV2(crypto: LatticeCrypto, input: PrepareHumanMemoryContentEmbeddingRequestInputV2): CreatedHumanMemoryContentEmbeddingRequestV2 {
+  return prepareHumanMemoryContentEmbeddingRequestForVersion(crypto, input, 2) as CreatedHumanMemoryContentEmbeddingRequestV2;
+}
+export function verifyHumanMemoryContentEmbeddingRequestV2(crypto: LatticeCrypto, input: Readonly<{
+  requestBytes: Uint8Array; committerSigningPublicKey: Uint8Array; now: UnixTimestamp;
+}>): HumanMemoryContentEmbeddingRequestV2 {
+  return verifyHumanMemoryContentEmbeddingRequestForVersion(crypto, input, 2) as HumanMemoryContentEmbeddingRequestV2;
+}
diff --git a/packages/lattice-crypto/src/memory/content-embedding-request-v3.ts b/packages/lattice-crypto/src/memory/content-embedding-request-v3.ts
new file mode 100644
index 000000000..98f6d1343
--- /dev/null
+++ b/packages/lattice-crypto/src/memory/content-embedding-request-v3.ts
@@ -0,0 +1,53 @@
+import type { LatticeCrypto } from "../crypto/index.ts";
+import type { UnixTimestamp } from "../v2-types/ids.ts";
+import type { MemoryEmbeddingDisclosureV2 } from "./embedding-disclosure-v2.ts";
+import {
+  humanMemoryContentEmbeddingRequestSigningBytesForVersion,
+  encodeHumanMemoryContentEmbeddingRequestForVersion,
+  decodeHumanMemoryContentEmbeddingRequestForVersion,
+  prepareHumanMemoryContentEmbeddingRequestForVersion,
+  verifyHumanMemoryContentEmbeddingRequestForVersion,
+  type HumanMemoryContentEmbeddingRequestUnsignedV2,
+} from "./content-embedding-request-v1.ts";
+
+export const HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V3 = 3 as const;
+export const HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V3 =
+  "nautilo/lattice-crypto/human-memory-content-embedding-request/v3";
+export const HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V3 = 2 as const;
+
+export interface HumanMemoryContentEmbeddingRequestUnsignedV3 extends Omit<
+  HumanMemoryContentEmbeddingRequestUnsignedV2,
+  "formatVersion" | "requestedProvider" | "requestedModel" | "dimensions" | "processorContractVersion"
+> {
+  readonly formatVersion: 3;
+  readonly requestedEmbedding: MemoryEmbeddingDisclosureV2;
+  readonly processorContractVersion: 2;
+}
+export interface HumanMemoryContentEmbeddingRequestV3 extends HumanMemoryContentEmbeddingRequestUnsignedV3 {
+  readonly signature: Uint8Array;
+}
+export interface PrepareHumanMemoryContentEmbeddingRequestInputV3 extends Omit<HumanMemoryContentEmbeddingRequestUnsignedV3, "formatVersion" | "purpose"> {
+  readonly committerSigningPublicKey: Uint8Array;
+  readonly committerSigningPrivateKey: Uint8Array;
+}
+export interface CreatedHumanMemoryContentEmbeddingRequestV3 {
+  readonly request: HumanMemoryContentEmbeddingRequestV3;
+  readonly bytes: Uint8Array;
+}
+export function humanMemoryContentEmbeddingRequestSigningBytesV3(value: HumanMemoryContentEmbeddingRequestUnsignedV3): Uint8Array {
+  return humanMemoryContentEmbeddingRequestSigningBytesForVersion(value, 3);
+}
+export function encodeHumanMemoryContentEmbeddingRequestV3(value: HumanMemoryContentEmbeddingRequestV3): Uint8Array {
+  return encodeHumanMemoryContentEmbeddingRequestForVersion(value, 3);
+}
+export function decodeHumanMemoryContentEmbeddingRequestV3(bytes: Uint8Array): HumanMemoryContentEmbeddingRequestV3 {
+  return decodeHumanMemoryContentEmbeddingRequestForVersion(bytes, 3) as HumanMemoryContentEmbeddingRequestV3;
+}
+export function prepareHumanMemoryContentEmbeddingRequestV3(crypto: LatticeCrypto, input: PrepareHumanMemoryContentEmbeddingRequestInputV3): CreatedHumanMemoryContentEmbeddingRequestV3 {
+  return prepareHumanMemoryContentEmbeddingRequestForVersion(crypto, input, 3) as CreatedHumanMemoryContentEmbeddingRequestV3;
+}
+export function verifyHumanMemoryContentEmbeddingRequestV3(crypto: LatticeCrypto, input: Readonly<{
+  requestBytes: Uint8Array; committerSigningPublicKey: Uint8Array; now: UnixTimestamp;
+}>): HumanMemoryContentEmbeddingRequestV3 {
+  return verifyHumanMemoryContentEmbeddingRequestForVersion(crypto, input, 3) as HumanMemoryContentEmbeddingRequestV3;
+}
diff --git a/packages/lattice-crypto/src/memory/embedding-disclosure-v2.ts b/packages/lattice-crypto/src/memory/embedding-disclosure-v2.ts
new file mode 100644
index 000000000..d01021ea2
--- /dev/null
+++ b/packages/lattice-crypto/src/memory/embedding-disclosure-v2.ts
@@ -0,0 +1,111 @@
+import { concatV2, decodeExact, encodeU32, frameText } from "../format/v2-primitives.ts";
+import { assertPortableId } from "../v2-types/ids.ts";
+import { V2_LIMITS } from "../v2-types/limits.ts";
+
+export interface MemoryEmbeddingDisclosureV2 {
+  readonly contractVersion: 2;
+  readonly canonicalSpace: Readonly<{
+    provider: "openai" | "openrouter" | "venice";
+    model: string;
+    dimensions: 1536;
+  }>;
+  readonly processingRoute:
+    | Readonly<{ transport: "direct" }>
+    | Readonly<{
+      transport: "surplus_marketplace";
+      marketplacePolicyVersion: "surplus-embedding-marketplace-v1";
+      dataRecipientClasses: readonly ["surplus", "marketplace_seller", "seller_upstream_processor"];
+    }>;
+}
+
+const RECIPIENTS = Object.freeze([
+  "surplus", "marketplace_seller", "seller_upstream_processor",
+] as const);
+const POLICY = "surplus-embedding-marketplace-v1";
+// One bounded canonical structure: version, provider/model/dimensions, route,
+// and (for marketplace execution) the fixed policy and three recipient classes.
+export const MAX_MEMORY_EMBEDDING_DISCLOSURE_WIRE_BYTES_V2 =
+  7 * (4 + V2_LIMITS.idBytes) + 8;
+
+function exactObject<Field extends string>(value: unknown, fields: readonly Field[]): asserts value is Record<Field, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)
+    || Reflect.ownKeys(value).length !== fields.length
+    || !fields.every((field) => Object.hasOwn(value, field))) {
+    throw new TypeError("Memory embedding disclosure has an invalid field set");
+  }
+}
+
+export function assertMemoryEmbeddingDisclosureV2(value: unknown): asserts value is MemoryEmbeddingDisclosureV2 {
+  exactObject(value, ["contractVersion", "canonicalSpace", "processingRoute"]);
+  if (value.contractVersion !== 2) throw new TypeError("Memory embedding disclosure version is invalid");
+  const space = value.canonicalSpace;
+  exactObject(space, ["provider", "model", "dimensions"]);
+  if ((space.provider !== "openai" && space.provider !== "openrouter" && space.provider !== "venice")
+    || space.dimensions !== 1536) throw new TypeError("Memory embedding canonical space is invalid");
+  assertPortableId("Memory embedding canonical model", space.model);
+  const route = value.processingRoute;
+  if (typeof route !== "object" || route === null) throw new TypeError("Memory embedding route is invalid");
+  if ((route as Record<string, unknown>)["transport"] === "direct") {
+    exactObject(route, ["transport"]);
+    return;
+  }
+  exactObject(route, ["transport", "marketplacePolicyVersion", "dataRecipientClasses"]);
+  const recipients = route.dataRecipientClasses;
+  if (route.transport !== "surplus_marketplace" || route.marketplacePolicyVersion !== POLICY
+    || !Array.isArray(recipients)
+    || recipients.length !== RECIPIENTS.length
+    || Reflect.ownKeys(recipients).length !== RECIPIENTS.length + 1
+    || !RECIPIENTS.every((recipient, index) => recipients[index] === recipient)
+    || space.provider !== "venice" || space.model !== "text-embedding-3-large") {
+    throw new TypeError("Memory embedding marketplace disclosure is invalid");
+  }
+}
+
+export function encodeMemoryEmbeddingDisclosureV2(value: MemoryEmbeddingDisclosureV2): Uint8Array {
+  assertMemoryEmbeddingDisclosureV2(value);
+  return concatV2(
+    encodeU32(value.contractVersion),
+    frameText(value.canonicalSpace.provider),
+    frameText(value.canonicalSpace.model),
+    encodeU32(value.canonicalSpace.dimensions),
+    frameText(value.processingRoute.transport),
+    ...(value.processingRoute.transport === "direct" ? [] : [
+      frameText(value.processingRoute.marketplacePolicyVersion),
+      ...value.processingRoute.dataRecipientClasses.map(frameText),
+    ]),
+  );
+}
+
+export function decodeMemoryEmbeddingDisclosureV2(bytes: Uint8Array): MemoryEmbeddingDisclosureV2 {
+  if (!(bytes instanceof Uint8Array) || bytes.length > MAX_MEMORY_EMBEDDING_DISCLOSURE_WIRE_BYTES_V2) {
+    throw new TypeError("Memory embedding disclosure wire is invalid");
+  }
+  const value = decodeExact(bytes, (reader) => {
+    const contractVersion = reader.readVersion(2);
+    const canonicalSpace = {
+      provider: reader.readText(V2_LIMITS.idBytes),
+      model: reader.readText(V2_LIMITS.idBytes),
+      dimensions: reader.readU32(),
+    };
+    const transport = reader.readText(V2_LIMITS.idBytes);
+    return { contractVersion, canonicalSpace, processingRoute: transport === "direct"
+      ? { transport }
+      : { transport, marketplacePolicyVersion: reader.readText(V2_LIMITS.idBytes),
+        dataRecipientClasses: RECIPIENTS.map(() => reader.readText(V2_LIMITS.idBytes)) } };
+  });
+  assertMemoryEmbeddingDisclosureV2(value);
+  const canonical = encodeMemoryEmbeddingDisclosureV2(value);
+  if (canonical.length !== bytes.length || canonical.some((byte, index) => byte !== bytes[index])) {
+    throw new TypeError("Memory embedding disclosure wire is noncanonical");
+  }
+  if (value.processingRoute.transport === "surplus_marketplace") Object.freeze(value.processingRoute.dataRecipientClasses);
+  Object.freeze(value.canonicalSpace);
+  Object.freeze(value.processingRoute);
+  return Object.freeze(value);
+}
+
+export function sameMemoryEmbeddingDisclosureV2(left: MemoryEmbeddingDisclosureV2, right: MemoryEmbeddingDisclosureV2): boolean {
+  const leftBytes = encodeMemoryEmbeddingDisclosureV2(left);
+  const rightBytes = encodeMemoryEmbeddingDisclosureV2(right);
+  return leftBytes.length === rightBytes.length && leftBytes.every((byte, index) => byte === rightBytes[index]);
+}
diff --git a/packages/lattice-crypto/src/wire.ts b/packages/lattice-crypto/src/wire.ts
index d4575cb75..872911af7 100644
--- a/packages/lattice-crypto/src/wire.ts
+++ b/packages/lattice-crypto/src/wire.ts
@@ -1338,6 +1338,31 @@ export {
 } from "./task/publication-request-v1.ts";
 
 export type { HumanTaskPublicationRequestUnsignedV1 } from "./task/publication-request-v1.ts";
+
+export {
+  assertMemoryEmbeddingDisclosureV2,
+  encodeMemoryEmbeddingDisclosureV2,
+  decodeMemoryEmbeddingDisclosureV2,
+  sameMemoryEmbeddingDisclosureV2,
+  MAX_MEMORY_EMBEDDING_DISCLOSURE_WIRE_BYTES_V2,
+} from "./memory/embedding-disclosure-v2.ts";
+export type { MemoryEmbeddingDisclosureV2 } from "./memory/embedding-disclosure-v2.ts";
+export {
+  HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V3,
+  HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V3,
+  HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V3,
+  humanMemoryContentEmbeddingRequestSigningBytesV3,
+  encodeHumanMemoryContentEmbeddingRequestV3,
+  decodeHumanMemoryContentEmbeddingRequestV3,
+  prepareHumanMemoryContentEmbeddingRequestV3,
+  verifyHumanMemoryContentEmbeddingRequestV3,
+} from "./memory/content-embedding-request-v3.ts";
+export type {
+  HumanMemoryContentEmbeddingRequestUnsignedV3,
+  HumanMemoryContentEmbeddingRequestV3,
+  PrepareHumanMemoryContentEmbeddingRequestInputV3,
+  CreatedHumanMemoryContentEmbeddingRequestV3,
+} from "./memory/content-embedding-request-v3.ts";
 export {
   HUMAN_EXISTING_TASK_REPRESENTATION_PUBLICATION_REQUEST_DOMAIN_V1,
   HUMAN_EXISTING_TASK_REPRESENTATION_PUBLICATION_REQUEST_MAX_TTL_MS_V1,
diff --git a/packages/lattice-crypto/tests/fixtures/public-api-allowlists.ts b/packages/lattice-crypto/tests/fixtures/public-api-allowlists.ts
index b7c9859c9..b01bf9137 100644
--- a/packages/lattice-crypto/tests/fixtures/public-api-allowlists.ts
+++ b/packages/lattice-crypto/tests/fixtures/public-api-allowlists.ts
@@ -545,9 +545,12 @@ export const WIRE_RUNTIME_EXPORTS = [
   "HUMAN_LIVE_SHADOW_MESSAGE_REQUEST_PURPOSE_V3",
   "HUMAN_LIVE_SHADOW_MESSAGE_REQUEST_PURPOSE_V4",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V2",
+  "HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V3",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DIMENSIONS_V2",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V2",
+  "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V3",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V2",
+  "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V3",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_MAX_CONTENT_BYTES_V2",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_MAX_NAMESPACE_ENVELOPES_V2",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_MAX_TTL_MS_V2",
@@ -631,6 +634,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "MAX_LIVE_SHADOW_MESSAGE_PLAN_WIRE_BYTES_V2",
   "MAX_LIVE_SHADOW_MESSAGE_PLAN_WIRE_BYTES_V3",
   "MAX_LIVE_SHADOW_MESSAGE_PLAN_WIRE_BYTES_V4",
+  "MAX_MEMORY_EMBEDDING_DISCLOSURE_WIRE_BYTES_V2",
   "MAX_NAMESPACE_DELIVERY_WIRE_BYTES_V1",
   "MAX_NAMESPACE_GENERATION_ENVELOPE_WIRE_BYTES_V1",
   "MAX_NAMESPACE_GENERATION_PUBLICATION_WIRE_BYTES_V1",
@@ -754,6 +758,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "assertCanonicalAgentManagerKeyringV2",
   "assertCanonicalHumanRecoveryArchiveV2",
   "assertCanonicalNamespaceKeyringV2",
+  "assertMemoryEmbeddingDisclosureV2",
   "assertNamespaceBindingV2",
   "assertNamespaceKeyringEnvelopeV2",
   "assertNamespaceRecoveryPackageV2",
@@ -820,6 +825,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "decodeHumanLiveShadowMessageRequestV3",
   "decodeHumanLiveShadowMessageRequestV4",
   "decodeHumanMemoryContentEmbeddingRequestV2",
+  "decodeHumanMemoryContentEmbeddingRequestV3",
   "decodeHumanMemoryExactAccessRequestV2",
   "decodeHumanMessageEditPlanV1",
   "decodeHumanMessageEditRequestV1",
@@ -832,6 +838,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "decodeLiveShadowMessagePlanV2",
   "decodeLiveShadowMessagePlanV3",
   "decodeLiveShadowMessagePlanV4",
+  "decodeMemoryEmbeddingDisclosureV2",
   "decodeNamespaceGenerationAcknowledgementV1",
   "decodeNamespaceGenerationFetchProofV1",
   "decodeNamespaceGenerationHeadV1",
@@ -950,6 +957,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "encodeHumanLiveShadowMessageRequestV3",
   "encodeHumanLiveShadowMessageRequestV4",
   "encodeHumanMemoryContentEmbeddingRequestV2",
+  "encodeHumanMemoryContentEmbeddingRequestV3",
   "encodeHumanMemoryExactAccessRequestV2",
   "encodeHumanMessageEditPlanV1",
   "encodeHumanMessageEditRequestV1",
@@ -961,6 +969,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "encodeLiveShadowMessagePlanV2",
   "encodeLiveShadowMessagePlanV3",
   "encodeLiveShadowMessagePlanV4",
+  "encodeMemoryEmbeddingDisclosureV2",
   "encodeNamespaceGenerationAcknowledgementV1",
   "encodeNamespaceGenerationFetchProofV1",
   "encodeNamespaceGenerationHeadV1",
@@ -1004,6 +1013,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "humanLiveShadowMessageRequestSigningBytesV3",
   "humanLiveShadowMessageRequestSigningBytesV4",
   "humanMemoryContentEmbeddingRequestSigningBytesV2",
+  "humanMemoryContentEmbeddingRequestSigningBytesV3",
   "humanMemoryExactAccessRequestSigningBytesV2",
   "humanPeerLiveShadowAcknowledgementSigningBytesV1",
   "humanPeerLiveShadowMessageRequestSigningBytesV1",
@@ -1062,6 +1072,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "participantDigestInputV2",
   "pendingDeviceRevisionV2",
   "prepareHumanAiReadableLiveShadowMessageRequestV2",
+  "prepareHumanMemoryContentEmbeddingRequestV3",
   "prepareHumanMessageEditRequestV1",
   "prepareNamespaceGenerationPublicationV1",
   "processorCredentialSigningBytesV1",
@@ -1077,6 +1088,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "recoveryPublicKeyDigestV2",
   "recoveryReadinessDigestV2",
   "redactProviderWelcomeV2",
+  "sameMemoryEmbeddingDisclosureV2",
   "serializeAgentManagerRecoveryPackageV2",
   "serializeAgentRuntimeDomainEnvelopeV1",
   "serializeDeviceTransferApprovalV2",
@@ -1125,6 +1137,7 @@ export const WIRE_RUNTIME_EXPORTS = [
   "verifyHistoricalTaskRuntimeSignerAuthorizationV1",
   "verifyHumanAiReadableLiveShadowMessageRequestExactReplayV2",
   "verifyHumanAiReadableLiveShadowMessageRequestV2",
+  "verifyHumanMemoryContentEmbeddingRequestV3",
   "verifyHumanMessageEditRequestV1",
   "verifyObjectAccessManifestV4",
   "verifyProcessorCredentialV1",
@@ -1760,6 +1773,7 @@ export const WIRE_TYPE_EXPORTS = [
   "CreatedAgentBackgroundGrantResponseV1",
   "CreatedAgentBackgroundGrantResponseV2",
   "CreatedBackgroundAuthorizationResponseV1",
+  "CreatedHumanMemoryContentEmbeddingRequestV3",
   "CreatedObjectAccessManifestV2",
   "CreatedObjectAccessManifestV4",
   "CreatedProcessorCredentialV1",
@@ -1826,6 +1840,8 @@ export const WIRE_TYPE_EXPORTS = [
   "HumanLiveShadowMessageRequestUnsignedV3",
   "HumanLiveShadowMessageRequestUnsignedV4",
   "HumanMemoryContentEmbeddingRequestUnsignedV2",
+  "HumanMemoryContentEmbeddingRequestUnsignedV3",
+  "HumanMemoryContentEmbeddingRequestV3",
   "HumanMemoryExactAccessRequestUnsignedV2",
   "HumanMessageEditAuthorizationSchemeV1",
   "HumanMessageEditObjectCoordinatesV1",
@@ -1840,6 +1856,7 @@ export const WIRE_TYPE_EXPORTS = [
   "HumanTaskPublicationRequestUnsignedV1",
   "LiveShadowAuthorizationRequiredV4",
   "LiveShadowAuthorizationReusableV4",
+  "MemoryEmbeddingDisclosureV2",
   "MemoryNativeNamespaceAccessEntryV1",
   "MemoryNativeNamespaceAuthorityEntryV1",
   "MlsV2JoinRequest",
@@ -1902,6 +1919,7 @@ export const WIRE_TYPE_EXPORTS = [
   "OpenNamespaceGenerationEnvelopeInputV1",
   "OpenedNamespaceGenerationV1",
   "PendingDeviceRevisionV2",
+  "PrepareHumanMemoryContentEmbeddingRequestInputV3",
   "PrepareNamespaceGenerationPublicationInputV1",
   "PrepareNamespaceGenerationPublicationSetClassV1",
   "PreparedAgentRuntimeHandoffChallengeV1",
diff --git a/packages/lattice-crypto/tests/integration/internal-v2-surface.test.ts b/packages/lattice-crypto/tests/integration/internal-v2-surface.test.ts
index 8cf2462ec..67db927c8 100644
--- a/packages/lattice-crypto/tests/integration/internal-v2-surface.test.ts
+++ b/packages/lattice-crypto/tests/integration/internal-v2-surface.test.ts
@@ -69,9 +69,12 @@ const EXPECTED_V2_RUNTIME_EXPORTS = Object.freeze([
   "HUMAN_EXISTING_MESSAGE_REPRESENTATION_PUBLICATION_REQUEST_FORMAT_VERSION_V1",
   "HUMAN_EXISTING_MESSAGE_REPRESENTATION_PUBLICATION_REQUEST_PURPOSE_V1",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V2",
+  "HUMAN_MEMORY_CONTENT_EMBEDDING_PROCESSOR_CONTRACT_VERSION_V3",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DIMENSIONS_V2",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V2",
+  "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_DOMAIN_V3",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V2",
+  "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_FORMAT_VERSION_V3",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_MAX_CONTENT_BYTES_V2",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_MAX_NAMESPACE_ENVELOPES_V2",
   "HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_MAX_TTL_MS_V2",
@@ -83,6 +86,7 @@ const EXPECTED_V2_RUNTIME_EXPORTS = Object.freeze([
   "LatticeCrypto",
   "MAX_HUMAN_EXISTING_MESSAGE_REPRESENTATION_PUBLICATION_REQUEST_WIRE_BYTES_V1",
   "MAX_HUMAN_MEMORY_CONTENT_EMBEDDING_REQUEST_WIRE_BYTES_V2",
+  "MAX_MEMORY_EMBEDDING_DISCLOSURE_WIRE_BYTES_V2",
   "MAX_OBJECT_ACCESS_MANIFEST_WIRE_BYTES_V5",
   "NAMESPACE_BINDING_DOMAIN",
   "NAMESPACE_BINDING_FORMAT_VERSION",
@@ -139,6 +143,7 @@ const EXPECTED_V2_RUNTIME_EXPORTS = Object.freeze([
   "assertCanonicalHumanRecoveryArchive",
   "assertCanonicalNamespaceKeyring",
   "assertEnvelopeAuthorizedV2",
+  "assertMemoryEmbeddingDisclosureV2",
   "assertNamespaceBinding",
   "assertNamespaceKeyringEnvelope",
   "assertNamespaceRecoveryPackage",
@@ -171,7 +176,9 @@ const EXPECTED_V2_RUNTIME_EXPORTS = Object.freeze([
   "decodeEncryptedPayloadV2",
   "decodeHumanExistingMessageRepresentationPublicationRequestV1",
   "decodeHumanMemoryContentEmbeddingRequestV2",
+  "decodeHumanMemoryContentEmbeddingRequestV3",
   "decodeHumanRecoveryArchive",
+  "decodeMemoryEmbeddingDisclosureV2",
   "decodeNamespaceKeyring",
   "decodeNamespaceObjectEnvelopeV2",
   "decodeNamespaceRecoveryPackage",
@@ -197,6 +204,8 @@ const EXPECTED_V2_RUNTIME_EXPORTS = Object.freeze([
   "encodeEncryptedPayloadV2",
   "encodeHumanExistingMessageRepresentationPublicationRequestV1",
   "encodeHumanMemoryContentEmbeddingRequestV2",
+  "encodeHumanMemoryContentEmbeddingRequestV3",
+  "encodeMemoryEmbeddingDisclosureV2",
   "encodeNamespaceKeyring",
   "encodeNamespaceObjectEnvelopeV2",
   "encodeObjectAccessManifestV2",
@@ -214,6 +223,7 @@ const EXPECTED_V2_RUNTIME_EXPORTS = Object.freeze([
   "humanExistingMessageRepresentationPublicationRequestSigningBytesV1",
   "humanId",
   "humanMemoryContentEmbeddingRequestSigningBytesV2",
+  "humanMemoryContentEmbeddingRequestSigningBytesV3",
   "humanRecoveryArchiveSigningBytes",
   "mintGrantV2",
   "namespaceBindingHash",
@@ -275,6 +285,7 @@ const EXPECTED_V2_RUNTIME_EXPORTS = Object.freeze([
   "prepareDomainEpochAdvanceV2",
   "prepareHumanExistingMessageRepresentationPublicationRequestV1",
   "prepareHumanMemoryContentEmbeddingRequestV2",
+  "prepareHumanMemoryContentEmbeddingRequestV3",
   "prepareHumanMemoryDeletionV1",
   "prepareHumanNamespaceRebindV2",
   "prepareHumanObjectAccessManifestGenesisSetV1",
@@ -292,6 +303,7 @@ const EXPECTED_V2_RUNTIME_EXPORTS = Object.freeze([
   "resealNamespaceKeyring",
   "reserveAgentRuntimeRotationChallengesV2",
   "resolveAuthorizedNamespaceObjectKeyV2",
+  "sameMemoryEmbeddingDisclosureV2",
   "sealAgentRuntimeToDomain",
   "sealNamespaceKeyring",
   "serializeAgentManagerRecoveryPackage",
@@ -311,6 +323,7 @@ const EXPECTED_V2_RUNTIME_EXPORTS = Object.freeze([
   "verifyHumanExistingMessageRepresentationPublicationRequestExactReplayV1",
   "verifyHumanExistingMessageRepresentationPublicationRequestV1",
   "verifyHumanMemoryContentEmbeddingRequestV2",
+  "verifyHumanMemoryContentEmbeddingRequestV3",
   "verifyNamespaceBinding",
   "verifyNamespaceBindingProof",
   "verifyNamespaceKeyringEnvelope",
diff --git a/packages/lattice-crypto/tests/integration/public-api-contract.test.ts b/packages/lattice-crypto/tests/integration/public-api-contract.test.ts
index 64a00b3bf..732ea6fa9 100644
--- a/packages/lattice-crypto/tests/integration/public-api-contract.test.ts
+++ b/packages/lattice-crypto/tests/integration/public-api-contract.test.ts
@@ -4398,7 +4398,7 @@ describe("M226 clean supported package API", () => {
     const versionedWire = explicitExports(`${sourceRoot}/wire.ts`);
     const classified = [...root, ...versionedWire];
 
-    expect(previous).toHaveLength(635);
+    expect(previous).toHaveLength(653);
     expect(classified).toHaveLength(inventory.length);
     expect(classificationErrors(inventory, root, versionedWire)).toEqual([]);
     expect(
diff --git a/packages/lattice-crypto/tests/property/human-memory-content-embedding-request-v3.property.test.ts b/packages/lattice-crypto/tests/property/human-memory-content-embedding-request-v3.property.test.ts
new file mode 100644
index 000000000..d9cec63a3
--- /dev/null
+++ b/packages/lattice-crypto/tests/property/human-memory-content-embedding-request-v3.property.test.ts
@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+
+import { LatticeCrypto, seededRng } from "../../src/crypto/index.ts";
+import {
+  decodeHumanMemoryContentEmbeddingRequestV3,
+  encodeHumanMemoryContentEmbeddingRequestV3,
+  prepareHumanMemoryContentEmbeddingRequestV3,
+  verifyHumanMemoryContentEmbeddingRequestV3,
+} from "../../src/memory/content-embedding-request-v3.ts";
+import {
+  authorizationRevision,
+  cryptoDeviceId,
+  humanId,
+  namespaceId,
+  objectId,
+  unixTimestamp,
+} from "../../src/v2-types/ids.ts";
+
+const MAX_SEED = 32;
+
+function selectedSeeds(): readonly number[] {
+  const raw = process.env["MEMORY_EMBEDDING_V3_PROPERTY_SEED"];
+  if (raw === undefined) {
+    return Array.from({ length: MAX_SEED }, (_, index) => index + 1);
+  }
+  const seed = Number(raw);
+  if (!Number.isSafeInteger(seed) || seed < 1 || seed > MAX_SEED) {
+    throw new RangeError(
+      `MEMORY_EMBEDDING_V3_PROPERTY_SEED must be 1-${MAX_SEED}`,
+    );
+  }
+  return [seed];
+}
+
+function replay(seed: number): string {
+  return `MEMORY_EMBEDDING_V3_PROPERTY_SEED=${seed} `
+    + "bun test --timeout 60000 tests/property/"
+    + "human-memory-content-embedding-request-v3.property.test.ts";
+}
+
+describe("Human Memory content-embedding request recorded-seed properties", () => {
+  test("round-trips Unicode, multiple exact sets, and rejects one-byte substitutions", () => {
+    for (const seed of selectedSeeds()) {
+      try {
+        const crypto = new LatticeCrypto(seededRng(24_300 + seed));
+        const signer = crypto.generateSigningKeyPair();
+        const envelopeCount = 1 + (seed % 4);
+        const created = prepareHumanMemoryContentEmbeddingRequestV3(crypto, {
+          subjectHumanId: humanId(`human-${seed}`),
+          requestId: `memory-embedding-${seed}`,
+          memoryId: `${seed.toString(16).padStart(8, "0")}-aaaa-4aaa-8aaa-aaaaaaaaaaaa`,
+          expectedProductRevision: seed === 1 ? 0 : seed,
+          nextProductRevision: seed === 1 ? 1 : seed + 1,
+          cryptoObjectId: objectId(`memory:v1:${seed}`),
+          ciphertextPayloadHash: new Uint8Array(32).fill(seed),
+          genesisManifestHash: new Uint8Array(32).fill(seed + 1),
+          namespaceEnvelopes: Array.from(
+            { length: envelopeCount },
+            (_, index) => ({
+              namespaceId: namespaceId(`namespace-${String(index).padStart(3, "0")}`),
+              envelopeHash: new Uint8Array(32).fill(seed + index + 3),
+            }),
+          ),
+          type: `fact-${seed}`,
+          content: `Memory ${seed}: Zażółć 🧠`,
+          ...(seed % 2 === 0 ? { importance: seed / 100 } : {}),
+          requestedEmbedding: seed % 2 === 0
+            ? { contractVersion: 2, canonicalSpace: { provider: "venice", model: "text-embedding-3-large", dimensions: 1536 },
+              processingRoute: { transport: "surplus_marketplace", marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+                dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] } }
+            : { contractVersion: 2, canonicalSpace: { provider: "openrouter", model: `model/${seed}`, dimensions: 1536 },
+              processingRoute: { transport: "direct" } },
+          processorContractVersion: 2,
+          issuedAt: unixTimestamp(1_000_000 + seed),
+          deadlineAt: unixTimestamp(1_010_000 + seed),
+          committerDeviceId: cryptoDeviceId(`device-${seed}`),
+          hostAuthorizationRevision: authorizationRevision(seed),
+          committerSigningPublicKey: signer.publicKey,
+          committerSigningPrivateKey: signer.privateKey,
+        });
+        const canonical = encodeHumanMemoryContentEmbeddingRequestV3(
+          decodeHumanMemoryContentEmbeddingRequestV3(created.bytes),
+        );
+        expect(canonical).toEqual(created.bytes);
+        expect(verifyHumanMemoryContentEmbeddingRequestV3(crypto, {
+          requestBytes: canonical,
+          committerSigningPublicKey: signer.publicKey,
+          now: unixTimestamp(1_005_000 + seed),
+        }).content).toBe(`Memory ${seed}: Zażółć 🧠`);
+
+        const tampered = canonical.slice();
+        const mutationIndex = (seed * 31) % tampered.length;
+        tampered[mutationIndex] = tampered[mutationIndex]! ^ 1;
+        expect(() => verifyHumanMemoryContentEmbeddingRequestV3(crypto, {
+          requestBytes: tampered,
+          committerSigningPublicKey: signer.publicKey,
+          now: unixTimestamp(1_005_000 + seed),
+        })).toThrow();
+      } catch (error) {
+        throw new Error(
+          `Human Memory content-embedding property failed at seed ${seed}; replay: ${replay(seed)}`,
+          { cause: error },
+        );
+      }
+    }
+  });
+});
diff --git a/packages/lattice-crypto/tests/unit/human-memory-content-embedding-request-v3.test.ts b/packages/lattice-crypto/tests/unit/human-memory-content-embedding-request-v3.test.ts
new file mode 100644
index 000000000..0150e7911
--- /dev/null
+++ b/packages/lattice-crypto/tests/unit/human-memory-content-embedding-request-v3.test.ts
@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test";
+import { LatticeCrypto, seededRng } from "../../src/crypto/index.ts";
+import { decodeHumanMemoryContentEmbeddingRequestV2, prepareHumanMemoryContentEmbeddingRequestV2 } from "../../src/memory/content-embedding-request-v1.ts";
+import {
+  decodeHumanMemoryContentEmbeddingRequestV3,
+  encodeHumanMemoryContentEmbeddingRequestV3,
+  prepareHumanMemoryContentEmbeddingRequestV3,
+  verifyHumanMemoryContentEmbeddingRequestV3,
+  type HumanMemoryContentEmbeddingRequestV3,
+  type PrepareHumanMemoryContentEmbeddingRequestInputV3,
+} from "../../src/memory/content-embedding-request-v3.ts";
+import { authorizationRevision, cryptoDeviceId, humanId, namespaceId, objectId, unixTimestamp } from "../../src/v2-types/ids.ts";
+
+function fixture() {
+  const crypto = new LatticeCrypto(seededRng(27_931));
+  const signer = crypto.generateSigningKeyPair();
+  const input: PrepareHumanMemoryContentEmbeddingRequestInputV3 = {
+    subjectHumanId: humanId("human-alice"), requestId: "request-1",
+    memoryId: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+    expectedProductRevision: 0, nextProductRevision: 1,
+    cryptoObjectId: objectId("memory:v1:object-1"),
+    ciphertextPayloadHash: new Uint8Array(32).fill(1), genesisManifestHash: new Uint8Array(32).fill(2),
+    namespaceEnvelopes: [{ namespaceId: namespaceId("namespace-1"), envelopeHash: new Uint8Array(32).fill(3) }],
+    type: "fact", content: "Private authored content 🧠", importance: 0.5,
+    requestedEmbedding: { contractVersion: 2,
+      canonicalSpace: { provider: "venice", model: "text-embedding-3-large", dimensions: 1536 },
+      processingRoute: { transport: "surplus_marketplace", marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+        dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] } },
+    processorContractVersion: 2, issuedAt: unixTimestamp(1_000), deadlineAt: unixTimestamp(11_000),
+    committerDeviceId: cryptoDeviceId("device-1"), hostAuthorizationRevision: authorizationRevision(1),
+    committerSigningPublicKey: signer.publicKey, committerSigningPrivateKey: signer.privateKey,
+  };
+  return { crypto, signer, input };
+}
+
+describe("Human Memory content embedding V3", () => {
+  test("round-trips, signs all marketplace semantics, and retains exact authority/content", () => {
+    const { crypto, signer, input } = fixture();
+    const created = prepareHumanMemoryContentEmbeddingRequestV3(crypto, input);
+    expect(decodeHumanMemoryContentEmbeddingRequestV3(created.bytes)).toEqual(created.request);
+    expect(encodeHumanMemoryContentEmbeddingRequestV3(created.request)).toEqual(created.bytes);
+    expect(verifyHumanMemoryContentEmbeddingRequestV3(crypto, { requestBytes: created.bytes,
+      committerSigningPublicKey: signer.publicKey, now: unixTimestamp(2_000) })).toEqual(created.request);
+    expect(created.request).toMatchObject({ formatVersion: 3, processorContractVersion: 2,
+      content: input.content, requestedEmbedding: input.requestedEmbedding });
+    const mutations: Partial<HumanMemoryContentEmbeddingRequestV3>[] = [
+      { requestedEmbedding: { ...input.requestedEmbedding, processingRoute: { transport: "direct" } } },
+      { content: "changed" }, { type: "preference" }, { importance: 0.9 }, { requestId: "request-2" },
+      { subjectHumanId: humanId("human-other") }, { committerDeviceId: cryptoDeviceId("device-other") },
+      { hostAuthorizationRevision: authorizationRevision(2) },
+      { memoryId: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb" },
+      { expectedProductRevision: 1, nextProductRevision: 2 }, { cryptoObjectId: objectId("other") },
+      { ciphertextPayloadHash: new Uint8Array(32).fill(9) }, { genesisManifestHash: new Uint8Array(32).fill(9) },
+      { namespaceEnvelopes: [{ namespaceId: namespaceId("namespace-other"), envelopeHash: new Uint8Array(32).fill(3) }] },
+      { namespaceEnvelopes: [{ namespaceId: namespaceId("namespace-1"), envelopeHash: new Uint8Array(32).fill(9) }] },
+      { issuedAt: unixTimestamp(1_001) }, { deadlineAt: unixTimestamp(11_001) },
+    ];
+    for (const patch of mutations) {
+      expect(() => verifyHumanMemoryContentEmbeddingRequestV3(crypto, {
+        requestBytes: encodeHumanMemoryContentEmbeddingRequestV3({ ...created.request, ...patch }),
+        committerSigningPublicKey: signer.publicKey, now: unixTimestamp(2_000),
+      })).toThrow("signature");
+    }
+    for (const requestedEmbedding of [
+      { ...input.requestedEmbedding, contractVersion: 1 },
+      { ...input.requestedEmbedding, processingRoute: { ...input.requestedEmbedding.processingRoute, marketplacePolicyVersion: "other" } },
+      { ...input.requestedEmbedding, processingRoute: { ...input.requestedEmbedding.processingRoute, dataRecipientClasses: ["surplus"] } },
+      { ...input.requestedEmbedding, canonicalSpace: { ...input.requestedEmbedding.canonicalSpace, model: "other" } },
+    ]) expect(() => encodeHumanMemoryContentEmbeddingRequestV3({ ...created.request, requestedEmbedding } as never)).toThrow();
+  });
+
+  test("binds direct canonical provider/model and rejects unknown versions and extra fields", () => {
+    const { crypto, signer, input } = fixture();
+    const direct = { ...input.requestedEmbedding, processingRoute: { transport: "direct" as const } };
+    const created = prepareHumanMemoryContentEmbeddingRequestV3(crypto, { ...input, requestedEmbedding: direct });
+    for (const canonicalSpace of [
+      { ...direct.canonicalSpace, provider: "openai" as const },
+      { ...direct.canonicalSpace, model: "other/model" },
+    ]) expect(() => verifyHumanMemoryContentEmbeddingRequestV3(crypto, {
+      requestBytes: encodeHumanMemoryContentEmbeddingRequestV3({ ...created.request, requestedEmbedding: { ...direct, canonicalSpace } }),
+      committerSigningPublicKey: signer.publicKey, now: unixTimestamp(2_000),
+    })).toThrow("signature");
+    for (const patch of [{ formatVersion: 2 }, { processorContractVersion: 1 }, { extra: true }, { requestedProvider: "venice" },
+      { requestedEmbedding: { ...direct, extra: true } }, { requestedEmbedding: undefined }]) {
+      expect(() => encodeHumanMemoryContentEmbeddingRequestV3({ ...created.request, ...patch } as never)).toThrow();
+    }
+    for (const patch of [{ formatVersion: 2 }, { purpose: "memory.content_embedding" }]) {
+      expect(() => prepareHumanMemoryContentEmbeddingRequestV3(crypto, { ...input, ...patch } as never)).toThrow("invalid field set");
+    }
+    for (const now of [999, 11_000]) expect(() => verifyHumanMemoryContentEmbeddingRequestV3(crypto, {
+      requestBytes: created.bytes, committerSigningPublicKey: signer.publicKey, now: unixTimestamp(now),
+    })).toThrow("not currently valid");
+  });
+
+  test("fences legacy and new version decoders, and owns nested disclosure snapshots", () => {
+    const { crypto, input } = fixture();
+    const created = prepareHumanMemoryContentEmbeddingRequestV3(crypto, input);
+    expect(() => decodeHumanMemoryContentEmbeddingRequestV2(created.bytes)).toThrow();
+    const { requestedEmbedding: _, processorContractVersion: _version, ...common } = input;
+    const legacy = prepareHumanMemoryContentEmbeddingRequestV2(crypto, { ...common,
+      requestedProvider: "venice", requestedModel: "text-embedding-3-large", dimensions: 1536, processorContractVersion: 1 });
+    expect(() => decodeHumanMemoryContentEmbeddingRequestV3(legacy.bytes)).toThrow();
+    expect(created.request.requestedEmbedding).not.toBe(input.requestedEmbedding);
+    expect(created.request.requestedEmbedding.canonicalSpace).not.toBe(input.requestedEmbedding.canonicalSpace);
+    for (const bytes of [created.bytes.slice(0, -1), Uint8Array.from([...created.bytes, 0])]) {
+      expect(() => decodeHumanMemoryContentEmbeddingRequestV3(bytes)).toThrow();
+    }
+  });
+});
diff --git a/packages/lattice-crypto/tests/unit/memory-embedding-disclosure-v2.test.ts b/packages/lattice-crypto/tests/unit/memory-embedding-disclosure-v2.test.ts
new file mode 100644
index 000000000..9e9dafa5e
--- /dev/null
+++ b/packages/lattice-crypto/tests/unit/memory-embedding-disclosure-v2.test.ts
@@ -0,0 +1,74 @@
+import { describe, expect, test } from "bun:test";
+import {
+  assertMemoryEmbeddingDisclosureV2,
+  decodeMemoryEmbeddingDisclosureV2,
+  encodeMemoryEmbeddingDisclosureV2,
+  sameMemoryEmbeddingDisclosureV2,
+  type MemoryEmbeddingDisclosureV2,
+} from "../../src/memory/embedding-disclosure-v2.ts";
+
+function marketplace(): MemoryEmbeddingDisclosureV2 {
+  return { contractVersion: 2,
+    canonicalSpace: { provider: "venice", model: "text-embedding-3-large", dimensions: 1536 },
+    processingRoute: { transport: "surplus_marketplace", marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+      dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] } };
+}
+
+describe("Memory embedding disclosure V2", () => {
+  test("round-trips the exact marketplace recipients and canonical space", () => {
+    const value = marketplace();
+    const bytes = encodeMemoryEmbeddingDisclosureV2(value);
+    const decoded = decodeMemoryEmbeddingDisclosureV2(bytes);
+    expect(decoded).toEqual(value);
+    expect(encodeMemoryEmbeddingDisclosureV2(decoded)).toEqual(bytes);
+    expect(sameMemoryEmbeddingDisclosureV2(value, decoded)).toBeTrue();
+    expect(Object.isFrozen(decoded.canonicalSpace)).toBeTrue();
+    expect(Object.isFrozen(decoded.processingRoute)).toBeTrue();
+    if (decoded.processingRoute.transport === "surplus_marketplace") {
+      expect(Object.isFrozen(decoded.processingRoute.dataRecipientClasses)).toBeTrue();
+    }
+    expect(sameMemoryEmbeddingDisclosureV2(value, { ...value, processingRoute: { transport: "direct" } })).toBeFalse();
+  });
+
+  test.each(["openai", "openrouter", "venice"] as const)("allows a portable exact direct %s binding", (provider) => {
+    const value = { ...marketplace(), canonicalSpace: { provider, model: "organization/model:version", dimensions: 1536 as const },
+      processingRoute: { transport: "direct" as const } };
+    expect(decodeMemoryEmbeddingDisclosureV2(encodeMemoryEmbeddingDisclosureV2(value))).toEqual(value);
+  });
+
+  test("rejects wrong, missing, extra, and unknown semantic fields", () => {
+    const value = marketplace();
+    const route = value.processingRoute;
+    const cases: unknown[] = [null, [], 2, {}, { ...value, contractVersion: 1 }, { ...value, extra: true },
+      { ...value, [Symbol("extra")]: true },
+      Object.defineProperty({ ...value }, "hidden", { value: true }),
+      { ...value, canonicalSpace: null }, { ...value, canonicalSpace: { ...value.canonicalSpace, extra: true } },
+      { ...value, canonicalSpace: { ...value.canonicalSpace, provider: "surplus" } },
+      { ...value, canonicalSpace: { ...value.canonicalSpace, provider: "openai" } },
+      { ...value, canonicalSpace: { ...value.canonicalSpace, model: "text-embedding-3-small" } },
+      { ...value, canonicalSpace: { ...value.canonicalSpace, dimensions: 3072 } },
+      { ...value, canonicalSpace: { ...value.canonicalSpace, model: "" } },
+      { ...value, processingRoute: null }, { ...value, processingRoute: { transport: "unknown" } },
+      { ...value, processingRoute: { transport: "direct", marketplacePolicyVersion: "anything" } },
+      { ...value, processingRoute: { ...route, extra: true } },
+      { ...value, processingRoute: { ...route, marketplacePolicyVersion: "surplus-embedding-marketplace-v2" } },
+      ...[[], ["surplus"], ["surplus", "seller_upstream_processor", "marketplace_seller"],
+        ["surplus", "marketplace_seller", "unknown"], ["surplus", "marketplace_seller", "seller_upstream_processor", "other"],
+        "surplus", null].map((dataRecipientClasses) => ({ ...value, processingRoute: { ...route, dataRecipientClasses } })),
+    ];
+    for (const candidate of cases) expect(() => assertMemoryEmbeddingDisclosureV2(candidate)).toThrow();
+    for (const model of [null, "", " spaces ", 123, "x".repeat(257)]) {
+      expect(() => assertMemoryEmbeddingDisclosureV2({ ...value,
+        canonicalSpace: { ...value.canonicalSpace, model }, processingRoute: { transport: "direct" } })).toThrow();
+    }
+  });
+
+  test("rejects malformed/trailing binary encodings and unknown route data", () => {
+    const bytes = encodeMemoryEmbeddingDisclosureV2(marketplace());
+    const badVersion = bytes.slice(); badVersion[3] = 1;
+    const badRecipient = bytes.slice(); badRecipient[badRecipient.length - 1] = 0x7a;
+    for (const candidate of [bytes.slice(0, -1), Uint8Array.from([...bytes, 0]), badVersion, badRecipient]) {
+      expect(() => decodeMemoryEmbeddingDisclosureV2(candidate)).toThrow();
+    }
+  });
+});
diff --git a/packages/lattice-crypto/tests/unit/mutation-governance.test.ts b/packages/lattice-crypto/tests/unit/mutation-governance.test.ts
index 1120ca70a..2ad48ee30 100644
--- a/packages/lattice-crypto/tests/unit/mutation-governance.test.ts
+++ b/packages/lattice-crypto/tests/unit/mutation-governance.test.ts
@@ -154,7 +154,7 @@ describe("M229 mutation governance", () => {
       fileURLToPath(new URL("../..", import.meta.url)),
     );
     expect(parsed.scopes).toHaveLength(30);
-    expect(eligible).toHaveLength(142);
+    expect(eligible).toHaveLength(144);
     expect(parsed.scopes.filter((scope) =>
       scope.name.startsWith("background-")
     ).map((scope) => ({
diff --git a/packages/query-invariants/baseline/query-inventory.jsonl b/packages/query-invariants/baseline/query-inventory.jsonl
index 252d0f1a3..467c46262 100644
--- a/packages/query-invariants/baseline/query-inventory.jsonl
+++ b/packages/query-invariants/baseline/query-inventory.jsonl
@@ -509,6 +509,7 @@
 {"locator":"packages/db/src/queries/llm-usage.ts#buildPersonalCostsByTaskQuery:raw_sql:fragment:5","fingerprint":"224e77e069eeff6b5f3f70a2f549e2c90093d5ae5d885172c21b66a0881b4e16","path":"packages/db/src/queries/llm-usage.ts","symbol":"buildPersonalCostsByTaskQuery","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#buildPersonalCostsByTaskQuery:raw_sql:fragment:6","fingerprint":"44f2814e370ba57833f49ea33db91b2dcb5ddd9c8f67789bb7537d57b457a6ef","path":"packages/db/src/queries/llm-usage.ts","symbol":"buildPersonalCostsByTaskQuery","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#buildPersonalSubscriptionUsageQuery:raw_sql:fragment:1","fingerprint":"b0e505b4204463072f92bb5e362ffc7444463a1abad41c0515e7946e45ffb113","path":"packages/db/src/queries/llm-usage.ts","symbol":"buildPersonalSubscriptionUsageQuery","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"bounded","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
+{"locator":"packages/db/src/queries/llm-usage.ts#classifySurplusLlmAttemptRecovery:raw_sql:fragment:1","fingerprint":"c15868bd0cfab1c6547c38b8468fd501279a494d34b7b3f2c465ea4b7ed51421","path":"packages/db/src/queries/llm-usage.ts","symbol":"classifySurplusLlmAttemptRecovery","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["json","dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#listPendingSurplusAttempts:raw_sql:fragment:1","fingerprint":"3244acae5a7f77f368c1466af901a5452ab6780bda11285ad2fbb2294087f36b","path":"packages/db/src/queries/llm-usage.ts","symbol":"listPendingSurplusAttempts","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#listPendingSurplusAttempts:raw_sql:fragment:2","fingerprint":"9d41b363275796bb78f52ebfccada7ec601fbbdd1090ba341c40a988bb14bb29","path":"packages/db/src/queries/llm-usage.ts","symbol":"listPendingSurplusAttempts","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["window","dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#personalAttemptLeaseExpiresAt:raw_sql:fragment:1","fingerprint":"ee166173f09ec2c2311acbaf59386ee5e04a51d257b8e8923a084741f21934c2","path":"packages/db/src/queries/llm-usage.ts","symbol":"personalAttemptLeaseExpiresAt","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
@@ -517,6 +518,11 @@
 {"locator":"packages/db/src/queries/llm-usage.ts#personalAttemptRenewBefore:raw_sql:fragment:1","fingerprint":"cfa88cd708cdb3dc5b79405ab10e148e9d1028371667b3e6ec6beb1630f82b55","path":"packages/db/src/queries/llm-usage.ts","symbol":"personalAttemptRenewBefore","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#reconcileSurplusLlmAttemptCost:raw_sql:fragment:1","fingerprint":"bf63d0419f29b87f857b270f59289be01a3b8b3dff42dfbd8124dea427ac2ec5","path":"packages/db/src/queries/llm-usage.ts","symbol":"reconcileSurplusLlmAttemptCost","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#recoveryUpdatedAtPredicate:raw_sql:fragment:1","fingerprint":"97a90da4c7fdd35270a13f15ca97e8ed9ad62de147878ffa5c603093091735ca","path":"packages/db/src/queries/llm-usage.ts","symbol":"recoveryUpdatedAtPredicate","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
+{"locator":"packages/db/src/queries/llm-usage.ts#requeueBlockedPersonalSurplusAttempts:raw_sql:fragment:1","fingerprint":"ad5769ac402ed99c980677162b6a322ba114c519e7739026e7c9d2b434937877","path":"packages/db/src/queries/llm-usage.ts","symbol":"requeueBlockedPersonalSurplusAttempts","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
+{"locator":"packages/db/src/queries/llm-usage.ts#requeueBlockedServerSurplusAttempts:raw_sql:fragment:1","fingerprint":"ad5769ac402ed99c980677162b6a322ba114c519e7739026e7c9d2b434937877","path":"packages/db/src/queries/llm-usage.ts","symbol":"requeueBlockedServerSurplusAttempts","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
+{"locator":"packages/db/src/queries/llm-usage.ts#requeueBlockedServerSurplusAttempts:raw_sql:fragment:2","fingerprint":"5ff317f36172c2f2300cdb00c0242bb446cafa6c069953e9339754452fed4aa3","path":"packages/db/src/queries/llm-usage.ts","symbol":"requeueBlockedServerSurplusAttempts","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["json","dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
+{"locator":"packages/db/src/queries/llm-usage.ts#requeueBlockedSurplusDecisionAttempts:raw_sql:fragment:1","fingerprint":"ad5769ac402ed99c980677162b6a322ba114c519e7739026e7c9d2b434937877","path":"packages/db/src/queries/llm-usage.ts","symbol":"requeueBlockedSurplusDecisionAttempts","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
+{"locator":"packages/db/src/queries/llm-usage.ts#requeueBlockedSurplusDecisionAttempts:raw_sql:fragment:2","fingerprint":"0fdaf7479196a2b9edd3cdba1115546dd375083dd78a9c78f6af87eeb0400e21","path":"packages/db/src/queries/llm-usage.ts","symbol":"requeueBlockedSurplusDecisionAttempts","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["json","dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#settleDirectLlmAttempt:raw_sql:fragment:1","fingerprint":"154e19d13f916cfc270096970908a03bfc51253f3e47d80055a80e05e9b8cb28","path":"packages/db/src/queries/llm-usage.ts","symbol":"settleDirectLlmAttempt","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["json","dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#settleSurplusLlmAttempt:raw_sql:fragment:1","fingerprint":"1764efe77924c47da71c371e0a9556130fce57cc5bd9f3d3e4c7045374c41ac7","path":"packages/db/src/queries/llm-usage.ts","symbol":"settleSurplusLlmAttempt","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
 {"locator":"packages/db/src/queries/llm-usage.ts#settleSurplusLlmAttempt:raw_sql:fragment:2","fingerprint":"ca2ca19c81003fb91d556dcd6d60f9c4f6275ec34455b6157e09ff0f8f4f8952","path":"packages/db/src/queries/llm-usage.ts","symbol":"settleSurplusLlmAttempt","owner":"packages/db","handle":"sql","operation":"fragment","tables":[],"features":["json","dynamic_sql"],"reachability":"live","boundedness":"unproven","proposedDisposition":"typed_db_primitive","safetyOpportunity":"typed_containment","reasonCode":"sql_fragment","securitySensitive":false}
diff --git a/packages/runtime/src/executors/fork-langgraph-executor.ts b/packages/runtime/src/executors/fork-langgraph-executor.ts
index 7b62a9e80..eb517d27e 100644
--- a/packages/runtime/src/executors/fork-langgraph-executor.ts
+++ b/packages/runtime/src/executors/fork-langgraph-executor.ts
@@ -16,6 +16,7 @@ import {
   getAgentExecutionConfigById,
   getAgentDisplayNameById,
   getDefaultForegroundAgentModelId,
+  hydrateForegroundAgentModelCatalog,
   resolveForegroundAgentModelId,
   loadForegroundModelControlSnapshot,
   foregroundModelControlPlanFromSnapshot,
@@ -390,6 +391,12 @@ export async function* forkLanggraphExecutor(
   const foregroundModelControlSnapshot = await loadForegroundModelControlSnapshot(
     roomId, agentId, perTurnModel || null,
   );
+  if (!perTurnModel && !profile?.defaultModel
+    && !foregroundModelControlSnapshot.turnModelId
+    && !foregroundModelControlSnapshot.roomSelection?.modelId
+    && !foregroundModelControlSnapshot.agentSelection?.modelId) {
+    await hydrateForegroundAgentModelCatalog(signal);
+  }
   const foregroundModelPlan = foregroundModelControlPlanFromSnapshot(foregroundModelControlSnapshot, () =>
     profile?.defaultModel
       ? profile.defaultModel
diff --git a/packages/runtime/src/executors/langgraph-executor.ts b/packages/runtime/src/executors/langgraph-executor.ts
index e7e5eb21a..e091d0a6d 100644
--- a/packages/runtime/src/executors/langgraph-executor.ts
+++ b/packages/runtime/src/executors/langgraph-executor.ts
@@ -25,6 +25,7 @@ import {
   getAgentExecutionConfigById,
   getAgentDisplayNameById,
   getDefaultForegroundAgentModelId,
+  hydrateForegroundAgentModelCatalog,
   resolveForegroundAgentModelId,
   loadForegroundModelControlSnapshot,
   foregroundModelControlPlanFromSnapshot,
@@ -960,6 +961,12 @@ export async function* langgraphExecutor(
   const foregroundModelControlSnapshot = await loadForegroundModelControlSnapshot(
     roomId, agentId, perTurnModelRaw || null,
   );
+  if (!configuredModel
+    && !foregroundModelControlSnapshot.turnModelId
+    && !foregroundModelControlSnapshot.roomSelection?.modelId
+    && !foregroundModelControlSnapshot.agentSelection?.modelId) {
+    await hydrateForegroundAgentModelCatalog(signal);
+  }
   const foregroundModelPlan = foregroundModelControlPlanFromSnapshot(foregroundModelControlSnapshot, () =>
     configuredModel
       ? configuredModel
diff --git a/packages/runtime/tests/unit-isolated/post-model-override-wiring.test.ts b/packages/runtime/tests/unit-isolated/post-model-override-wiring.test.ts
index 787e614f0..43dabf382 100644
--- a/packages/runtime/tests/unit-isolated/post-model-override-wiring.test.ts
+++ b/packages/runtime/tests/unit-isolated/post-model-override-wiring.test.ts
@@ -24,6 +24,8 @@ import * as externalRoomContext from "../../src/executors/external-room-context"
 
 let capturedDeps: unknown = undefined;
 let capturedPolicyResolver: unknown = undefined;
+let foregroundCatalogHydrated = true;
+let foregroundCatalogHydrationCalls = 0;
 type ModelSnapshotFixture = {
   roomSelection: { modelId: string } | null;
   agentSelection: { modelId: string } | null;
@@ -37,7 +39,7 @@ const modelSnapshot: ModelSnapshotFixture = {
   turnModelId: null,
 };
 let captureGraphInput = false;
-let profileDefaultModel = "test:chat";
+let profileDefaultModel: string | null = "test:chat";
 let snapshotsToLoad: ModelSnapshotFixture[] = [];
 const snapshotLoads: Array<[string, string, string | null]> = [];
 const capturedGraphInputs: Record<string, unknown>[] = [];
@@ -77,6 +79,15 @@ mock.module("@nautilo/agent", () => ({
   // graph. Keep this wiring test hermetic by supplying the catalog coordinate
   // it now reaches on the way to the mocked graph boundary.
   getDefaultModel: () => ({ id: "test:chat" }),
+  getDefaultForegroundAgentModelId: () => {
+    if (!foregroundCatalogHydrated) throw new Error("expired-foreground-model-catalog");
+    return "test:auto";
+  },
+  hydrateForegroundAgentModelCatalog: async () => {
+    foregroundCatalogHydrationCalls += 1;
+    await Promise.resolve();
+    foregroundCatalogHydrated = true;
+  },
   getAgentExecutionConfigById: async () => ({
     soulFile: null,
     name: "Test Agent",
@@ -148,6 +159,8 @@ afterEach(() => {
   capturedPolicyResolver = undefined;
   captureGraphInput = false;
   profileDefaultModel = "test:chat";
+  foregroundCatalogHydrated = true;
+  foregroundCatalogHydrationCalls = 0;
   snapshotsToLoad = [];
   snapshotLoads.length = 0;
   capturedGraphInputs.length = 0;
@@ -263,6 +276,20 @@ describe("langgraphExecutor — Full Workstation override resolver wiring", () =
 });
 
 describe("foreground model-control snapshot ingress", () => {
+  test("main and fork await catalog hydration before resolving an expired automatic default", async () => {
+    captureGraphInput = true;
+    profileDefaultModel = null;
+
+    foregroundCatalogHydrated = false;
+    await driveExecutorOnce();
+    expect(capturedGraphInputs.at(-1)?.["model"]).toBe("test:auto");
+
+    foregroundCatalogHydrated = false;
+    await driveForkOnce({});
+    expect(capturedGraphInputs.at(-1)?.["model"]).toBe("test:auto");
+    expect(foregroundCatalogHydrationCalls).toBe(2);
+  });
+
   test("main and fork preserve an explicit turn model above Room and profile choices", async () => {
     captureGraphInput = true;
     profileDefaultModel = "unknown:unavailable-profile-default";
@@ -288,6 +315,7 @@ describe("foreground model-control snapshot ingress", () => {
     expect(capturedGraphInputs.map((input) => input["foregroundModelControlSnapshot"]))
       .toEqual([snapshot, snapshot]);
     expect(resolvedModelIds).toEqual([explicitModel, explicitModel]);
+    expect(foregroundCatalogHydrationCalls).toBe(0);
   });
 
   test("main and fork load a fresh Room snapshot without evaluating an unavailable profile default", async () => {
@@ -317,5 +345,6 @@ describe("foreground model-control snapshot ingress", () => {
     expect(capturedGraphInputs.map((input) => input["foregroundModelControlSnapshot"]))
       .toEqual([firstSnapshot, secondSnapshot, firstSnapshot, secondSnapshot]);
     expect(resolvedModelIds).not.toContain(profileDefaultModel);
+    expect(foregroundCatalogHydrationCalls).toBe(0);
   });
 });
diff --git a/packages/server/src/lib/foreground-chat-preflight.ts b/packages/server/src/lib/foreground-chat-preflight.ts
index 8028fee98..6d991016e 100644
--- a/packages/server/src/lib/foreground-chat-preflight.ts
+++ b/packages/server/src/lib/foreground-chat-preflight.ts
@@ -2,8 +2,11 @@ import {
   foregroundModelControlPlanFromSnapshot,
   getAgentExecutionConfigById,
   getDefaultForegroundAgentModelId,
+  hydrateSurplusChatCatalog,
   loadForegroundModelControlSnapshot,
+  resolveProviderKey,
 } from "@nautilo/agent";
+import { getCachedServerModelConfigRow } from "@nautilo/db";
 import { resolveModelFunding } from "./model-funding";
 
 export interface ForegroundChatPreflightDeps {
@@ -11,6 +14,9 @@ export interface ForegroundChatPreflightDeps {
   getExecutionConfig: typeof getAgentExecutionConfigById;
   defaultForegroundModelId: typeof getDefaultForegroundAgentModelId;
   resolveFunding: typeof resolveModelFunding;
+  hydrateSurplusChatCatalog?: typeof hydrateSurplusChatCatalog;
+  getPreferSurplus?: () => boolean;
+  getSurplusKeyConfigured?: () => boolean;
 }
 
 /** @internal Stable production wiring, exported for an identity-level unit assertion. */
@@ -19,6 +25,9 @@ export const DEFAULT_FOREGROUND_CHAT_PREFLIGHT_DEPS = Object.freeze({
   getExecutionConfig: getAgentExecutionConfigById,
   defaultForegroundModelId: getDefaultForegroundAgentModelId,
   resolveFunding: resolveModelFunding,
+  hydrateSurplusChatCatalog,
+  getPreferSurplus: () => getCachedServerModelConfigRow()?.preferSurplus === true,
+  getSurplusKeyConfigured: () => resolveProviderKey("surplus") !== null,
 }) satisfies ForegroundChatPreflightDeps;
 
 /** Project the executor's selected model before auxiliary work can spend.
@@ -34,6 +43,18 @@ export async function resolveForegroundChatPreflightModelId(
 ) {
   const snapshot = await deps.loadSnapshot(input.roomId, input.agentId, input.turnModelId);
   const profile = await deps.getExecutionConfig(input.agentId).catch(() => null);
+  if (!input.turnModelId && !snapshot.roomSelection?.modelId
+    && !snapshot.agentSelection?.modelId && !profile?.defaultModel
+    && deps.getPreferSurplus?.() === true
+    && deps.getSurplusKeyConfigured?.() === true
+    && deps.hydrateSurplusChatCatalog) {
+    try {
+      await deps.hydrateSurplusChatCatalog();
+    } catch {
+      // The synchronous default resolver remains fail-closed on the last
+      // verified map and can still select a directly credentialed model.
+    }
+  }
   const plan = foregroundModelControlPlanFromSnapshot(snapshot, () =>
     input.turnModelId || profile?.defaultModel || deps.defaultForegroundModelId(),
   );
diff --git a/packages/server/src/lib/image-assistance.ts b/packages/server/src/lib/image-assistance.ts
index 64d87b46c..a15fc7e6b 100644
--- a/packages/server/src/lib/image-assistance.ts
+++ b/packages/server/src/lib/image-assistance.ts
@@ -1,7 +1,9 @@
 import {
+  hydrateSurplusChatCatalog,
   resolveQualifiedSurplusChatRoute,
   resolveCatalogModel,
   type ForegroundChatFundingSession,
+  type QualifiedSurplusChatRoute,
 } from "@nautilo/agent";
 import {
   getCachedServerModelConfigRow,
@@ -36,6 +38,9 @@ export interface ImageAssistanceSelectionDeps extends ImageUnderstandingPreferen
   readonly readPreferences?: (humanUserId: string) => Promise<PersonalCapabilityPreferences>;
   /** Request-local only. Its identity includes both saved selections and revisions. */
   readonly selectionCache?: Map<string, Promise<ModelFundingDecision | null>>;
+  readonly hydrateSurplusChatCatalog?: typeof hydrateSurplusChatCatalog;
+  /** Pure offline seam for exact vendor-confirmed route tests. */
+  readonly getQualifiedSurplusChatRoutes?: () => readonly QualifiedSurplusChatRoute[];
 }
 
 export interface ImageAssistanceExecutionDeps extends ImageAssistanceSelectionDeps {
@@ -89,8 +94,19 @@ export async function resolveCallerImageInput(
   deps: ImageAssistanceSelectionDeps = {},
 ): Promise<"direct" | "assisted" | "unavailable"> {
   if (isSignedImageUnderstandingModel(input.modelId, deps)) {
+    const routes = deps.getQualifiedSurplusChatRoutes?.();
+    if (input.funding.providerRoute === "surplus" && routes === undefined) {
+      try {
+        await (deps.hydrateSurplusChatCatalog ?? hydrateSurplusChatCatalog)({
+          catalogModelIds: [input.modelId],
+        });
+      } catch {
+        // The exact route lookup below remains fail-closed on the last
+        // verified snapshot while direct image-capable funding still works.
+      }
+    }
     return input.funding.providerRoute !== "surplus"
-      || resolveQualifiedSurplusChatRoute(input.modelId)?.supportsVision === true ? "direct" : "unavailable";
+      || resolveQualifiedSurplusChatRoute(input.modelId, routes)?.supportsVision === true ? "direct" : "unavailable";
   }
   if (input.funding.providerRoute === "openai-chatgpt") return "unavailable";
   try {
diff --git a/packages/server/src/lib/model-funding.ts b/packages/server/src/lib/model-funding.ts
index d24878389..aa3f25c8e 100644
--- a/packages/server/src/lib/model-funding.ts
+++ b/packages/server/src/lib/model-funding.ts
@@ -2,6 +2,7 @@ import type { PersonalProviderCredential } from "@nautilo/agent";
 import { chatGPTFundingModels, chatGPTFundingRegistration, chatGPTSessionStore, type ChatGPTFundingRegistration } from "./chatgpt-plan/runtime";
 import {
   DEFAULT_PROVIDER_TIMEOUT_MS,
+  hydrateSurplusChatCatalog,
   modelHasRunnableCredentials,
   resolveCatalogModel,
   resolveSurplusDecisionServingAvailability,
@@ -110,6 +111,10 @@ export interface ModelFundingDeps {
     transport?: "direct" | "surplus",
   ) => string | null;
   personalSurplusRoute?: (modelId: string, workload?: ModelFundingWorkload) => boolean;
+  /** Async discovery boundary; omitted by pure/offline tests. */
+  hydrateSurplusChatCatalog?: typeof hydrateSurplusChatCatalog;
+  getPreferSurplus?: () => boolean;
+  getServerSurplusKeyConfigured?: () => boolean;
   readCustody: () => Promise<PersonalProviderCustody>;
   decrypt: typeof decryptPersonalProviderCredential;
   getSubscription?: (userId: string, id?: string) => Promise<ChatGPTFundingRegistration | null>;
@@ -193,6 +198,9 @@ const DEFAULT_DEPS: ModelFundingDeps = {
     policyEnabled: getCachedServerModelConfigRow()?.preferSurplus === true,
     keyConfigured: true, fundingKind: "personal",
   }).status === "available",
+  hydrateSurplusChatCatalog,
+  getPreferSurplus: () => getCachedServerModelConfigRow()?.preferSurplus === true,
+  getServerSurplusKeyConfigured: () => resolveProviderKey("surplus") !== null,
   readCustody: readPersonalProviderCustody,
   decrypt: decryptPersonalProviderCredential,
 };
@@ -259,6 +267,9 @@ export async function resolveModelFunding(
   if (input.directOnly && input.workload === "memory") {
     throw new ModelFundingError("unsupported_workload");
   }
+  if (input.directOnly && input.transport === "surplus") {
+    throw new ModelFundingError("funding_source_changed");
+  }
   if (!input.humanUserId.trim()) throw new ModelFundingError("server_credentials_forbidden");
   const provider = directProvider(input.modelId);
   if (provider === "typesafe" && input.workload !== "decision") throw new ModelFundingError("unsupported_provider");
@@ -288,6 +299,45 @@ export async function resolveModelFunding(
     throw new ModelFundingError("personal_credentials_forbidden");
   }
 
+  const pinnedPersonalTransport = prior?.kind === "personal" && prior.modelId === input.modelId
+    && prior.providerRoute !== "openai-chatgpt"
+    ? prior.providerRoute === "surplus" ? "surplus" : "direct"
+    : undefined;
+  const pinnedServerTransport = prior?.kind === "server"
+    ? prior.providerRoute === "surplus" ? "surplus" : "direct"
+    : undefined;
+  if (input.transport === "surplus"
+    && (pinnedPersonalTransport === "direct" || pinnedServerTransport === "direct")) {
+    throw new ModelFundingError("funding_source_changed");
+  }
+  const requestedPersonalTransport = input.transport
+    ?? (input.directOnly ? "direct" : pinnedPersonalTransport);
+  const requestedServerTransport = input.transport
+    ?? (input.directOnly ? "direct" : pinnedServerTransport);
+  const surplusPolicyEnabled = (transport: "direct" | "surplus" | undefined) =>
+    !input.directOnly && transport !== "direct" && (deps.getPreferSurplus?.() ?? true);
+  const hydrateSurplus = async (
+    keyConfigured: boolean,
+    transport: "direct" | "surplus" | undefined,
+  ): Promise<void> => {
+    if (!surplusPolicyEnabled(transport) || !keyConfigured || !deps.hydrateSurplusChatCatalog) return;
+    try {
+      await deps.hydrateSurplusChatCatalog({ catalogModelIds: [input.modelId] });
+    } catch {
+      // Discovery failure is fail-closed for Surplus. Direct routes remain
+      // usable and the sync resolver below observes only the last verified map.
+    }
+  };
+  const serverRoute = async (
+    transport: "direct" | "surplus" | undefined = requestedServerTransport,
+  ) => {
+    await hydrateSurplus(deps.getServerSurplusKeyConfigured?.() === true, transport);
+    const route = deps.serverRoute(input.modelId, input.workload, transport);
+    // Only image-capable signed routes may receive the helper's image envelope.
+    return input.workload === "image_assistance" && route === "surplus"
+      && resolveQualifiedSurplusChatRoute(input.modelId)?.supportsVision !== true ? null : route;
+  };
+
   // Explicit subscription selection pins a registration, including its failed
   // state. It must never degrade into API-key or server-funded inference.
   const pinnedSubscription = prior?.kind === "personal" && prior.providerRoute === "openai-chatgpt";
@@ -319,15 +369,9 @@ export async function resolveModelFunding(
 
   // Priority applies only to fresh admissions. An eligible server-first route
   // needs neither a personal row lookup nor access to personal key custody.
-  const serverRoute = (transport: "direct" | "surplus" | undefined = input.directOnly ? "direct" : input.transport) => {
-    const route = deps.serverRoute(input.modelId, input.workload, transport);
-    // Only image-capable signed routes may receive the helper's image envelope.
-    return input.workload === "image_assistance" && route === "surplus"
-      && resolveQualifiedSurplusChatRoute(input.modelId)?.supportsVision !== true ? null : route;
-  };
   if (!prior && input.fundingKind !== "personal" && policy.fundingPreference === "server_first"
     && caps.includes("use_server_provider_credentials")) {
-    const route = serverRoute();
+    const route = await serverRoute();
     if (route) {
       return {
         kind: "server", humanUserId: input.humanUserId,
@@ -352,14 +396,23 @@ export async function resolveModelFunding(
 
   // Switch-off and admitted server operations never inspect personal rows.
   if (personalAllowed && provider && prior?.kind !== "server" && input.fundingKind !== "server") {
-    const surplusEligible = !input.directOnly && input.transport !== "direct"
-      && deps.personalSurplusRoute?.(input.modelId, input.workload) === true;
-    const surplusCredential = surplusEligible
+    // Production discovers before consulting the sync route map. Pure test
+    // dependencies without the policy/discovery seam retain their explicit
+    // route-first behavior and never acquire a network dependency.
+    const explicitSurplusEligibility = deps.getPreferSurplus === undefined
+      ? requestedPersonalTransport !== "direct"
+        && deps.personalSurplusRoute?.(input.modelId, input.workload) === true
+      : surplusPolicyEnabled(requestedPersonalTransport);
+    const surplusCredential = explicitSurplusEligibility
       ? prior?.kind === "personal" && prior.providerRoute === "surplus"
         ? priorCredential : await deps.getCredential(input.humanUserId, "surplus")
       : null;
-    const selectedProvider = surplusCredential ? "surplus" : provider;
-    const credential = surplusCredential ?? (input.transport === "surplus" ? null
+    await hydrateSurplus(surplusCredential !== null, requestedPersonalTransport);
+    const surplusEligible = surplusCredential !== null
+      && (deps.getPreferSurplus === undefined || deps.personalSurplusRoute?.(input.modelId, input.workload) === true);
+    const qualifiedSurplusCredential = surplusEligible ? surplusCredential : null;
+    const selectedProvider = qualifiedSurplusCredential ? "surplus" : provider;
+    const credential = qualifiedSurplusCredential ?? (requestedPersonalTransport === "surplus" ? null
       : prior?.kind === "personal" && prior.providerRoute === provider
         ? priorCredential : await deps.getCredential(input.humanUserId, provider));
     if (credential) {
@@ -380,7 +433,7 @@ export async function resolveModelFunding(
       // still admit it. The distinct requested transport or later model's
       // credential is absent, so invocation may safely consult the configured
       // same-payer model chain without starting a provider call.
-      if (prior.providerRoute === "surplus" && input.transport === "direct") {
+      if (prior.providerRoute === "surplus" && requestedPersonalTransport === "direct") {
         throw new PersonalDirectFundingUnavailableError();
       }
       if (prior.modelId !== input.modelId) {
@@ -400,14 +453,7 @@ export async function resolveModelFunding(
       ? "personal_credential_missing"
       : "server_credentials_forbidden");
   }
-  const pinnedServerTransport = prior?.kind === "server"
-    ? prior.providerRoute === "surplus" ? "surplus" : "direct"
-    : undefined;
-  if (input.transport === "surplus" && pinnedServerTransport === "direct") {
-    throw new ModelFundingError("funding_source_changed");
-  }
-  const requestedServerTransport = input.transport ?? (input.directOnly ? "direct" : pinnedServerTransport);
-  const route = serverRoute(requestedServerTransport);
+  const route = await serverRoute(requestedServerTransport);
   if (!route) throw new ModelFundingError("provider_credentials_missing");
   if (requestedServerTransport === "surplus" && route !== "surplus") {
     throw new ModelFundingError("funding_source_changed");
@@ -493,6 +539,8 @@ export async function withAdmittedPersonalCredential<T>(
 
 /** Request-local readiness projection; subscription discovery can refresh tokens but never runs inference. Never use these dependencies to dispatch. */
 export async function createModelFundingSnapshot(humanUserId: string) {
+  const preferSurplus = DEFAULT_DEPS.getPreferSurplus?.() === true;
+  const serverSurplusKeyConfigured = DEFAULT_DEPS.getServerSurplusKeyConfigured?.() === true;
   const [policy, capabilities, credentials] = await Promise.all([
     DEFAULT_DEPS.getPolicy(), DEFAULT_DEPS.getCapabilities(humanUserId),
     listPersonalProviderCredentials(getServerDirectDb(), humanUserId),
@@ -515,6 +563,8 @@ export async function createModelFundingSnapshot(humanUserId: string) {
       return value;
     },
     getPolicy: () => Promise.resolve(policy),
+    getPreferSurplus: () => preferSurplus,
+    getServerSurplusKeyConfigured: () => serverSurplusKeyConfigured,
     getCapabilities: (human) => Promise.resolve(human === humanUserId ? capabilities : []),
     getCredential: (human, provider) => Promise.resolve(
       human === humanUserId ? credentials.find((row) => row.provider === provider) ?? null : null,
diff --git a/packages/server/src/lib/native-task-funding.ts b/packages/server/src/lib/native-task-funding.ts
index 6969a3359..ae0cfffd5 100644
--- a/packages/server/src/lib/native-task-funding.ts
+++ b/packages/server/src/lib/native-task-funding.ts
@@ -698,7 +698,7 @@ async function openSession(task: FundingTaskSource, run: FundingRunSource,
       throw error;
     }
   };
-  await resolveCandidate(modelId);
+  const initialDecision = await resolveCandidate(modelId);
   const allowUnpinnedSurplusRetry = nativeTaskAllowsUnpinnedSurplusRetry(task);
   const fundingPolicy = admitted.kind === "server"
     ? await getServerProviderPolicy(getServerDirectDb())
@@ -706,6 +706,9 @@ async function openSession(task: FundingTaskSource, run: FundingRunSource,
   let lastAttempt: ModelFundingDecision | undefined;
   return {
     kind: admitted.kind,
+    ...(admitted.kind === "server" ? {
+      admittedTransport: initialDecision.providerRoute === "surplus" ? "surplus" as const : "direct" as const,
+    } : {}),
     ...(allowUnpinnedSurplusRetry ? { allowUnpinnedSurplusRetry: true as const } : {}),
     capabilityFunding: await prepareCapabilityFundingSession(
       task.requestorId,
@@ -887,9 +890,12 @@ export async function openProtectedTaskWakeFundingSession(input: Readonly<{
       ) => fundingBoundary(
         () => resolveCandidateUnchecked(candidateModelId, transport),
       );
-      await resolveCandidate(modelId);
+      const initialDecision = await resolveCandidate(modelId);
       return {
         kind: "server",
+        admittedTransport: initialDecision.providerRoute === "surplus"
+          ? "surplus" as const
+          : "direct" as const,
         async recheckAttempt(candidate, transport) {
           await resolveCandidate(candidate, transport);
         },
diff --git a/packages/server/src/lib/surplus-cost-reconciliation.ts b/packages/server/src/lib/surplus-cost-reconciliation.ts
index e397aef84..a59eb7598 100644
--- a/packages/server/src/lib/surplus-cost-reconciliation.ts
+++ b/packages/server/src/lib/surplus-cost-reconciliation.ts
@@ -1,5 +1,6 @@
 import {
   fetchSurplusSettlement,
+  getQualifiedSurplusEmbeddingRoute,
   resolveProviderKey,
   surplusCredentialFingerprint,
 } from "@nautilo/agent";
@@ -32,9 +33,109 @@ interface SurplusCostRecoveryDependencies {
   requeueBlockedServer(): Promise<number>;
   requeueBlockedDecisions(): Promise<number>;
   fetchCost: typeof fetchSurplusSettlement;
+  fetchEmbeddingCost(input: {
+    requestId: string;
+    apiKey: string;
+    expectedReceiptModel: string;
+    knownServingProviders: readonly string[];
+    observedServingProvider: string;
+    signal: AbortSignal;
+  }): Promise<Awaited<ReturnType<typeof fetchSurplusSettlement>>>;
   now(): number;
 }
 
+async function readBoundedReceiptJson(response: Response): Promise<unknown> {
+  const reader = response.body?.getReader();
+  if (!reader) return null;
+  const parts: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      if (!(chunk.value instanceof Uint8Array)) return null;
+      size += chunk.value.byteLength;
+      if (size > 65_536) {
+        await reader.cancel();
+        return null;
+      }
+      parts.push(chunk.value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const part of parts) {
+      bytes.set(part, offset);
+      offset += part.byteLength;
+    }
+    return JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    return null;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/** Embedding receipts bind both the qualified adapter model and its observed processor. */
+async function fetchQualifiedEmbeddingSettlement(input: {
+  requestId: string;
+  apiKey: string;
+  expectedReceiptModel: string;
+  knownServingProviders: readonly string[];
+  observedServingProvider: string;
+  signal: AbortSignal;
+}): Promise<Awaited<ReturnType<typeof fetchSurplusSettlement>>> {
+  if (!/^[a-zA-Z0-9_-]{1,128}$/.test(input.requestId)) {
+    return { status: "blocked_repair", failureCode: "receipt_request_rejected" };
+  }
+  const response = await fetch(
+    `https://api.surplusintelligence.ai/v1/requests/${encodeURIComponent(input.requestId)}`,
+    {
+      method: "GET",
+      redirect: "error",
+      signal: input.signal,
+      headers: { Authorization: `Bearer ${input.apiKey.trim()}` },
+    },
+  );
+  if (!response.ok) {
+    await response.body?.cancel();
+    if (response.status === 401 || response.status === 403) {
+      return { status: "blocked_repair", failureCode: "receipt_read_unauthorized" };
+    }
+    if (response.status === 404) {
+      return { status: "retryable", failureCode: "receipt_not_found" };
+    }
+    if (response.status === 429) {
+      return { status: "retryable", failureCode: "receipt_rate_limited" };
+    }
+    if (response.status >= 500) {
+      return { status: "retryable", failureCode: "receipt_service_unavailable" };
+    }
+    return { status: "blocked_repair", failureCode: "receipt_request_rejected" };
+  }
+  const value = await readBoundedReceiptJson(response);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { status: "retryable", failureCode: "receipt_not_confirmed" };
+  }
+  const row = value as Record<string, unknown>;
+  const provider = typeof row["provider"] === "string"
+    ? row["provider"].trim().toLowerCase() : "";
+  if (row["request_id"] !== input.requestId
+    || row["model"] !== input.expectedReceiptModel
+    || !input.knownServingProviders.includes(provider)
+    || provider !== input.observedServingProvider.trim().toLowerCase()
+    || row["settlement_status"] !== "accrued"
+    || row["settlement_type"] !== "credit"
+    || (row["settlement_error"] !== undefined && row["settlement_error"] !== null)
+    || typeof row["confirmed_at"] !== "string"
+    || !Number.isFinite(Date.parse(row["confirmed_at"]))) {
+    return { status: "retryable", failureCode: "receipt_not_confirmed" };
+  }
+  const cost = row["buyer_cost_micro"];
+  return typeof cost === "number" && Number.isSafeInteger(cost) && cost >= 0
+    ? { status: "settled", costMicro: cost }
+    : { status: "retryable", failureCode: "receipt_not_confirmed" };
+}
+
 function defaultCredential(row: SurplusPendingAttempt): Promise<RecoveryCredential> | RecoveryCredential {
   if (row.fundingKind === "personal") {
     if (!row.payerHumanId || !row.credentialId || !row.credentialRevision) {
@@ -63,6 +164,7 @@ export function createSurplusCostRecovery(overrides: Partial<SurplusCostRecovery
     requeueBlockedServer: requeueBlockedServerSurplusAttempts,
     requeueBlockedDecisions: requeueBlockedSurplusDecisionAttempts,
     fetchCost: fetchSurplusSettlement,
+    fetchEmbeddingCost: fetchQualifiedEmbeddingSettlement,
     now: Date.now,
     ...overrides,
   };
@@ -122,21 +224,49 @@ export function createSurplusCostRecovery(overrides: Partial<SurplusCostRecovery
           continue;
         }
         const imageEndpoint = row.endpoint === "/v1/images/generations" || row.endpoint === "/v1/images/edits";
-        if (!imageEndpoint && row.endpoint !== "/v1/chat/completions" && row.endpoint !== "/v1/decisions") {
+        const embeddingEndpoint = row.endpoint === "/v1/embeddings";
+        if (!imageEndpoint && !embeddingEndpoint
+          && row.endpoint !== "/v1/chat/completions" && row.endpoint !== "/v1/decisions") {
           await classify(row, "blocked_repair", "receipt_endpoint_unsupported");
           continue;
         }
         const binding = row.metadata;
-        const unpinnedModel = !imageEndpoint && binding?.["surplusUnpinnedModel"] === true;
+        const unpinnedModel = !imageEndpoint && !embeddingEndpoint
+          && binding?.["surplusUnpinnedModel"] === true;
         const catalogProvider = typeof binding?.["catalogModelId"] === "string"
           ? binding["catalogModelId"].split(":", 1)[0]
           : binding?.["surplusProviderPin"];
+        const embeddingProviders = binding?.["surplusEmbeddingServingProviders"];
+        const embeddingDimensions = binding?.["surplusEmbeddingDimensions"];
+        const embeddingRoute = embeddingEndpoint
+          && typeof embeddingDimensions === "number"
+          ? getQualifiedSurplusEmbeddingRoute(row.model, embeddingDimensions)
+          : null;
+        const validEmbeddingBinding = embeddingEndpoint
+          && embeddingRoute !== null
+          && row.fundingKind === "service"
+          && row.callType === "embedding"
+          && row.provider === embeddingRoute.provider
+          && binding?.["catalogModelId"] === row.model
+          && binding?.["surplusModelId"] === embeddingRoute.wireModel
+          && binding?.["surplusEmbeddingPolicy"] === embeddingRoute.servingPolicy
+          && embeddingDimensions === embeddingRoute.dimensions
+          && binding?.["surplusEmbeddingReceiptModel"] === embeddingRoute.receiptModel
+          && Array.isArray(embeddingProviders)
+          && embeddingProviders.length === embeddingRoute.knownServingProviders.length
+          && embeddingRoute.knownServingProviders.every(
+            (provider, index) => embeddingProviders[index] === provider,
+          )
+          && typeof row.servingProvider === "string"
+          && embeddingProviders.includes(row.servingProvider.toLowerCase());
         if (typeof binding?.["surplusCredentialFingerprint"] !== "string"
           || typeof binding["surplusModelId"] !== "string"
-          || (imageEndpoint
+          || (embeddingEndpoint
+            ? !validEmbeddingBinding
+            : imageEndpoint
             ? binding["surplusUnpinnedMedia"] !== true
             : typeof binding["surplusProviderPin"] !== "string")
-          || catalogProvider !== row.provider) {
+          || (!embeddingEndpoint && catalogProvider !== row.provider)) {
           await classify(row, "blocked_repair", "receipt_binding_invalid");
           continue;
         }
@@ -167,16 +297,26 @@ export function createSurplusCostRecovery(overrides: Partial<SurplusCostRecovery
         }
 
         try {
-          const result = await deps.fetchCost({
-            apiKey: credential.apiKey,
-            binding: {
-              requestId: row.providerRequestId,
-              surplusModelId: binding["surplusModelId"],
-              providerPin: imageEndpoint || unpinnedModel ? null : binding["surplusProviderPin"] as string,
-              ...(unpinnedModel ? { unpinnedModel: true as const } : {}),
-            },
-            signal: AbortSignal.any([shutdown.signal, AbortSignal.timeout(10_000)]),
-          });
+          const signal = AbortSignal.any([shutdown.signal, AbortSignal.timeout(10_000)]);
+          const result = embeddingEndpoint
+            ? await deps.fetchEmbeddingCost({
+                apiKey: credential.apiKey,
+                requestId: row.providerRequestId,
+                expectedReceiptModel: binding["surplusEmbeddingReceiptModel"] as string,
+                knownServingProviders: embeddingProviders as string[],
+                observedServingProvider: row.servingProvider!,
+                signal,
+              })
+            : await deps.fetchCost({
+                apiKey: credential.apiKey,
+                binding: {
+                  requestId: row.providerRequestId,
+                  surplusModelId: binding["surplusModelId"],
+                  providerPin: imageEndpoint || unpinnedModel ? null : binding["surplusProviderPin"] as string,
+                  ...(unpinnedModel ? { unpinnedModel: true as const } : {}),
+                },
+                signal,
+              });
           if (isStopped()) return;
           if (result.status === "blocked_repair") {
             await classify(row, "blocked_repair", result.failureCode);
diff --git a/packages/server/src/messaging/peer-broadcast.ts b/packages/server/src/messaging/peer-broadcast.ts
index 72ed32756..bd73b07d5 100644
--- a/packages/server/src/messaging/peer-broadcast.ts
+++ b/packages/server/src/messaging/peer-broadcast.ts
@@ -2,9 +2,9 @@ import { randomUUID } from "node:crypto";
 import {
   appendTranscriptMessages,
   buildForegroundUserHumanMessage,
-  getDefaultModel,
+  modelIdForCapabilityProjection,
 } from "@nautilo/agent";
-import { and, db, eq, isNull, rooms, sessionMessages, sessions, sessionMessageRecipientState } from "@nautilo/db";
+import { and, db, eq, getCachedServerModelConfigRow, isNull, rooms, sessionMessages, sessions, sessionMessageRecipientState } from "@nautilo/db";
 import { log } from "@nautilo/logger";
 import { eventBus } from "@nautilo/runtime";
 import type { RoomDetailPayload } from "@nautilo/trust";
@@ -136,6 +136,9 @@ export async function peerBroadcastHumanMessage(args: {
   const { room, senderUserId, content, attachmentTextBlocks, multimodalImages, replyToMessageId } =
     args;
   const humanTurnId = args.persistedMessage?.humanTurnId ?? randomUUID();
+  const projectionModelId = modelIdForCapabilityProjection("chat",
+    process.env["NAUTILO_MODEL"]?.trim()
+      || getCachedServerModelConfigRow()?.defaultChatModel?.trim());
   const result: Awaited<ReturnType<typeof appendTranscriptMessages>> = args.persistedMessage === undefined
     ? await appendTranscriptMessages(
       room.graphThreadId,
@@ -145,7 +148,7 @@ export async function peerBroadcastHumanMessage(args: {
         userText: content,
         attachmentTextBlocks,
         multimodalImages,
-        modelId: getDefaultModel().id,
+        modelId: projectionModelId,
         replyToMessageId: replyToMessageId ?? null,
       })],
       {
diff --git a/packages/server/src/routes/config.ts b/packages/server/src/routes/config.ts
index 3f325d7a5..3c525002b 100644
--- a/packages/server/src/routes/config.ts
+++ b/packages/server/src/routes/config.ts
@@ -5,11 +5,14 @@ import {
   getEligibleModels,
   getActiveModelCatalogProvenance,
   getDefaultImageModel,
+  hydrateSurplusChatCatalog,
   kickRuntimeModelCatalogRefresh,
   MAX_RETAINED_MODEL_IDS,
   resolveCatalogModel,
   resolveRetainedModels,
   resolveProviderKey,
+  resolveQualifiedSurplusChatRoute,
+  type QualifiedSurplusChatRoute,
 } from "@nautilo/agent";
 import { fromRuntimeConfig } from "@nautilo/config";
 import { getPersonalCapabilityPreferences } from "@nautilo/db";
@@ -44,6 +47,9 @@ export interface CallerModelAvailabilityDeps {
   readonly resolveImageInput?: typeof resolveCallerImageInput;
   readonly imageAssistanceSelections?: Map<string, Promise<ModelFundingDecision | null>>;
   readonly readImageAssistancePreferences?: () => Promise<PersonalCapabilityPreferences>;
+  readonly hydrateSurplusChatCatalog?: typeof hydrateSurplusChatCatalog;
+  /** Pure offline seam for vendor-confirmed route projections. */
+  readonly getQualifiedSurplusChatRoutes?: () => readonly QualifiedSurplusChatRoute[];
 }
 
 const FUNDING_UNAVAILABLE_REASON: Readonly<Record<ModelFundingError["code"], string>> = {
@@ -115,14 +121,37 @@ export async function resolveCallerModelAvailability(
       modelId,
       workload: "foreground_text_chat",
     });
-    if (funding.kind === "server" && options.purpose === "chat-tools"
-      && catalogModel.features.tools !== true) {
+    const injectedRoutes = deps.getQualifiedSurplusChatRoutes?.();
+    if (funding.providerRoute === "surplus" && injectedRoutes === undefined) {
+      try {
+        await (deps.hydrateSurplusChatCatalog ?? hydrateSurplusChatCatalog)({
+          catalogModelIds: [modelId],
+        });
+      } catch {
+        // Fall through to the exact fail-closed route lookup below.
+      }
+    }
+    const surplusRoute = funding.providerRoute === "surplus"
+      ? resolveQualifiedSurplusChatRoute(modelId, injectedRoutes)
+      : null;
+    if (funding.providerRoute === "surplus" && !surplusRoute) {
+      return {
+        model: unavailableForCaller(base, "the selected model is not available through Surplus"),
+        funding: null,
+        selectableInThisRelease: false,
+      };
+    }
+    const supportsTools = surplusRoute
+      ? catalogModel.features.tools === true && surplusRoute.supportsTools
+      : catalogModel.features.tools === true;
+    if (options.purpose === "chat-tools" && !supportsTools
+      && (funding.kind === "server" || surplusRoute !== null)) {
       return {
         model: {
           ...base,
           enabled: false,
           availability: "unsupported-capability",
-          unavailableReason: catalogModel.features.tools === false
+          unavailableReason: catalogModel.features.tools === false || surplusRoute?.supportsTools === false
             ? "model does not support tool/function calling"
             : "tool/function calling capability is unverified",
         },
@@ -150,8 +179,24 @@ export async function resolveCallerModelAvailability(
         ...(deps.resolveFunding ? { resolveFunding: deps.resolveFunding } : {}),
         ...(deps.imageAssistanceSelections ? { selectionCache: deps.imageAssistanceSelections } : {}),
         ...(deps.readImageAssistancePreferences ? { readPreferences: deps.readImageAssistancePreferences } : {}),
+        ...(deps.hydrateSurplusChatCatalog ? { hydrateSurplusChatCatalog: deps.hydrateSurplusChatCatalog } : {}),
+        ...(deps.getQualifiedSurplusChatRoutes ? { getQualifiedSurplusChatRoutes: deps.getQualifiedSurplusChatRoutes } : {}),
       }),
-      ...(funding.kind === "personal"
+      ...(surplusRoute
+        ? {
+            capabilities: {
+              ...selectedBase.capabilities,
+              tools: supportsTools,
+              vision: catalogModel.input.includes("image") && surplusRoute.supportsVision,
+              reasoning: catalogModel.features.reasoning === true && surplusRoute.supportsReasoning,
+              webSearch: false,
+            },
+            limits: {
+              contextTokens: surplusRoute.maxContextTokens,
+              outputTokens: surplusRoute.maxOutputTokens,
+            },
+          }
+        : funding.kind === "personal"
         ? {
             capabilities: {
               ...selectedBase.capabilities,
diff --git a/packages/server/src/routes/human-memory-embedding-processor.ts b/packages/server/src/routes/human-memory-embedding-processor.ts
index 926ac4c2d..beb58f2ba 100644
--- a/packages/server/src/routes/human-memory-embedding-processor.ts
+++ b/packages/server/src/routes/human-memory-embedding-processor.ts
@@ -1,7 +1,13 @@
 import {
   embedTextWithProvenance,
   getProtectedMemoryEmbeddingConfiguration,
+  getMemoryEmbeddingDisclosure,
 } from "@nautilo/agent";
+import {
+  assertMemoryEmbeddingDisclosureV2,
+  sameMemoryEmbeddingDisclosureV2,
+  type MemoryEmbeddingDisclosureV2,
+} from "@nautilo/lattice-crypto/wire";
 import {
   createMemoryForegroundEmbeddingProcessor,
   MEMORY_EMBEDDING_DIMENSIONS,
@@ -11,11 +17,16 @@ import {
  * Request input cannot select an endpoint or silently choose a new provider. */
 export function createHumanMemoryEmbeddingProcessor(input: Readonly<{
   configuration?: typeof getProtectedMemoryEmbeddingConfiguration;
+  disclosure?: () => MemoryEmbeddingDisclosureV2;
   embed?: typeof embedTextWithProvenance;
   now?: () => number;
 }> = {}) {
   const configuration = input.configuration ?? getProtectedMemoryEmbeddingConfiguration;
   const embed = input.embed ?? embedTextWithProvenance;
+  const disclosure = input.disclosure ?? (input.configuration === undefined
+    ? getMemoryEmbeddingDisclosure
+    : () => ({ contractVersion: 2 as const,
+      canonicalSpace: descriptor(), processingRoute: { transport: "direct" as const } }));
   const descriptor = () => {
     const configured = configuration();
     if (configured.dimensions !== MEMORY_EMBEDDING_DIMENSIONS) {
@@ -23,20 +34,40 @@ export function createHumanMemoryEmbeddingProcessor(input: Readonly<{
     }
     return Object.freeze({ ...configured, dimensions: MEMORY_EMBEDDING_DIMENSIONS });
   };
+  const descriptorV2 = (): MemoryEmbeddingDisclosureV2 => {
+    const value = disclosure();
+    assertMemoryEmbeddingDisclosureV2(value);
+    return value;
+  };
   return Object.freeze({
     descriptor,
+    descriptorV2,
     processor: createMemoryForegroundEmbeddingProcessor({
       now: input.now ?? Date.now,
       provider: { async embed(request) {
         const expected = descriptor();
+        const currentDisclosure = descriptorV2();
         if (expected.provider !== request.requestedProvider
           || expected.model !== request.requestedModel
           || expected.dimensions !== request.dimensions) {
           throw new TypeError("The approved Memory embedding configuration changed");
         }
+        if (request.embeddingDisclosure === undefined) {
+          if (currentDisclosure.processingRoute.transport !== "direct") {
+            throw new TypeError("A fresh Memory marketplace disclosure is required");
+          }
+        } else if (!sameMemoryEmbeddingDisclosureV2(
+          currentDisclosure, request.embeddingDisclosure,
+        )) {
+          throw new TypeError("The approved Memory processing route changed");
+        }
         // The canonical provider owner rechecks this expectation before sending
         // any bytes, including when configuration changes between these calls.
-        return embed(request.plaintext, request.signal, expected);
+        return embed(request.plaintext, request.signal, {
+          ...expected,
+          ...(request.embeddingDisclosure === undefined ? {}
+            : { disclosure: request.embeddingDisclosure }),
+        });
       } },
     }),
   });
diff --git a/packages/server/src/routes/human-memory-live-composition.ts b/packages/server/src/routes/human-memory-live-composition.ts
index 187a8a5e1..9f8145df0 100644
--- a/packages/server/src/routes/human-memory-live-composition.ts
+++ b/packages/server/src/routes/human-memory-live-composition.ts
@@ -61,6 +61,7 @@ async function assembleHumanMemoryRequest(input: AssemblyRequest): Promise<Prote
   const services = await createHumanMemoryRequestServices(input);
   const exact = createHumanMemoryExactAccessServices({ ...input, services });
   const embedding = services.embedding.descriptor();
+  const embeddingDisclosure = services.embedding.descriptorV2();
   const ports = createHumanMemoryProtectedRoutePortsFromTrustedPorts({
     target: input.authority,
     now: Date.now,
@@ -79,7 +80,9 @@ async function assembleHumanMemoryRequest(input: AssemblyRequest): Promise<Prote
     resolveNamespaceAuthority: services.resolveNamespaceAuthority,
   });
   const mutations = withHumanMemoryMutationEffects({
-    ports: { ...ports, embeddingConfiguration: embedding },
+    ports: { ...ports, embeddingDisclosure,
+      ...(embeddingDisclosure.processingRoute.transport === "direct"
+        ? { embeddingConfiguration: embedding } : {}) },
     deliver: ({ authority, operationId, memoryId }) => deliverCommittedHumanMemoryEffect({
       canonicalRunner: services.context.canonicalRunner,
       publication: services.publication,
diff --git a/packages/server/src/routes/human-memory-mutation-effects.ts b/packages/server/src/routes/human-memory-mutation-effects.ts
index 14ca62e64..dda283afe 100644
--- a/packages/server/src/routes/human-memory-mutation-effects.ts
+++ b/packages/server/src/routes/human-memory-mutation-effects.ts
@@ -36,6 +36,9 @@ export function withHumanMemoryMutationEffects(input: Readonly<{
     ...(input.ports.embeddingConfiguration === undefined ? {} : {
       embeddingConfiguration: input.ports.embeddingConfiguration,
     }),
+    ...(input.ports.embeddingDisclosure === undefined ? {} : {
+      embeddingDisclosure: input.ports.embeddingDisclosure,
+    }),
     planCreate: input.ports.planCreate.bind(input.ports),
     list: input.ports.list.bind(input.ports),
     detail: input.ports.detail.bind(input.ports),
diff --git a/packages/server/src/routes/invites.ts b/packages/server/src/routes/invites.ts
index f9a339890..9d0c4db31 100644
--- a/packages/server/src/routes/invites.ts
+++ b/packages/server/src/routes/invites.ts
@@ -306,22 +306,18 @@ export function invitesRoutes(app: FastifyInstance, opts: InvitesRoutesOpts): vo
   async function listInvitableRoomsForCaller(userId: string, canManageAnyRoom: boolean): Promise<
     Array<{ roomId: string; label: string; type: string }>
   > {
-    const rows = canManageAnyRoom
-      ? await db
-          .select({
-            roomId: rooms.id,
-            label: rooms.label,
-            type: rooms.type,
-          })
-          .from(rooms)
-      : await db
-          .select({
-            roomId: rooms.id,
-            label: rooms.label,
-            type: rooms.type,
-          })
-          .from(rooms)
-          .where(eq(rooms.ownerId, userId));
+    const rows = await db
+      .select({
+        roomId: rooms.id,
+        label: rooms.label,
+        type: rooms.type,
+      })
+      .from(rooms)
+      .where(and(
+        eq(rooms.kind, "open"),
+        eq(rooms.externalContext, false),
+        canManageAnyRoom ? undefined : eq(rooms.ownerId, userId),
+      ));
     return rows;
   }
 
diff --git a/packages/server/src/routes/memory.ts b/packages/server/src/routes/memory.ts
index 584e8932f..671b461fe 100644
--- a/packages/server/src/routes/memory.ts
+++ b/packages/server/src/routes/memory.ts
@@ -6,7 +6,12 @@ import { z } from "zod";
 import {
   createForegroundMemoryProcessorRecipient,
   MEMORY_QUERY_EMBEDDING_MAX_BYTES,
+  decodeMemoryProcessorSearchQueryV2,
 } from "@nautilo/lattice-bridge";
+import {
+  sameMemoryEmbeddingDisclosureV2,
+  type MemoryEmbeddingDisclosureV2,
+} from "@nautilo/lattice-crypto/wire";
 import {
   memoryProcessorSealedRequestV1Schema,
   protectedMemoryBriefResponseV1Schema,
@@ -78,6 +83,7 @@ import {
 import {
   resolveCurrentProtectedMemoryRoutePorts,
   type ProtectedMemoryCompositionSource,
+  type ProtectedMemoryRoutePorts,
 } from "./protected-memory-composition";
 import { protectedMemoryRoutes } from "./protected-memory-routes";
 import {
@@ -87,6 +93,15 @@ import {
   strictShadowHttpStatus,
 } from "../lib/strict-shadow-policy";
 
+function embeddingDisclosureForPorts(ports: ProtectedMemoryRoutePorts): MemoryEmbeddingDisclosureV2 | undefined {
+  return ports.embeddingDisclosure
+    ?? (ports.embeddingConfiguration === undefined ? undefined : {
+      contractVersion: 2 as const,
+      canonicalSpace: ports.embeddingConfiguration,
+      processingRoute: { transport: "direct" as const },
+    });
+}
+
 const protectedMemoryBriefRouteResponseSchema =
   protectedMemoryBriefResponseV1Schema.or(
     protectedMemoryUnavailableResponseV1Schema,
@@ -117,7 +132,12 @@ const protectedMemorySearchRequestSchema = z.object({
   mode: z.enum(["text", "semantic"]),
   limit: z.number().int().min(1).max(256).optional(),
   includeArchive: z.boolean().optional(),
-}).strict();
+}).strict().or(z.object({
+  sealedQueryV2: memoryProcessorSealedRequestV1Schema,
+  mode: z.enum(["text", "semantic"]),
+  limit: z.number().int().min(1).max(256).optional(),
+  includeArchive: z.boolean().optional(),
+}).strict());
 function assertProtectedMemoryMode(
   response: { readonly memoryMode: "namespace" | "scope" },
   expected: "namespace" | "scope",
@@ -593,12 +613,30 @@ export function memoryRoutes(
       return reply.code(404).send({ error: "Protected Memory processor is unavailable" });
     }
     reply.header("Cache-Control", "no-store");
+    const disclosure = embeddingDisclosureForPorts(resolved.ports);
     return reply.send({ ...(await recipient()).descriptor,
-      ...(resolved.ports.embeddingConfiguration === undefined ? {}
-        : { embedding: resolved.ports.embeddingConfiguration }),
+      ...(disclosure?.processingRoute.transport === "direct"
+        ? { embedding: disclosure.canonicalSpace } : {}),
     });
   });
 
+  app.get("/api/memory/processor-recipient/v2", async (request, reply) => {
+    const userId = sessionUserId(request);
+    if (!userId) return reply.code(401).send({ error: "Authentication required" });
+    if (!(await requireReadMemories(userId))) {
+      return reply.code(403).send({ error: "read_memories capability required" });
+    }
+    const resolved = await resolveProtectedMemoryRequest(request, userId, protectedComposition);
+    if (resolved === null) {
+      return reply.code(404).send({ error: "Protected Memory processor is unavailable" });
+    }
+    const descriptor = (await recipient()).descriptor;
+    const disclosure = embeddingDisclosureForPorts(resolved.ports);
+    reply.header("Cache-Control", "no-store");
+    return reply.send({ ...descriptor, formatVersion: 2,
+      ...(disclosure === undefined ? {} : { embedding: disclosure }) });
+  });
+
   app.get("/api/memory/brief", async (request, reply) => {
     const userId = sessionUserId(request);
     if (!userId) {
@@ -885,9 +923,29 @@ export function memoryRoutes(
         reason: "text_search_unsupported",
       }));
     }
-    const query = await (await recipient()).open(body.data.sealedQuery, {
+    const versioned = "sealedQueryV2" in body.data;
+    const payload = await (await recipient()).open(
+      "sealedQueryV2" in body.data ? body.data.sealedQueryV2 : body.data.sealedQuery, {
       purpose: "memory.query_embedding", subjectId: userId,
     });
+    let query = payload;
+    let embeddingDisclosure: MemoryEmbeddingDisclosureV2 | undefined;
+    if (versioned && payload !== null) {
+      try {
+        const decoded = decodeMemoryProcessorSearchQueryV2(payload);
+        query = decoded.query;
+        embeddingDisclosure = decoded.embeddingDisclosure;
+        const current = embeddingDisclosureForPorts(protectedRequest.ports);
+        if (current === undefined
+          || !sameMemoryEmbeddingDisclosureV2(current, embeddingDisclosure)) {
+          return reply.code(409).send({ error: "The Memory embedding route changed. Prepare the search again." });
+        }
+      } catch {
+        return reply.code(400).send({ error: "Valid protected Memory query disclosure required" });
+      }
+    } else if (protectedRequest.ports.embeddingDisclosure?.processingRoute.transport === "surplus_marketplace") {
+      return reply.code(409).send({ error: "A fresh Memory marketplace disclosure is required. Update the client and prepare the search again." });
+    }
     if (query === null || query.trim().length === 0
       || new TextEncoder().encode(query).length > MEMORY_QUERY_EMBEDDING_MAX_BYTES) {
       return reply.code(400).send({ error: "Valid protected Memory query carrier required" });
@@ -900,6 +958,7 @@ export function memoryRoutes(
       authority: protectedRequest.authority,
       namespaceIds,
       query: query.trim(),
+      ...(embeddingDisclosure === undefined ? {} : { embeddingDisclosure }),
       ...(body.data.limit === undefined ? {} : { limit: body.data.limit }),
       includeArchive: body.data.includeArchive ?? false,
     });
diff --git a/packages/server/src/routes/protected-memory-composition.ts b/packages/server/src/routes/protected-memory-composition.ts
index 723de8d5c..1e192c8fe 100644
--- a/packages/server/src/routes/protected-memory-composition.ts
+++ b/packages/server/src/routes/protected-memory-composition.ts
@@ -18,6 +18,7 @@ import type {
   ProtectedMemoryRepairResponseV1,
 } from "@nautilo/api-client";
 import type { MemoryAccessEnvelope } from "@nautilo/trust";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/lattice-crypto/wire";
 
 export type ProtectedMemoryMode = "namespace" | "scope";
 
@@ -73,6 +74,7 @@ export interface ProtectedMemoryRoutePorts {
       prepared: ProtectedMemoryPreparedRepairRequestV1 }>): Promise<ProtectedMemoryRepairResponseV1>;
   }>;
   readonly embeddingConfiguration?: MemoryProcessorRecipientV1["embedding"];
+  readonly embeddingDisclosure?: MemoryEmbeddingDisclosureV2;
   planCreate(input: Readonly<{
     authority: ProtectedMemoryRouteAuthority;
   }>): Promise<
@@ -105,6 +107,7 @@ export interface ProtectedMemoryRoutePorts {
     authority: ProtectedMemoryRouteAuthority;
     namespaceIds: readonly string[];
     query: string;
+    embeddingDisclosure?: MemoryEmbeddingDisclosureV2;
     limit?: number;
     includeArchive: boolean;
   }>): Promise<ProtectedMemoryReadResult<ProtectedMemorySearchResponseV1>>;
@@ -351,6 +354,10 @@ export function createProtectedMemoryTestShadowComposition(input: Readonly<{
   assertPorts(input.ports);
   const ports: ProtectedMemoryRoutePorts = Object.freeze({
     ...(input.ports.repair === undefined ? {} : { repair: input.ports.repair }),
+    ...(input.ports.embeddingConfiguration === undefined ? {}
+      : { embeddingConfiguration: input.ports.embeddingConfiguration }),
+    ...(input.ports.embeddingDisclosure === undefined ? {}
+      : { embeddingDisclosure: input.ports.embeddingDisclosure }),
     planCreate: input.ports.planCreate.bind(input.ports),
     createPrepared: input.ports.createPrepared.bind(input.ports),
     list: input.ports.list.bind(input.ports),
diff --git a/packages/server/src/routes/server-models.ts b/packages/server/src/routes/server-models.ts
index 35147cd16..e7157e2a8 100644
--- a/packages/server/src/routes/server-models.ts
+++ b/packages/server/src/routes/server-models.ts
@@ -7,7 +7,7 @@ import {
   getEligibleModels,
   getProtectedMemoryEmbeddingConfiguration,
   getServerSpeechModel,
-  hasRunnableOpenRouterTransport,
+  hydrateSurplusChatCatalog,
   kickRuntimeModelCatalogRefresh,
   listMediaGenerationModels,
   listResolvedCatalogModels,
@@ -110,10 +110,13 @@ function embeddingModels() {
     const provider = id.split(":")[0] as "venice" | "openrouter" | "openai";
     const label = provider === "venice" ? "Venice" : provider === "openrouter" ? "OpenRouter" : "OpenAI";
     const modelId = id.slice(id.indexOf(":") + 1);
-    return { id, displayName: `${label} — ${modelId} (1,536 dimensions)`,
-      available: provider === "openrouter"
-        ? hasRunnableOpenRouterTransport()
-        : resolveProviderKey(provider) !== null };
+    let available = false;
+    try {
+      available = getProtectedMemoryEmbeddingConfiguration(id).dimensions === 1536;
+    } catch (error) {
+      if (!(error instanceof EmbeddingProviderError)) throw error;
+    }
+    return { id, displayName: `${label} — ${modelId} (1,536 dimensions)`, available };
   });
 }
 
@@ -542,6 +545,7 @@ export interface ServerModelsRouteDeps {
   getEffectiveMediaModel?: typeof effectiveMediaGenerationModel;
   getEffectiveSpeechModel?: () => string | null;
   getSurplusKeyConfigured?: () => boolean;
+  hydrateSurplusChatCatalog?: typeof hydrateSurplusChatCatalog;
   /** Pure offline seam; production derives routes from the signed catalogue. */
   getQualifiedSurplusChatRoutes?: () => readonly QualifiedSurplusChatRoute[];
 }
@@ -562,10 +566,21 @@ export function serverModelsRoutes(
   const listMediaModels = overrides.listMediaModels ?? mediaGenerationModels;
   const listVisionModels = overrides.listImageUnderstandingModels ?? imageUnderstandingModels;
   const getEffectiveMediaModel = overrides.getEffectiveMediaModel ?? effectiveMediaGenerationModel;
+  const getSurplusKeyConfigured = overrides.getSurplusKeyConfigured
+    ?? (() => resolveProviderKey("surplus") !== null);
+  const getQualifiedSurplusChatRoutes = overrides.getQualifiedSurplusChatRoutes;
+  const hydrateSurplusProjection = async (policyEnabled: boolean, keyConfigured: boolean) => {
+    if (!policyEnabled || !keyConfigured || getQualifiedSurplusChatRoutes) return;
+    try {
+      await (overrides.hydrateSurplusChatCatalog ?? hydrateSurplusChatCatalog)();
+    } catch {
+      // Keep administration reachable; the sync projection remains fail-closed
+      // on the last verified discovery snapshot.
+    }
+  };
   const wire = (config: ResolvedServerModelConfig) => {
-    const keyConfigured = (overrides.getSurplusKeyConfigured
-      ?? (() => resolveProviderKey("surplus") !== null))();
-    const routes = overrides.getQualifiedSurplusChatRoutes?.();
+    const keyConfigured = getSurplusKeyConfigured();
+    const routes = getQualifiedSurplusChatRoutes?.();
     const surplus = resolveSurplusChatServingAvailability({
       policyEnabled: config.preferSurplus,
       keyConfigured,
@@ -609,10 +624,15 @@ export function serverModelsRoutes(
     if (!(await viewerHasCapability(userId, "read_server_settings", getCapabilities))) {
       return reply.code(403).send({ error: "admin only" });
     }
+    await hydrateSurplusProjection(
+      getCachedServerModelConfigRow()?.preferSurplus === true,
+      getSurplusKeyConfigured(),
+    );
     const config = await getConfig(getDb(), getDefaults());
     // Retry reconciliation on reload; report the actual runtime snapshot even
     // when refresh retains stale state after a database failure.
     await refreshConfigCache(true);
+    await hydrateSurplusProjection(config.preferSurplus, getSurplusKeyConfigured());
     return reply.send(wire(config));
   });
 
@@ -624,14 +644,21 @@ export function serverModelsRoutes(
     }
 
     const db = getDb();
+    const bodyPolicy = (request.body as Record<string, unknown> | null)?.["preferSurplus"];
+    await hydrateSurplusProjection(
+      typeof bodyPolicy === "boolean"
+        ? bodyPolicy
+        : getCachedServerModelConfigRow()?.preferSurplus === true,
+      getSurplusKeyConfigured(),
+    );
     const defaults = getDefaults();
     const before = await getConfig(db, defaults);
     const requestedPolicy = typeof (request.body as Record<string, unknown> | null)?.["preferSurplus"] === "boolean"
       ? (request.body as Record<string, boolean>)["preferSurplus"]!
       : before.preferSurplus;
-    const keyConfigured = (overrides.getSurplusKeyConfigured
-      ?? (() => resolveProviderKey("surplus") !== null))();
-    const routes = overrides.getQualifiedSurplusChatRoutes?.();
+    const keyConfigured = getSurplusKeyConfigured();
+    const routes = getQualifiedSurplusChatRoutes?.();
+    await hydrateSurplusProjection(requestedPolicy, keyConfigured);
     const parsed = parseUpdateBody(request.body, listMediaModels, {
       policyEnabled: requestedPolicy,
       keyConfigured,
diff --git a/packages/server/src/routes/setup-status.ts b/packages/server/src/routes/setup-status.ts
index 30f6d696d..5642899fb 100644
--- a/packages/server/src/routes/setup-status.ts
+++ b/packages/server/src/routes/setup-status.ts
@@ -14,6 +14,7 @@ import {
 import {
   getActiveModelCatalogSync,
   getProfile,
+  hydrateSurplusChatCatalog,
   resolveProviderKey,
   resolveSurplusChatServingAvailability,
   type QualifiedSurplusChatRoute,
@@ -57,6 +58,7 @@ export interface SetupStatusRouteDeps {
   readonly getQualifiedSurplusChatRoutes?: () => readonly QualifiedSurplusChatRoute[];
   readonly getPreferSurplus?: () => boolean;
   readonly getSurplusKeyConfigured?: () => boolean;
+  readonly hydrateSurplusChatCatalog?: typeof hydrateSurplusChatCatalog;
 }
 
 interface SetupLlmReadinessInput {
@@ -69,7 +71,7 @@ interface SetupLlmReadinessInput {
  * Setup readiness describes a server-funded foreground agent path. A Surplus
  * key is only credential presence; it becomes readiness when server policy is
  * enabled and a released chat route passes the central serving resolver for
- * the ordinary agent defaults: tools and the signed maximum output.
+ * the ordinary agent defaults: tools and a valid positive route context.
  * Request-specific context and vision gates still run at invocation time.
  */
 export function computeSetupHasLlm(
@@ -96,19 +98,31 @@ export function computeSetupHasLlm(
       fundingKind: "server",
       ...(routes === undefined ? {} : { routes }),
     });
-    if (availability.status !== "available" || !availability.route.supportsTools) return false;
-
-    const signedMaxOutputTokens = entry.limits?.outputTokens;
-    if (typeof signedMaxOutputTokens !== "number"
-      || !Number.isSafeInteger(signedMaxOutputTokens)
-      || signedMaxOutputTokens < 1) return false;
-    if (availability.route.maxOutputTokens < signedMaxOutputTokens) return false;
-    // Leave room for at least one prompt token at the signed default output.
-    if (availability.route.maxContextTokens <= signedMaxOutputTokens) return false;
-    return true;
+    return availability.status === "available"
+      && availability.route.supportsTools
+      && availability.route.maxContextTokens > 0;
   });
 }
 
+/** Await discovery before the synchronous setup projection reads its map. */
+export async function hydrateSetupSurplusReadiness(
+  input: SetupLlmReadinessInput,
+  deps: SetupStatusRouteDeps = {},
+): Promise<void> {
+  if (input.directProviderReady || !input.authenticated || !input.claimed
+    || deps.getQualifiedSurplusChatRoutes) return;
+  const policyEnabled = (deps.getPreferSurplus
+    ?? (() => getCachedServerModelConfigRow()?.preferSurplus === true))();
+  const keyConfigured = (deps.getSurplusKeyConfigured
+    ?? (() => resolveProviderKey("surplus") !== null))();
+  if (!policyEnabled || !keyConfigured) return;
+  try {
+    await (deps.hydrateSurplusChatCatalog ?? hydrateSurplusChatCatalog)();
+  } catch {
+    // Setup remains available and reports the last verified, fail-closed state.
+  }
+}
+
 function managedByCloudFromInstance(): boolean {
   return resolveInstance().deploymentMode === "cloud-managed";
 }
@@ -290,11 +304,13 @@ async function deriveSetupStateCore(args: {
     // policy, then compose server serving readiness here without exposing or
     // returning provider records (which carry masked-value metadata).
     const { summary } = await check();
-    hasLlm = computeSetupHasLlm({
+    const readinessInput = {
       directProviderReady: summary.hasLlm,
       authenticated: true,
       claimed: hasA,
-    }, args.deps ?? {});
+    } as const;
+    await hydrateSetupSurplusReadiness(readinessInput, args.deps ?? {});
+    hasLlm = computeSetupHasLlm(readinessInput, args.deps ?? {});
     hasVoice = summary.hasVoice;
     hasSearch = summary.hasSearch;
     hasConversion = summary.hasConversion;
diff --git a/packages/server/tests/integration/personal-soul-setup-service.integration.test.ts b/packages/server/tests/integration/personal-soul-setup-service.integration.test.ts
index 26c184467..275ecb2a8 100644
--- a/packages/server/tests/integration/personal-soul-setup-service.integration.test.ts
+++ b/packages/server/tests/integration/personal-soul-setup-service.integration.test.ts
@@ -1,8 +1,12 @@
+import { randomUUID } from "node:crypto";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { installPersonalLlmAttemptOwner } from "@nautilo/agent";
 import {
   actors,
   agents,
+  beginSurplusLlmAttempt,
   channelIdentities,
+  classifySurplusLlmAttemptRecovery,
   consumePersonalSoulAttempt,
   credentials,
   eq,
@@ -12,6 +16,7 @@ import {
   PERSONAL_SOUL_WINDOW_MS,
   profiles,
   soulGenerationAttempts,
+  settleSurplusLlmAttempt,
   SoulGenerationRateLimitError,
   upsertServerProviderPolicy,
   users,
@@ -30,6 +35,10 @@ import { authedInject } from "./helpers/request-helpers";
 
 const SOUL_MODEL = "openrouter:minimax/minimax-m3";
 const SERVER_KEY = "sk-synthetic-soul-setup-service";
+const SURPLUS_KEY = "sk-synthetic-surplus-soul-setup-service";
+const SURPLUS_CHAT_URL = "https://api.surplusintelligence.ai/v1/chat/completions";
+const REQUEST_RUN_ID = randomUUID();
+const TIKTOKEN_GPT2_URL = "https://tiktoken.pages.dev/js/gpt2.json";
 const GENERATED_SOUL = [
   "# Vela — Soul File",
   "",
@@ -39,18 +48,45 @@ const GENERATED_SOUL = [
   "## Tone",
   "She writes with warmth and precision, keeps promises concrete, and lets a small dry joke through when it helps.",
 ].join("\n");
+const SURPLUS_SAVED_SOUL = [
+  "# Sable — Soul File",
+  "",
+  "## Essence",
+  "Sable notices the useful edge of a problem and answers with patient precision.",
+  "",
+  "## Tone",
+  "Calm, exact, and lightly playful.",
+].join("\n");
+const SURPLUS_PREVIEW_SOUL = [
+  "# Sable — Preview Soul File",
+  "",
+  "## Essence",
+  "This second generated Soul is returned as a preview and is not saved by the stream route.",
+  "",
+  "## Tone",
+  "Direct and observant.",
+].join("\n");
 
 type Peer = Awaited<ReturnType<typeof seatPeerUser>>;
 
 let fx: AppFixture;
 let community: Peer;
+let surplusCommunity: Peer;
+let surplusRecoveryCommunity: Peer;
 let guest: Peer;
 let originalFetch: typeof fetch;
 let priorOpenRouterKey: string | undefined;
 let priorGatewayKey: string | undefined;
 let priorGatewayUrl: string | undefined;
 let priorSoulModel: string | undefined;
+let uninstallPersonalAttemptOwner: (() => void) | undefined;
 const providerRequests: Array<{ authorization: string | null; stream: boolean }> = [];
+const surplusProviderRequests: Array<{
+  authorization: string | null;
+  body: Record<string, unknown>;
+  requestId: string;
+}> = [];
+let surplusRecoveryStart: number | undefined;
 
 async function moveToCommunity(peer: Peer): Promise<void> {
   const [communityGroup] = await fx.db
@@ -92,6 +128,9 @@ function restoreEnvironment(): void {
 }
 
 beforeAll(async () => {
+  uninstallPersonalAttemptOwner = installPersonalLlmAttemptOwner({
+    ownerToken: randomUUID(),
+  });
   originalFetch = globalThis.fetch;
   priorOpenRouterKey = process.env["OPENROUTER_API_KEY"];
   priorGatewayKey = process.env["NAUTILO_MANAGED_GATEWAY_API_KEY"];
@@ -110,6 +149,16 @@ beforeAll(async () => {
     groupType: "contributors",
   });
   await moveToCommunity(community);
+  surplusCommunity = await seatPeerUser(fx.db, {
+    suiteName: "personalsoulsurplus",
+    groupType: "contributors",
+  });
+  await moveToCommunity(surplusCommunity);
+  surplusRecoveryCommunity = await seatPeerUser(fx.db, {
+    suiteName: "soulrecovery",
+    groupType: "contributors",
+  });
+  await moveToCommunity(surplusRecoveryCommunity);
   guest = await seatPeerUser(fx.db, {
     suiteName: "personalsoul",
     groupType: "guests",
@@ -117,39 +166,118 @@ beforeAll(async () => {
 
   globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
     const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    if (url !== "https://openrouter.ai/api/v1/chat/completions") {
-      throw new Error(`Unexpected outbound request in Soul setup integration test: ${url}`);
-    }
     const request = input instanceof Request ? input : undefined;
+    const method = init?.method ?? request?.method ?? "GET";
+    if (method === "GET" && url === TIKTOKEN_GPT2_URL) {
+      // Keep token-estimation fallback hermetic. This provider/persistence
+      // fixture deliberately uses LangChain's approximate count rather than
+      // turning the test into a tokenizer-asset network request.
+      return Response.json({});
+    }
     const headers = new Headers(init?.headers ?? request?.headers);
     const rawBody = typeof init?.body === "string"
       ? init.body
       : request
         ? await request.clone().text()
         : "{}";
-    const body = JSON.parse(rawBody) as { stream?: boolean };
-    const stream = body.stream === true;
+    const body = JSON.parse(rawBody) as Record<string, unknown>;
+    if (url === SURPLUS_CHAT_URL) {
+      const requestIndex = surplusProviderRequests.length;
+      const requestId = `surplus-soul-${REQUEST_RUN_ID}-${requestIndex + 1}`;
+      const soulFile = requestIndex === 0 ? SURPLUS_SAVED_SOUL : SURPLUS_PREVIEW_SOUL;
+      surplusProviderRequests.push({
+        authorization: headers.get("authorization"),
+        body,
+        requestId,
+      });
+      if (surplusRecoveryStart !== undefined && requestIndex - surplusRecoveryStart < 2) {
+        const unavailable = requestIndex === surplusRecoveryStart;
+        return Response.json({
+          error: {
+            code: unavailable ? "no_healthy_sellers" : "no_sellers_for_model",
+            message: "Synthetic model supply refusal.",
+          },
+        }, {
+          status: unavailable ? 503 : 404,
+          headers: {
+            "x-request-id": requestId,
+            "x-si-provider-family": "unknown",
+            "x-si-marketplace-attempts": "0",
+            "x-si-truncated": "0",
+          },
+        });
+      }
+      const midpoint = Math.floor(soulFile.length / 2);
+      const buyerCostMicro = 321 + requestIndex;
+      const chunks = [
+        {
+          id: `chatcmpl-${requestId}`,
+          object: "chat.completion.chunk",
+          created: 1,
+          model: body["model"],
+          choices: [{ index: 0, delta: { role: "assistant", content: soulFile.slice(0, midpoint) }, finish_reason: null }],
+        },
+        {
+          id: `chatcmpl-${requestId}`,
+          object: "chat.completion.chunk",
+          created: 1,
+          model: body["model"],
+          choices: [{ index: 0, delta: { content: soulFile.slice(midpoint) }, finish_reason: null }],
+        },
+        {
+          id: `chatcmpl-${requestId}`,
+          object: "chat.completion.chunk",
+          created: 1,
+          model: body["model"],
+          choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+          usage: {
+            prompt_tokens: 18,
+            completion_tokens: 42,
+            total_tokens: 60,
+            buyer_cost_micro: buyerCostMicro,
+          },
+        },
+      ];
+      return new Response(
+        `${chunks.map((chunk) => `data: ${JSON.stringify(chunk)}\n\n`).join("")}data: [DONE]\n\n`,
+        {
+          headers: {
+            "content-type": "text/event-stream",
+            "x-request-id": requestId,
+            "x-si-provider-family": typeof body["provider"] === "string" ? body["provider"] : "openrouter",
+            "x-si-marketplace-attempts": "1",
+            "x-si-buyer-cost-micro": String(buyerCostMicro),
+            "x-si-truncated": "0",
+          },
+        },
+      );
+    }
+    if (url !== "https://openrouter.ai/api/v1/chat/completions") {
+      throw new Error(`Unexpected outbound request in Soul setup integration test: ${url}`);
+    }
+    const stream = body["stream"] === true;
     providerRequests.push({ authorization: headers.get("authorization"), stream });
+    const requestId = `direct-soul-${REQUEST_RUN_ID}-${providerRequests.length}`;
 
     if (stream) {
       const midpoint = Math.floor(GENERATED_SOUL.length / 2);
       const chunks = [
         {
-          id: "chatcmpl-soul-stream",
+          id: requestId,
           object: "chat.completion.chunk",
           created: 1,
           model: "minimax/minimax-m3",
           choices: [{ index: 0, delta: { role: "assistant", content: GENERATED_SOUL.slice(0, midpoint) }, finish_reason: null }],
         },
         {
-          id: "chatcmpl-soul-stream",
+          id: requestId,
           object: "chat.completion.chunk",
           created: 1,
           model: "minimax/minimax-m3",
           choices: [{ index: 0, delta: { content: GENERATED_SOUL.slice(midpoint) }, finish_reason: null }],
         },
         {
-          id: "chatcmpl-soul-stream",
+          id: requestId,
           object: "chat.completion.chunk",
           created: 1,
           model: "minimax/minimax-m3",
@@ -164,7 +292,7 @@ beforeAll(async () => {
     }
 
     return Response.json({
-      id: "chatcmpl-soul-nonstream",
+      id: requestId,
       object: "chat.completion",
       created: 1,
       model: "minimax/minimax-m3",
@@ -179,16 +307,61 @@ beforeAll(async () => {
 });
 
 afterAll(async () => {
+  uninstallPersonalAttemptOwner?.();
+  uninstallPersonalAttemptOwner = undefined;
   globalThis.fetch = originalFetch;
   restoreEnvironment();
   if (!fx) return;
   await upsertServerProviderPolicy(fx.db, { allowPersonalProviderKeys: false });
   if (community) await removePeer(community);
+  if (surplusCommunity) await removePeer(surplusCommunity);
+  if (surplusRecoveryCommunity) await removePeer(surplusRecoveryCommunity);
   if (guest) await removePeer(guest);
   await fx.cleanup();
 });
 
 describe.serial("personal-key own-Genie Soul setup service", () => {
+  test("receipt recovery preserves inference diagnostics in the durable attempt", async () => {
+    const attemptId = randomUUID();
+    try {
+      await beginSurplusLlmAttempt({
+        id: attemptId, userId: fx.ownerId, callType: "soul", provider: "openrouter",
+        model: SOUL_MODEL, endpoint: "/v1/chat/completions", fundingKind: "service",
+        metadata: { syntheticReceiptRecovery: true },
+      });
+      await settleSurplusLlmAttempt({
+        attemptId, outcome: "unknown", costState: "pending",
+        providerRequestId: `synthetic-receipt-${attemptId}`, failureCode: "outcome_unknown",
+        metadata: { surplusErrorCode: "upstream_unavailable", surplusResponseStatus: 503 },
+      });
+      const [before] = await fx.db.select().from(llmUsageEvents).where(eq(llmUsageEvents.id, attemptId));
+      expect(before).toBeDefined();
+      expect(await classifySurplusLlmAttemptRecovery({
+        attemptId, expectedUpdatedAt: before!.updatedAt,
+        recoveryState: "retryable", failureCode: "receipt_not_found",
+      })).toBe(true);
+      const [after] = await fx.db.select().from(llmUsageEvents).where(eq(llmUsageEvents.id, attemptId));
+      expect(after).toMatchObject({
+        attemptOutcome: "unknown", costState: "pending", actualCostUsd: null,
+        failureCode: "outcome_unknown", recoveryState: "retryable",
+        metadata: { syntheticReceiptRecovery: true, surplusErrorCode: "upstream_unavailable",
+          surplusResponseStatus: 503, surplusReceiptRecoveryFailureCode: "receipt_not_found" },
+      });
+      await settleSurplusLlmAttempt({ attemptId, outcome: "unknown", costState: "actual", actualCostUsd: 0.0001,
+        failureCode: "outcome_unknown" });
+      expect(await classifySurplusLlmAttemptRecovery({
+        attemptId, expectedUpdatedAt: after!.updatedAt,
+        recoveryState: "blocked_repair", failureCode: "receipt_binding_invalid",
+      })).toBe(false);
+      const [settled] = await fx.db.select().from(llmUsageEvents).where(eq(llmUsageEvents.id, attemptId));
+      expect(settled?.failureCode).toBe("outcome_unknown");
+      expect(settled?.actualCostUsd).toBe("0.00010000");
+      expect(settled?.recoveryState).toBeNull();
+    } finally {
+      await fx.db.delete(llmUsageEvents).where(eq(llmUsageEvents.id, attemptId));
+    }
+  });
+
   test("admits a personal-only Community Human through both endpoints and records server-funded Soul usage", async () => {
     await upsertServerProviderPolicy(fx.db, { allowPersonalProviderKeys: true });
     const requestsBefore = providerRequests.length;
@@ -245,6 +418,220 @@ describe.serial("personal-key own-Genie Soul setup service", () => {
     )).toBe(true);
   });
 
+  test("uses Surplus for both real-generator endpoints while only the non-stream route persists", async () => {
+    const priorOpenRouter = process.env["OPENROUTER_API_KEY"];
+    const priorSurplus = process.env["SURPLUS_API_KEY"];
+    const ownerBearer = await fx.mintOwnerBearer();
+    const priorModelsResponse = await authedInject(fx.app, {
+      method: "GET",
+      url: "/api/admin/server-models",
+      bearer: ownerBearer,
+    });
+    expect(priorModelsResponse.statusCode, priorModelsResponse.body).toBe(200);
+    const priorPreferSurplus = priorModelsResponse.json<{ preferSurplus: boolean }>().preferSurplus;
+    const requestsBefore = surplusProviderRequests.length;
+
+    try {
+      delete process.env["OPENROUTER_API_KEY"];
+      process.env["SURPLUS_API_KEY"] = SURPLUS_KEY;
+      invalidateRuntimeConfigCache();
+      expect(process.env["OPENROUTER_API_KEY"]).toBeUndefined();
+
+      const enabled = await authedInject(fx.app, {
+        method: "POST",
+        url: "/api/admin/server-models",
+        bearer: ownerBearer,
+        payload: { preferSurplus: true },
+      });
+      expect(enabled.statusCode, enabled.body).toBe(200);
+
+      const generated = await authedInject(fx.app, {
+        method: "POST",
+        url: "/api/profile/generate-soul",
+        bearer: surplusCommunity.bearer,
+        payload: { name: "Sable", personalityPrompt: "Patient, exact, and lightly playful." },
+      });
+      expect(generated.statusCode, generated.body).toBe(200);
+      expect(JSON.parse(generated.body)).toEqual({ soulFile: SURPLUS_SAVED_SOUL });
+
+      const [savedAfterGenerate] = await fx.db
+        .select({ soulFile: profiles.soulFile })
+        .from(profiles)
+        .where(eq(profiles.userId, surplusCommunity.userId))
+        .limit(1);
+      expect(savedAfterGenerate?.soulFile).toBe(SURPLUS_SAVED_SOUL);
+
+      const streamed = await authedInject(fx.app, {
+        method: "POST",
+        url: "/api/profile/generate-soul/stream",
+        bearer: surplusCommunity.bearer,
+        payload: { name: "Sable", personalityPrompt: "Direct, observant, and patient." },
+      });
+      expect(streamed.statusCode, streamed.body).toBe(200);
+      expect(streamed.body).toContain("event: soul.started");
+      expect(streamed.body).toContain("event: soul.completed");
+      expect(streamed.body).toContain("Preview Soul File");
+
+      const [savedAfterPreview] = await fx.db
+        .select({ soulFile: profiles.soulFile })
+        .from(profiles)
+        .where(eq(profiles.userId, surplusCommunity.userId))
+        .limit(1);
+      expect(savedAfterPreview?.soulFile).toBe(SURPLUS_SAVED_SOUL);
+
+      const requests = surplusProviderRequests.slice(requestsBefore);
+      expect(requests).toHaveLength(2);
+      for (const request of requests) {
+        expect(request.authorization).toBe(`Bearer ${SURPLUS_KEY}`);
+        expect(request.body).toMatchObject({
+          model: "minimax/minimax-m3",
+          stream: true,
+        });
+        expect(request.body["provider"]).toBeUndefined();
+      }
+
+      const usage = await fx.db
+        .select()
+        .from(llmUsageEvents)
+        .where(eq(llmUsageEvents.userId, surplusCommunity.userId));
+      const soulUsage = usage.filter((event) => event.callType === "soul");
+      expect(soulUsage).toHaveLength(2);
+      expect(soulUsage.map((event) => event.providerRequestId).sort()).toEqual(
+        requests.map((request) => request.requestId).sort(),
+      );
+      expect(soulUsage.map((event) => event.actualCostUsd).sort()).toEqual([
+        "0.00032100",
+        "0.00032200",
+      ]);
+      for (const event of soulUsage) {
+        expect(event).toMatchObject({
+          callType: "soul",
+          fundingKind: "service",
+          payerHumanId: null,
+          providerRoute: "surplus",
+          attemptOutcome: "succeeded",
+          costState: "actual",
+          servingProvider: "openrouter",
+        });
+        expect(event.metadata?.["agentId"]).toBe(surplusCommunity.agentId);
+      }
+    } finally {
+      if (priorOpenRouter === undefined) delete process.env["OPENROUTER_API_KEY"];
+      else process.env["OPENROUTER_API_KEY"] = priorOpenRouter;
+      if (priorSurplus === undefined) delete process.env["SURPLUS_API_KEY"];
+      else process.env["SURPLUS_API_KEY"] = priorSurplus;
+      invalidateRuntimeConfigCache();
+      const restored = await authedInject(fx.app, {
+        method: "POST",
+        url: "/api/admin/server-models",
+        bearer: ownerBearer,
+        payload: { preferSurplus: priorPreferSurplus },
+      });
+      expect(restored.statusCode, restored.body).toBe(200);
+    }
+  });
+
+  test("recovers both Soul endpoints using marketplace selection and later models without direct keys", async () => {
+    const directKeyNames = [
+      "OPENROUTER_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY",
+      "VENICE_API_KEY", "GOOGLE_API_KEY", "TYPESAFE_API_KEY",
+    ] as const;
+    const priorDirectKeys = directKeyNames.map((key) => [key, process.env[key]] as const);
+    const priorSurplus = process.env["SURPLUS_API_KEY"];
+    const ownerBearer = await fx.mintOwnerBearer();
+    const priorModels = await authedInject(fx.app, {
+      method: "GET", url: "/api/admin/server-models", bearer: ownerBearer,
+    });
+    expect(priorModels.statusCode, priorModels.body).toBe(200);
+    const priorPreferSurplus = priorModels.json<{ preferSurplus: boolean }>().preferSurplus;
+    const directBefore = providerRequests.length;
+    const requestsBefore = surplusProviderRequests.length;
+
+    try {
+      for (const key of directKeyNames) delete process.env[key];
+      process.env["SURPLUS_API_KEY"] = SURPLUS_KEY;
+      invalidateRuntimeConfigCache();
+      const enabled = await authedInject(fx.app, {
+        method: "POST", url: "/api/admin/server-models", bearer: ownerBearer,
+        payload: { preferSurplus: true },
+      });
+      expect(enabled.statusCode, enabled.body).toBe(200);
+
+      for (const stream of [false, true]) {
+        surplusRecoveryStart = surplusProviderRequests.length;
+        const response = await authedInject(fx.app, {
+          method: "POST",
+          url: stream ? "/api/profile/generate-soul/stream" : "/api/profile/generate-soul",
+          bearer: surplusRecoveryCommunity.bearer,
+          payload: { name: "Sable", personalityPrompt: "Patient, exact, and lightly playful." },
+        });
+        expect(response.statusCode, response.body).toBe(200);
+        if (stream) {
+          expect(response.body).toContain("event: soul.completed");
+          expect(response.body).not.toContain("event: soul.error");
+        } else {
+          expect(response.json<{ soulFile: string }>()).toEqual({ soulFile: SURPLUS_PREVIEW_SOUL });
+        }
+        const attempts = surplusProviderRequests.slice(surplusRecoveryStart);
+        expect(attempts).toHaveLength(3);
+        expect(attempts[0]?.body["model"]).toBe("minimax/minimax-m3");
+        expect(attempts[0]?.body["provider"]).toBeUndefined();
+        expect(attempts[1]?.body["model"]).toBe("minimax-m3-preview");
+        expect(attempts[1]?.body["provider"]).toBe("venice");
+        expect(attempts[2]?.body["model"]).not.toBe("minimax/minimax-m3");
+        expect(attempts[2]?.body["model"]).not.toBe(attempts[1]?.body["model"]);
+        expect(attempts[2]?.body["provider"]).toBeUndefined();
+        expect(attempts.every((attempt) => attempt.authorization === `Bearer ${SURPLUS_KEY}`)).toBe(true);
+      }
+
+      expect(providerRequests).toHaveLength(directBefore);
+      const requests = surplusProviderRequests.slice(requestsBefore);
+      const usage = await fx.db.select().from(llmUsageEvents)
+        .where(eq(llmUsageEvents.userId, surplusRecoveryCommunity.userId));
+      expect(usage).toHaveLength(6);
+      expect(new Set(usage.map((row) => row.id)).size).toBe(6);
+      expect(usage.map((row) => row.providerRequestId ?? row.metadata?.["surplusTraceId"]).sort()).toEqual(
+        requests.map((request) => request.requestId).sort(),
+      );
+      expect(usage.filter((row) => row.attemptOutcome === "failed")).toHaveLength(4);
+      expect(usage.filter((row) => row.attemptOutcome === "succeeded")).toHaveLength(2);
+      for (const row of usage) {
+        expect(row).toMatchObject({ callType: "soul", fundingKind: "service", providerRoute: "surplus", payerHumanId: null });
+        expect(row.metadata?.["agentId"]).toBe(surplusRecoveryCommunity.agentId);
+        if (row.attemptOutcome === "failed") {
+          expect(row.providerRequestId).toBeNull();
+          expect(row.metadata?.["surplusTraceId"]).toBeString();
+          expect(["no_healthy_sellers", "no_sellers_for_model"]
+            .some((code) => code === row.metadata?.["surplusErrorCode"])).toBe(true);
+          expect(row.costState).toBe("actual");
+          expect(row.actualCostUsd).toBe("0.00000000");
+          expect(row.recoveryState).toBeNull();
+        } else {
+          expect(row.costState).toBe("actual");
+          expect(row.actualCostUsd).not.toBeNull();
+          expect(row.model).not.toBe(SOUL_MODEL);
+        }
+      }
+      const admissions = await fx.db.select({ id: soulGenerationAttempts.id }).from(soulGenerationAttempts)
+        .where(eq(soulGenerationAttempts.humanUserId, surplusRecoveryCommunity.userId));
+      expect(admissions).toHaveLength(2);
+    } finally {
+      surplusRecoveryStart = undefined;
+      for (const [key, value] of priorDirectKeys) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+      if (priorSurplus === undefined) delete process.env["SURPLUS_API_KEY"];
+      else process.env["SURPLUS_API_KEY"] = priorSurplus;
+      invalidateRuntimeConfigCache();
+      const restored = await authedInject(fx.app, {
+        method: "POST", url: "/api/admin/server-models", bearer: ownerBearer,
+        payload: { preferSurplus: priorPreferSurplus },
+      });
+      expect(restored.statusCode, restored.body).toBe(200);
+    }
+  });
+
   test("a shared rolling limit counts sequential attempts across both routes but leaves server-authorized Humans unchanged", async () => {
     const third = await authedInject(fx.app, {
       method: "POST", url: "/api/profile/generate-soul", bearer: community.bearer,
diff --git a/packages/server/tests/integration/surplus-embedding-service.integration.test.ts b/packages/server/tests/integration/surplus-embedding-service.integration.test.ts
new file mode 100644
index 000000000..63a521f6e
--- /dev/null
+++ b/packages/server/tests/integration/surplus-embedding-service.integration.test.ts
@@ -0,0 +1,302 @@
+import { randomUUID } from "node:crypto";
+import { afterAll, beforeAll, describe, expect, type Mock, spyOn, test } from "bun:test";
+import {
+  embedTextWithProvenance,
+  getMemoryEmbeddingDisclosure,
+} from "@nautilo/agent";
+import { setConfigOverrides } from "@nautilo/config";
+import * as dbModule from "@nautilo/db";
+import {
+  __setLlmUsageDbForTests,
+  createDirectDb,
+  ensureDatabase,
+  eq,
+  inArray,
+  listPendingSurplusAttempts,
+  llmUsageEvents,
+  type DirectDatabase,
+  type SurplusPendingAttempt,
+} from "@nautilo/db";
+import { bootstrapTestDbInstance } from "@nautilo/db/testing";
+import { createSurplusCostRecovery } from "../../src/lib/surplus-cost-reconciliation";
+
+const MODEL_ID = "venice:text-embedding-3-large";
+const MODEL = "text-embedding-3-large";
+const DIMENSIONS = 1_536;
+const SURPLUS_KEY = "synthetic-surplus-embedding-service-key";
+const SURPLUS_EMBEDDINGS_URL = "https://api.surplusintelligence.ai/v1/embeddings";
+const SURPLUS_REQUESTS_URL = "https://api.surplusintelligence.ai/v1/requests/";
+
+let db: DirectDatabase;
+let originalFetch: typeof fetch;
+let priorSurplusKey: string | undefined;
+let serverConfigSpy: Mock<typeof dbModule.getCachedServerModelConfigRow>;
+const attemptIds: string[] = [];
+let fetchHandler: typeof fetch;
+
+function requestUrl(input: Parameters<typeof fetch>[0]): string {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+
+function requestBody(body: unknown): unknown {
+  if (typeof body !== "string") throw new Error("Expected a JSON request body");
+  return JSON.parse(body) as unknown;
+}
+
+function response(input: {
+  requestId: string;
+  status?: number;
+  costMicro?: number;
+  model?: string;
+  dimensions?: number;
+}): Response {
+  const headers = new Headers({
+    "x-request-id": input.requestId,
+    "x-si-provider-family": "Mordiem",
+    "x-si-adapted-params": "safe_mode",
+  });
+  if (input.costMicro !== undefined) {
+    headers.set("x-si-buyer-cost-micro", String(input.costMicro));
+  }
+  const dimensions = input.dimensions ?? DIMENSIONS;
+  return Response.json({
+    model: input.model ?? MODEL,
+    data: [{ index: 0, embedding: Array.from({ length: dimensions }, (_, index) => index / dimensions) }],
+    usage: { prompt_tokens: 3, total_tokens: 3 },
+  }, { status: input.status ?? 200, headers });
+}
+
+async function rowForRequest(requestId: string) {
+  const [row] = await db.select().from(llmUsageEvents)
+    .where(eq(llmUsageEvents.providerRequestId, requestId));
+  if (!row) throw new Error(`Missing synthetic embedding attempt ${requestId}`);
+  if (!attemptIds.includes(row.id)) attemptIds.push(row.id);
+  return row;
+}
+
+async function until(assertion: () => Promise<void>, timeoutMs = 5_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  let lastError: unknown;
+  while (Date.now() < deadline) {
+    try {
+      await assertion();
+      return;
+    } catch (error) {
+      lastError = error;
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+  throw lastError;
+}
+
+beforeAll(async () => {
+  bootstrapTestDbInstance();
+  await ensureDatabase();
+  db = createDirectDb(2);
+  __setLlmUsageDbForTests(db);
+
+  originalFetch = globalThis.fetch;
+  priorSurplusKey = process.env["SURPLUS_API_KEY"];
+  process.env["SURPLUS_API_KEY"] = SURPLUS_KEY;
+  setConfigOverrides({
+    nautilo_embedding_model: MODEL_ID,
+    nautilo_embedding_dims: DIMENSIONS,
+  });
+  serverConfigSpy = spyOn(dbModule, "getCachedServerModelConfigRow").mockReturnValue({
+    embeddingModel: MODEL_ID,
+    preferSurplus: true,
+  } as NonNullable<ReturnType<typeof dbModule.getCachedServerModelConfigRow>>);
+  globalThis.fetch = ((input, init) => fetchHandler(input, init)) as typeof fetch;
+}, 120_000);
+
+afterAll(async () => {
+  globalThis.fetch = originalFetch;
+  if (priorSurplusKey === undefined) delete process.env["SURPLUS_API_KEY"];
+  else process.env["SURPLUS_API_KEY"] = priorSurplusKey;
+  setConfigOverrides({});
+  serverConfigSpy?.mockRestore();
+  __setLlmUsageDbForTests(null);
+  if (db) {
+    if (attemptIds.length > 0) {
+      await db.delete(llmUsageEvents).where(inArray(llmUsageEvents.id, attemptIds));
+    }
+    await db.end();
+  }
+});
+
+describe.serial("service-funded Surplus embeddings", () => {
+  test("persists the qualified canonical space, serving provider, and zero actual cost", async () => {
+    const requestId = `embedding-zero-${randomUUID()}`;
+    let wires = 0;
+    fetchHandler = (async (input, init) => {
+      wires++;
+      expect(requestUrl(input)).toBe(SURPLUS_EMBEDDINGS_URL);
+      expect(init?.method).toBe("POST");
+      expect(new Headers(init?.headers).get("authorization")).toBe(`Bearer ${SURPLUS_KEY}`);
+      expect(requestBody(init?.body)).toEqual({
+        model: MODEL,
+        input: ["durable private memory"],
+        dimensions: DIMENSIONS,
+      });
+      return response({ requestId, costMicro: 0 });
+    }) as typeof fetch;
+
+    const disclosure = getMemoryEmbeddingDisclosure();
+    const result = await embedTextWithProvenance("durable private memory", undefined, {
+      provider: "venice",
+      model: MODEL,
+      dimensions: DIMENSIONS,
+      disclosure,
+    });
+    expect(result).toMatchObject({
+      provider: "venice",
+      canonicalModel: MODEL,
+      dimensions: DIMENSIONS,
+    });
+    expect(result.vector).toHaveLength(DIMENSIONS);
+    expect(wires).toBe(1);
+
+    expect(await rowForRequest(requestId)).toMatchObject({
+      callType: "embedding",
+      provider: "venice",
+      model: MODEL_ID,
+      fundingKind: "service",
+      providerRoute: "surplus",
+      endpoint: "/v1/embeddings",
+      servingProvider: "mordiem",
+      attemptOutcome: "succeeded",
+      costState: "actual",
+      actualCostUsd: "0.00000000",
+      inputTokens: 3,
+      totalTokens: 3,
+    });
+  });
+
+  test("reconciles one pending embedding through the exact qualified receipt", async () => {
+    const requestId = `embedding-pending-${randomUUID()}`;
+    let posts = 0;
+    let receiptReads = 0;
+    fetchHandler = (async (input, init) => {
+      const url = requestUrl(input);
+      if (url === SURPLUS_EMBEDDINGS_URL) {
+        posts++;
+        return response({ requestId });
+      }
+      if (url === `${SURPLUS_REQUESTS_URL}${requestId}`) {
+        receiptReads++;
+        expect(init?.method).toBe("GET");
+        expect(init?.redirect).toBe("error");
+        expect(new Headers(init?.headers).get("authorization")).toBe(`Bearer ${SURPLUS_KEY}`);
+        return Response.json({
+          request_id: requestId,
+          model: "venice-embed-1",
+          provider: "mordiem",
+          settlement_status: "accrued",
+          settlement_type: "credit",
+          settlement_error: null,
+          confirmed_at: "2026-10-21T10:00:00.000Z",
+          buyer_cost_micro: 283,
+        });
+      }
+      throw new Error(`Unexpected synthetic request: ${url}`);
+    }) as typeof fetch;
+
+    const disclosure = getMemoryEmbeddingDisclosure();
+    const result = await embedTextWithProvenance("pending private memory", undefined, {
+      provider: "venice", model: MODEL, dimensions: DIMENSIONS, disclosure,
+    });
+    expect(result.vector).toHaveLength(DIMENSIONS);
+    const pending = await rowForRequest(requestId);
+    expect(pending).toMatchObject({
+      attemptOutcome: "succeeded",
+      costState: "pending",
+      actualCostUsd: null,
+      servingProvider: "mordiem",
+    });
+
+    const recovery = createSurplusCostRecovery({
+      now: () => Date.now() + 120_000,
+      list: async (input) => (await listPendingSurplusAttempts(input))
+        .filter((row) => row.id === pending.id),
+      resolveServerCredential: () => SURPLUS_KEY,
+      resolveCredential: (row: SurplusPendingAttempt) => {
+        if (row.id !== pending.id) throw new Error("Recovery escaped the synthetic embedding attempt");
+        return { status: "available", apiKey: SURPLUS_KEY, receiptReadStatus: "unknown" };
+      },
+      requeueBlockedServer: async () => 0,
+      requeueBlockedDecisions: async () => 0,
+    });
+    try {
+      recovery.wake();
+      await until(async () => {
+        expect(await rowForRequest(requestId)).toMatchObject({
+          attemptOutcome: "succeeded",
+          costState: "actual",
+          actualCostUsd: "0.00028300",
+          recoveryState: null,
+        });
+      });
+    } finally {
+      await recovery.stop();
+    }
+    expect(posts).toBe(1);
+    expect(receiptReads).toBe(1);
+  });
+
+  test("does not fall back or replay a transient marketplace failure", async () => {
+    const requestId = `embedding-unavailable-${randomUUID()}`;
+    let wires = 0;
+    fetchHandler = (async (input) => {
+      expect(requestUrl(input)).toBe(SURPLUS_EMBEDDINGS_URL);
+      wires++;
+      return response({ requestId, status: 503, costMicro: 0 });
+    }) as typeof fetch;
+
+    const error = await embedTextWithProvenance("unavailable private memory", undefined, {
+      provider: "venice", model: MODEL, dimensions: DIMENSIONS,
+      disclosure: getMemoryEmbeddingDisclosure(),
+    }).catch((caught: unknown) => caught);
+    expect(error).toMatchObject({
+      code: "request_failed",
+      provider: "venice",
+      status: 503,
+      retryable: true,
+    });
+    expect(wires).toBe(1);
+    expect(await rowForRequest(requestId)).toMatchObject({
+      attemptOutcome: "failed",
+      costState: "actual",
+      actualCostUsd: "0.00000000",
+      failureCode: "provider_unavailable",
+    });
+  });
+
+  test("rejects wrong model and dimension responses without returning their vectors", async () => {
+    for (const invalid of [
+      { model: "text-embedding-3-small", dimensions: DIMENSIONS },
+      { model: MODEL, dimensions: DIMENSIONS - 1 },
+    ]) {
+      const requestId = `embedding-invalid-${randomUUID()}`;
+      let wires = 0;
+      fetchHandler = (async () => {
+        wires++;
+        return response({ requestId, costMicro: 0, ...invalid });
+      }) as unknown as typeof fetch;
+      const error = await embedTextWithProvenance("invalid private memory", undefined, {
+        provider: "venice", model: MODEL, dimensions: DIMENSIONS,
+        disclosure: getMemoryEmbeddingDisclosure(),
+      }).catch((caught: unknown) => caught);
+      expect(error).toMatchObject({ code: "invalid_response", provider: "venice" });
+      expect(error).not.toHaveProperty("vector");
+      expect(wires).toBe(1);
+      expect(await rowForRequest(requestId)).toMatchObject({
+        attemptOutcome: "failed",
+        costState: "actual",
+        actualCostUsd: "0.00000000",
+        failureCode: "invalid_response",
+      });
+    }
+  });
+});
diff --git a/packages/server/tests/unit-isolated/human-memory-live-composition-embedding.test.ts b/packages/server/tests/unit-isolated/human-memory-live-composition-embedding.test.ts
new file mode 100644
index 000000000..a04ef74db
--- /dev/null
+++ b/packages/server/tests/unit-isolated/human-memory-live-composition-embedding.test.ts
@@ -0,0 +1,141 @@
+import { describe, expect, mock, test } from "bun:test";
+import type { LiveShadowEncryptionTransitionPolicy } from "@nautilo/db";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/lattice-crypto/wire";
+import type { MemoryAccessEnvelope } from "@nautilo/trust";
+import { createHumanMemoryEmbeddingProcessor } from
+  "../../src/routes/human-memory-embedding-processor";
+import * as requestServices from "../../src/routes/human-memory-request-services";
+import type { ProtectedMemoryRouteAuthority } from
+  "../../src/routes/protected-memory-composition";
+
+const marketplaceSpace = { provider: "venice" as const,
+  model: "text-embedding-3-large", dimensions: 1536 as const };
+const marketplaceDisclosure: MemoryEmbeddingDisclosureV2 = {
+  contractVersion: 2,
+  canonicalSpace: marketplaceSpace,
+  processingRoute: { transport: "surplus_marketplace",
+    marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+    dataRecipientClasses: ["surplus", "marketplace_seller",
+      "seller_upstream_processor"] },
+};
+const directSpace = { provider: "openrouter" as const,
+  model: "openai/text-embedding-3-small", dimensions: 1536 as const };
+const directDisclosure: MemoryEmbeddingDisclosureV2 = {
+  contractVersion: 2,
+  canonicalSpace: directSpace,
+  processingRoute: { transport: "direct" },
+};
+let currentDisclosure = marketplaceDisclosure;
+const providerCalls: unknown[][] = [];
+const searchCalls: unknown[] = [];
+
+const unavailable = async () => ({ dtoVersion: 1 as const,
+  status: "unavailable" as const, reason: "authorization_required" as const });
+
+mock.module("../../src/routes/human-memory-request-services", () => ({
+  ...requestServices,
+  createHumanMemoryRequestServices: async () => {
+    const disclosure = currentDisclosure;
+    const embedding = createHumanMemoryEmbeddingProcessor({
+      configuration: () => disclosure.canonicalSpace,
+      disclosure: () => disclosure,
+      embed: async (...args) => {
+        providerCalls.push(args);
+        return { provider: disclosure.canonicalSpace.provider,
+          canonicalModel: disclosure.canonicalSpace.model,
+          dimensions: 1536 as const, vector: new Array<number>(1536).fill(0.25),
+          contractVersion: 1 as const };
+      },
+    });
+    return {
+      context: { canonicalRunner: {} }, publication: {}, embedding,
+      resolveHumanId: async () => "human-one",
+      resolveNamespaceAuthority: async () => null,
+      product: {
+        list: unavailable,
+        detail: unavailable,
+        brief: unavailable,
+        transitionTier: unavailable,
+        searchSemantic: async (request: unknown) => {
+          searchCalls.push(request);
+          return { dtoVersion: 1 as const, items: [], memoryMode: "namespace" as const,
+            queryDisclosure: "embedding_provider" as const };
+        },
+      },
+      preparedCreate: { planCreate: unavailable, createPrepared: unavailable },
+      preparedUpdate: { updatePrepared: unavailable },
+    } as never;
+  },
+}));
+mock.module("../../src/routes/human-memory-exact-access-services", () => ({
+  createHumanMemoryExactAccessServices: () => ({
+    exactAccessProduct: {}, exactAccessCrypto: {}, accessDeadlineAt: Date.now,
+  }),
+}));
+mock.module("../../src/routes/human-memory-repair-services", () => ({
+  createHumanMemoryRepairServices: () => undefined,
+}));
+
+const { createProductionHumanMemoryRouteFactory } = await import(
+  "../../src/routes/human-memory-live-composition"
+);
+
+const namespaceId = "11111111-1111-4111-8111-111111111111";
+const roomId = "22222222-2222-4222-8222-222222222222";
+const envelope: MemoryAccessEnvelope = {
+  ownerId: "user", actorId: "actor", agentId: "context-agent", roomId,
+  readableNamespaces: [namespaceId], mutableNamespaces: [namespaceId],
+  writableNamespaces: [namespaceId], toolPolicy: {},
+};
+const authority: ProtectedMemoryRouteAuthority = {
+  userId: "user", actorId: "actor", agentId: null, memoryMode: "namespace",
+  readableNamespaceIds: [namespaceId], mutableNamespaceIds: [namespaceId],
+  writableNamespaceIds: [namespaceId], sourceRoomId: roomId, scopeId: null,
+  originWritableNamespaceId: null,
+};
+const encryptedPolicy: LiveShadowEncryptionTransitionPolicy = {
+  mode: "encrypted_only", revision: 1, shadowBehavior: "strict",
+  shadowEncryptionStartedAt: null, updatedAt: new Date("2026-10-23T00:00:00Z"),
+};
+
+describe("production Human Memory embedding composition", () => {
+  test("keeps marketplace disclosure through mutation effects and keeps direct legacy search", async () => {
+    providerCalls.length = 0;
+    searchCalls.length = 0;
+    const factory = createProductionHumanMemoryRouteFactory({
+      loadPolicy: async () => encryptedPolicy,
+      wakeRecovery: () => {},
+    });
+
+    currentDisclosure = marketplaceDisclosure;
+    const marketplace = await factory(authority, envelope);
+    if (marketplace === null) {
+      throw new Error("Production composition did not assemble marketplace ports");
+    }
+    expect(marketplace.embeddingDisclosure).toBe(marketplaceDisclosure);
+    expect(marketplace).not.toHaveProperty("embeddingConfiguration");
+    const preparedDisclosure = marketplace.embeddingDisclosure;
+    if (preparedDisclosure === undefined) {
+      throw new Error("Production composition dropped the marketplace disclosure");
+    }
+    expect(await marketplace.search({ authority, namespaceIds: [namespaceId],
+      query: "private marketplace query", embeddingDisclosure: preparedDisclosure,
+      includeArchive: false })).toMatchObject({ memoryMode: "namespace" });
+    expect(providerCalls[0]).toEqual(["private marketplace query", undefined,
+      { ...marketplaceSpace, disclosure: marketplaceDisclosure }]);
+    expect(searchCalls).toHaveLength(1);
+
+    currentDisclosure = directDisclosure;
+    const direct = await factory(authority, envelope);
+    if (direct === null) {
+      throw new Error("Production composition did not assemble direct ports");
+    }
+    expect(direct.embeddingDisclosure).toBe(directDisclosure);
+    expect(direct.embeddingConfiguration).toEqual(directSpace);
+    expect(await direct.search({ authority, namespaceIds: [namespaceId],
+      query: "private direct query", includeArchive: false }))
+      .toMatchObject({ memoryMode: "namespace" });
+    expect(providerCalls[1]).toEqual(["private direct query", undefined, directSpace]);
+    expect(searchCalls).toHaveLength(2);
+  });
+});
diff --git a/packages/server/tests/unit-isolated/invitable-rooms.test.ts b/packages/server/tests/unit-isolated/invitable-rooms.test.ts
new file mode 100644
index 000000000..95f9651db
--- /dev/null
+++ b/packages/server/tests/unit-isolated/invitable-rooms.test.ts
@@ -0,0 +1,161 @@
+/**
+ * Hermetic regression coverage for the two invitable-Room listing routes.
+ *
+ * Isolated runner: `mock.module` replacements are process-global. The query
+ * fixture compiles and evaluates the genuine Drizzle `where` expression so an
+ * implementation that merely relies on pre-filtered mock rows cannot pass.
+ */
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import Fastify, { type FastifyInstance } from "fastify";
+import { PgDialect } from "drizzle-orm/pg-core";
+import type { SQL } from "drizzle-orm";
+import * as realDb from "@nautilo/db";
+import * as realTrust from "@nautilo/trust";
+
+const CALLER_ID = "11111111-1111-4111-8111-111111111111";
+const OTHER_ID = "22222222-2222-4222-8222-222222222222";
+const routes = [
+  "/api/invitable-rooms",
+  "/api/invites/invitable-rooms/ignored-agent-id",
+] as const;
+
+type RoomFixture = {
+  roomId: string;
+  label: string;
+  type: string;
+  kind: "private" | "group" | "multi_agent" | "subthread" | "open" | "task" | "access";
+  externalContext: boolean;
+  ownerId: string;
+};
+
+const roomFixtures: readonly RoomFixture[] = [
+  { roomId: "open-own", label: "Own public Room", type: "shared", kind: "open", externalContext: false, ownerId: CALLER_ID },
+  { roomId: "open-other", label: "Other public Room", type: "shared", kind: "open", externalContext: false, ownerId: OTHER_ID },
+  { roomId: "external-open", label: "External public Room", type: "shared", kind: "open", externalContext: true, ownerId: CALLER_ID },
+  { roomId: "private", label: "Private Room", type: "private", kind: "private", externalContext: false, ownerId: CALLER_ID },
+  { roomId: "group", label: "Group Room", type: "shared", kind: "group", externalContext: false, ownerId: CALLER_ID },
+  { roomId: "multi-agent", label: "Multi-agent Room", type: "shared", kind: "multi_agent", externalContext: false, ownerId: CALLER_ID },
+  { roomId: "subthread", label: "Subthread", type: "shared", kind: "subthread", externalContext: false, ownerId: CALLER_ID },
+  { roomId: "task", label: "Task Room", type: "private", kind: "task", externalContext: false, ownerId: CALLER_ID },
+  { roomId: "access", label: "Access Room", type: "private", kind: "access", externalContext: false, ownerId: CALLER_ID },
+];
+
+let capabilities: string[] = [];
+const compiledPredicates: Array<{ sql: string; params: unknown[] }> = [];
+const getUserCapabilities = mock(async (_userId: string) => capabilities);
+const dialect = new PgDialect();
+
+function selectedRows(condition?: SQL): Array<{ roomId: string; label: string; type: string }> {
+  let rows = [...roomFixtures];
+  if (condition !== undefined) {
+    const query = dialect.sqlToQuery(condition.getSQL());
+    compiledPredicates.push({ sql: query.sql, params: query.params });
+    expect(query.sql).not.toContain(" or ");
+
+    for (const match of query.sql.matchAll(/"rooms"\."(kind|external_context|owner_id)" = \$(\d+)/g)) {
+      const column = match[1];
+      const parameterIndex = Number(match[2]) - 1;
+      const value = query.params[parameterIndex];
+      if (column === "kind") rows = rows.filter((row) => row.kind === value);
+      if (column === "external_context") rows = rows.filter((row) => row.externalContext === value);
+      if (column === "owner_id") rows = rows.filter((row) => row.ownerId === value);
+    }
+  }
+  return rows.map(({ roomId, label, type }) => ({ roomId, label, type }));
+}
+
+function roomSelectBuilder() {
+  const execute = (condition?: SQL) => Promise.resolve(selectedRows(condition));
+  return {
+    where: (condition: SQL) => execute(condition),
+    // Preserve Drizzle's awaitable builder behavior so a missing `.where(...)`
+    // executes as an unfiltered query and makes the regression fail visibly.
+    then: <TResult1 = Array<{ roomId: string; label: string; type: string }>, TResult2 = never>(
+      onfulfilled?: ((value: Array<{ roomId: string; label: string; type: string }>) => TResult1 | PromiseLike<TResult1>) | null,
+      onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+    ) => execute().then(onfulfilled, onrejected),
+  };
+}
+
+const db = {
+  select: mock((_selection?: unknown) => ({
+    from: mock((table: unknown) => {
+      if (table !== realDb.rooms) throw new Error("unexpected table in invitable-Room test");
+      return roomSelectBuilder();
+    }),
+  })),
+};
+
+mock.module("@nautilo/db", () => ({ ...realDb, db }));
+mock.module("@nautilo/trust", () => ({ ...realTrust, getUserCapabilities }));
+
+const apps: FastifyInstance[] = [];
+
+async function makeApp(sessionUserId: string | null): Promise<FastifyInstance> {
+  const href = new URL("../../src/routes/invites.ts", import.meta.url).href;
+  const { invitesRoutes } = await import(`${href}?t=${Date.now()}-${Math.random()}`) as typeof import("../../src/routes/invites");
+  const app = Fastify({ logger: false });
+  apps.push(app);
+  app.decorateRequest("sessionUserId", null);
+  app.addHook("preHandler", async (request) => {
+    request.sessionUserId = sessionUserId;
+  });
+  invitesRoutes(app, {
+    ownerId: "bootstrap-owner",
+    securityAuditLogPath: "/unused/invitable-rooms-audit.jsonl",
+    publicInviteBaseUrl: "https://example.test",
+  });
+  await app.ready();
+  return app;
+}
+
+beforeEach(() => {
+  capabilities = [];
+  compiledPredicates.length = 0;
+  getUserCapabilities.mockClear();
+  db.select.mockClear();
+});
+
+afterEach(async () => {
+  await Promise.all(apps.splice(0).map((app) => app.close()));
+});
+
+describe.each([...routes])("GET %s", (url: (typeof routes)[number]) => {
+  test("lists only the caller's internal public Rooms for self-service", async () => {
+    capabilities = ["create_invites"];
+    const response = await (await makeApp(CALLER_ID)).inject({ method: "GET", url });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json<{ rooms: Array<{ roomId: string; label: string; type: string }> }>()).toEqual({
+      rooms: [{ roomId: "open-own", label: "Own public Room", type: "shared" }],
+    });
+    expect(compiledPredicates).toHaveLength(1);
+    expect(compiledPredicates[0]?.params).toEqual(["open", false, CALLER_ID]);
+  });
+
+  test("lets Room managers list internal public Rooms across owners", async () => {
+    capabilities = ["manage_members", "manage_rooms"];
+    const response = await (await makeApp(CALLER_ID)).inject({ method: "GET", url });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json<{ rooms: Array<{ roomId: string; label: string; type: string }> }>()).toEqual({
+      rooms: [
+        { roomId: "open-own", label: "Own public Room", type: "shared" },
+        { roomId: "open-other", label: "Other public Room", type: "shared" },
+      ],
+    });
+    expect(compiledPredicates).toHaveLength(1);
+    expect(compiledPredicates[0]?.params).toEqual(["open", false]);
+  });
+
+  test("preserves unauthenticated and unauthorized responses without querying Rooms", async () => {
+    const unauthenticated = await (await makeApp(null)).inject({ method: "GET", url });
+    const forbidden = await (await makeApp(CALLER_ID)).inject({ method: "GET", url });
+
+    expect(unauthenticated.statusCode).toBe(401);
+    expect(unauthenticated.json<{ error: string }>()).toEqual({ error: "Unauthorized" });
+    expect(forbidden.statusCode).toBe(403);
+    expect(forbidden.json<{ error: string }>()).toEqual({ error: "forbidden" });
+    expect(db.select).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/server/tests/unit-isolated/memory-routes.test.ts b/packages/server/tests/unit-isolated/memory-routes.test.ts
index 891a65926..a36cecff5 100644
--- a/packages/server/tests/unit-isolated/memory-routes.test.ts
+++ b/packages/server/tests/unit-isolated/memory-routes.test.ts
@@ -5,11 +5,19 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import Fastify from "fastify";
 import {
   NautiloApiClient,
+  memoryProcessorRecipientV1Schema,
+  memoryProcessorRecipientV2Schema,
   type MemoryProcessorRecipientV1,
   type NautiloApiFetch,
 } from "@nautilo/api-client";
 import { LatticeCrypto } from "@nautilo/lattice-crypto";
-import { sealForegroundMemoryProcessorRequest } from "@nautilo/lattice-bridge";
+import {
+  encodeMemoryProcessorSearchQueryV2,
+  sealForegroundMemoryProcessorRequest,
+  sealForegroundMemoryProcessorRequestV2,
+  sealForegroundMemoryProcessorSearchQueryV2,
+} from "@nautilo/lattice-bridge";
+import type { MemoryEmbeddingDisclosureV2 } from "@nautilo/lattice-crypto/wire";
 import {
   createHumanMemoryProtectedRoutePorts,
   type HumanMemoryProtectedProductRoutePort,
@@ -511,6 +519,22 @@ describe("memory routes (D234)", () => {
     });
   }
 
+  function marketplaceDisclosure(): MemoryEmbeddingDisclosureV2 {
+    return {
+      contractVersion: 2,
+      canonicalSpace: { provider: "venice", model: "text-embedding-3-large", dimensions: 1536 },
+      processingRoute: { transport: "surplus_marketplace", marketplacePolicyVersion: "surplus-embedding-marketplace-v1",
+        dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] },
+    };
+  }
+
+  async function recipientV2(app: ReturnType<typeof makeApp>) {
+    const response = await app.inject({ method: "GET", url: "/api/memory/processor-recipient/v2" });
+    expect(response.statusCode).toBe(200);
+    expect(response.headers["cache-control"]).toBe("no-store");
+    return memoryProcessorRecipientV2Schema.parse(response.json());
+  }
+
   async function sealedPrepared(
     app: ReturnType<typeof makeApp>,
     prepared: ReturnType<typeof preparedCreatePayload>
@@ -778,6 +802,134 @@ describe("memory routes (D234)", () => {
     expect(searchMemoryMock.mock.calls.length).toBe(0);
   });
 
+  test("keeps the legacy recipient strict-compatible while disclosing the complete marketplace route through V2", async () => {
+    const disclosure = marketplaceDisclosure();
+    const ports = { ...protectedPorts(), embeddingConfiguration: disclosure.canonicalSpace, embeddingDisclosure: disclosure };
+    const app = makeApp(protectedEnvelope(), async () => ports);
+    try {
+      const legacyResponse = await app.inject({ method: "GET", url: "/api/memory/processor-recipient" });
+      expect(legacyResponse.statusCode).toBe(200);
+      expect(legacyResponse.headers["cache-control"]).toBe("no-store");
+      const legacy = memoryProcessorRecipientV1Schema.parse(legacyResponse.json());
+      expect(legacy).not.toHaveProperty("embedding");
+      expect(legacy).not.toHaveProperty("embeddingDisclosure");
+      const versioned = await recipientV2(app);
+      expect(versioned).toEqual({ ...legacy, formatVersion: 2, embedding: disclosure });
+      expect(ports.search).not.toHaveBeenCalled();
+    } finally { await app.close(); }
+  });
+
+  test("preserves the legacy direct descriptor and derives its exact V2 disclosure", async () => {
+    const canonicalSpace = { provider: "openai" as const, model: "text-embedding-3-small", dimensions: 1536 as const };
+    const ports = { ...protectedPorts(), embeddingConfiguration: canonicalSpace };
+    const app = makeApp(protectedEnvelope(), async () => ports);
+    try {
+      const response = await app.inject({ method: "GET", url: "/api/memory/processor-recipient" });
+      const legacy = memoryProcessorRecipientV1Schema.parse(response.json());
+      expect(legacy.embedding).toEqual(canonicalSpace);
+      expect((await recipientV2(app)).embedding).toEqual({ contractVersion: 2, canonicalSpace, processingRoute: { transport: "direct" } });
+    } finally { await app.close(); }
+  });
+
+  test.each(["direct", "surplus_marketplace"] as const)("admits an exact sealed V2 %s query and passes its disclosure to the processor", async (transport) => {
+    const marketplace = marketplaceDisclosure();
+    const disclosure: MemoryEmbeddingDisclosureV2 = transport === "direct"
+      ? { ...marketplace, processingRoute: { transport } } : marketplace;
+    const ports = { ...protectedPorts(), embeddingConfiguration: disclosure.canonicalSpace, embeddingDisclosure: disclosure };
+    const app = makeApp(protectedEnvelope(), async () => ports);
+    try {
+      const recipient = await recipientV2(app);
+      const sealedQueryV2 = await sealForegroundMemoryProcessorSearchQueryV2({ crypto: new LatticeCrypto(), recipient,
+        subjectId: "user-1", query: "  private marketplace query  ", embeddingDisclosure: disclosure });
+      expect(JSON.stringify(sealedQueryV2)).not.toContain("private marketplace query");
+      const response = await app.inject({ method: "POST", url: "/api/memory/search",
+        payload: { sealedQueryV2, mode: "semantic", limit: 10, includeArchive: true } });
+      expect(response.statusCode).toBe(200);
+      expect(ports.search).toHaveBeenCalledTimes(1);
+      expect(ports.search.mock.calls[0]?.[0]).toMatchObject({
+        authority: { userId: "user-1", readableNamespaceIds: [UUID_NS] }, namespaceIds: [UUID_NS],
+        query: "private marketplace query", embeddingDisclosure: disclosure, limit: 10, includeArchive: true,
+      });
+      expect(searchMemoryMock).not.toHaveBeenCalled();
+    } finally { await app.close(); }
+  });
+
+  test.each(["transport", "provider", "model"] as const)("rejects a V2 query after its advertised %s changes before processor access", async (changedField) => {
+    const direct: MemoryEmbeddingDisclosureV2 = { ...marketplaceDisclosure(), processingRoute: { transport: "direct" } };
+    const ports = protectedPorts();
+    let current = direct;
+    const app = makeApp(protectedEnvelope(), async () => ({ ...ports,
+      embeddingConfiguration: current.canonicalSpace, embeddingDisclosure: current }));
+    try {
+      const recipient = await recipientV2(app);
+      const sealedQueryV2 = await sealForegroundMemoryProcessorSearchQueryV2({ crypto: new LatticeCrypto(), recipient,
+        subjectId: "user-1", query: "private stale query", embeddingDisclosure: direct });
+      current = changedField === "transport" ? marketplaceDisclosure()
+        : { ...direct, canonicalSpace: { ...direct.canonicalSpace,
+          ...(changedField === "provider" ? { provider: "openai" as const } : { model: "text-embedding-3-small" }) } };
+      const response = await app.inject({ method: "POST", url: "/api/memory/search",
+        payload: { sealedQueryV2, mode: "semantic" } });
+      expect(response.statusCode).toBe(409);
+      expect(response.body).not.toContain("private stale query");
+      expect(ports.search).not.toHaveBeenCalled();
+      expect(searchMemoryMock).not.toHaveBeenCalled();
+    } finally { await app.close(); }
+  });
+
+  test("rejects malformed or unknown V2 disclosure semantics inside valid sealed carriers before processor access", async () => {
+    const disclosure = marketplaceDisclosure();
+    const ports = { ...protectedPorts(), embeddingDisclosure: disclosure };
+    const app = makeApp(protectedEnvelope(), async () => ports);
+    try {
+      const recipient = await recipientV2(app);
+      const body = { formatVersion: 2, purpose: "memory.query_embedding", query: "private invalid query", embeddingDisclosure: disclosure };
+      const malformed: unknown[] = [
+        { ...body, formatVersion: 1 }, { ...body, purpose: "memory.content_embedding" }, { ...body, extra: true },
+        { ...body, embeddingDisclosure: { ...disclosure, contractVersion: 1 } },
+        { ...body, embeddingDisclosure: { ...disclosure, extra: true } },
+        { ...body, embeddingDisclosure: { ...disclosure, canonicalSpace: { ...disclosure.canonicalSpace, dimensions: 3072 } } },
+        { ...body, embeddingDisclosure: { ...disclosure, processingRoute: { ...disclosure.processingRoute, marketplacePolicyVersion: "unknown" } } },
+        { ...body, embeddingDisclosure: { ...disclosure, processingRoute: { ...disclosure.processingRoute, dataRecipientClasses: ["surplus"] } } },
+        { ...body, embeddingDisclosure: undefined },
+      ];
+      for (const invalid of malformed) {
+        const sealedQueryV2 = await sealForegroundMemoryProcessorRequestV2({ crypto: new LatticeCrypto(), recipient,
+          subjectId: "user-1", purpose: "memory.query_embedding", payload: JSON.stringify(invalid) });
+        const response = await app.inject({ method: "POST", url: "/api/memory/search", payload: { sealedQueryV2, mode: "semantic" } });
+        expect(response.statusCode).toBe(400);
+        expect(response.body).not.toContain("private invalid query");
+      }
+      const sealedQueryV2 = await sealForegroundMemoryProcessorRequestV2({ crypto: new LatticeCrypto(), recipient,
+        subjectId: "user-1", purpose: "memory.query_embedding", payload: "legacy raw plaintext query" });
+      expect((await app.inject({ method: "POST", url: "/api/memory/search", payload: { sealedQueryV2, mode: "semantic" } })).statusCode).toBe(400);
+      expect(ports.search).not.toHaveBeenCalled();
+      expect(searchMemoryMock).not.toHaveBeenCalled();
+    } finally { await app.close(); }
+  });
+
+  test("rejects legacy marketplace queries and V2 subject or purpose substitutions before processor access", async () => {
+    const disclosure = marketplaceDisclosure();
+    const ports = { ...protectedPorts(), embeddingConfiguration: disclosure.canonicalSpace, embeddingDisclosure: disclosure };
+    const app = makeApp(protectedEnvelope(), async () => ports);
+    try {
+      const sealedQuery = await sealFor(app, "memory.query_embedding", "legacy private query");
+      expect((await app.inject({ method: "POST", url: "/api/memory/search", payload: { sealedQuery, mode: "semantic" } })).statusCode).toBe(409);
+      const recipient = await recipientV2(app);
+      for (const binding of [
+        { purpose: "memory.content_embedding" as const, subjectId: "user-1" },
+        { purpose: "memory.query_embedding" as const, subjectId: "other-user" },
+      ]) {
+        const sealedQueryV2 = await sealForegroundMemoryProcessorRequestV2({ crypto: new LatticeCrypto(), recipient, ...binding,
+          payload: encodeMemoryProcessorSearchQueryV2({ formatVersion: 2, purpose: "memory.query_embedding", query: "private subject-bound query", embeddingDisclosure: disclosure }) });
+        const response = await app.inject({ method: "POST", url: "/api/memory/search", payload: { sealedQueryV2, mode: "semantic" } });
+        expect(response.statusCode).toBeGreaterThanOrEqual(400);
+        expect(response.statusCode).toBeLessThan(500);
+      }
+      expect(ports.search).not.toHaveBeenCalled();
+      expect(searchMemoryMock).not.toHaveBeenCalled();
+    } finally { await app.close(); }
+  });
+
   test("executes the dormant Human assembler through the canonical API client", async () => {
     const routeMocks = protectedPorts();
     const semanticProductSearch = mock(async (_input: unknown) => ({
diff --git a/packages/server/tests/unit-isolated/native-task-funding-multiuser.test.ts b/packages/server/tests/unit-isolated/native-task-funding-multiuser.test.ts
index df75be13d..f516f11a1 100644
--- a/packages/server/tests/unit-isolated/native-task-funding-multiuser.test.ts
+++ b/packages/server/tests/unit-isolated/native-task-funding-multiuser.test.ts
@@ -1,5 +1,7 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterAll, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 import { rejects } from "node:assert/strict";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { ToolCatalog, clearToolCatalog, initToolCatalog } from "@nautilo/catalog";
 import type { Task, TaskRun } from "@nautilo/db";
 
 const HUMAN_A = "11111111-1111-4111-8111-111111111111";
@@ -14,6 +16,7 @@ const PARENT_ID = "66666666-6666-4666-8666-666666666666";
 const PARENT_RUN_ID = "77777777-7777-4777-8777-777777777777";
 const SERVER_MODEL = "openrouter:server-model";
 const PERSONAL_MODEL = "openrouter:personal-model";
+const DIRECT_AGENT_MODEL = "openrouter:openai/gpt-5.6-sol";
 const PERSONAL_BINDING = {
   kind: "personal" as const,
   providerRoute: "openrouter",
@@ -24,6 +27,8 @@ const PERSONAL_BINDING = {
 const actualAgent = await import("@nautilo/agent");
 const actualDb = await import("@nautilo/db");
 const actualTrust = await import("@nautilo/trust");
+const actualSurplusRoute = await import("../../../agent/src/providers/surplus-route");
+const actualChatInvocation = await import("../../../agent/src/utils/chat-model-invocation");
 
 let invocationAllowed = true;
 let sourceRoomLive = true;
@@ -113,7 +118,10 @@ mock.module("../../src/lib/model-funding", () => ({
     return input.modelId === PERSONAL_MODEL
       ? { ...PERSONAL_BINDING, humanUserId: input.humanUserId, payerHumanId: input.humanUserId,
           modelId: input.modelId, workload: "native_text_task" as const }
-      : { kind: "server" as const, providerRoute: "openrouter", humanUserId: input.humanUserId,
+      : { kind: "server" as const, providerRoute: input.priorDecision
+          && typeof input.priorDecision === "object" && "providerRoute" in input.priorDecision
+          && input.priorDecision.providerRoute === "surplus" ? "surplus"
+          : input.modelId.startsWith("venice:") ? "venice" : "openrouter", humanUserId: input.humanUserId,
           modelId: input.modelId, workload: "native_text_task" as const };
   },
   withAdmittedPersonalCredential: async (
@@ -264,11 +272,153 @@ describe("multi-user native Task funding", () => {
     taskRows.set(candidate.id, candidate);
     runRows.set(run.id, run);
     const session = await nativeTaskFundingPort.openSession(candidate, run, SERVER_MODEL, false);
+    expect(session.admittedTransport).toBe("direct");
+    expect(session.admission).toBeUndefined();
     invocationAllowed = false;
     await rejects(session.recheckAttempt(SERVER_MODEL), /invocation_access_withdrawn/);
     expect(fundingInputs.every(({ humanUserId }) => humanUserId === HUMAN_A)).toBeTrue();
   });
 
+  test("restored server Surplus sessions expose transport without a foreground snapshot", async () => {
+    const candidate = task();
+    const run = {
+      id: PARENT_RUN_ID,
+      taskId: candidate.id,
+      status: "running",
+      modelId: SERVER_MODEL,
+      graphThreadId: "task-thread",
+      fundingBinding: { kind: "server", providerRoute: "surplus" },
+      fundingPredecessorRunId: null,
+    } as TaskRun;
+    taskRows.set(candidate.id, candidate);
+    runRows.set(run.id, run);
+
+    const session = await nativeTaskFundingPort.openSession(candidate, run, SERVER_MODEL, false);
+
+    expect(session.admittedTransport).toBe("surplus");
+    expect(session.admission).toBeUndefined();
+  });
+
+  test("a foreign Genie's report-back wake retains its native funding and resume boundary", async () => {
+    const wakeModel = "venice:wake-model";
+    const candidate = task({ status: "completed" });
+    const run = {
+      id: PARENT_RUN_ID, taskId: candidate.id, status: "completed",
+      modelId: SERVER_MODEL, graphThreadId: "task-thread",
+      fundingBinding: { kind: "server", providerRoute: "openrouter" },
+      fundingPredecessorRunId: null,
+    } as TaskRun;
+    taskRows.set(candidate.id, candidate);
+    runRows.set(run.id, run);
+
+    const session = await nativeTaskFundingPort.openSession(candidate, run, wakeModel, true);
+
+    // This fixture's Genie is absent from the calling Room. A foreground
+    // snapshot would route approval resume through a stricter Room-member gate.
+    expect(session.admission).toBeUndefined();
+    expect(session.admittedTransport).toBe("direct");
+    expect(await session.runAttempt(wakeModel, async (attempt) => attempt.usageFunding))
+      .toMatchObject({ kind: "server", providerRoute: "venice" });
+    expect(fundingInputs).toHaveLength(2);
+    for (const input of fundingInputs) {
+      expect(input).toMatchObject({ humanUserId: HUMAN_A, modelId: wakeModel,
+        prior: { kind: "server", modelId: SERVER_MODEL, providerRoute: "openrouter" } });
+    }
+  });
+
+  test("a restored direct server admission crosses the real agent-node hydration boundary", async () => {
+    const candidate = task({ requestedModelId: DIRECT_AGENT_MODEL });
+    const run = {
+      id: PARENT_RUN_ID,
+      taskId: candidate.id,
+      status: "running",
+      modelId: DIRECT_AGENT_MODEL,
+      graphThreadId: "task-thread",
+      fundingBinding: { kind: "server", providerRoute: "openrouter" },
+      fundingPredecessorRunId: null,
+    } as TaskRun;
+    taskRows.set(candidate.id, candidate);
+    runRows.set(run.id, run);
+    const session = await nativeTaskFundingPort.openSession(candidate, run, DIRECT_AGENT_MODEL, false);
+    const hydrate = spyOn(actualSurplusRoute, "hydrateSurplusChatCatalog").mockImplementation(async () => {
+      throw new Error("unexpected Surplus catalogue discovery");
+    });
+    const invoke = spyOn(actualChatInvocation, "invokeChatModelWithFallback").mockResolvedValue({
+      response: new AIMessage("Direct provider completed the request."),
+      modelUsed: DIRECT_AGENT_MODEL,
+    });
+    const config = spyOn(actualDb, "getCachedServerModelConfigRow").mockReturnValue({
+      preferSurplus: true,
+    } as ReturnType<typeof actualDb.getCachedServerModelConfigRow>);
+    const previousOpenRouterKey = process.env["OPENROUTER_API_KEY"];
+    const previousSurplusKey = process.env["SURPLUS_API_KEY"];
+    process.env["OPENROUTER_API_KEY"] = "synthetic-direct-key";
+    process.env["SURPLUS_API_KEY"] = "synthetic-surplus-key";
+    initToolCatalog(new ToolCatalog());
+    const prompt = new HumanMessage("Complete this restored direct-provider task.");
+
+    try {
+      const result = await actualAgent.agentNode({
+        model: DIRECT_AGENT_MODEL,
+        subagentDepth: 1,
+        taskRun: true,
+        trustedExecutionEntrypoint: "background.task",
+        modelFallbackMode: "none",
+        preparedMessages: [prompt],
+        messages: [prompt],
+        userId: HUMAN_A,
+        causalHumanUserId: HUMAN_A,
+        agentId: AGENT,
+        roomId: null,
+        turnId: "restored-direct-admission-turn",
+        actorRole: "owner",
+        memoryAccessEnvelope: null,
+        toolWhitelist: [],
+        activatedToolNames: [],
+        activatedToolLeases: [],
+        currentThreadId: "restored-direct-admission-thread",
+        currentFolder: "",
+        workspacePath: "",
+      } as unknown as Parameters<typeof actualAgent.agentNode>[0],
+      undefined, undefined, false, undefined, undefined, session);
+
+      expect(result.model).toBe(DIRECT_AGENT_MODEL);
+      expect(hydrate).not.toHaveBeenCalled();
+      expect(invoke).toHaveBeenCalledTimes(1);
+      expect(invoke.mock.calls[0]?.[7]).toMatchObject({ fundingSession: session });
+    } finally {
+      clearToolCatalog();
+      config.mockRestore();
+      invoke.mockRestore();
+      hydrate.mockRestore();
+      if (previousOpenRouterKey === undefined) delete process.env["OPENROUTER_API_KEY"];
+      else process.env["OPENROUTER_API_KEY"] = previousOpenRouterKey;
+      if (previousSurplusKey === undefined) delete process.env["SURPLUS_API_KEY"];
+      else process.env["SURPLUS_API_KEY"] = previousSurplusKey;
+    }
+  });
+
+  test("restored personal sessions do not gain native admission capabilities", async () => {
+    const candidate = task({ requestedModelId: PERSONAL_MODEL });
+    const run = {
+      id: PARENT_RUN_ID,
+      taskId: candidate.id,
+      status: "running",
+      modelId: PERSONAL_MODEL,
+      graphThreadId: "task-thread",
+      fundingBinding: PERSONAL_BINDING,
+      fundingPredecessorRunId: null,
+    } as TaskRun;
+    taskRows.set(candidate.id, candidate);
+    runRows.set(run.id, run);
+
+    const session = await nativeTaskFundingPort.openSession(candidate, run, PERSONAL_MODEL, false);
+
+    expect(session.kind).toBe("personal");
+    expect(session.admission).toBeUndefined();
+    expect(session.admittedTransport).toBeUndefined();
+  });
+
   test("a server-first native Task exposes bounded personal recovery", async () => {
     fundingPreference = "server_first";
     const candidate = task();
diff --git a/packages/server/tests/unit-isolated/native-task-funding-protected.test.ts b/packages/server/tests/unit-isolated/native-task-funding-protected.test.ts
index 0228de202..4a0062100 100644
--- a/packages/server/tests/unit-isolated/native-task-funding-protected.test.ts
+++ b/packages/server/tests/unit-isolated/native-task-funding-protected.test.ts
@@ -1,4 +1,4 @@
-import { afterAll, describe, expect, mock, test } from "bun:test";
+import { afterAll, afterEach, describe, expect, mock, test } from "bun:test";
 import type { Task, TaskRun } from "@nautilo/db";
 
 const HUMAN = "11111111-1111-4111-8111-111111111111";
@@ -29,6 +29,7 @@ let returnPersonalForServer = false;
 let failServerFundingAt = Number.POSITIVE_INFINITY;
 let fundingRequests: Array<Record<string, unknown>> = [];
 let fundingDecisions: Array<Record<string, unknown>> = [];
+let serverProviderRoutes: readonly string[] = ["anthropic"];
 
 function task(overrides: Partial<Task> = {}): Task {
   return {
@@ -173,7 +174,11 @@ mock.module("../../src/lib/model-funding", () => ({
       throw new TestModelFundingError("server_credentials_forbidden");
     }
     const decision = input["fundingKind"] === "server" && !returnPersonalForServer
-      ? { kind: "server" as const, providerRoute: "anthropic",
+      ? { kind: "server" as const,
+          providerRoute: serverProviderRoutes[Math.min(
+            fundingDecisions.length,
+            serverProviderRoutes.length - 1,
+          )] ?? "anthropic",
           humanUserId: input["humanUserId"], modelId: input["modelId"],
           workload: input["workload"] }
       : { ...binding, humanUserId: HUMAN, payerHumanId: HUMAN,
@@ -202,6 +207,7 @@ const {
 } = await import("../../src/lib/native-task-funding");
 
 afterAll(() => { mock.restore(); });
+afterEach(() => { serverProviderRoutes = ["anthropic"]; });
 
 describe("protected native Task funding", () => {
   test("requires live protected authority and retains it around credential custody", async () => {
@@ -391,7 +397,7 @@ describe("protected native Task funding", () => {
     }
   });
 
-  test("opens a server-pinned legacy wake without caller-only shape or custody", async () => {
+  test("opens a direct server-pinned legacy wake without caller-only shape or custody", async () => {
     currentTask = task({
       ownerId: PEER,
       fundingMode: "legacy_server",
@@ -408,6 +414,7 @@ describe("protected native Task funding", () => {
     });
     fundingRequests = [];
     fundingDecisions = [];
+    serverProviderRoutes = ["surplus", "anthropic"];
     legacyTaskProjectionKeys = [];
     providerAttempts = 0;
     let authorityChecks = 0;
@@ -423,6 +430,8 @@ describe("protected native Task funding", () => {
     });
     expect(session).not.toBeNull();
     expect(session!.kind).toBe("server");
+    expect(session!.admission).toBeUndefined();
+    expect(session!.admittedTransport).toBe("direct");
     expect(session!.capabilityFunding).toBeUndefined();
     expect(await session!.runAttempt(MODEL, async attempt => attempt.usageFunding))
       .toEqual({ kind: "server", providerRoute: "anthropic" });
@@ -458,6 +467,43 @@ describe("protected native Task funding", () => {
     expect(fundingRequests).toHaveLength(4);
   });
 
+  test("opens a Surplus server-pinned legacy wake with the same live server policy", async () => {
+    currentTask = task({ fundingMode: "legacy_server" });
+    currentRun = run({ status: "completed", fundingBinding: null });
+    fundingRequests = [];
+    fundingDecisions = [];
+    serverProviderRoutes = ["anthropic", "surplus"];
+    let authorityChecks = 0;
+    let current = true;
+    const session = await openProtectedTaskWakeFundingSession({
+      taskSource: currentTask,
+      runSource: currentRun,
+      modelId: MODEL,
+      assertCurrent: async () => {
+        authorityChecks += 1;
+        if (!current) throw new Error("protected_authority_revoked");
+      },
+    });
+
+    expect(session).not.toBeNull();
+    expect(session!.admission).toBeUndefined();
+    expect(session!.admittedTransport).toBe("surplus");
+    expect(fundingRequests).toHaveLength(2);
+    expect(fundingRequests.every(request => request["fundingKind"] === "server"
+      && request["workload"] === "native_text_task"
+      && request["humanUserId"] === HUMAN)).toBeTrue();
+    expect(fundingRequests[0]?.["priorDecision"]).toBeUndefined();
+    expect(fundingRequests[1]?.["priorDecision"]).toBe(fundingDecisions[0]);
+    expect(authorityChecks).toBeGreaterThanOrEqual(4);
+
+    current = false;
+    expect(await session!.recheckAttempt(MODEL).then(
+      () => null,
+      (error: unknown) => (error as Error).message,
+    )).toBe("protected_authority_revoked");
+    expect(fundingRequests).toHaveLength(2);
+  });
+
   test("fences legacy funding coordinates and rejects a non-server resolution", async () => {
     const acceptedTask = task({ fundingMode: "legacy_server" });
     const acceptedRun = run({ status: "errored", fundingBinding: null });
diff --git a/packages/server/tests/unit-isolated/peer-broadcast-retained-attachments.test.ts b/packages/server/tests/unit-isolated/peer-broadcast-retained-attachments.test.ts
index a08689738..20b8b508f 100644
--- a/packages/server/tests/unit-isolated/peer-broadcast-retained-attachments.test.ts
+++ b/packages/server/tests/unit-isolated/peer-broadcast-retained-attachments.test.ts
@@ -41,7 +41,8 @@ mock.module("@nautilo/agent", () => ({
     };
   }),
   buildForegroundUserHumanMessage: mock(() => ({})),
-  getDefaultModel: mock(() => ({ id: "model:test" })),
+  getDefaultModel: mock(() => { throw new Error("peer broadcast must not require a runnable model"); }),
+  modelIdForCapabilityProjection: mock(() => "model:test"),
 }));
 
 mock.module("@nautilo/db", () => ({
@@ -51,6 +52,7 @@ mock.module("@nautilo/db", () => ({
       values: () => ({ onConflictDoNothing: async () => undefined }),
     }),
   },
+  getCachedServerModelConfigRow: mock(() => null),
   getSessionMessageFingerprintById: mock(async () => {
     calls.push("fingerprint");
     return fingerprint;
diff --git a/packages/server/tests/unit-isolated/profile-soul-stream-route.test.ts b/packages/server/tests/unit-isolated/profile-soul-stream-route.test.ts
index e9223cdb3..a57f03388 100644
--- a/packages/server/tests/unit-isolated/profile-soul-stream-route.test.ts
+++ b/packages/server/tests/unit-isolated/profile-soul-stream-route.test.ts
@@ -10,6 +10,7 @@ const generateSoulFileMock = mock(async (
   _signal?: AbortSignal,
   _authorization?: unknown,
 ) => "# Generated\n\n## Essence\nA usable generated Soul.\n\n## Tone\nExact.");
+const upsertSoulProfileMock = mock(async (_userId: string, _agentId: string, _data: unknown) => undefined);
 const generateSoulFileStreamMock = mock(
   (
     _input: Partial<SoulFileInput>,
@@ -28,6 +29,7 @@ describe("POST /api/profile/generate-soul/stream", () => {
 
   afterEach(async () => {
     generateSoulFileMock.mockClear();
+    upsertSoulProfileMock.mockClear();
     generateSoulFileStreamMock.mockReset();
     await Promise.all(apps.splice(0).map((app) => app.close()));
   });
@@ -56,7 +58,7 @@ describe("POST /api/profile/generate-soul/stream", () => {
       },
       generateSoulFile: generator,
       generateSoulFileStream: generateSoulFileStreamMock,
-      upsertSoulProfile: async () => undefined,
+      upsertSoulProfile: upsertSoulProfileMock,
     });
     app.addHook("preHandler", async (request) => {
       request.sessionUserId = "test-user";
@@ -90,6 +92,7 @@ describe("POST /api/profile/generate-soul/stream", () => {
     expect(response.body).toContain("# Safe fallback");
     expect(response.body).toContain("Unable to generate a soul file right now; using a fallback.");
     expect(response.body).not.toContain(secret);
+    expect(upsertSoulProfileMock).not.toHaveBeenCalled();
     expect(generateSoulFileStreamMock.mock.calls[0]?.[2]).toMatchObject({
       humanUserId: "test-user",
       agentId: "agent-own",
@@ -117,6 +120,7 @@ describe("POST /api/profile/generate-soul/stream", () => {
     expect(response.statusCode).toBe(200);
     expect(signal).toBeDefined();
     expect(signal?.aborted).toBe(false);
+    expect(upsertSoulProfileMock).not.toHaveBeenCalled();
   });
 
   test("denies before starting the soul provider stream without server funding", async () => {
@@ -141,6 +145,10 @@ describe("POST /api/profile/generate-soul/stream", () => {
     });
     expect(response.statusCode).toBe(200);
     expect(generateSoulFileMock).toHaveBeenCalledTimes(1);
+    expect(upsertSoulProfileMock).toHaveBeenCalledTimes(1);
+    expect(upsertSoulProfileMock).toHaveBeenCalledWith("test-user", "agent-own", {
+      soulFile: "# Generated\n\n## Essence\nA usable generated Soul.\n\n## Tone\nExact.",
+    });
     expect(generateSoulFileMock.mock.calls[0]?.[2]).toMatchObject({
       humanUserId: "test-user",
       agentId: "agent-own",
diff --git a/packages/server/tests/unit/capability-funding.test.ts b/packages/server/tests/unit/capability-funding.test.ts
index 266c3add2..d2f57f3fb 100644
--- a/packages/server/tests/unit/capability-funding.test.ts
+++ b/packages/server/tests/unit/capability-funding.test.ts
@@ -1,4 +1,6 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { installSurplusCatalogFixture } from "../../../agent/tests/helpers/surplus-catalog-fixture";
+import { resetSurplusModelCatalog } from "../../../agent/src/providers/surplus-catalog";
 import { resolveCatalogModel } from "@nautilo/agent";
 import type { PersonalProviderCredentialRecord, PersonalProviderId } from "@nautilo/db";
 import {
@@ -18,6 +20,8 @@ const DECISION_MODEL = "openrouter:typesafe/jev-1.13";
 const RESEARCH_MODEL = "openrouter:anthropic/claude-sonnet-4.6";
 const VISION_MODEL = "anthropic:claude-sonnet-4-6";
 const SUBSCRIPTION_VISION_MODEL = "openai:gpt-5.6-luna";
+beforeEach(installSurplusCatalogFixture);
+afterEach(resetSurplusModelCatalog);
 
 function credential(
   provider: PersonalProviderId,
diff --git a/packages/server/tests/unit/config-model-controls.test.ts b/packages/server/tests/unit/config-model-controls.test.ts
index 866ea0e14..d8beba931 100644
--- a/packages/server/tests/unit/config-model-controls.test.ts
+++ b/packages/server/tests/unit/config-model-controls.test.ts
@@ -274,6 +274,16 @@ describe("caller-scoped model availability", () => {
 
   test("admits a server-funded Surplus-only route without changing personal capability isolation", async () => {
     const modelId = "venice:openai-gpt-55";
+    const route = {
+      catalogModelId: modelId,
+      surplusModelId: "gpt-5.5",
+      providerPin: "venice" as const,
+      supportsTools: true,
+      supportsVision: false,
+      supportsReasoning: false,
+      maxContextTokens: 100_000,
+      maxOutputTokens: 8_000,
+    };
     const result = await resolveCallerModelAvailability(
       "human-1",
       modelId,
@@ -286,6 +296,7 @@ describe("caller-scoped model availability", () => {
           providerRoute: "surplus",
           workload: input.workload,
         }),
+        getQualifiedSurplusChatRoutes: () => [route],
       },
     );
     expect(result).toMatchObject({
@@ -293,6 +304,33 @@ describe("caller-scoped model availability", () => {
       funding: { kind: "server", providerRoute: "surplus" },
       selectableInThisRelease: true,
     });
+    expect(result.model.capabilities).toMatchObject({
+      tools: true,
+      vision: false,
+      reasoning: false,
+      webSearch: false,
+    });
+    expect(result.model.limits).toEqual({ contextTokens: 100_000, outputTokens: 8_000 });
+  });
+
+  test("rejects chat-tools when the confirmed Surplus route lacks tool support", async () => {
+    const modelId = "venice:openai-gpt-55";
+    const result = await resolveCallerModelAvailability("human-1", modelId,
+      { purpose: "chat-tools", env: {} }, {
+        resolveFunding: async (input) => ({ kind: "server", humanUserId: input.humanUserId,
+          modelId: input.modelId, providerRoute: "surplus", workload: input.workload }),
+        getQualifiedSurplusChatRoutes: () => [{
+          catalogModelId: modelId, surplusModelId: "gpt-5.5", providerPin: "venice",
+          supportsTools: false, supportsVision: true, supportsReasoning: true,
+          maxContextTokens: 100_000, maxOutputTokens: 8_000,
+        }],
+      });
+    expect(result.selectableInThisRelease).toBe(false);
+    expect(result.model).toMatchObject({
+      enabled: false,
+      availability: "unsupported-capability",
+      unavailableReason: "model does not support tool/function calling",
+    });
   });
 
   test("server-funded caller rows obey the same tool qualification as model writes", async () => {
diff --git a/packages/server/tests/unit/foreground-chat-preflight.test.ts b/packages/server/tests/unit/foreground-chat-preflight.test.ts
index 14afa9c5e..59900d039 100644
--- a/packages/server/tests/unit/foreground-chat-preflight.test.ts
+++ b/packages/server/tests/unit/foreground-chat-preflight.test.ts
@@ -77,4 +77,22 @@ describe("foreground auxiliary preflight model selection", () => {
     expect(defaultReads).toBe(1);
     expect(result).toMatchObject({ kind: "server", providerRoute: "surplus" });
   });
+
+  test("hydrates Surplus before resolving an automatic default", async () => {
+    const calls: string[] = [];
+    await resolveForegroundChatPreflightFunding({
+      humanUserId: "caller", roomId: "private-room", agentId: "own-genie", turnModelId: null,
+    }, {
+      loadSnapshot: async () => ({ roomSelection: null, agentSelection: null,
+        serverReasoningPolicy: null, turnModelId: null }),
+      getExecutionConfig: async (agentId) => ({ profileId: "profile", userId: "caller", agentId,
+        name: "Genie", defaultModel: null, soulFile: null, soulRevision: 0 }),
+      getPreferSurplus: () => true,
+      getSurplusKeyConfigured: () => true,
+      hydrateSurplusChatCatalog: async () => { calls.push("hydrate"); },
+      defaultForegroundModelId: () => { calls.push("default"); return "openai:default"; },
+      resolveFunding: async (input) => ({ ...input, kind: "server", providerRoute: "surplus" }),
+    });
+    expect(calls).toEqual(["hydrate", "default"]);
+  });
 });
diff --git a/packages/server/tests/unit/human-memory-embedding-processor.test.ts b/packages/server/tests/unit/human-memory-embedding-processor.test.ts
index 1c58c143c..68c278755 100644
--- a/packages/server/tests/unit/human-memory-embedding-processor.test.ts
+++ b/packages/server/tests/unit/human-memory-embedding-processor.test.ts
@@ -39,3 +39,53 @@ describe("Human Memory configured embedding boundary", () => {
     expect(calls).toBe(0);
   });
 });
+
+describe("Human Memory marketplace disclosure boundary", () => {
+  const space = { provider: "venice" as const, model: "text-embedding-3-large", dimensions: 1536 as const };
+  const marketplace = { contractVersion: 2 as const, canonicalSpace: space,
+    processingRoute: { transport: "surplus_marketplace" as const,
+      marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+      dataRecipientClasses: ["surplus", "marketplace_seller", "seller_upstream_processor"] as const } };
+  const currentRequest = { ...request, ...space, contractVersion: 2 as const,
+    embeddingDisclosure: marketplace };
+
+  test("legacy direct approval cannot enter the marketplace even when its model matches", async () => {
+    let calls = 0;
+    const instance = createHumanMemoryEmbeddingProcessor({
+      now: () => 1_100, configuration: () => space, disclosure: () => marketplace,
+      embed: async () => { calls++; throw new Error("must not disclose"); },
+    });
+    expect(await instance.processor.embed({ request: { ...request, ...space },
+      authenticatedSubjectId: request.subjectId })).toEqual({ status: "unavailable", reason: "provider_unavailable" });
+    expect(calls).toBe(0);
+  });
+
+  test("the exact marketplace disclosure reaches the canonical provider owner", async () => {
+    const calls: unknown[][] = [];
+    const instance = createHumanMemoryEmbeddingProcessor({
+      now: () => 1_100, configuration: () => space, disclosure: () => marketplace,
+      embed: async (...args) => {
+        calls.push(args);
+        return { provider: space.provider, canonicalModel: space.model, dimensions: 1536,
+          vector: new Array<number>(1536).fill(0.1), contractVersion: 1 };
+      },
+    });
+    expect(await instance.processor.embed({ request: currentRequest,
+      authenticatedSubjectId: request.subjectId })).toMatchObject({ status: "embedded",
+      embedding: { provider: "venice", canonicalModel: space.model, processorContractVersion: 1 } });
+    expect(calls).toEqual([[request.plaintext, undefined, { ...space, disclosure: marketplace }]]);
+  });
+
+  test("a prepared marketplace request cannot switch to direct during execution", async () => {
+    let calls = 0;
+    const instance = createHumanMemoryEmbeddingProcessor({
+      now: () => 1_100, configuration: () => space,
+      disclosure: () => ({ contractVersion: 2, canonicalSpace: space,
+        processingRoute: { transport: "direct" } }),
+      embed: async () => { calls++; throw new Error("must not disclose"); },
+    });
+    expect(await instance.processor.embed({ request: currentRequest,
+      authenticatedSubjectId: request.subjectId })).toEqual({ status: "unavailable", reason: "provider_unavailable" });
+    expect(calls).toBe(0);
+  });
+});
diff --git a/packages/server/tests/unit/human-memory-mutation-effects.test.ts b/packages/server/tests/unit/human-memory-mutation-effects.test.ts
index fd623568a..9752d028f 100644
--- a/packages/server/tests/unit/human-memory-mutation-effects.test.ts
+++ b/packages/server/tests/unit/human-memory-mutation-effects.test.ts
@@ -42,14 +42,27 @@ describe("Human Memory post-commit effects", () => {
     expect(wake).toHaveBeenCalledTimes(1);
   });
 
-  test("preserves the approved embedding disclosure descriptor", () => {
+  test("preserves the approved embedding disclosure descriptors", () => {
     const embeddingConfiguration = { provider: "openai" as const,
       model: "text-embedding-3-small", dimensions: 1536 as const };
-    const wrapped = withHumanMemoryMutationEffects({
+    const canonicalSpace = { provider: "venice" as const,
+      model: "text-embedding-3-large", dimensions: 1536 as const };
+    const embeddingDisclosure = { contractVersion: 2 as const,
+      canonicalSpace,
+      processingRoute: { transport: "surplus_marketplace" as const,
+        marketplacePolicyVersion: "surplus-embedding-marketplace-v1" as const,
+        dataRecipientClasses: ["surplus", "marketplace_seller",
+          "seller_upstream_processor"] as const } };
+    const direct = withHumanMemoryMutationEffects({
       ports: { ...ports(), embeddingConfiguration },
       deliver: async () => "pending", wakeRecovery: () => {},
     });
-    expect(wrapped.embeddingConfiguration).toEqual(embeddingConfiguration);
+    expect(direct.embeddingConfiguration).toEqual(embeddingConfiguration);
+    const marketplace = withHumanMemoryMutationEffects({
+      ports: { ...ports(), embeddingDisclosure },
+      deliver: async () => "pending", wakeRecovery: () => {},
+    });
+    expect(marketplace.embeddingDisclosure).toBe(embeddingDisclosure);
   });
 
   test("returns the successful exact receipt even if notification or its wake fails", async () => {
diff --git a/packages/server/tests/unit/image-assistance.test.ts b/packages/server/tests/unit/image-assistance.test.ts
index 56bca24db..ba92879d1 100644
--- a/packages/server/tests/unit/image-assistance.test.ts
+++ b/packages/server/tests/unit/image-assistance.test.ts
@@ -76,8 +76,13 @@ describe("automatic caller image selection", () => {
 
   test("a native vision model with an unqualified marketplace image route cannot advertise assistance", async () => {
     const h = harness(["openai:vision"]);
+    const hydrated: string[][] = [];
+    const deps = { ...h.deps, hydrateSurplusChatCatalog: async (input: {
+      readonly catalogModelIds?: readonly string[];
+    } = {}) => { hydrated.push([...(input.catalogModelIds ?? [])]); } };
     expect(await resolveCallerImageInput({ humanUserId: HUMAN, modelId: "openai:vision",
-      funding: { ...decision("openai:vision"), providerRoute: "surplus" } }, h.deps)).toBe("unavailable");
+      funding: { ...decision("openai:vision"), providerRoute: "surplus" } }, deps)).toBe("unavailable");
+    expect(hydrated).toEqual([["openai:vision"]]);
     expect(h.calls).toEqual([]);
   });
 
diff --git a/packages/server/tests/unit/model-funding.test.ts b/packages/server/tests/unit/model-funding.test.ts
index 9be33da4d..4f9f3fea9 100644
--- a/packages/server/tests/unit/model-funding.test.ts
+++ b/packages/server/tests/unit/model-funding.test.ts
@@ -151,6 +151,23 @@ describe("trusted model funding", () => {
     }, h.deps))).toBe("unsupported_workload");
   });
 
+  test("direct-only inference rejects a conflicting Surplus transport", async () => {
+    const h = harness();
+    h.capabilities.set(ALICE, ["use_personal_provider_credentials"]);
+    h.rows.set(`${ALICE}:surplus`, row(ALICE, "surplus"));
+    h.setSurplusEligible(true);
+    const admitted = await resolveModelFunding(request(ALICE), h.deps);
+    expect(admitted).toMatchObject({ kind: "personal", providerRoute: "surplus" });
+    let hydrations = 0;
+    h.deps.getPreferSurplus = () => true;
+    h.deps.hydrateSurplusChatCatalog = async () => { hydrations += 1; };
+
+    expect(await code(resolveModelFunding({
+      ...request(ALICE), priorDecision: admitted, directOnly: true, transport: "surplus",
+    }, h.deps))).toBe("funding_source_changed");
+    expect(hydrations).toBe(0);
+  });
+
   test("API-key-only personal recovery may select Surplus without consulting subscriptions", async () => {
     const h = harness();
     h.capabilities.set(ALICE, ["use_server_provider_credentials", "use_personal_provider_credentials"]);
@@ -228,6 +245,121 @@ describe("trusted model funding", () => {
     })).toBe("venice");
   });
 
+  test("hydrates the requested model before synchronous server-route admission", async () => {
+    const h = harness();
+    const calls: string[] = [];
+    h.capabilities.set(ALICE, ["use_server_provider_credentials"]);
+    h.setFundingPreference("server_first");
+    h.deps.getPreferSurplus = () => true;
+    h.deps.getServerSurplusKeyConfigured = () => true;
+    h.deps.hydrateSurplusChatCatalog = async (input) => {
+      calls.push(`hydrate:${input?.catalogModelIds?.join(",")}`);
+    };
+    h.deps.serverRoute = () => { calls.push("route"); return "surplus"; };
+
+    expect(await resolveModelFunding(request(ALICE), h.deps)).toMatchObject({
+      kind: "server", providerRoute: "surplus",
+    });
+    expect(calls).toEqual([`hydrate:${MODEL}`, "route"]);
+  });
+
+  test("does not hydrate Surplus when policy or server credentials are absent", async () => {
+    const h = harness();
+    let hydrations = 0;
+    h.capabilities.set(ALICE, ["use_server_provider_credentials"]);
+    h.setFundingPreference("server_first");
+    h.deps.getPreferSurplus = () => false;
+    h.deps.getServerSurplusKeyConfigured = () => true;
+    h.deps.hydrateSurplusChatCatalog = async () => { hydrations += 1; };
+    expect((await resolveModelFunding(request(ALICE), h.deps)).kind).toBe("server");
+    h.deps.getPreferSurplus = () => true;
+    h.deps.getServerSurplusKeyConfigured = () => false;
+    expect((await resolveModelFunding(request(ALICE), h.deps)).kind).toBe("server");
+    expect(hydrations).toBe(0);
+  });
+
+  test("hydrates once for a personal Surplus credential when the server key is absent", async () => {
+    const h = harness();
+    let hydrations = 0;
+    h.capabilities.set(ALICE, ["use_personal_provider_credentials"]);
+    h.rows.set(`${ALICE}:surplus`, row(ALICE, "surplus"));
+    h.deps.getPreferSurplus = () => true;
+    h.deps.getServerSurplusKeyConfigured = () => false;
+    h.deps.hydrateSurplusChatCatalog = async (input) => {
+      expect(input?.catalogModelIds).toEqual([MODEL]);
+      hydrations += 1;
+    };
+    h.deps.personalSurplusRoute = () => {
+      expect(hydrations).toBe(1);
+      return true;
+    };
+
+    expect(await resolveModelFunding(request(ALICE), h.deps)).toMatchObject({
+      kind: "personal", providerRoute: "surplus",
+    });
+    expect(hydrations).toBe(1);
+  });
+
+  test("same-model personal direct rechecks stay on their admitted credential without Surplus discovery", async () => {
+    const h = harness();
+    let hydrations = 0;
+    h.capabilities.set(ALICE, ["use_personal_provider_credentials"]);
+    const direct = { ...row(ALICE, "openrouter"), id: "50000000-0000-4000-8000-000000000005" };
+    direct.envelope = encryptPersonalProviderCredential(custody, "caller-direct", direct);
+    h.rows.set(`${ALICE}:openrouter`, direct);
+    const surplus = { ...row(ALICE, "surplus"), id: "60000000-0000-4000-8000-000000000006" };
+    surplus.envelope = encryptPersonalProviderCredential(custody, "marketplace", surplus);
+    h.rows.set(`${ALICE}:surplus`, surplus);
+    h.deps.getPreferSurplus = () => true;
+    h.deps.hydrateSurplusChatCatalog = async () => {
+      hydrations += 1;
+      if (hydrations > 1) h.setSurplusEligible(true);
+    };
+
+    const admitted = await resolveModelFunding(request(ALICE), h.deps);
+    expect(admitted).toMatchObject({
+      kind: "personal", providerRoute: "openrouter", credentialId: direct.id,
+    });
+
+    const rechecked = await resolveModelFunding({ ...request(ALICE), priorDecision: admitted }, h.deps);
+    expect(rechecked).toEqual(admitted);
+    if (rechecked.kind !== "personal") throw new Error("Expected personal funding");
+    expect(await withAdmittedPersonalProviderKey(rechecked, (key) => key, h.deps, admitted))
+      .toBe("caller-direct");
+    expect(hydrations).toBe(1);
+    expect(h.reads).toEqual([
+      `${ALICE}:surplus`,
+      `${ALICE}:openrouter`,
+      `${ALICE}:openrouter`,
+      `${ALICE}:openrouter`,
+      `${ALICE}:openrouter`,
+    ]);
+
+    expect(await code(resolveModelFunding({
+      ...request(ALICE), priorDecision: admitted, transport: "surplus",
+    }, h.deps))).toBe("funding_source_changed");
+    expect(hydrations).toBe(1);
+  });
+
+  test("same-model server direct rechecks skip irrelevant Surplus discovery", async () => {
+    const h = harness();
+    let preferSurplus = false;
+    let hydrations = 0;
+    h.setFundingPreference("server_first");
+    h.capabilities.set(ALICE, ["use_server_provider_credentials"]);
+    h.deps.getPreferSurplus = () => preferSurplus;
+    h.deps.getServerSurplusKeyConfigured = () => true;
+    h.deps.hydrateSurplusChatCatalog = async () => { hydrations += 1; };
+
+    const admitted = await resolveModelFunding(request(ALICE), h.deps);
+    expect(admitted).toMatchObject({ kind: "server", providerRoute: "openrouter" });
+
+    preferSurplus = true;
+    expect(await resolveModelFunding({ ...request(ALICE), priorDecision: admitted }, h.deps))
+      .toEqual(admitted);
+    expect(hydrations).toBe(0);
+  });
+
   test("native text Tasks admit independently and pin their own source", async () => {
     const h = harness();
     h.capabilities.set(ALICE, ["use_server_provider_credentials", "use_personal_provider_credentials"]);
@@ -657,6 +789,19 @@ describe("personal marketplace transport funding", () => {
     h.rows.set(`${ALICE}:surplus`, row(ALICE, "surplus", 2));
     expect(await code(resolveModelFunding({ ...request(ALICE), priorDecision: admitted, transport: "direct" }, h.deps))).toBe("personal_credential_stale");
   });
+  test("same-model marketplace rechecks stay pinned until an explicit direct recovery", async () => {
+    const h = harness(); h.setSurplusEligible(true); h.capabilities.set(ALICE, ["use_personal_provider_credentials"]);
+    h.rows.set(`${ALICE}:surplus`, row(ALICE, "surplus"));
+    h.rows.set(`${ALICE}:openrouter`, row(ALICE, "openrouter"));
+    const admitted = await resolveModelFunding(request(ALICE), h.deps);
+    expect(admitted).toMatchObject({ kind: "personal", providerRoute: "surplus" });
+    expect(await resolveModelFunding({ ...request(ALICE), priorDecision: admitted }, h.deps))
+      .toEqual(admitted);
+
+    h.setSurplusEligible(false);
+    expect(await code(resolveModelFunding({ ...request(ALICE), priorDecision: admitted }, h.deps)))
+      .toBe("personal_credential_missing");
+  });
   test("missing direct fallback never borrows a server credential", async () => {
     const h = harness(); h.setSurplusEligible(true); h.capabilities.set(ALICE, ["use_personal_provider_credentials", "use_server_provider_credentials"]);
     h.rows.set(`${ALICE}:surplus`, row(ALICE, "surplus"));
diff --git a/packages/server/tests/unit/server-models-route.test.ts b/packages/server/tests/unit/server-models-route.test.ts
index e37ec3812..cf25f3e4b 100644
--- a/packages/server/tests/unit/server-models-route.test.ts
+++ b/packages/server/tests/unit/server-models-route.test.ts
@@ -397,7 +397,7 @@ describe("server-models route authorization, partial writes, and audit", () => {
       .toEqual({ status: 403, body: { error: "admin only" } });
   });
 
-  test("projects signed chat models across supported providers through Surplus only while policy and key are enabled", async () => {
+  test("keeps signed chat models unavailable until vendor discovery confirms exact routes", async () => {
     const directCredentialKeys = [
       "ANTHROPIC_API_KEY",
       "OPENAI_API_KEY",
@@ -425,6 +425,7 @@ describe("server-models route authorization, partial writes, and audit", () => {
           listMediaModels,
           getEffectiveMediaModel: () => null,
           getSurplusKeyConfigured: () => surplusKeyConfigured,
+          getQualifiedSurplusChatRoutes: () => [],
         });
         const response = await call("GET", { ...requestBase, sessionUserId: "viewer" });
         expect(response.status).toBe(200);
@@ -438,7 +439,7 @@ describe("server-models route authorization, partial writes, and audit", () => {
       const enabled = await read(true);
       expect(enabled).toMatchObject({
         preferSurplus: true,
-        surplus: { keyConfigured: true, policyEnabled: true, chatStatus: "available" },
+        surplus: { keyConfigured: true, policyEnabled: true, chatStatus: "not-qualified" },
       });
       for (const id of [
         "anthropic:claude-sonnet-4-6",
@@ -449,7 +450,7 @@ describe("server-models route authorization, partial writes, and audit", () => {
         "venice:kimi-k3",
       ]) {
         expect(enabled.catalogModels.find((model) => model.id === id), id)
-          .toMatchObject({ availability: "selectable" });
+          .toMatchObject({ availability: "missing_credentials" });
       }
       expect(enabled.catalogModels.find((model) => model.id === "openrouter:typesafe/jev-1.13"))
         .toMatchObject({ availability: "selectable" });
@@ -474,7 +475,7 @@ describe("server-models route authorization, partial writes, and audit", () => {
       const disabled = await read(false);
       expect(disabled).toMatchObject({
         preferSurplus: false,
-        surplus: { keyConfigured: true, policyEnabled: false, chatStatus: "qualified-unavailable" },
+        surplus: { keyConfigured: true, policyEnabled: false, chatStatus: "not-qualified" },
       });
       for (const id of [
         "anthropic:claude-sonnet-4-6",
@@ -495,7 +496,7 @@ describe("server-models route authorization, partial writes, and audit", () => {
       const missingKey = await read(true, false);
       expect(missingKey).toMatchObject({
         preferSurplus: true,
-        surplus: { keyConfigured: false, policyEnabled: true, chatStatus: "qualified-unavailable" },
+        surplus: { keyConfigured: false, policyEnabled: true, chatStatus: "not-qualified" },
       });
       for (const id of [
         "anthropic:claude-sonnet-4-6",
@@ -545,6 +546,26 @@ describe("server-models route authorization, partial writes, and audit", () => {
       .toMatchObject({ availability: "selectable" });
   });
 
+  test("awaits discovery before constructing an enabled Surplus projection", async () => {
+    const calls: string[] = [];
+    const call = routeHarness({
+      getCapabilities: async () => ["read_server_settings"],
+      getDb: () => ({}) as never,
+      getConfig: async () => ({ ...modelConfig, preferSurplus: true }),
+      refreshConfigCache: async () => null,
+      getEffectiveEmbeddingModel: () => null,
+      getActiveEmbeddingSelection: () => null,
+      listMediaModels,
+      getEffectiveMediaModel: () => null,
+      getSurplusKeyConfigured: () => true,
+      hydrateSurplusChatCatalog: async () => { calls.push("hydrate"); },
+      listImageUnderstandingModels: () => { calls.push("project"); return []; },
+    });
+    expect((await call("GET", { ...requestBase, sessionUserId: "viewer" })).status).toBe(200);
+    expect(calls.filter((call) => call === "hydrate").length).toBeGreaterThanOrEqual(1);
+    expect(calls.indexOf("hydrate")).toBeLessThan(calls.indexOf("project"));
+  });
+
   test("catalog inventory includes decision models and live missing-credential reasons without admitting them for chat", async () => {
     const previous = process.env["OPENROUTER_API_KEY"];
     configureRuntimeModelCatalog({ catalogPointerUrl: null });
@@ -864,6 +885,7 @@ test("embedding selection distinguishes inheritance, automatic, and qualified cr
     expect(parseUpdateBodyForTests({ embeddingModel: "venice:text-embedding-qwen3-8b" })).toEqual({ ok: true, patch: { embeddingModel: "venice:text-embedding-qwen3-8b" } });
     expect(parseUpdateBodyForTests({ embeddingModel: "openrouter:qwen/qwen3-embedding-8b" })).toEqual({ ok: true, patch: { embeddingModel: "openrouter:qwen/qwen3-embedding-8b" } });
     expect(parseUpdateBodyForTests({ embeddingModel: "venice:text-embedding-3-small" })).toEqual({ ok: true, patch: { embeddingModel: "venice:text-embedding-3-small" } });
+    expect(parseUpdateBodyForTests({ embeddingModel: "venice:text-embedding-3-large" })).toEqual({ ok: true, patch: { embeddingModel: "venice:text-embedding-3-large" } });
     for (const embeddingModel of [false, "venice:bge-m3", KNOWN_MODEL, "text-embedding-3-small"]) {
       expect(parseUpdateBodyForTests({ embeddingModel }).ok).toBe(false);
     }
@@ -892,7 +914,7 @@ test("embedding GET reports actual runtime selection and pending state after a f
   expect(body.embeddingModels.map((entry) => entry.id)).toEqual([
     "venice:text-embedding-qwen3-8b", "openrouter:qwen/qwen3-embedding-8b",
     "venice:text-embedding-3-small", "openrouter:openai/text-embedding-3-small",
-    "openai:text-embedding-3-small",
+    "openai:text-embedding-3-small", "venice:text-embedding-3-large",
   ]);
   expect(body.embeddingModels.map((entry) => entry.displayName)).toEqual([
     "Venice — text-embedding-qwen3-8b (1,536 dimensions)",
@@ -900,6 +922,7 @@ test("embedding GET reports actual runtime selection and pending state after a f
     "Venice — text-embedding-3-small (1,536 dimensions)",
     "OpenRouter — openai/text-embedding-3-small (1,536 dimensions)",
     "OpenAI — text-embedding-3-small (1,536 dimensions)",
+    "Venice — text-embedding-3-large (1,536 dimensions)",
   ]);
   expect(refreshCount).toBe(1);
 });
diff --git a/packages/server/tests/unit/setup-status-surplus-readiness.test.ts b/packages/server/tests/unit/setup-status-surplus-readiness.test.ts
index ef2af16cb..194701e80 100644
--- a/packages/server/tests/unit/setup-status-surplus-readiness.test.ts
+++ b/packages/server/tests/unit/setup-status-surplus-readiness.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, mock, test } from "bun:test";
 import type { QualifiedSurplusChatRoute } from "@nautilo/agent";
-import { computeSetupHasLlm } from "../../src/routes/setup-status";
+import { computeSetupHasLlm, hydrateSetupSurplusReadiness } from "../../src/routes/setup-status";
 
 const QUALIFIED_TOOL_ROUTE: QualifiedSurplusChatRoute = {
   catalogModelId: "venice:openai-gpt-55",
@@ -14,9 +14,7 @@ const QUALIFIED_TOOL_ROUTE: QualifiedSurplusChatRoute = {
 };
 
 const NON_REASONING_TOOL_ROUTE: QualifiedSurplusChatRoute = {
-  catalogModelId: "google:gemini-2.5-pro",
-  surplusModelId: "gemini-2.5-pro",
-  providerPin: "google-ai-studio",
+  ...QUALIFIED_TOOL_ROUTE,
   supportsTools: true,
   supportsVision: false,
   supportsReasoning: false,
@@ -31,6 +29,17 @@ const FULL_BUDGET_REASONING_ROUTE: QualifiedSurplusChatRoute = {
   maxOutputTokens: 131_072,
 };
 
+const QUALIFIED_SONNET_ROUTE: QualifiedSurplusChatRoute = {
+  catalogModelId: "openrouter:anthropic/claude-sonnet-4.6",
+  surplusModelId: "anthropic/claude-sonnet-4.6",
+  providerPin: "openrouter",
+  supportsTools: true,
+  supportsVision: true,
+  supportsReasoning: true,
+  maxContextTokens: 1_000_000,
+  maxOutputTokens: 64_000,
+};
+
 const CLAIMED_AUTHENTICATED = {
   directProviderReady: false,
   authenticated: true,
@@ -38,11 +47,28 @@ const CLAIMED_AUTHENTICATED = {
 } as const;
 
 describe("Surplus setup readiness", () => {
-  test("accepts a derived signed route when Surplus policy and credentials are ready", () => {
+  test("fails closed when vendor discovery confirms no exact route", () => {
     expect(computeSetupHasLlm(CLAIMED_AUTHENTICATED, {
       getPreferSurplus: () => true,
       getSurplusKeyConfigured: () => true,
-    })).toBe(true);
+      getQualifiedSurplusChatRoutes: () => [],
+    })).toBe(false);
+  });
+
+  test("hydrates only for an authenticated claimed server with active policy and credentials", async () => {
+    const hydrate = mock(async () => {});
+    await hydrateSetupSurplusReadiness(CLAIMED_AUTHENTICATED, {
+      getPreferSurplus: () => true,
+      getSurplusKeyConfigured: () => true,
+      hydrateSurplusChatCatalog: hydrate,
+    });
+    expect(hydrate).toHaveBeenCalledTimes(1);
+    await hydrateSetupSurplusReadiness({ ...CLAIMED_AUTHENTICATED, directProviderReady: true }, {
+      getPreferSurplus: () => true,
+      getSurplusKeyConfigured: () => true,
+      hydrateSurplusChatCatalog: hydrate,
+    });
+    expect(hydrate).toHaveBeenCalledTimes(1);
   });
 
   test("requires enabled policy and a configured server credential", () => {
@@ -59,13 +85,13 @@ describe("Surplus setup readiness", () => {
     })).toBe(false);
   });
 
-  test("does not treat the limited non-reasoning pilot as ordinary Room readiness", () => {
+  test("accepts a qualified lower output budget when it leaves input context", () => {
     const deps = {
       getPreferSurplus: () => true,
       getSurplusKeyConfigured: () => true,
       getQualifiedSurplusChatRoutes: () => [QUALIFIED_TOOL_ROUTE],
     };
-    expect(computeSetupHasLlm(CLAIMED_AUTHENTICATED, deps)).toBe(false);
+    expect(computeSetupHasLlm(CLAIMED_AUTHENTICATED, deps)).toBe(true);
   });
 
   test("accepts a signed non-reasoning route with tools and the full default budget", () => {
@@ -83,7 +109,7 @@ describe("Surplus setup readiness", () => {
       getQualifiedSurplusChatRoutes: () => [{
         ...QUALIFIED_TOOL_ROUTE,
         supportsTools: false,
-      }, NON_REASONING_TOOL_ROUTE],
+      }, QUALIFIED_SONNET_ROUTE],
     })).toBe(true);
   });
 
@@ -96,6 +122,14 @@ describe("Surplus setup readiness", () => {
     expect(computeSetupHasLlm(CLAIMED_AUTHENTICATED, deps)).toBe(true);
   });
 
+  test("accepts the exact Sonnet route at its qualified Surplus output budget", () => {
+    expect(computeSetupHasLlm(CLAIMED_AUTHENTICATED, {
+      getPreferSurplus: () => true,
+      getSurplusKeyConfigured: () => true,
+      getQualifiedSurplusChatRoutes: () => [QUALIFIED_SONNET_ROUTE],
+    })).toBe(true);
+  });
+
   test("rejects a tool-unsupported route even when its budget fits", () => {
     expect(computeSetupHasLlm(CLAIMED_AUTHENTICATED, {
       getPreferSurplus: () => true,
@@ -107,6 +141,17 @@ describe("Surplus setup readiness", () => {
     })).toBe(false);
   });
 
+  test("accepts a positive route context when runtime clamps output to remaining context", () => {
+    expect(computeSetupHasLlm(CLAIMED_AUTHENTICATED, {
+      getPreferSurplus: () => true,
+      getSurplusKeyConfigured: () => true,
+      getQualifiedSurplusChatRoutes: () => [{
+        ...NON_REASONING_TOOL_ROUTE,
+        maxContextTokens: NON_REASONING_TOOL_ROUTE.maxOutputTokens,
+      }],
+    })).toBe(true);
+  });
+
   test("does not inspect policy or provider keys for guests or unclaimed servers", () => {
     const getPreferSurplus = mock(() => true);
     const getSurplusKeyConfigured = mock(() => true);
diff --git a/packages/server/tests/unit/surplus-cost-reconciliation.test.ts b/packages/server/tests/unit/surplus-cost-reconciliation.test.ts
index adfdadf17..00542c9ba 100644
--- a/packages/server/tests/unit/surplus-cost-reconciliation.test.ts
+++ b/packages/server/tests/unit/surplus-cost-reconciliation.test.ts
@@ -34,6 +34,158 @@ function createRecovery(
 }
 
 describe("Surplus automatic financial recovery", () => {
+  test("recovers a qualified embedding receipt with its observed serving provider", async () => {
+    const writes: unknown[] = [];
+    let genericReads = 0;
+    let embeddingReads = 0;
+    const embedding = {
+      ...row,
+      endpoint: "/v1/embeddings",
+      callType: "embedding",
+      provider: "venice",
+      model: "venice:text-embedding-3-large",
+      servingProvider: "mordiem",
+      metadata: {
+        catalogModelId: "venice:text-embedding-3-large",
+        surplusModelId: "text-embedding-3-large",
+        surplusEmbeddingPolicy: "surplus-embedding-marketplace-v1",
+        surplusEmbeddingDimensions: 1_536,
+        surplusEmbeddingReceiptModel: "venice-embed-1",
+        surplusEmbeddingServingProviders: ["mordiem", "venice"],
+        surplusCredentialFingerprint: surplusCredentialFingerprint(key),
+      },
+    } satisfies SurplusPendingAttempt;
+    const recovery = createRecovery({
+      list: async () => [embedding],
+      resolveCredential: () => available(),
+      fetchCost: async () => {
+        genericReads++;
+        return { status: "settled", costMicro: 0 };
+      },
+      fetchEmbeddingCost: async (input) => {
+        embeddingReads++;
+        expect(input).toMatchObject({
+          requestId: embedding.providerRequestId,
+          expectedReceiptModel: "venice-embed-1",
+          knownServingProviders: ["mordiem", "venice"],
+          observedServingProvider: "mordiem",
+        });
+        return { status: "settled", costMicro: 0 };
+      },
+      settle: async (input) => { writes.push(input); return true; },
+    });
+    recovery.wake();
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    await recovery.stop();
+    expect(genericReads).toBe(0);
+    expect(embeddingReads).toBe(1);
+    expect(writes).toEqual([{
+      attemptId: embedding.id,
+      providerRequestId: embedding.providerRequestId,
+      expectedUpdatedAtToken: embedding.updatedAtToken,
+      actualCostUsd: 0,
+    }]);
+  });
+
+  test("blocks an embedding recovery row whose immutable route binding drifted", async () => {
+    let reads = 0;
+    const classifications: unknown[] = [];
+    const baseEmbedding = {
+      ...row,
+      endpoint: "/v1/embeddings",
+      callType: "embedding",
+      provider: "venice",
+      model: "venice:text-embedding-3-large",
+      servingProvider: "mordiem",
+      metadata: {
+        catalogModelId: "venice:text-embedding-3-large",
+        surplusModelId: "text-embedding-3-large",
+        surplusEmbeddingPolicy: "surplus-embedding-marketplace-v1",
+        surplusEmbeddingDimensions: 1_536,
+        surplusEmbeddingReceiptModel: "venice-embed-1",
+        surplusEmbeddingServingProviders: ["mordiem", "venice"],
+        surplusCredentialFingerprint: surplusCredentialFingerprint(key),
+      },
+    } satisfies SurplusPendingAttempt;
+    const rows = [
+      { ...baseEmbedding, model: "venice:text-embedding-3-small" },
+      { ...baseEmbedding, servingProvider: "unknown" },
+      { ...baseEmbedding, metadata: { ...baseEmbedding.metadata,
+        surplusEmbeddingReceiptModel: "another-model" } },
+      { ...baseEmbedding, fundingKind: "personal" },
+      { ...baseEmbedding, callType: "chat" },
+    ] satisfies SurplusPendingAttempt[];
+    const recovery = createRecovery({
+      list: async () => rows,
+      resolveCredential: () => available(),
+      fetchEmbeddingCost: async () => {
+        reads++;
+        return { status: "settled", costMicro: 0 };
+      },
+      classify: async (input) => { classifications.push(input); return true; },
+    });
+    recovery.wake();
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    await recovery.stop();
+    expect(reads).toBe(0);
+    expect(classifications).toHaveLength(5);
+    expect(classifications.every((input) => (
+      input as { failureCode: string }
+    ).failureCode === "receipt_binding_invalid")).toBe(true);
+  });
+
+  test("default embedding receipt read requires its canonical receipt alias and provider", async () => {
+    const originalFetch = globalThis.fetch;
+    const embedding = {
+      ...row,
+      endpoint: "/v1/embeddings",
+      callType: "embedding",
+      provider: "venice",
+      model: "venice:text-embedding-3-large",
+      servingProvider: "mordiem",
+      metadata: {
+        catalogModelId: "venice:text-embedding-3-large",
+        surplusModelId: "text-embedding-3-large",
+        surplusEmbeddingPolicy: "surplus-embedding-marketplace-v1",
+        surplusEmbeddingDimensions: 1_536,
+        surplusEmbeddingReceiptModel: "venice-embed-1",
+        surplusEmbeddingServingProviders: ["mordiem", "venice"],
+        surplusCredentialFingerprint: surplusCredentialFingerprint(key),
+      },
+    } satisfies SurplusPendingAttempt;
+    const writes: unknown[] = [];
+    try {
+      globalThis.fetch = (async (input, init) => {
+        const url = typeof input === "string" ? input
+          : input instanceof URL ? input.href : input.url;
+        expect(url).toEndWith(`/v1/requests/${embedding.providerRequestId}`);
+        expect(init?.redirect).toBe("error");
+        return Response.json({
+          request_id: embedding.providerRequestId,
+          model: "venice-embed-1",
+          provider: "mordiem",
+          settlement_status: "accrued",
+          settlement_type: "credit",
+          settlement_error: null,
+          confirmed_at: "2026-10-21T12:00:00.000Z",
+          buyer_cost_micro: 0,
+        });
+      }) as typeof fetch;
+      const recovery = createRecovery({
+        list: async () => [embedding],
+        resolveCredential: () => available(),
+        settle: async (input) => { writes.push(input); return true; },
+      });
+      recovery.wake();
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      await recovery.stop();
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+    expect(writes).toHaveLength(1);
+    expect(writes[0]).toMatchObject({ actualCostUsd: 0 });
+  });
+
   test("image recovery uses exact model/account proof without an invented processor pin", async () => {
     const writes: unknown[] = [];
     const media = { ...row, endpoint: "/v1/images/generations", provider: "venice", model: "venice:gpt-image-2",
diff --git a/packages/trust/src/eligible-models-types.ts b/packages/trust/src/eligible-models-types.ts
index a034cda26..e00afc738 100644
--- a/packages/trust/src/eligible-models-types.ts
+++ b/packages/trust/src/eligible-models-types.ts
@@ -270,6 +270,11 @@ export interface EligibleModel {
   enabled: boolean;
   routing?: RoutingClass;
   capabilities: EligibleModelCapabilities;
+  /** Effective request limits after intersecting catalog policy with the serving route. */
+  limits?: {
+    contextTokens: number;
+    outputTokens: number;
+  };
   /** Caller-authorized image input, including automatic assistance. */
   imageInput?: "direct" | "assisted" | "unavailable";
   /** public projection of reviewed catalog controls; no provider selectors/provenance. */
diff --git a/packaging/docker/runtime-install/bun.lock b/packaging/docker/runtime-install/bun.lock
index 765d1f0a8..cc7ae0ec3 100644
--- a/packaging/docker/runtime-install/bun.lock
+++ b/packaging/docker/runtime-install/bun.lock
@@ -53,6 +53,7 @@
         "@nautilo/db": "workspace:*",
         "@nautilo/fonts": "workspace:*",
         "@nautilo/lattice-bridge": "workspace:*",
+        "@nautilo/lattice-crypto": "workspace:*",
         "@nautilo/loffice": "workspace:*",
         "@nautilo/logger": "workspace:*",
         "@nautilo/message-invariants": "workspace:*",
diff --git a/packaging/docker/runtime-install/packages/agent/package.json b/packaging/docker/runtime-install/packages/agent/package.json
index 5ab66d77a..d4ac36dab 100644
--- a/packaging/docker/runtime-install/packages/agent/package.json
+++ b/packaging/docker/runtime-install/packages/agent/package.json
@@ -30,6 +30,7 @@
     "@nautilo/db": "workspace:*",
     "@nautilo/fonts": "workspace:*",
     "@nautilo/lattice-bridge": "workspace:*",
+    "@nautilo/lattice-crypto": "workspace:*",
     "@nautilo/loffice": "workspace:*",
     "@nautilo/logger": "workspace:*",
     "@nautilo/message-invariants": "workspace:*",