@yanlinglabs/winter-runtime-sdk 0.0.1

package/dist/seams/handoff.d.ts

@@ -0,0 +1,77 @@
+import type { SessionKey } from "@yanlinglabs/winter-agent-sdk";
+import type { RuntimeKind, RuntimeSelection, SelectionRefusal } from "../selection/runtime-selection.js";
+import type { SelectionReview } from "../selection/select-runtime.js";
+/**
+ * WHAT THE DESTINATION BRANCH WOULD ACTUALLY RUN — Lane D's door, consulted at plan time.
+ *
+ * WHY THE PLAN CARRIES THIS AT ALL. The barrier moves a session between two runtimes that do not
+ * serve the same providers, and until this field existed the plan simply carried the SOURCE's
+ * persisted provider fields with the destination's `runtimeKind` stamped over them. That is a plan a
+ * host can confirm and a destination must then refuse — a `gemini` row handed to the official
+ * runtime, or a Claude OAuth credential handed to Winter, which D28 says never routes there. The
+ * refusal arrived at the destination's `confirmInit`, after the lease, the drain and the staging.
+ *
+ * `refused` IS A TYPED REFUSAL, NEVER A SUBSTITUTION. The barrier does not invent a provider the
+ * destination can serve — "deciding a session serves a different provider is the selector's
+ * business" (WS-00 §2's D13) — so the plan says why, `plan.steps[7]` carries the same sentence as
+ * `knownUnprovable`, and `execute()` offers the visibly lossy fork WS-05 §12 asks for instead of
+ * moving ownership.
+ *
+ * `unreviewed` IS THE HONEST DEFAULT when the host supplies no catalog to review against: nothing was
+ * checked, the persisted record travels as it always did, and the plan says so rather than implying a
+ * check that did not happen.
+ */
+export type HandoffSelection = {
+    kind: "servable";
+    selection: RuntimeSelection;
+    review: SelectionReview;
+} | {
+    kind: "refused";
+    refusal: SelectionRefusal;
+    detail: string;
+} | {
+    kind: "unreviewed";
+    selection: RuntimeSelection;
+    detail: string;
+};
+/** WS-05 §12's eight steps, by number, so an outcome can name exactly where it stopped. */
+export type HandoffStepNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export interface HandoffStep {
+    step: HandoffStepNumber;
+    /** The step's own name, e.g. "acquire the handoff lease" / "compare the canonical tail". */
+    name: string;
+    /**
+     * Whether this step is known to be unprovable BEFORE execution starts — a plan a host can be shown
+     * honestly ("this will be a fork, here is why") rather than one that looks clean and then refuses.
+     */
+    knownUnprovable?: string;
+}
+export interface HandoffPlan {
+    session: SessionKey;
+    from: RuntimeKind;
+    to: RuntimeKind;
+    /** The eight steps, in order. */
+    steps: HandoffStep[];
+    /** WS-13 §8.2's two doors: decorations in the materialized copy, or one labelled handoff entry. */
+    decorationDoor: "preferred" | "fallback";
+    /** WS-05 §12 step 7 / §9.1: destination Winter ADOPTS the temp root; destination Claude gets a CLONE-COPY. */
+    tempContinuity: "adopt" | "clone-copy";
+    /** What the DESTINATION would run this session on, or the typed refusal that says it cannot. */
+    selection: HandoffSelection;
+}
+export type HandoffOutcome = {
+    kind: "resumed";
+    selection: RuntimeSelection;
+} | {
+    kind: "lossy-fork-offered";
+    reason: string;
+    step: HandoffStepNumber;
+} | {
+    kind: "blocked";
+    reason: "repair-required" | "mirror-error" | "lease-held";
+};
+/** WS-05 §12's mechanics. Lane C implements; the spine pins the signature. */
+export interface HandoffBarrier {
+    plan(session: SessionKey, to: RuntimeKind): Promise<HandoffPlan>;
+    execute(plan: HandoffPlan): Promise<HandoffOutcome>;
+}

package/dist/seams/index.d.ts

@@ -0,0 +1,11 @@
+export type { SeamContext, SeamContextWithDirectory } from "./context.js";
+export type { RuntimeDirectory, DirectoryResolution, DirectoryResolutionContext, RuntimeDirectoryRecovery, RuntimeDirectoryRecoveryStep } from "./directory.js";
+export type { CursorStore, DeliveryRecord, DeliveryRecordStore, HeldMessageRecord, IdleSubscriptionRecord, IdleSubscriptionStore, MailboxStore, NameLeaseRecord, NameLeaseStore, RuntimeDirectoryEntry, RuntimeDirectoryStore, RuntimeTransport, } from "./directory-store.js";
+export { createInMemoryRuntimeDirectoryStore } from "./directory-store.js";
+export type { GlobalMessaging, SendMessageRequest } from "./global-messaging.js";
+export type { HandoffBarrier, HandoffOutcome, HandoffPlan, HandoffStep, HandoffStepNumber } from "./handoff.js";
+export type { KeychainSeam } from "./keychain.js";
+export type { MaterializedResumeDecorator, MaterializedResumeDoor, MaterializedResumeInput, MaterializedResumeProbeId, MaterializedResumeProbeReport, MaterializedResumeProbeResult, MaterializedResumeResult, } from "./materialized-resume.js";
+export type { DeliveryOutcome, GlobalAgentMessage, ListedRuntimeObject, PermissionClassLabel, RuntimeAddress, RuntimeMessagingAdapter, RuntimeObjectKind, SerializedRuntimeAddress, } from "./messaging-contract.js";
+export type { OfficialSdkModule, OfficialSpawnOptions, OfficialSpawnedProcess, } from "./official-sdk-shapes.js";
+export type { EnvInput, OfficialAdapter, OfficialLaunchPlan, OfficialLaunchProfile, OfficialOptions, OfficialQuery, OfficialResumePlan, OfficialSession, OfficialSpawnClaudeCodeProcess, OfficialUserMessage, OptionsTemplateInput, } from "./official-adapter.js";

package/dist/seams/keychain.d.ts

@@ -0,0 +1,11 @@
+import type { CredentialRef } from "@yanlinglabs/winter-agent-sdk";
+export interface KeychainSeam {
+    /**
+     * The credential material for `ref`, or `undefined` when the host has none for it.
+     *
+     * `undefined` is a normal answer, not an error: the selector's own `CredentialPresence` is what
+     * decides whether a route is available, and a missing credential at spawn is a typed refusal
+     * (WS-10's `child-provider-unavailable`), never a throw from the middle of a launch.
+     */
+    read(ref: CredentialRef): Promise<string | undefined>;
+}

package/dist/seams/materialized-resume.d.ts

@@ -0,0 +1,46 @@
+import type { SessionKey } from "@yanlinglabs/winter-agent-sdk";
+import type { RuntimeKind } from "../selection/runtime-selection.js";
+export type MaterializedResumeDoor = "preferred" | "fallback";
+/** The four probes that gate PREFERRED (WS-17 §8's row-129 narrative). */
+export type MaterializedResumeProbeId = "neighbor-file-survival" | "no-wash-back" | "sidecar-round-trip" | "crash-pairs";
+export interface MaterializedResumeProbeResult {
+    probe: MaterializedResumeProbeId;
+    passed: boolean;
+    /** What was observed — recorded whether it passed or not, so "enabled" is always attributable. */
+    evidence: string;
+}
+export interface MaterializedResumeProbeReport {
+    /** PREFERRED is open only when every probe passed. */
+    door: MaterializedResumeDoor;
+    results: MaterializedResumeProbeResult[];
+    /** ISO-8601. */
+    probedAt: string;
+}
+export interface MaterializedResumeInput {
+    session: SessionKey;
+    /** The runtime the resumed generation will run on — it decides what a decoration may say. */
+    to: RuntimeKind;
+    /** Path of the materialized copy the destination runtime will read. */
+    materializedPath: string;
+    /** The handoff note the destination's first generation should see. */
+    decoration: {
+        kind: "handoff";
+        from: RuntimeKind;
+        at: string;
+        text: string;
+    };
+}
+export interface MaterializedResumeResult {
+    door: MaterializedResumeDoor;
+    /** The file the destination runtime is pointed at (the materialized copy under PREFERRED). */
+    resumePath: string;
+    /** True when the canonical transcript was NOT written to — the property PREFERRED exists for. */
+    canonicalUntouched: boolean;
+}
+/** WS-13 §8.2's decoration doors. Lane C implements; the spine pins the signature. */
+export interface MaterializedResumeDecorator {
+    /** Which door is currently open, per the last probe run. */
+    readonly door: MaterializedResumeDoor;
+    probe(): Promise<MaterializedResumeProbeReport>;
+    decorate(input: MaterializedResumeInput): Promise<MaterializedResumeResult>;
+}

package/dist/seams/messaging-contract.d.ts

@@ -0,0 +1,29 @@
+import type { RuntimeKind } from "../selection/runtime-selection.js";
+export type { RuntimeKind };
+export type { 
+/** WS-10 §11 (messaging companion §4). */
+RuntimeObjectKind, 
+/** WS-10 §11's addressing record. `winterSessionId` is the product id (`s_<hex>`, WS-01 §4). */
+RuntimeAddress, 
+/** WS-10 §10.2's listing element. */
+ListedRuntimeObject, 
+/** WS-15 §6.2 / WS-10 §12's outcome union — ten arms, no eleventh. */
+DeliveryOutcome, 
+/** WS-10 §13's inbound classes. */
+PermissionClassLabel, 
+/** The fully-resolved, ADDRESSED envelope — never the model-facing `SendMessage` input schema. */
+GlobalAgentMessage, 
+/** WS-10 §15's runtime adapter contract. Lane B implements two of these. */
+RuntimeMessagingAdapter, } from "@yanlinglabs/winter-agent-sdk/messaging";
+/**
+ * WS-10 §11's opaque serialization: `session:<winterSessionId>` / `agent:<parent>:<childId>`.
+ *
+ * Runtime kind and backend ids live in the directory record, never trusted from user or model text —
+ * which is why a router that parses one of these must overlay `runtimeKind` from its own entry (the
+ * subpath's own barrel says so at length; `resolveTarget` does it wherever a listing row is at hand).
+ *
+ * DECLARED HERE rather than re-exported: the subpath types a serialized address as the bare `string`
+ * on `ListedRuntimeObject.address`, and this alias is the router's name for that string — the key
+ * every `RuntimeDirectoryStore` method takes.
+ */
+export type SerializedRuntimeAddress = string;

package/dist/seams/official-adapter.d.ts

@@ -0,0 +1,125 @@
+import type { BrandProfile, SessionStore } from "@yanlinglabs/winter-agent-sdk";
+import type { SerializedRuntimeAddress } from "./messaging-contract.js";
+import type { OfficialOptions, OfficialQuery, OfficialSpawnClaudeCodeProcess, OfficialUserMessage } from "./official-sdk-shapes.js";
+import type { RuntimeSelection } from "../selection/runtime-selection.js";
+export type { OfficialOptions, OfficialQuery, OfficialSpawnClaudeCodeProcess, OfficialUserMessage };
+/**
+ * WS-14 §1: `CLAUDE_CONFIG_DIR` has TWO values by launch profile.
+ *
+ * `fresh-spool` — `<winterHome>/runtimes/official-agent-spool`, the spool a fresh or spool-resident
+ * generation lives in. `store-backed-resume` — `<tmpdir>/claude-resume-<uuid>`, a throwaway root for
+ * a generation resumed out of the shared session store.
+ */
+export type OfficialLaunchProfile = "fresh-spool" | "store-backed-resume";
+/**
+ * R-7b-11: whether this session lets the pinned runtime fetch its REMOTE FEATURE CONFIGURATION.
+ *
+ * `"deny"` IS THE DEFAULT AND IT IS A PIN QUESTION, not a privacy preference. Measured on 0.3.250,
+ * same binary, same options, same endpoint: with the four traffic opt-outs unset the runtime
+ * advertises 25 tools; with them set, 21 — `DesignSync`, `Monitor`, `PushNotification` and
+ * `advisor_20260301:advisor` appear only when a feature-flag CDN answers. So "the official branch's
+ * tool surface" is a property of the artifact ONLY when that fetch is off; with it on, one pin has as
+ * many tool surfaces as the CDN has days, and WS-02 §6.1's "a new official version is a reviewed
+ * compatibility event" is defeated without any version changing.
+ *
+ * `"allow"` is the host saying it wants the runtime's own remote configuration anyway — a deliberate,
+ * documented choice (WS-14 §3's "unless explicitly configured"), and one that is RECORDED on the
+ * session's directory entry (`RuntimeDirectoryEntry.remoteConfig`) so a later reader can tell which
+ * of the two surfaces a session actually ran with.
+ */
+export type RemoteConfigPolicy = "deny" | "allow";
+/** What `buildOptions` is given. Every field is something WS-14 §2/§5 pins as normative. */
+export interface OptionsTemplateInput {
+    mode: "code" | "dispatch" | "chat";
+    selection: RuntimeSelection;
+    cwd: string;
+    /** The ONE shared store instance/version both branches consume (WS-05 §6, WS-14 §5). */
+    sessionStore: SessionStore;
+    /** The one shared auto-memory directory, identical for both branches (WS-14 §2). */
+    autoMemoryDirectory: string;
+    /** Winter-owned names come from here; Claude-mirroring literals stay fixed (WS-01 §5 / D16). */
+    brand: BrandProfile;
+    /** WS-14 §5.1: the VENDORED runtime — never the user's installed Claude binary. */
+    pathToClaudeCodeExecutable: string;
+    spawnProxy: OfficialSpawnClaudeCodeProcess;
+    profile: OfficialLaunchProfile;
+    /** The value this generation is CONFIGURED with; §6's observed value is what gets recorded. */
+    configDir: string;
+}
+/** What `buildChildEnv` is given. WS-14 §3: the child env is a REPLACEMENT built from an allowlist. */
+export interface EnvInput {
+    selection: RuntimeSelection;
+    configDir: string;
+    /**
+     * The RESOLVED brand profile (I2). Every Winter-owned name in the child environment derives from
+     * it — `envName(brand, …)` for anything this branch is told to pass, and the spool/home segments
+     * WS-14 §1 builds. Never a literal: the brand gate forbids one, and a reuser's child would
+     * otherwise be handed Winter's names.
+     */
+    brand: BrandProfile;
+    /**
+     * Exactly one auth family's variables, fetched from the host's Keychain seam AT SPAWN and never
+     * written to disk (WS-14 §12). The adapter must not retain them (§6).
+     */
+    credentials: Readonly<Record<string, string>>;
+    /** The minimal OS variables the child needs (PATH, HOME, …). Nothing is inherited implicitly. */
+    base?: Readonly<Record<string, string>>;
+}
+export interface OfficialLaunchPlan {
+    /**
+     * The session's canonical directory address (P7b fix round 1, review r1 M3 — a granted seam edit).
+     *
+     * WITHOUT IT THE DEFAULT ADAPTER RECORDS NOTHING. §6 rule 2's durable record is written onto this
+     * session's `RuntimeDirectoryEntry` (`configDir`, `processIdentity`), and the entry is addressed —
+     * so an adapter built with no explicit sink had nowhere to write and silently defaulted to a no-op.
+     * Carrying the address on the plan is what lets `createOfficialAdapter(context)` default its sink to
+     * the directory store the spine already hands it.
+     */
+    address: SerializedRuntimeAddress;
+    selection: RuntimeSelection;
+    prompt: string | AsyncIterable<OfficialUserMessage>;
+    options: OfficialOptions;
+    profile: OfficialLaunchProfile;
+    configDir: string;
+    cwd: string;
+    /**
+     * R-7b-11's choice for THIS session. Absent = `"deny"`, the shipped default.
+     *
+     * It travels on the plan rather than on the adapter's policy because it is a per-SESSION fact that
+     * has to be recorded on the session's own directory row — and because the env this plan carries was
+     * built with the same answer, so the two cannot drift apart without the plan saying so.
+     */
+    remoteConfig?: RemoteConfigPolicy;
+}
+export interface OfficialResumePlan extends OfficialLaunchPlan {
+    /** The backend session id to resume (WS-05 §7's resolution rules apply to finding it). */
+    resume: string;
+    /** A visible fork rather than a resume (WS-00 §2 D13's "never a silent rewrite"). */
+    forkSession?: boolean;
+}
+/** A live official generation. The `query` is the official SDK's own — the stream passes through. */
+export interface OfficialSession {
+    readonly query: OfficialQuery;
+    /**
+     * The `CLAUDE_CONFIG_DIR` this generation actually got, read from `SpawnOptions.env` — never the
+     * value that was configured (WS-14 §6 rule 2).
+     *
+     * THE DURABLE HALF OF THAT RULE IS `RuntimeDirectoryEntry.configDir`, and this field is the live
+     * copy beside it. Until fix round 2 this doc comment promised a record with no sink behind it;
+     * recording it is Lane A's spawn proxy's job, before the process is returned, and the seam that
+     * receives it is the directory store's.
+     */
+    readonly configDir: string;
+    readonly profile: OfficialLaunchProfile;
+    readonly selection: RuntimeSelection;
+    /** R-7b-11: which of the pin's two tool surfaces this generation was configured for. */
+    readonly remoteConfig: RemoteConfigPolicy;
+}
+/** WS-14 §1–§13. Lane A implements; the spine pins the signature. */
+export interface OfficialAdapter {
+    launch(plan: OfficialLaunchPlan): OfficialSession;
+    resume(plan: OfficialResumePlan): OfficialSession;
+    buildOptions(input: OptionsTemplateInput): OfficialOptions;
+    buildChildEnv(input: EnvInput): Record<string, string>;
+    readonly spawnProxy: OfficialSpawnClaudeCodeProcess;
+}

package/dist/seams/official-sdk-shapes.d.ts

@@ -0,0 +1,126 @@
+/**
+ * One message in a streaming prompt handed to the official runtime.
+ *
+ * An open record on purpose: the router never reads a field of one. The real `SDKUserMessage` is a
+ * type alias of an object literal, so it carries an implicit index signature and is assignable here.
+ */
+export type OfficialUserMessage = {
+    readonly [key: string]: unknown;
+};
+/**
+ * The official runtime's query handle, reduced to what the router's own surface touches: the message
+ * stream (passed through verbatim — the router never re-shapes it) and WS-14 §9's interrupt.
+ */
+export interface OfficialQuery extends AsyncIterable<unknown> {
+    /**
+     * WS-14 §9: stops the foreground turn while preserving background agents/workflows.
+     *
+     * `Promise<unknown>` and not `Promise<void>`: the pinned 0.3.250 resolves an interrupt RESPONSE
+     * (`Promise<SDKControlInterruptResponse | undefined>`), which the conformance test caught the first
+     * time it ran. The router never reads it, so the seam names it `unknown` rather than re-declaring a
+     * response shape it has no use for.
+     */
+    interrupt(): Promise<unknown>;
+}
+/** WS-14 §6's spawn options — the ONE member the spec makes load-bearing is `env`. */
+export interface OfficialSpawnOptions {
+    command: string;
+    args: string[];
+    cwd?: string;
+    /**
+     * The child environment the official runtime is about to use. WS-14 §1/§6: "the host MUST treat the
+     * value observed in `SpawnOptions.env.CLAUDE_CONFIG_DIR` as authoritative for the generation, not
+     * the value it configured", and it must be durably recorded BEFORE the process is returned.
+     */
+    env: Record<string, string | undefined>;
+    signal: AbortSignal;
+}
+/**
+ * The process handle the official runtime expects back.
+ *
+ * `stdin`/`stdout` are the runtime's own Node stream types and are deliberately NOT re-declared: a
+ * hand-written structural stand-in for `Writable`/`Readable` would be both wrong and unnecessary.
+ * Lane A holds the precise types inside `src/official/**`, where the optional peer may be imported.
+ */
+export interface OfficialSpawnedProcess {
+    stdin: unknown;
+    stdout: unknown;
+    readonly killed: boolean;
+    readonly exitCode: number | null;
+    kill(signal: string): boolean;
+    on(event: "exit", listener: (code: number | null, signal: string | null) => void): void;
+    on(event: "error", listener: (error: Error) => void): void;
+}
+/** WS-14 §6 / D12: the supervised spawn proxy, in the shape the official runtime's own option takes. */
+export type OfficialSpawnClaudeCodeProcess = (options: OfficialSpawnOptions) => OfficialSpawnedProcess;
+/**
+ * The official runtime's `Options`, carrying WS-14 §2's normative fields by name and everything else
+ * through the index signature.
+ *
+ * THE INDEX SIGNATURE IS THE POINT: the router pins the fields the SPEC pins and stays out of the way
+ * of the ~200 it does not. Lane A builds one of these; nothing ever assigns Anthropic's own `Options`
+ * INTO the router (the injected module is typed by `OfficialSdkModule` below), so this type is the
+ * contract on both sides of the seam.
+ */
+export interface OfficialOptions {
+    [key: string]: unknown;
+    /**
+     * WS-14 §2: `[]` — the official branch reads no real settings file at any tier.
+     *
+     * NARROWED TO THE RUNTIME'S OWN THREE VALUES (review r2, NEW-2). `string[]` was WIDER than the
+     * runtime accepts, at a field the spec pins normatively: nothing stopped a lane writing
+     * `settingSources: ["flag"]`, the compiler was happy and the runtime would not have been. The union
+     * is independently authored (three ordinary words), not an Anthropic artifact, and
+     * `official-shapes-conformance.test.ts` now pins BOTH directions on it.
+     */
+    settingSources?: Array<"user" | "project" | "local">;
+    /** WS-14 §2: `{ type: "local", path: "<cwd>/<projectDir>", skipMcpDiscovery: true }`. */
+    plugins?: unknown;
+    /** WS-14 §2: `{ preset: "claude_code" }` — a Claude-mirroring literal, fixed (WS-01 §5 / D16). */
+    systemPrompt?: unknown;
+    plansDirectory?: string;
+    /** WS-14 §2: `true`, with the ONE shared `autoMemoryDirectory` — identical for both branches. */
+    autoMemoryEnabled?: boolean;
+    autoMemoryDirectory?: string;
+    strictMcpConfig?: boolean;
+    /** WS-05 §6 / WS-14 §5: the shared filesystem store instance. Typed `unknown` here because the two SDKs' store types are each other's business; Lane A passes the Winter store through. */
+    sessionStore?: unknown;
+    /** WS-14 §7: `SendMessage` / `ListAgents` redirected onto the Winter MCP server's handlers. */
+    toolAliases?: Record<string, string>;
+    /** WS-14 §6: the supervised proxy. */
+    spawnClaudeCodeProcess?: OfficialSpawnClaudeCodeProcess;
+    /** WS-14 §5.1: the VENDORED runtime — never the user's installed binary. */
+    pathToClaudeCodeExecutable?: string;
+    cwd?: string;
+    /**
+     * WS-14 §3: a REPLACEMENT built from an allowlist; nothing is inherited.
+     *
+     * The value type carries `| undefined` because the pinned runtime's own does — measured by the
+     * conformance test, which refused `Record<string, string>`.
+     */
+    env?: Record<string, string | undefined>;
+    resume?: string;
+    forkSession?: boolean;
+    /** WS-14 §5.1: MUST NOT be combined with `sessionStore`. */
+    persistSession?: boolean;
+    /** WS-14 §5.1: MUST NOT be set at all. */
+    enableFileCheckpointing?: boolean;
+}
+/**
+ * The injected official-SDK module, reduced to what the router calls on it.
+ *
+ * A structural interface rather than `typeof import("@anthropic-ai/claude-agent-sdk")` — see this
+ * file's header. **This is a documented departure from the plan's pinned `RuntimeSdkPeers`**, forced
+ * by the same optionality the plan itself declares: a `typeof import(…)` of an OPTIONAL peer is a
+ * required resolution.
+ *
+ * GROWING IT IS A SPINE EDIT: a lane that needs another member of the injected module (Lane A will
+ * want the MCP-server constructor for WS-14 §11) adds it here, and the conformance test proves the
+ * real module still satisfies it.
+ */
+export interface OfficialSdkModule {
+    query(params: {
+        prompt: string | AsyncIterable<OfficialUserMessage>;
+        options?: OfficialOptions;
+    }): OfficialQuery;
+}

package/dist/seams/stubs.d.ts

@@ -0,0 +1,34 @@
+import type { SeamContext, SeamContextWithDirectory } from "./context.js";
+import type { RuntimeDirectory } from "./directory.js";
+import type { GlobalMessaging } from "./global-messaging.js";
+import type { HandoffBarrier } from "./handoff.js";
+import type { MaterializedResumeDecorator } from "./materialized-resume.js";
+import type { OfficialAdapter } from "./official-adapter.js";
+/**
+ * WS-14 §1–§13 — Lane A.
+ *
+ * Takes the full context because its real factory needs three things from it that nothing else in the
+ * spine reaches: the injected `peers.claude` (to construct a query at all), the `KeychainSeam` (WS-14
+ * §12's "fetched at spawn" — `EnvInput.credentials` arrives already built, so the fetch is Lane A's),
+ * and the resolved `brand`.
+ */
+export declare function stubOfficialAdapter(context: SeamContextWithDirectory): OfficialAdapter;
+/**
+ * WS-15 §6.1 — Lane B.
+ *
+ * Built FIRST, from the context without a directory in it, because everything else takes the
+ * directory. That ordering is why `createRuntimeSdk` hoists it out of the handle's object literal.
+ */
+export declare function stubRuntimeDirectory(context: SeamContext): RuntimeDirectory;
+/** WS-15 §6.2–6.4 — Lane B. Needs the directory (resolution) and the store's new durable sinks (I1). */
+export declare function stubGlobalMessaging(context: SeamContextWithDirectory): GlobalMessaging;
+/** WS-05 §12 — Lane C. Needs the directory and the store to compute `HandoffPlan.from`. */
+export declare function stubHandoffBarrier(context: SeamContextWithDirectory): HandoffBarrier;
+/**
+ * WS-13 §8.2 — Lane C.
+ *
+ * `door` is `"fallback"` and not a throw, deliberately: WS-13 §8.2 makes FALLBACK the always-available
+ * door and PREFERRED the one that four probes must open. "Which door is open" therefore has a correct
+ * answer before the lane lands, and it is this one — reporting `"preferred"` would be the lie.
+ */
+export declare function stubMaterializedResumeDecorator(context: SeamContextWithDirectory): MaterializedResumeDecorator;

package/dist/selection/child-runtime.d.ts

@@ -0,0 +1,81 @@
+import type { ChildSelectionInput, RuntimeSelection, SelectionRefusal } from "./runtime-selection.js";
+/**
+ * R-7b-1: the child's runtime, decided by the CHILD's slot, never inherited from the parent.
+ *
+ * The `parent` argument is read for nothing at all in this function — see
+ * `selectChildRuntimePairing` for the one thing it IS for. It stays in the signature because the
+ * plan, the spine's pinned interface and every call site name it, and because a caller holding a
+ * parent record is exactly the caller who must be told, at the type level, that the parent does not
+ * decide.
+ */
+export declare function selectChildRuntime(parent: RuntimeSelection, child: ChildSelectionInput): RuntimeSelection | SelectionRefusal;
+/**
+ * How a parent and its child can talk (WS-15 §6.1, R-7b-1's last clause).
+ *
+ * `channel` is the bit Lane B's messaging router branches on: a same-runtime pair reaches its child
+ * through that runtime's own adapter (a Winter session's `Query.messaging` facet, an official
+ * session's own child handles), while a CROSS-RUNTIME pair "talks only through the RuntimeDirectory"
+ * — neither runtime can see into the other, so the address must be resolved centrally and the
+ * delivery must go through the router's own adapter for the child's runtime.
+ */
+export interface ChildRuntimePairing {
+    /** The child's own record — the thing that gets persisted with the child. */
+    child: RuntimeSelection;
+    /** The parent's runtime at spawn time, recorded for the pairing only. */
+    parentRuntime: RuntimeSelection["runtimeKind"];
+    /** True when parent and child ended up on different runtimes. */
+    crossRuntime: boolean;
+    /** `directory` exactly when `crossRuntime` — the two are one fact, spelled for the two readers. */
+    channel: "in-runtime" | "directory";
+}
+/** `selectChildRuntime` plus the cross-runtime bit, for the messaging lane. */
+export declare function selectChildRuntimePairing(parent: RuntimeSelection, child: ChildSelectionInput): ChildRuntimePairing | SelectionRefusal;
+/** WS-10's Phase 6.6 amendment: the exact reason prefix a drifted or credential-less child reports. */
+export declare const CHILD_PROVIDER_UNAVAILABLE = "child-provider-unavailable";
+/**
+ * The answer to "can this child be resumed on its own record?" (WS-13c §8, WS-10 §15 amendment).
+ *
+ * `resumed` carries the child's OWN persisted record, by identity — a resume never re-decides and
+ * never rewrites. `unavailable` is `retryable: false` because the two things that produce it (a
+ * credential that is gone, a mapping that drifted to a different provider) are not transient, and
+ * Lane B maps it straight onto `DeliveryOutcome`'s `{ status: "unavailable"; retryable: false; reason }`
+ * with NO generation started.
+ */
+export type ChildResumeOutcome = {
+    kind: "resumed";
+    selection: RuntimeSelection;
+} | {
+    kind: "unavailable";
+    retryable: false;
+    reason: string;
+};
+/**
+ * Re-resolves a child under its OWN recorded model and provider, for a resume or a SendMessage.
+ *
+ * WHAT IT ASKS, precisely: "is the row this child is RECORDED on still servable?" — not "which row
+ * would a fresh decision pick". WS-10's Phase 6.6 amendment requires that "the resolved provider id
+ * must equal the recorded one", and the recorded provider is PINNED into the resolution
+ * (`provider: record.providerId`), so `candidatesFor` drops every other provider's rows before this
+ * function ever sees them: provider equality is enforced by the pin, not by a comparison afterwards.
+ * (It used to be a comparison afterwards, which review r1's M1 measured as unreachable — a live-looking
+ * guard that no drifted catalog could fire.)
+ *
+ * The two things the pin does NOT enforce, and which this function therefore checks:
+ *
+ *   1. THE ROW ITSELF. One provider can serve two rows for one canonical model, so "the pinned
+ *      provider still serves this model" is weaker than "the recorded row is still there". The
+ *      recorded `modelRef` is a provider-qualified row key (row 17's whole point), and it must appear
+ *      among the servable candidates.
+ *   2. THE FAMILY. A row key can move between families across a catalog regeneration, and continuing
+ *      a `claude` child on a row that is now in another family would be "a substitution… a different
+ *      family", which WS-13c §4 forbids in exactly those words.
+ *
+ * Either miss is a refusal, never a fall-back onto whichever sibling row still has a credential — that
+ * silent re-routing is what would strand a session's continuation on a backend it never ran on.
+ *
+ * THE RUNTIME IS NEVER RE-DECIDED EITHER. Even when the resolution succeeds, the returned selection is
+ * the persisted record, not a new one — "resume and SendMessage follow the child's record, never the
+ * parent's current runtime" (R-7b-1), and a resume that re-ran the D13 table could move a live child
+ * between runtimes on a credential change.
+ */
+export declare function resumeChildSelection(record: RuntimeSelection, context: Omit<ChildSelectionInput, "slot" | "model" | "provider">): ChildResumeOutcome;