@yanlinglabs/winter-runtime-sdk 0.0.1 → 0.0.2

package/dist/index.js

@@ -27,7 +27,7 @@ class RuntimeHandoffRequiredError extends RuntimeSdkError {
 class RuntimeLaunchInputError extends RuntimeSdkError {
   field;
   constructor(args) {
-    super(`winter-runtime-sdk: the official leg needs \`${args.field}\` — ${args.reason}`);
+    super(`winter-runtime-sdk: ${args.leg === undefined ? "" : `the ${args.leg} leg: `}\`${args.field}\` — ${args.reason}`);
     this.field = args.field;
   }
 }
@@ -68,6 +68,7 @@ class RuntimeSdkDisposedError extends RuntimeSdkError {
 
 // src/door.ts
 import { buildChildAddress, buildSessionAddress, serializeRuntimeAddress } from "@yanlinglabs/winter-agent-sdk/messaging";
+import { transcriptSourceForSessionKey } from "@yanlinglabs/winter-agent-sdk/tools";
 
 // src/official/branding.ts
 function officialBranchLabel(brand) {
@@ -76,95 +77,11 @@ function officialBranchLabel(brand) {
 
 // src/official/aliases.ts
 import { mcpToolName } from "@yanlinglabs/winter-agent-sdk";
-
-// src/native-args.ts
-import { validateToField } from "@yanlinglabs/winter-agent-sdk/messaging";
-var SEND_MESSAGE_TO_MAX = 300;
-var SEND_MESSAGE_SUMMARY_MAX = 200;
-var LIST_AGENTS_FIELD_MAX = 256;
-var NATIVE_SEND_MESSAGE_SCHEMA = {
-  type: "object",
-  properties: {
-    to: { type: "string", maxLength: SEND_MESSAGE_TO_MAX, description: 'no newline, no "*" broadcast' },
-    message: { type: "string", description: 'required; defaults "" for pure idle subscription' },
-    summary: { type: "string", maxLength: SEND_MESSAGE_SUMMARY_MAX },
-    notify_when_idle: { type: "boolean", description: "one-shot; main conversation -> same-machine session only" }
-  },
-  required: ["to", "message"]
-};
-var NATIVE_LIST_AGENTS_SCHEMA = {
-  type: "object",
-  properties: {
-    channel: { type: "string", maxLength: LIST_AGENTS_FIELD_MAX, description: "reserved" },
-    q: { type: "string", maxLength: LIST_AGENTS_FIELD_MAX, description: "reserved" }
-  }
-};
-var NATIVE_LIST_AGENTS_OUTPUT_SCHEMA = {
-  type: "object",
-  properties: { listing: { type: "string" } },
-  required: ["listing"]
-};
-var SEND_MESSAGE_FIELDS = new Set(Object.keys(NATIVE_SEND_MESSAGE_SCHEMA.properties));
-var LIST_AGENTS_FIELDS = new Set(Object.keys(NATIVE_LIST_AGENTS_SCHEMA.properties));
-function acceptNativeSendMessageArgs(input) {
-  if (typeof input !== "object" || input === null)
-    return { ok: false, reason: "expected an object of SendMessage arguments" };
-  const record = input;
-  const extra = Object.keys(record).filter((key) => !SEND_MESSAGE_FIELDS.has(key));
-  if (extra.length > 0)
-    return { ok: false, reason: `unknown argument(s): ${extra.join(", ")}` };
-  const to = record["to"];
-  const validated = validateToField(to);
-  if (!validated.ok)
-    return { ok: false, reason: validated.message };
-  const message = record["message"];
-  if (typeof message !== "string")
-    return { ok: false, reason: "`message` is required and must be a string (an empty string is a pure idle subscription)" };
-  const summary = record["summary"];
-  if (summary !== undefined && (typeof summary !== "string" || summary.length > SEND_MESSAGE_SUMMARY_MAX)) {
-    return { ok: false, reason: `\`summary\` must be a string of at most ${SEND_MESSAGE_SUMMARY_MAX} characters` };
-  }
-  const notify = record["notify_when_idle"];
-  if (notify !== undefined && typeof notify !== "boolean")
-    return { ok: false, reason: "`notify_when_idle` must be a boolean" };
-  return {
-    ok: true,
-    args: {
-      to,
-      message,
-      ...summary === undefined ? {} : { summary },
-      ...notify === undefined ? {} : { notify_when_idle: notify }
-    }
-  };
-}
-function acceptNativeListAgentsArgs(input) {
-  if (input === undefined || input === null)
-    return { ok: true, args: {} };
-  if (typeof input !== "object")
-    return { ok: false, reason: "expected an object of ListAgents arguments" };
-  const record = input;
-  const extra = Object.keys(record).filter((key) => !LIST_AGENTS_FIELDS.has(key));
-  if (extra.length > 0)
-    return { ok: false, reason: `unknown argument(s): ${extra.join(", ")}` };
-  for (const field of ["channel", "q"]) {
-    const value = record[field];
-    if (value !== undefined && (typeof value !== "string" || value.length > LIST_AGENTS_FIELD_MAX)) {
-      return { ok: false, reason: `\`${field}\` must be a string of at most ${LIST_AGENTS_FIELD_MAX} characters` };
-    }
-  }
-  return {
-    ok: true,
-    args: {
-      ...typeof record["channel"] === "string" ? { channel: record["channel"] } : {},
-      ...typeof record["q"] === "string" ? { q: record["q"] } : {}
-    }
-  };
-}
-
-// src/official/aliases.ts
 var ALIASED_BUILTINS = [
   { builtin: "SendMessage", tool: "send_message" },
-  { builtin: "ListAgents", tool: "list_agents" }
+  { builtin: "ListAgents", tool: "list_agents" },
+  { builtin: "ReadNotifications", tool: "read_notifications" },
+  { builtin: "advisor", tool: "advisor" }
 ];
 function officialToolAliases(brand) {
   return Object.fromEntries(ALIASED_BUILTINS.map(({ builtin, tool }) => [builtin, mcpToolName(brand, tool)]));
@@ -270,6 +187,15 @@ class OfficialStdoutUnterminatedError extends OfficialBranchError {
     this.graceMs = args.graceMs;
   }
 }
+class OfficialMcpError extends OfficialBranchError {
+  code = "official_mcp_failure";
+  winterClass = "WinterSDKError";
+  server;
+  constructor(args) {
+    super(`${args.branchLabel}: the MCP server ${args.server} failed — ${args.reason}`, args.branchLabel);
+    this.server = args.server;
+  }
+}
 class OfficialInvalidResumeError extends OfficialBranchError {
   code = "official_invalid_resume";
   winterClass = "WinterSDKError";
@@ -426,14 +352,14 @@ function createApprovalBridge(options) {
     const request = { toolName, input, ...rest };
     const containment = containmentDecisionFor(toolName, input, containmentPolicy);
     if (!containment.allow) {
-      const result = { behavior: "deny", message: containment.reason, toolUseID: request.toolUseID };
-      options.onDecision?.({ request, result, source: "containment-floor" });
-      return result;
+      const result2 = { behavior: "deny", message: containment.reason, toolUseID: request.toolUseID };
+      options.onDecision?.({ request, result: result2, source: "containment-floor" });
+      return result2;
     }
     if (options.mode === "dontAsk") {
-      const result = { behavior: "allow", updatedInput: input, toolUseID: request.toolUseID };
-      options.onDecision?.({ request, result, source: "dont-ask" });
-      return result;
+      const result2 = { behavior: "allow", updatedInput: input, toolUseID: request.toolUseID };
+      options.onDecision?.({ request, result: result2, source: "dont-ask" });
+      return result2;
     }
     const result = await options.broker(request);
     if (savedApprovals === "disable" && result.behavior === "allow" && result.updatedPermissions !== undefined) {
@@ -1578,6 +1504,123 @@ function assertOptionsInvariants(options, branchLabel) {
   }
 }
 
+// src/official/mcp-descriptors.ts
+import { isWinterMcpServerInstance, mcpToolName as mcpToolName3 } from "@yanlinglabs/winter-agent-sdk";
+import {
+  WINTER_DEFAULT_TOOL_DEFINITIONS,
+  createAdvisorToolHandler,
+  createMessagingToolHandlers
+} from "@yanlinglabs/winter-agent-sdk/tools";
+function mcpResult(handler) {
+  return async (args, extra) => {
+    const result = await handler(args, extra);
+    return { content: [{ type: "text", text: result.text }], ...result.isError === undefined ? {} : { isError: result.isError } };
+  };
+}
+function descriptorFor(definition, handler) {
+  return {
+    tool: definition.toolName,
+    description: definition.description,
+    inputSchema: definition.inputSchema,
+    ...definition.outputSchema === undefined ? {} : { outputSchema: definition.outputSchema },
+    ...definition.annotations === undefined ? {} : { annotations: definition.annotations },
+    exposure: "deferred",
+    permissionClass: definition.permissionClass,
+    handler: mcpResult(handler)
+  };
+}
+function winterMcpServerDescriptor(args) {
+  const messaging = createMessagingToolHandlers(args.port, args.caller);
+  const advisor = createAdvisorToolHandler({
+    transcriptSource: args.advisor.transcriptSource,
+    resolveReviewer: args.advisor.resolveReviewer ?? (() => {
+      return;
+    }),
+    ...args.advisor.maxChars === undefined ? {} : { maxChars: args.advisor.maxChars }
+  });
+  const handlers = {
+    send_message: messaging.sendMessage,
+    list_agents: messaging.listAgents,
+    read_notifications: messaging.readNotifications,
+    advisor
+  };
+  const tools = WINTER_DEFAULT_TOOL_DEFINITIONS.map((definition) => {
+    const handler = handlers[definition.toolName];
+    if (handler === undefined)
+      throw new OfficialMcpError({ server: args.brand.mcpServerName, reason: `the SDK declares a default tool this branch has no handler for: \`${definition.toolName}\``, branchLabel: "winter-claude-agent" });
+    return descriptorFor(definition, handler);
+  });
+  return { name: args.brand.mcpServerName, version: args.version ?? "1.0.0", tools: [...tools, ...args.capabilities ?? []] };
+}
+function capabilityServerDescriptor(server, version = "1.0.0") {
+  if (!isWinterMcpServerInstance(server.instance)) {
+    throw new RuntimeLaunchInputError({
+      field: "capabilities",
+      reason: `the capability server \`${server.name}\` carries no in-process instance the router can call (\`listTools\`/\`callTool\`), so its tools could be forwarded to the Winter leg and never registered on the official one`
+    });
+  }
+  const instance = server.instance;
+  const declared = server.tools ?? instance.listTools();
+  const tools = declared.map((tool) => {
+    const meta = tool._meta;
+    const permissionClass = typeof meta?.["permissionClass"] === "string" ? meta["permissionClass"] : server.name;
+    return {
+      tool: tool.name,
+      description: tool.description ?? "",
+      inputSchema: capabilityInputSchema(tool.inputSchema, server.name, tool.name),
+      ...tool.annotations === undefined ? {} : { annotations: tool.annotations },
+      exposure: "eager",
+      permissionClass,
+      handler: async (rawArgs) => {
+        const result = await instance.callTool(tool.name, rawArgs ?? {});
+        return { content: result.content, ...result.isError === undefined ? {} : { isError: result.isError } };
+      }
+    };
+  });
+  return { name: server.name, version, tools };
+}
+function capabilityNameCollisionError(args) {
+  return new RuntimeLaunchInputError({
+    field: args.field,
+    reason: `\`${args.name}\` is the name of a capability server this handle forwards, and the caller's own \`mcpServers\` already carries it — one of the two would silently not be registered, and the other leg would still have the capability, so the door refuses rather than choose for you`
+  });
+}
+function capabilityServerDescriptors(servers) {
+  return servers.map((server) => capabilityServerDescriptor(server));
+}
+function capabilityInputSchema(raw, server, tool) {
+  const properties = raw["properties"];
+  if (raw["type"] !== "object" || properties !== undefined && (typeof properties !== "object" || properties === null)) {
+    throw new RuntimeLaunchInputError({
+      field: "capabilities",
+      reason: `the capability tool \`${tool}\` on \`${server}\` declares an input schema that is not a JSON-Schema object, and the official branch's in-process registration has no conversion for anything else`
+    });
+  }
+  const required = raw["required"];
+  const additionalProperties = raw["additionalProperties"];
+  return {
+    type: "object",
+    ...properties === undefined ? {} : { properties },
+    ...Array.isArray(required) ? { required: required.map(String) } : {},
+    ...typeof additionalProperties === "boolean" ? { additionalProperties } : {}
+  };
+}
+function materializeOfficialMcpServer(args) {
+  const { createSdkMcpServer, tool } = args.module;
+  if (typeof createSdkMcpServer !== "function" || typeof tool !== "function") {
+    throw new OfficialMcpError({
+      server: args.descriptor.name,
+      reason: "the injected official SDK module exposes no in-process MCP server constructor, so the standing server cannot be registered and every aliased built-in would resolve to a missing tool",
+      branchLabel: args.branchLabel
+    });
+  }
+  const tools = args.descriptor.tools.map((descriptor) => tool(descriptor.tool, descriptor.description, args.toInputShape(descriptor.inputSchema), async (rawArgs, extra) => descriptor.handler(rawArgs, extra), descriptor.annotations === undefined ? undefined : { annotations: descriptor.annotations }));
+  return createSdkMcpServer({ name: args.descriptor.name, version: args.descriptor.version, tools });
+}
+function officialMcpServers(args) {
+  return { [args.descriptor.name]: materializeOfficialMcpServer(args) };
+}
+
 // src/vendor-paths.ts
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -1722,10 +1765,60 @@ function officialConnectionEnv(args) {
     explicit["ANTHROPIC_BASE_URL"] = baseUrl;
   return explicit;
 }
+function officialCapabilityServers(deps, args) {
+  if (deps.toInputShape === undefined) {
+    if (deps.capabilities === undefined)
+      return;
+    throw new RuntimeLaunchInputError({
+      leg: "official",
+      field: "toInputShape",
+      reason: "this handle was constructed with `capabilities` but no JSON-Schema → validator-shape bridge, and the official runtime registers in-process servers only through its own validator's shape — so those tools would exist on the Winter leg and silently not on this one (WS-14 §11)"
+    });
+  }
+  for (const name of Object.keys(args.hostOwned ?? {})) {
+    if ((deps.capabilities ?? []).some((descriptor) => descriptor.name === name))
+      throw capabilityNameCollisionError({ field: "runtime.official.mcpServers", name });
+  }
+  const toInputShape = deps.toInputShape;
+  const module = deps.mcpModule;
+  if (module === undefined) {
+    throw new RuntimeLaunchInputError({
+      leg: "official",
+      field: "peers.claude",
+      reason: "the official leg cannot register the standing server without the official SDK module the servers are registered into"
+    });
+  }
+  const standing = winterMcpServerDescriptor({
+    brand: deps.brand,
+    port: deps.messaging,
+    caller: args.caller,
+    advisor: { transcriptSource: args.transcriptSource, ...deps.advisor?.resolveReviewer === undefined ? {} : { resolveReviewer: deps.advisor.resolveReviewer }, ...deps.advisor?.maxChars === undefined ? {} : { maxChars: deps.advisor.maxChars } }
+  });
+  const servers = {};
+  for (const descriptor of [standing, ...deps.capabilities ?? []]) {
+    Object.assign(servers, officialMcpServers({ descriptor, module, toInputShape, branchLabel: args.branchLabel }));
+  }
+  return servers;
+}
 function openOfficialLeg(deps, request) {
   const branchLabel = officialBranchLabel(deps.brand);
-  const parsed = request.input.parentSessionId === undefined ? buildSessionAddress(request.input.sessionId) : buildChildAddress(request.input.parentSessionId, request.input.sessionId);
   const address = officialLegAddress(request.input);
+  const advisorTranscriptSource = () => ({
+    async getEntries() {
+      const cwd = request.options.cwd;
+      const projectKey = request.input.projectKey ?? (cwd === undefined || cwd.length === 0 ? undefined : deps.transcriptProjectKey(cwd));
+      if (projectKey === undefined)
+        return [];
+      const row = await deps.directory.get(address);
+      const sessionId = row?.backendSessionId ?? request.options.sessionId;
+      if (sessionId === undefined || sessionId.length === 0)
+        return [];
+      return transcriptSourceForSessionKey({ projectKey, sessionId }, { store: deps.shared().store }).getEntries();
+    }
+  });
+  const messagingCaller = request.input.parentSessionId === undefined ? { sessionId: request.input.sessionId } : { sessionId: request.input.parentSessionId, agentId: request.input.sessionId };
+  const routerBuiltMcpServers = officialCapabilityServers(deps, { caller: messagingCaller, transcriptSource: advisorTranscriptSource(), branchLabel, hostOwned: request.input.mcpServers });
+  const parsed = request.input.parentSessionId === undefined ? buildSessionAddress(request.input.sessionId) : buildChildAddress(request.input.parentSessionId, request.input.sessionId);
   const stream = typeof request.prompt === "string" ? undefined : createOfficialInputStream();
   let detach;
   let sawInit = false;
@@ -1821,7 +1914,7 @@ function openOfficialLeg(deps, request) {
       ...request.input.options ?? {},
       advertisesHandoff: request.input.advertisesHandoff ?? true,
       env,
-      ...request.input.mcpServers === undefined ? {} : { mcpServers: request.input.mcpServers },
+      ...routerBuiltMcpServers === undefined && request.input.mcpServers === undefined ? {} : { mcpServers: { ...routerBuiltMcpServers, ...request.input.mcpServers } },
       ...bridge === undefined ? {} : { canUseTool: bridge },
       ...request.options.permissionMode === undefined ? {} : { permissionMode: request.options.permissionMode },
       ...request.options.sessionId === undefined ? {} : { sessionId: request.options.sessionId },
@@ -2123,7 +2216,7 @@ function createInMemoryRuntimeDirectoryStore() {
 }
 
 // src/directory/directory.ts
-import { parseRuntimeAddress, resolveTarget, serializeRuntimeAddress as serializeRuntimeAddress3, validateToField as validateToField2 } from "@yanlinglabs/winter-agent-sdk/messaging";
+import { parseRuntimeAddress, resolveTarget, serializeRuntimeAddress as serializeRuntimeAddress3, validateToField } from "@yanlinglabs/winter-agent-sdk/messaging";
 
 // src/directory/entries.ts
 import { buildSessionAddress as buildSessionAddress2, serializeRuntimeAddress as serializeRuntimeAddress2 } from "@yanlinglabs/winter-agent-sdk/messaging";
@@ -2369,7 +2462,7 @@ function createRuntimeDirectory(context, options = {}) {
     return (await store.load()).find((entry) => entry.address === address);
   }
   async function resolveIn(snap, to, ctx) {
-    const valid = validateToField2(to);
+    const valid = validateToField(to);
     if (!valid.ok)
       return { kind: "not-found", reason: valid.message };
     const callerOwner = owningSessionIdOf(ctx.from);
@@ -2452,7 +2545,6 @@ function createRuntimeDirectory(context, options = {}) {
 }
 // src/messaging/router.ts
 import {
-  callerAddress,
   createLoopGuard,
   createMessagingRouter,
   createNotificationQueue,
@@ -3199,32 +3291,32 @@ function selectChildRuntimePairing(parent, child) {
   };
 }
 var CHILD_PROVIDER_UNAVAILABLE = "child-provider-unavailable";
-function resumeChildSelection(record, context) {
-  const input = childInput({ ...context, model: record.modelRef, provider: record.providerId });
-  const rows = resolveCandidateRows({ ...input, requested: { ...input.requested, model: record.modelRef } });
+function resumeChildSelection(record2, context) {
+  const input = childInput({ ...context, model: record2.modelRef, provider: record2.providerId });
+  const rows = resolveCandidateRows({ ...input, requested: { ...input.requested, model: record2.modelRef } });
   if (isRefusal2(rows)) {
     return {
       kind: "unavailable",
       retryable: false,
-      reason: `${CHILD_PROVIDER_UNAVAILABLE}: ${record.modelRef} on provider ${record.providerId} — ${rows.detail}`
+      reason: `${CHILD_PROVIDER_UNAVAILABLE}: ${record2.modelRef} on provider ${record2.providerId} — ${rows.detail}`
     };
   }
-  const recorded = rows.find((candidate) => candidate.row.key === record.modelRef);
+  const recorded = rows.find((candidate) => candidate.row.key === record2.modelRef);
   if (recorded === undefined) {
     return {
       kind: "unavailable",
       retryable: false,
-      reason: `${CHILD_PROVIDER_UNAVAILABLE}: this child is recorded on the row ${record.modelRef} (provider ${record.providerId}), which is no longer among the servable rows for that provider (now: ${rows.map((candidate) => candidate.row.key).join(", ")}); a resumed child re-resolves under its OWN recorded model and provider (WS-10, Phase 6.6 amendment)`
+      reason: `${CHILD_PROVIDER_UNAVAILABLE}: this child is recorded on the row ${record2.modelRef} (provider ${record2.providerId}), which is no longer among the servable rows for that provider (now: ${rows.map((candidate) => candidate.row.key).join(", ")}); a resumed child re-resolves under its OWN recorded model and provider (WS-10, Phase 6.6 amendment)`
     };
   }
-  if (recorded.family !== record.family) {
+  if (recorded.family !== record2.family) {
     return {
       kind: "unavailable",
       retryable: false,
-      reason: `${CHILD_PROVIDER_UNAVAILABLE}: this child is recorded in the ${record.family} family and its recorded row ${record.modelRef} now resolves into ${recorded.family}; never a substitution, never a different family (WS-13c §4)`
+      reason: `${CHILD_PROVIDER_UNAVAILABLE}: this child is recorded in the ${record2.family} family and its recorded row ${record2.modelRef} now resolves into ${recorded.family}; never a substitution, never a different family (WS-13c §4)`
     };
   }
-  return { kind: "resumed", selection: record };
+  return { kind: "resumed", selection: record2 };
 }
 
 // src/messaging/winter-adapter.ts
@@ -3509,8 +3601,8 @@ function createGlobalMessaging(context, options = {}) {
       } catch {
         return;
       }
-      for (const record of drained.notifications) {
-        await handle.noteIdle(address, { notificationId: record.notification_id, content: record.content });
+      for (const record2 of drained.notifications) {
+        await handle.noteIdle(address, { notificationId: record2.notification_id, content: record2.content });
       }
       if (drained.remaining === 0 || drained.notifications.length === 0)
         return;
@@ -3735,58 +3827,6 @@ function createGlobalMessaging(context, options = {}) {
   };
   return handle;
 }
-function callerAddressOf(caller) {
-  return callerAddress(caller);
-}
-// src/messaging/handlers.ts
-var VENDOR_TOOL_USE_ID_META_KEY = "claudecode/toolUseId";
-function toolUseIdFromExtra(extra) {
-  if (typeof extra !== "object" || extra === null)
-    return;
-  const meta = extra._meta;
-  if (typeof meta !== "object" || meta === null)
-    return;
-  const id = meta[VENDOR_TOOL_USE_ID_META_KEY];
-  return typeof id === "string" && id.length > 0 ? id : undefined;
-}
-var MODEL_FACING_FAILURES = new Set(["refused", "ambiguous", "not_found", "unavailable"]);
-function text(body, isError = false) {
-  return { content: [{ type: "text", text: body }], ...isError ? { isError: true } : {} };
-}
-function createMessagingToolHandlers(messaging, caller) {
-  const identity = () => typeof caller === "function" ? caller() : caller;
-  return {
-    async sendMessage(rawArgs, extra) {
-      const accepted = acceptNativeSendMessageArgs(rawArgs);
-      if (!accepted.ok)
-        return text(accepted.reason, true);
-      const bound = identity();
-      const perCall = toolUseIdFromExtra(extra);
-      const who = perCall === undefined ? bound : { ...bound, toolUseId: perCall };
-      const from = callerAddressOf(who);
-      const result = await messaging.sendDetailed({
-        from,
-        to: accepted.args.to,
-        body: accepted.args.message,
-        ...accepted.args.summary === undefined ? {} : { summary: accepted.args.summary },
-        ...accepted.args.notify_when_idle === undefined ? {} : { notifyWhenIdle: accepted.args.notify_when_idle },
-        ...who.toolUseId === undefined ? {} : { originToolCallId: who.toolUseId }
-      });
-      const payload = result.notify === undefined ? result.outcome : { ...result.outcome, notify: result.notify };
-      return text(JSON.stringify(payload), MODEL_FACING_FAILURES.has(result.outcome.status));
-    },
-    async listAgents(rawArgs) {
-      const accepted = acceptNativeListAgentsArgs(rawArgs);
-      if (!accepted.ok)
-        return text(accepted.reason, true);
-      const from = callerAddressOf(identity());
-      const rows = await messaging.listReachable({ from });
-      const listing = rows.length === 0 ? "No agents or sessions are currently reachable." : rows.map((row) => `- ${row.name === undefined ? row.address : `${row.name} (${row.address})`} [${row.objectKind}/${row.runtimeKind}] status=${row.status} mode=${row.mode}`).join(`
-`);
-      return text(JSON.stringify({ listing }));
-    }
-  };
-}
 // src/messaging/index.ts
 function createRuntimeMessaging(context, options = {}) {
   let messaging;
@@ -3928,14 +3968,14 @@ function createSharedSessionStore(input) {
     }
     return state;
   };
-  const recordMirrorError = (key, record) => {
+  const recordMirrorError = (key, record2) => {
     const state = stateFor(key);
     state.health = "repair-required";
     state.errors.push({
       projectKey: key.projectKey,
       sessionId: key.sessionId,
       ...key.subpath === undefined ? {} : { subpath: key.subpath },
-      ...record,
+      ...record2,
       at: now().toISOString()
     });
   };
@@ -4018,12 +4058,12 @@ function createSharedSessionStore(input) {
       for (const batch of [...batches.values()])
         await flush(batch.key);
       await tail;
-      const errors = [...sessions.values()].flatMap((state) => state.errors);
+      const errors = [...sessions.values()].flatMap((state2) => state2.errors);
       return {
         settled: batches.size === 0,
-        batchesCommitted: [...sessions.values()].reduce((sum, state) => sum + state.batchesCommitted, 0),
+        batchesCommitted: [...sessions.values()].reduce((sum, state2) => sum + state2.batchesCommitted, 0),
         errors,
-        transcriptHealth: [...sessions.values()].some((state) => state.health === "repair-required") ? "repair-required" : "ok"
+        transcriptHealth: [...sessions.values()].some((state2) => state2.health === "repair-required") ? "repair-required" : "ok"
       };
     }
     const session = sessionOf(key);
@@ -4639,7 +4679,7 @@ function sidecarPath(home, key) {
 }
 function writeSidecar(path, records) {
   mkdirSync2(dirname(path), { recursive: true, mode: 448 });
-  const lines = records.map((record) => JSON.stringify({ sessionId: PROBE_KEY.sessionId, anchorUuid: record.anchorUuid, provider: "probe", model: "probe", itemIndex: 0, kind: record.kind, payload: "opaque" }));
+  const lines = records.map((record2) => JSON.stringify({ sessionId: PROBE_KEY.sessionId, anchorUuid: record2.anchorUuid, provider: "probe", model: "probe", itemIndex: 0, kind: record2.kind, payload: "opaque" }));
   writeFile(path, Buffer.from(`${lines.join(`
 `)}
 `, "utf8"));
@@ -4734,12 +4774,12 @@ async function probeNoWashBack(context, deps) {
     });
     legs.push(await pinnedLeg("mirror from a decorated copy", deps, async (bed) => {
       const canonicalBeforeResume = readFileSync2(canonicalPath);
-      const before = await entryCount(shared, PROBE_KEY);
+      const before2 = await entryCount(shared, PROBE_KEY);
       await bed.freshProcessResume({ home, stagingRoot, key: PROBE_KEY, shared });
       await shared.settle(PROBE_KEY);
-      const after = await entryCount(shared, PROBE_KEY);
-      if (after <= before) {
-        return { passed: false, evidence: `unexercised: the resume from the decorated copy produced no entries (${before} before, ${after} after), so no mirror write was observed` };
+      const after2 = await entryCount(shared, PROBE_KEY);
+      if (after2 <= before2) {
+        return { passed: false, evidence: `unexercised: the resume from the decorated copy produced no entries (${before2} before, ${after2} after), so no mirror write was observed` };
       }
       const canonicalAfterResume = readFileSync2(canonicalPath);
       const prefixIntact = canonicalAfterResume.subarray(0, canonicalBeforeResume.length).equals(canonicalBeforeResume);
@@ -4748,7 +4788,7 @@ async function probeNoWashBack(context, deps) {
       const duplicateUuids = uuids.length - new Set(uuids).size;
       return {
         passed: prefixIntact && stillNoDecoration && duplicateUuids === 0,
-        evidence: `after a resume from the decorated copy that mirrored ${after - before} entr(y|ies): canonical prefix intact=${prefixIntact}; decoration still absent=${stillNoDecoration}; duplicate uuids=${duplicateUuids}`
+        evidence: `after a resume from the decorated copy that mirrored ${after2 - before2} entr(y|ies): canonical prefix intact=${prefixIntact}; decoration still absent=${stillNoDecoration}; duplicate uuids=${duplicateUuids}`
       };
     }));
     return legs;
@@ -4799,8 +4839,8 @@ async function probeSidecarRoundTrip(context, deps) {
       const seenUuids = new Set;
       let orderIntact = lines.length > 0;
       for (const line of lines) {
-        const parent = parentOf(line);
-        if (typeof parent === "string" && !seenUuids.has(parent)) {
+        const parent2 = parentOf(line);
+        if (typeof parent2 === "string" && !seenUuids.has(parent2)) {
           orderIntact = false;
           break;
         }
@@ -5072,11 +5112,11 @@ function createHandoffBarrier(context, deps = {}) {
   };
   const reviewSelectionFor = async (args) => {
     const { persisted, to } = args;
-    const stamped = { ...persisted, runtimeKind: to };
+    const stamped2 = { ...persisted, runtimeKind: to };
     if (deps.selectionInputFor === undefined) {
       return {
         kind: "unreviewed",
-        selection: stamped,
+        selection: stamped2,
         detail: `no selection input was supplied, so nothing checked whether ${to} can serve ${persisted.providerId}/${persisted.modelRef}; the destination's own init is the first thing that will (supply \`selectionInputFor\` to review it here instead)`
       };
     }
@@ -5112,7 +5152,7 @@ function createHandoffBarrier(context, deps = {}) {
         detail: `the official runtime does not serve ${persisted.providerId}/${persisted.modelRef}`
       };
     }
-    return { kind: "servable", selection: stamped, review };
+    return { kind: "servable", selection: stamped2, review };
   };
   const plan = async (session, to) => {
     const entry = await loadEntry(session);
@@ -5138,30 +5178,30 @@ function createHandoffBarrier(context, deps = {}) {
       selection
     };
   };
-  const execute = async (plan) => {
+  const execute = async (plan2) => {
     const trail = [];
-    const record = (step, ok, detail) => {
+    const record2 = (step, ok, detail) => {
       trail.push({ step, name: HANDOFF_STEPS[step - 1].name, ok, detail });
     };
     const lossy = (step, reason) => {
-      record(step, false, reason);
+      record2(step, false, reason);
       return { kind: "lossy-fork-offered", reason, step, detail: reason, steps: trail };
     };
     const blocked = (step, reason, detail) => {
-      record(step, false, detail);
+      record2(step, false, detail);
       return { kind: "blocked", reason, step, detail, steps: trail };
     };
-    const session = plan.session;
+    const session = plan2.session;
     let shared;
-    let winterHome;
+    let winterHome2;
     try {
       shared = sharedOf();
-      winterHome = homeOf();
+      winterHome2 = homeOf();
     } catch (error) {
       return lossy(1, `the shared session store could not be resolved, so nothing about this session can be read or written: ${error instanceof Error ? error.message : String(error)}`);
     }
-    if (plan.selection.kind === "refused") {
-      return lossy(8, plan.selection.refusal.detail);
+    if (plan2.selection.kind === "refused") {
+      return lossy(8, plan2.selection.refusal.detail);
     }
     let lease;
     let stagedRoot;
@@ -5187,13 +5227,13 @@ function createHandoffBarrier(context, deps = {}) {
     try {
       entry = await loadEntry(session);
       assertOneDecoratorStore();
-      if (entry.runtimeKind !== plan.from) {
-        return lossy(1, `this plan was built when ${plan.from} owned the session and ${entry.runtimeKind} owns it now; re-plan against the current owner`);
+      if (entry.runtimeKind !== plan2.from) {
+        return lossy(1, `this plan was built when ${plan2.from} owned the session and ${entry.runtimeKind} owns it now; re-plan against the current owner`);
       }
-      const owner = await deps.participants?.source?.(session, plan.from) ?? undefined;
+      const owner = await deps.participants?.source?.(session, plan2.from) ?? undefined;
       const healthNow = owner?.health === undefined ? undefined : await owner.health();
-      const markers = new Map([...markersFor({ entry, to: plan.to, session, ...healthNow === undefined ? {} : { health: healthNow } })]);
-      for (const step of plan.steps) {
+      const markers = new Map([...markersFor({ entry, to: plan2.to, session, ...healthNow === undefined ? {} : { health: healthNow } })]);
+      for (const step of plan2.steps) {
         if (step.knownUnprovable !== undefined)
           markers.set(step.step, step.knownUnprovable);
       }
@@ -5208,12 +5248,12 @@ function createHandoffBarrier(context, deps = {}) {
         return blocked(1, "lease-held", error instanceof Error ? error.message : String(error));
       }
       await owner?.stopNewTurns?.();
-      record(1, true, "the handoff lease is held by this process and the source is not taking new turns");
+      record2(1, true, "the handoff lease is held by this process and the source is not taking new turns");
       at = 2;
       const drained = owner === undefined ? { ok: true, detail: "there is no live owner to drain" } : await owner.drainToIdleBoundary();
       if (!drained.ok)
         return lossy(2, drained.reason);
-      record(2, true, drained.detail ?? "the active turn reached an idle terminal boundary");
+      record2(2, true, drained.detail ?? "the active turn reached an idle terminal boundary");
       at = 3;
       const streamed = owner === undefined ? { ok: true, detail: "there is no live stream to drain" } : await owner.drainStream();
       if (!streamed.ok)
@@ -5221,7 +5261,7 @@ function createHandoffBarrier(context, deps = {}) {
       const settled = await shared.settle(session);
       if (!settled.settled)
         return lossy(3, "the pending append barrier did not settle, so the canonical tail is still moving");
-      record(3, true, `${streamed.detail ?? "the stream reached its terminal result"}; ${settled.batchesCommitted} canonical append batch(es) settled`);
+      record2(3, true, `${streamed.detail ?? "the stream reached its terminal result"}; ${settled.batchesCommitted} canonical append batch(es) settled`);
       at = 4;
       const eligibility = owner?.eligibility === undefined ? undefined : await owner.eligibility();
       if (eligibility !== undefined && !eligibility.eligible) {
@@ -5235,11 +5275,11 @@ function createHandoffBarrier(context, deps = {}) {
         if (report.status === "diverged" || report.appended !== comparison.missing) {
           return blocked(4, "repair-required", `the canonical store could not be reconciled against ${localRoot}: ${comparison.missing} entr(y|ies) were missing and ${report.appended} landed (${report.status})`);
         }
-        record(4, true, `the canonical tail was ${comparison.missing} entr(y|ies) behind the recorded local-write root and has been reconciled`);
+        record2(4, true, `the canonical tail was ${comparison.missing} entr(y|ies) behind the recorded local-write root and has been reconciled`);
       } else if (comparison.kind === "diverged" || comparison.kind === "canonical-ahead") {
         return blocked(4, "repair-required", comparison.reason);
       } else {
-        record(4, true, comparison.reason);
+        record2(4, true, comparison.reason);
       }
       const storeHealth = shared.health(session);
       if (storeHealth.transcriptHealth !== "ok") {
@@ -5247,10 +5287,10 @@ function createHandoffBarrier(context, deps = {}) {
         return blocked(4, "mirror-error", `the mirror recorded ${storeHealth.errors.length} failure(s) for this session${cause === undefined ? "" : ` (last: ${cause.cause})`}, and it is not reconciled`);
       }
       at = 5;
-      const validation = await validateSessionTranscript(shared, session, winterHome);
+      const validation = await validateSessionTranscript(shared, session, winterHome2);
       if (!validation.ok)
         return lossy(5, validation.reason);
-      record(5, true, validation.detail);
+      record2(5, true, validation.detail);
       at = 6;
       const closed = await owner?.close() ?? undefined;
       if (closed !== undefined && closed.ok === false)
@@ -5266,18 +5306,18 @@ function createHandoffBarrier(context, deps = {}) {
       let staged;
       pendingWritten = true;
       try {
-        staged = await markHandoffPending({ shared, session, entry, plan, level, now: now() });
+        staged = await markHandoffPending({ shared, session, entry, plan: plan2, level, now: now() });
       } catch (error) {
         await unwind();
         return lossy(6, `the handoff could not be staged: ${error instanceof Error ? error.message : String(error)}`);
       }
-      record(6, true, `the owner is closed, the writer lease was granted to this process, and a pending handoff to ${plan.to} at level ${level} is recorded — ownership has NOT moved`);
+      record2(6, true, `the owner is closed, the writer lease was granted to this process, and a pending handoff to ${plan2.to} at level ${level} is recorded — ownership has NOT moved`);
       at = 7;
       let continuity;
       try {
         const layout = (deps.tempLayoutFor ?? defaultTempLayout(context))(entry, session);
         continuity = materializeTempContinuity({
-          to: plan.to,
+          to: plan2.to,
           layout,
           ...owner?.effectiveTempDir === undefined ? {} : { recordedTempDir: owner.effectiveTempDir }
         });
@@ -5285,25 +5325,25 @@ function createHandoffBarrier(context, deps = {}) {
         await unwind();
         return lossy(7, `temp continuity could not be materialized: ${error instanceof Error ? error.message : String(error)}`);
       }
-      record(7, true, `${continuity.mode}: the session's scratch is at ${continuity.effectiveTempDir}${continuity.supersededDir === undefined ? "" : `, superseding ${continuity.supersededDir} (retained)`}`);
+      record2(7, true, `${continuity.mode}: the session's scratch is at ${continuity.effectiveTempDir}${continuity.supersededDir === undefined ? "" : `, superseding ${continuity.supersededDir} (retained)`}`);
       at = 8;
-      const stagingRoot = plan.to === "claude-agent" ? stagingRootFor(staged.stagingUuid) : undefined;
+      const stagingRoot = plan2.to === "claude-agent" ? stagingRootFor(staged.stagingUuid) : undefined;
       if (stagingRoot !== undefined)
         stagedRoot = stagingRoot;
       const decorated = await decoratorOf().decorate({
         session,
-        to: plan.to,
-        materializedPath: stagingRoot === undefined ? canonicalTranscriptPath(winterHome, session) : materializedTranscriptPath(stagingRoot, session),
+        to: plan2.to,
+        materializedPath: stagingRoot === undefined ? canonicalTranscriptPath(winterHome2, session) : materializedTranscriptPath(stagingRoot, session),
         decoration: {
           kind: "handoff",
-          from: plan.from,
+          from: plan2.from,
           at: now().toISOString(),
-          text: (deps.noteText ?? defaultNoteText)({ from: plan.from, to: plan.to, session })
+          text: (deps.noteText ?? defaultNoteText)({ from: plan2.from, to: plan2.to, session })
         }
       });
       target = {
         address: entry.address,
-        runtimeKind: plan.to,
+        runtimeKind: plan2.to,
         backendSessionId: session.sessionId,
         projectKey: session.projectKey,
         compatibilityLevel: level,
@@ -5311,9 +5351,9 @@ function createHandoffBarrier(context, deps = {}) {
         ...stagingRoot === undefined ? {} : { stagingRoot, profile: "store-backed-resume" },
         effectiveTempDir: continuity.effectiveTempDir,
         door: decorated.door,
-        selection: plan.selection.selection
+        selection: plan2.selection.selection
       };
-      const destination = await deps.participants?.destination?.(session, plan.to) ?? undefined;
+      const destination = await deps.participants?.destination?.(session, plan2.to) ?? undefined;
       if (destination === undefined) {
         await unwind();
         return lossy(8, "no destination runtime confirmed the resumed session and level, and the next user message must not be delivered until one does");
@@ -5334,7 +5374,7 @@ function createHandoffBarrier(context, deps = {}) {
         await unwind();
         const reason = `the destination confirmed init but the producer record could not be written: ${error instanceof Error ? error.message : String(error)}`;
         const enriched = target?.stagingRoot === undefined ? reason : `${reason}. The destination is reading ${target.stagingRoot}; that staging copy is retained deliberately and belongs to the host's retention pass.`;
-        record(8, false, enriched);
+        record2(8, false, enriched);
         return {
           kind: "lossy-fork-offered",
           reason,
@@ -5346,7 +5386,7 @@ function createHandoffBarrier(context, deps = {}) {
       }
       const notes = [];
       try {
-        await syncDirectoryEntry({ context, entry, plan, staged, now: now() });
+        await syncDirectoryEntry({ context, entry, plan: plan2, staged, now: now() });
       } catch (error) {
         notes.push(`the host directory's derived copy is behind and will be repaired on the next plan(): ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -5358,12 +5398,12 @@ function createHandoffBarrier(context, deps = {}) {
           notes.push(`the labelled handoff note could not be appended: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
-      record(8, true, confirmed.detail ?? `the destination confirmed ${session.sessionId} at level ${level}, and ownership moved`);
+      record2(8, true, confirmed.detail ?? `the destination confirmed ${session.sessionId} at level ${level}, and ownership moved`);
       return {
         kind: "resumed",
-        selection: plan.selection.selection,
+        selection: plan2.selection.selection,
         step: 8,
-        detail: `the session resumed on ${plan.to} at level ${level} through the ${decorated.door} decoration door${notes.length === 0 ? "" : ` — ${notes.join("; ")}`}`,
+        detail: `the session resumed on ${plan2.to} at level ${level} through the ${decorated.door} decoration door${notes.length === 0 ? "" : ` — ${notes.join("; ")}`}`,
         target,
         steps: trail
       };
@@ -5372,9 +5412,9 @@ function createHandoffBarrier(context, deps = {}) {
       if (committed && entry !== undefined) {
         return {
           kind: "resumed",
-          selection: plan.selection.selection,
+          selection: plan2.selection.selection,
           step: 8,
-          detail: `the session resumed on ${plan.to}, but the barrier failed afterwards: ${detail}`,
+          detail: `the session resumed on ${plan2.to}, but the barrier failed afterwards: ${detail}`,
           ...target === undefined ? {} : { target },
           steps: trail
         };
@@ -5423,8 +5463,8 @@ async function compareAgainstLocalRoot(args) {
       continue;
     compared += 1;
     const entries = await args.shared.store.load(key) ?? [];
-    const canonicalLines = entries.filter((entry) => entry["type"] !== "agent_metadata").map((entry) => JSON.stringify(entry));
-    const comparison = compareTranscriptTail({ localPath, canonicalLines, isDecoration: (uuid) => args.shared.decorations.has(args.session, uuid) });
+    const canonicalLines2 = entries.filter((entry) => entry["type"] !== "agent_metadata").map((entry) => JSON.stringify(entry));
+    const comparison = compareTranscriptTail({ localPath, canonicalLines: canonicalLines2, isDecoration: (uuid) => args.shared.decorations.has(args.session, uuid) });
     const what = key.subpath === undefined ? "the session's transcript" : `subkey ${key.subpath}`;
     switch (comparison.kind) {
       case "match":
@@ -5605,7 +5645,7 @@ async function markHandoffPending(args) {
   const chainable = entries.filter((entry) => typeof entry["uuid"] === "string");
   const cursor = chainable[chainable.length - 1]?.["uuid"] ?? "";
   const health = args.shared.health(args.session);
-  const record = {
+  const record2 = {
     type: DIALECT_RECORD_ENTRY_TYPE,
     backendSessionId: args.session.sessionId,
     transcriptProjectKey: args.session.projectKey,
@@ -5625,18 +5665,18 @@ async function markHandoffPending(args) {
     }
   ]);
   await args.shared.settle(args.session);
-  return { cursor, stagingUuid: cryptoRandomUuid(), record };
+  return { cursor, stagingUuid: cryptoRandomUuid(), record: record2 };
 }
 async function commitProducerRecord(args) {
-  const record = {
+  const record2 = {
     ...args.staged.record,
     ...args.producer?.sdkVersion === undefined ? {} : { producerSdkVersion: args.producer.sdkVersion },
     ...args.producer?.engineVersion === undefined ? {} : { producerEngineVersion: args.producer.engineVersion }
   };
-  await args.shared.store.append(args.session, [record]);
+  await args.shared.store.append(args.session, [record2]);
   await args.shared.settle(args.session);
   const summary = await args.shared.canonical.readSessionSummary({ projectKey: args.session.projectKey, sessionId: args.session.sessionId });
-  if (summary?.["producerRuntime"] !== record["producerRuntime"]) {
+  if (summary?.["producerRuntime"] !== record2["producerRuntime"]) {
     throw new HandoffCommitError(`the producer record did not land: the summary still names ${String(summary?.["producerRuntime"] ?? "no producer")}`);
   }
 }
@@ -6337,7 +6377,7 @@ class SelectionRefusedError extends RuntimeSdkError {
 import { createRequire as createRequire2 } from "node:module";
 import { dirname as dirname2, join as join7 } from "node:path";
 import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
-var SUPPORTED = { winterAgentSdk: ">=0.0.2 <0.1.0", claudeAgentSdk: "0.3.250" };
+var SUPPORTED = { winterAgentSdk: ">=0.0.3 <0.1.0", claudeAgentSdk: "0.3.250" };
 var SUPPORTED_PROTOCOL_VERSIONS = ["1.0"];
 function parseVersion(raw) {
   const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(raw.trim());
@@ -6400,18 +6440,17 @@ var VERSION_EXPORT_NAMES = ["SDK_VERSION", "VERSION", "PACKAGE_VERSION", "versio
 function readExportedVersion(namespace) {
   if (typeof namespace !== "object" || namespace === null)
     return;
-  const record = namespace;
+  const record2 = namespace;
   for (const name of VERSION_EXPORT_NAMES) {
-    const value = record[name];
+    const value = record2[name];
     if (typeof value === "string" && parseVersion(value) !== undefined)
       return value;
   }
   return;
 }
-function readResolvedManifestVersion(packageName) {
+function readResolvedManifestVersion(packageName, resolveEntry = (name) => createRequire2(import.meta.url).resolve(name)) {
   try {
-    const require2 = createRequire2(import.meta.url);
-    let dir = dirname2(require2.resolve(packageName));
+    let dir = dirname2(resolveEntry(packageName));
     for (let depth = 0;depth < 10; depth++) {
       const manifest = join7(dir, "package.json");
       if (existsSync4(manifest)) {
@@ -6429,19 +6468,25 @@ function readResolvedManifestVersion(packageName) {
     return;
   }
 }
-function identityFor(packageName, namespace, supported) {
+function identityFor(packageName, namespace, supported, declared, seams) {
+  if (declared !== undefined && parseVersion(declared) !== undefined) {
+    return { packageName, packageVersion: declared, source: "host-declared", supported };
+  }
   const exported = readExportedVersion(namespace);
   if (exported !== undefined)
     return { packageName, packageVersion: exported, source: "peer-export", supported };
-  const resolved = readResolvedManifestVersion(packageName);
+  const resolved = readResolvedManifestVersion(packageName, seams.resolveEntry);
   if (resolved !== undefined)
     return { packageName, packageVersion: resolved, source: "resolved-manifest", supported };
   return;
 }
 var UNKNOWN_ACTUAL = "unknown (the injected module exports no version identity and no installed copy could be resolved)";
-function assertVersionMatrix(peers) {
+function assertVersionMatrix(peers, declared) {
+  return resolveVersionMatrix(peers, declared);
+}
+function resolveVersionMatrix(peers, declared, seams = {}) {
   const winterName = "@yanlinglabs/winter-agent-sdk";
-  const winterIdentity = identityFor(winterName, peers.winter, SUPPORTED.winterAgentSdk);
+  const winterIdentity = identityFor(winterName, peers.winter, SUPPORTED.winterAgentSdk, declared?.winterAgentSdk, seams);
   if (winterIdentity === undefined) {
     throw new RuntimeSdkVersionError({ expected: `${winterName} ${SUPPORTED.winterAgentSdk}`, actual: UNKNOWN_ACTUAL });
   }
@@ -6470,7 +6515,7 @@ function assertVersionMatrix(peers) {
   if (peers.claude === undefined)
     return report;
   const claudeName = "@anthropic-ai/claude-agent-sdk";
-  const claudeIdentity = identityFor(claudeName, peers.claude, SUPPORTED.claudeAgentSdk);
+  const claudeIdentity = identityFor(claudeName, peers.claude, SUPPORTED.claudeAgentSdk, declared?.claudeAgentSdk, seams);
   if (claudeIdentity === undefined) {
     throw new RuntimeSdkVersionError({ expected: `${claudeName} ${SUPPORTED.claudeAgentSdk}`, actual: UNKNOWN_ACTUAL });
   }
@@ -6486,10 +6531,10 @@ function runtimeSdkInternals(sdk) {
   return sdk[INTERNALS];
 }
 var INTERNALS = Symbol.for("winter-runtime-sdk.internals");
-function forwardableOptions(options, brand) {
+function forwardableOptions(options, brand, capabilityServers) {
   const stripKeys = ROUTER_ONLY_OPTION_KEYS.filter((key) => (key in options));
   const injectBrand = brand !== undefined && options.brand === undefined;
-  if (stripKeys.length === 0 && !injectBrand)
+  if (stripKeys.length === 0 && !injectBrand && capabilityServers === undefined)
     return options;
   const forwarded = {};
   for (const key of Object.keys(options)) {
@@ -6499,15 +6544,51 @@ function forwardableOptions(options, brand) {
   }
   if (injectBrand)
     forwarded["brand"] = brand;
+  if (capabilityServers !== undefined)
+    forwarded["mcpServers"] = mergedMcpServers(options.mcpServers, capabilityServers);
   return forwarded;
 }
+function mergedMcpServers(callerOwned, capabilityServers) {
+  if (callerOwned === undefined)
+    return capabilityServers;
+  assertNoCapabilityCollision(callerOwned, capabilityServers);
+  return { ...callerOwned, ...capabilityServers };
+}
+function assertNoCapabilityCollision(callerOwned, capabilityServers) {
+  if (callerOwned === undefined)
+    return;
+  for (const name of Object.keys(capabilityServers)) {
+    if (name in callerOwned)
+      throw capabilityNameCollisionError({ field: "mcpServers", name });
+  }
+}
+function capabilityServerRecord(capabilities, brand) {
+  if (capabilities === undefined || capabilities.length === 0)
+    return;
+  const record2 = {};
+  for (const server of capabilities) {
+    if (server.name === brand.mcpServerName) {
+      throw new RuntimeLaunchInputError({
+        field: "capabilities",
+        reason: `\`${server.name}\` is the brand's own standing-server name, which the router registers the messaging tools under on the official branch — a capability server may not claim it (WS-09 §1.3)`
+      });
+    }
+    if (server.name in record2) {
+      throw new RuntimeLaunchInputError({ field: "capabilities", reason: `two capability servers are named \`${server.name}\`, so one of them would never be registered` });
+    }
+    record2[server.name] = server;
+  }
+  return record2;
+}
 function createRuntimeSdk(opts) {
-  const versions = assertVersionMatrix(opts.peers);
+  const versions = assertVersionMatrix(opts.peers, opts.peerVersions);
   const resolved = opts.peers.winter.resolveBrand(opts.brand);
   if (!resolved.ok)
     throw new opts.peers.winter.InvalidBrandError(resolved.reason);
   const brand = resolved.brand;
   const directoryStore = opts.directoryStore ?? createInMemoryRuntimeDirectoryStore();
+  const capabilityServers = capabilityServerRecord(opts.capabilities, brand);
+  const capabilityDescriptors = opts.capabilities === undefined || opts.capabilities.length === 0 ? undefined : capabilityServerDescriptors(opts.capabilities);
   const base = {
     peers: opts.peers,
     keychain: opts.keychain,
@@ -6554,6 +6635,8 @@ function createRuntimeSdk(opts) {
   const queryImpl = (args) => {
     assertLive("query");
     const options = args.options ?? {};
+    if (capabilityServers !== undefined)
+      assertNoCapabilityCollision(options.mcpServers, capabilityServers);
     const runtime = options.runtime;
     const decided = runtime === undefined ? undefined : runtime.selection ?? (runtime.select === undefined ? undefined : decide(runtime.select));
     const ledgerKey = runtime?.official !== undefined ? officialLegAddress(runtime.official) : runtime?.sessionId === undefined ? undefined : sessionLedgerKey(runtime.sessionId);
@@ -6584,10 +6667,14 @@ function createRuntimeSdk(opts) {
         transcriptProjectKey,
         ...opts.vendoredOfficialRuntime === undefined ? {} : { vendoredOfficialRuntime: opts.vendoredOfficialRuntime },
         ...opts.official === undefined ? {} : { policy: opts.official },
+        ...capabilityDescriptors === undefined ? {} : { capabilities: capabilityDescriptors },
+        ...opts.toInputShape === undefined ? {} : { toInputShape: opts.toInputShape },
+        ...opts.peers.claude === undefined ? {} : { mcpModule: opts.peers.claude },
+        ...opts.advisor === undefined ? {} : { advisor: opts.advisor },
         onOpened: noteOpened
       }, { prompt: args.prompt, options: forwardableOptions(options, opts.brand === undefined ? undefined : brand), input: official, selection: decided });
     }
-    const winterQuery = opts.peers.winter.query({ prompt: args.prompt, options: forwardableOptions(options, opts.brand === undefined ? undefined : brand) });
+    const winterQuery = opts.peers.winter.query({ prompt: args.prompt, options: forwardableOptions(options, opts.brand === undefined ? undefined : brand, capabilityServers) });
     noteOpened("winter-agent");
     return winterQuery;
   };
@@ -6617,63 +6704,54 @@ function createRuntimeSdk(opts) {
   return sdk;
 }
 export {
-  CHILD_PROVIDER_UNAVAILABLE,
-  D14_CLAUDE_OAUTH_APPROVED_DEFAULT,
-  EXECUTION_INDIRECTION_ENV_NAMES,
-  EXECUTION_INDIRECTION_ENV_PREFIXES,
-  LIST_AGENTS_FIELD_MAX,
-  MATERIALIZED_RESUME_PROBE_REPORTS,
-  NATIVE_LIST_AGENTS_OUTPUT_SCHEMA,
-  NATIVE_LIST_AGENTS_SCHEMA,
-  NATIVE_SEND_MESSAGE_SCHEMA,
-  NotImplementedYet,
-  RESUME_STAGING_PREFIX,
-  ROUTER_ONLY_OPTION_KEYS,
-  RuntimeHandoffRequiredError,
-  RuntimeLaunchInputError,
-  RuntimeSdkDisposedError,
-  RuntimeSdkError,
-  RuntimeSdkVersionError,
-  SELECTION_RULES,
-  SEND_MESSAGE_SUMMARY_MAX,
-  SEND_MESSAGE_TO_MAX,
-  SUPPORTED,
-  SUPPORTED_PROTOCOL_VERSIONS,
-  SelectionRefusedError,
-  TRAFFIC_OPT_OUT_VARIABLES,
-  TRAFFIC_OPT_OUT_VARIABLE_NAMES,
-  UNKNOWN_VERSION,
-  UnaddressableEntryError,
-  VERSION_EXPORT_NAMES,
-  acceptNativeListAgentsArgs,
-  acceptNativeSendMessageArgs,
-  assertVersionMatrix,
-  createAttachedSessionRegistry,
-  createInMemoryRuntimeDirectoryStore,
-  createMessagingToolHandlers,
-  createOfficialInputStream,
-  createRuntimeMessaging,
-  createRuntimeSdk,
-  forwardableOptions,
-  isExecutionIndirectionVariable,
-  isOfficialQuery,
-  isResumeStagingRoot,
-  isSelectionRefusal,
-  materializedResumeReportForPin,
-  officialConnectionEnv,
-  officialCredentialPlan,
-  officialUserTurn,
-  parseVersion,
-  readExportedVersion,
-  readResolvedManifestVersion,
-  resumeChildSelection,
-  resumeStagingRoot,
-  reviewPersistedSelection,
-  ruleIdOf,
-  runtimeSdkInternals,
-  satisfiesRange,
-  selectChildRuntime,
-  selectChildRuntimePairing,
+  selectionVersionsFrom,
   selectRuntime,
-  selectionVersionsFrom
+  selectChildRuntimePairing,
+  selectChildRuntime,
+  satisfiesRange,
+  runtimeSdkInternals,
+  ruleIdOf,
+  reviewPersistedSelection,
+  resumeStagingRoot,
+  resumeChildSelection,
+  readResolvedManifestVersion,
+  readExportedVersion,
+  parseVersion,
+  officialUserTurn,
+  officialCredentialPlan,
+  officialConnectionEnv,
+  materializedResumeReportForPin,
+  isSelectionRefusal,
+  isResumeStagingRoot,
+  isOfficialQuery,
+  isExecutionIndirectionVariable,
+  forwardableOptions,
+  createRuntimeSdk,
+  createRuntimeMessaging,
+  createOfficialInputStream,
+  createInMemoryRuntimeDirectoryStore,
+  createAttachedSessionRegistry,
+  assertVersionMatrix,
+  VERSION_EXPORT_NAMES,
+  UnaddressableEntryError,
+  UNKNOWN_VERSION,
+  TRAFFIC_OPT_OUT_VARIABLE_NAMES,
+  TRAFFIC_OPT_OUT_VARIABLES,
+  SelectionRefusedError,
+  SUPPORTED_PROTOCOL_VERSIONS,
+  SUPPORTED,
+  SELECTION_RULES,
+  RuntimeSdkVersionError,
+  RuntimeSdkError,
+  RuntimeSdkDisposedError,
+  RuntimeLaunchInputError,
+  RuntimeHandoffRequiredError,
+  ROUTER_ONLY_OPTION_KEYS,
+  RESUME_STAGING_PREFIX,
+  NotImplementedYet,
+  MATERIALIZED_RESUME_PROBE_REPORTS,
+  EXECUTION_INDIRECTION_ENV_PREFIXES,
+  EXECUTION_INDIRECTION_ENV_NAMES,
+  D14_CLAUDE_OAUTH_APPROVED_DEFAULT,
+  CHILD_PROVIDER_UNAVAILABLE
 };