super-dsh 0.1.5 → 0.1.9

package/superd-hub/dist/system-head.js

@@ -10,16 +10,10 @@
  * (before any step) — so every bridge-written log violated one rule or the
  * other and became unresumable across restarts.
  *
- * The native loop never hits this because it opens the step before writing
- * anything: `turn/start → step/start → system/message → user/message …`,
- * and later prompt changes REPLACE the protected head (the operation
- * compaction also uses). This module gives bridge adapters that posture with
- * a one-line wrap:
- *
- *   this.session = withSystemHead(session, () => createSystemMessage(""))
- *
- * The wrap is a transparent Proxy that tracks the open turn/step (exactly as
- * the v4 reader does) and intervenes minimally:
+ * The wrap installs the co-writer as OWN PROPERTIES on the session object
+ * itself (an `append` own-property shadow over the prototype method, plus
+ * `stampSystemPrompt`) and tracks the open turn/step (exactly as the v4
+ * reader does), intervening minimally:
  *
  *   - the FIRST `user/message` append on a still-headless, still-empty
  *     surface first opens the turn's next step (when a turn is open but no
@@ -35,6 +29,18 @@
  *     queued and flushed inside the next step the adapter opens;
  *   - everything else delegates unchanged.
  *
+ * IDENTITY IS THE CONTRACT (2026-09-28, D1): the wrap must return the session
+ * object ITSELF, never a wrapper. Upstream identity-checks live sessions by
+ * object equality — `session-title`'s `rename()` refuses unless
+ * `ctx.sessions.get(session.id) === session` (session-title/src/index.ts),
+ * and adapters register the RAW prepared session with `sessions.enter()` /
+ * `announce()` (e.g. agent-pi/src/index.ts). An earlier revision returned a
+ * transparent `Proxy`; every world-context rename then failed with
+ * `session "<id>" is not live in this store` because the Agent handle's
+ * `session` (the Proxy) was never the store-registered object. Returning the
+ * same object keeps `agent.session === ctx.sessions.get(id)` true, so the
+ * whole upstream session plane (rename included) sees one identity.
+ *
  * A surface that already starts with a user message and has no head (legacy
  * logs) stays headless — valid — and is never stamped: appending a head
  * there is exactly the corruption this module exists to prevent.
@@ -59,14 +65,22 @@ function surfaceIsEmpty(events) {
  * @param session - the adapter's real Session.
  * @param placeholder - builds the placeholder head message when the first
  *   user message arrives on an empty surface.
- * @returns the session (transparently delegated) with `stampSystemPrompt`.
+ * @returns the SAME session object with the co-writer installed as own
+ *   properties (`append` shadow + `stampSystemPrompt`). Identity is the
+ *   contract (D1): upstream liveness checks compare
+ *   `ctx.sessions.get(id) === agent.session`, so the returned object must be
+ *   the one registered with `sessions.enter()` — never a wrapper.
  */
 export function withSystemHead(session, placeholder) {
+    // Idempotent: a session already carrying the co-writer is returned as-is.
+    if (Object.prototype.hasOwnProperty.call(session, 'stampSystemPrompt'))
+        return session;
     // The one narrow this module performs: the loose face above is what makes
     // the generic real Session assignable; every call below issues exactly the
     // SystemHeadAppend shape.
     const appendHead = session.append.bind(session);
     const rawAppend = session.append.bind(session);
+    const rawAppendFull = session.append.bind(session);
     // Reader-mirrored turn/step state.
     let turn = null;
     let step = null;
@@ -115,80 +129,82 @@ export function withSystemHead(session, placeholder) {
         }
         headSeq = appendHead('system/message', { turn: turn ?? turnArg, step: step ?? stepArg, message }, { surfaceOp: { op: 'replace', startSeq: headSeq, endSeq: headSeq }, sourceEventSeqs: [headSeq] }).seq;
     };
-    return new Proxy(session, {
-        get(target, property) {
-            if (property === 'stampSystemPrompt') {
-                return (turnArg, stepArg, message) => { stamp(turnArg, stepArg, message); };
+    const interceptAppend = (type, data, opts) => {
+        if (type === 'turn/start') {
+            turn = data.turn;
+            nextStep = 1;
+            wrapOpenedStep = false;
+            wrapClosedStep = undefined;
+        }
+        else if (type === 'turn/end') {
+            // A step THIS wrap opened must not survive the turn boundary.
+            if (step !== null && wrapOpenedStep) {
+                rawAppend('step/end', { turn, step });
+                wrapClosedStep = step;
+                step = null;
+                nextStep += 1;
+            }
+            turn = null;
+        }
+        else if (type === 'step/start') {
+            const dataStep = data;
+            if (step !== null && wrapOpenedStep && dataStep.turn === turn && dataStep.step === step) {
+                // The adapter opened the step the wrap already wrote: drop the
+                // duplicate (the adapter's own counters stay consistent).
+                return { type, seq: session.snapshotEvents().length, time: Date.now(), data };
+            }
+            if (step === null && dataStep.step !== undefined)
+                step = dataStep.step;
+            wrapOpenedStep = false;
+            const applied = rawAppendFull(type, data);
+            if (queuedStamp !== undefined && step !== null) {
+                const pending = queuedStamp;
+                queuedStamp = undefined;
+                stamp(pending.turn, pending.step, pending.message);
             }
-            if (property === 'append') {
-                return (type, data, opts) => {
-                    if (type === 'turn/start') {
-                        turn = data.turn;
-                        nextStep = 1;
-                        wrapOpenedStep = false;
-                        wrapClosedStep = undefined;
-                    }
-                    else if (type === 'turn/end') {
-                        // A step THIS wrap opened must not survive the turn boundary.
-                        if (step !== null && wrapOpenedStep) {
-                            rawAppend('step/end', { turn, step });
-                            wrapClosedStep = step;
-                            step = null;
-                            nextStep += 1;
-                        }
-                        turn = null;
-                    }
-                    else if (type === 'step/start') {
-                        const dataStep = data;
-                        if (step !== null && wrapOpenedStep && dataStep.turn === turn && dataStep.step === step) {
-                            // The adapter opened the step the wrap already wrote: drop the
-                            // duplicate (the adapter's own counters stay consistent).
-                            return { type, seq: session.snapshotEvents().length, time: Date.now(), data };
-                        }
-                        if (step === null && dataStep.step !== undefined)
-                            step = dataStep.step;
-                        wrapOpenedStep = false;
-                        const applied = rawAppend(type, data);
-                        if (queuedStamp !== undefined && step !== null) {
-                            const pending = queuedStamp;
-                            queuedStamp = undefined;
-                            stamp(pending.turn, pending.step, pending.message);
-                        }
-                        return applied;
-                    }
-                    else if (type === 'step/end') {
-                        const dataStep = data;
-                        if (step === null && wrapClosedStep !== undefined && dataStep.step === wrapClosedStep) {
-                            wrapClosedStep = undefined;
-                            return { type, seq: session.snapshotEvents().length, time: Date.now(), data }; // the wrap already closed it
-                        }
-                        step = null;
-                        if (dataStep.step !== undefined)
-                            nextStep = dataStep.step + 1;
-                    }
-                    else if (type === 'user/message') {
-                        ensureHead();
-                    }
-                    else if (type === 'system/message') {
-                        // A direct adapter append (notices, bootstraps): give it the step
-                        // context the reader demands — open the turn's next step when
-                        // none is open and NORMALIZE the coordinates to that context
-                        // (requireStep compares them for equality; a mismatched append
-                        // is doomed otherwise). Surface ordering beyond the head rules
-                        // stays the adapter's own responsibility.
-                        if (step === null && turn !== null)
-                            openWrapStep();
-                        if (step !== null && turn !== null) {
-                            const direct = data;
-                            if (direct.turn !== turn || direct.step !== step)
-                                data = { ...data, turn, step };
-                        }
-                    }
-                    return Reflect.apply(target.append, target, [type, data, opts]);
-                };
+            return applied;
+        }
+        else if (type === 'step/end') {
+            const dataStep = data;
+            if (step === null && wrapClosedStep !== undefined && dataStep.step === wrapClosedStep) {
+                wrapClosedStep = undefined;
+                return { type, seq: session.snapshotEvents().length, time: Date.now(), data }; // the wrap already closed it
+            }
+            step = null;
+            if (dataStep.step !== undefined)
+                nextStep = dataStep.step + 1;
+        }
+        else if (type === 'user/message') {
+            ensureHead();
+        }
+        else if (type === 'system/message') {
+            // A direct adapter append (notices, bootstraps): give it the step
+            // context the reader demands — open the turn's next step when
+            // none is open and NORMALIZE the coordinates to that context
+            // (requireStep compares them for equality; a mismatched append
+            // is doomed otherwise). Surface ordering beyond the head rules
+            // stays the adapter's own responsibility.
+            if (step === null && turn !== null)
+                openWrapStep();
+            if (step !== null && turn !== null) {
+                const direct = data;
+                if (direct.turn !== turn || direct.step !== step)
+                    data = { ...data, turn, step };
             }
-            const value = Reflect.get(target, property, target);
-            return typeof value === 'function' ? value.bind(target) : value;
-        },
+        }
+        return rawAppendFull(type, data, opts);
+    };
+    // Install the co-writer as OWN PROPERTIES on the session itself. The
+    // `append` shadow covers every holder of the object (the adapter's Agent
+    // AND upstream services that resolved the session from the store); both
+    // properties are non-enumerable so scans/serialization of the session see
+    // nothing, and writable/configurable so it stays an ordinary instance.
+    Object.defineProperty(session, 'append', {
+        value: interceptAppend, writable: true, configurable: true, enumerable: false,
+    });
+    Object.defineProperty(session, 'stampSystemPrompt', {
+        value: (turnArg, stepArg, message) => { stamp(turnArg, stepArg, message); },
+        writable: true, configurable: true, enumerable: false,
     });
+    return session;
 }

package/superd-hub/dist/toast-core.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Toast feedback core (C1 task 4) — the pure, host-half half of the
+ * official-primitive toast: the props seam and the module store. The React
+ * wrapper (the always-mounted host component + element factory) lives in
+ * `src/client/toast.ts`; this split mirrors switch-core (pure logic where
+ * tsc emits and node tests import; the DOM/React face is injected by the
+ * client lane).
+ *
+ * The toast copy rides the platform's `Toast` primitive — top-center
+ * banner, dark surface in both themes, warn-orange icon seat, green
+ * `tone="success"` — rendered by the HOST's React tree through the
+ * primitive's own body portal. Failure notices hold ~6 s: the primitive's
+ * docblock prescribes longer holds for failures that name what broke.
+ *
+ * @module superd-hub/toast-core
+ */
+/** Options: the toast tone and hold window. */
+export interface SuperdToastOptions {
+    /** `'success'` renders the primitive's green check glyph. */
+    tone?: 'success';
+    /** Full-opacity hold before the fade; defaults to {@link TOAST_DEFAULT_HOLD_MS}. */
+    holdMs?: number;
+}
+/** Failures that name what broke need a longer read than a one-liner. */
+export declare const TOAST_DEFAULT_HOLD_MS = 6000;
+/** One pending toast: a monotonic sequence plus its resolved copy. */
+export interface PendingSuperdToast {
+    readonly seq: number;
+    readonly text: string;
+    readonly options: SuperdToastOptions;
+}
+/** The exact props the official primitive receives (pure — the unit seam). */
+export declare function toastProps(text: string, options?: SuperdToastOptions): {
+    text: string;
+    tone?: 'success';
+    holdMs: number;
+};
+/** Fire one toast (best-effort: without a mounted owner nothing renders). */
+export declare function showSuperdToast(text: string, options?: SuperdToastOptions): void;
+/** Clear a shown toast (the fade's `onDone`); stale sequences are no-ops. */
+export declare function clearSuperdToast(done: number): void;
+/** Subscribe to the store (the host's effect face); returns unsubscribe. */
+export declare function onSuperdToast(fn: (toast: PendingSuperdToast | undefined) => void): () => void;

package/superd-hub/dist/toast-core.js

@@ -0,0 +1,63 @@
+/**
+ * Toast feedback core (C1 task 4) — the pure, host-half half of the
+ * official-primitive toast: the props seam and the module store. The React
+ * wrapper (the always-mounted host component + element factory) lives in
+ * `src/client/toast.ts`; this split mirrors switch-core (pure logic where
+ * tsc emits and node tests import; the DOM/React face is injected by the
+ * client lane).
+ *
+ * The toast copy rides the platform's `Toast` primitive — top-center
+ * banner, dark surface in both themes, warn-orange icon seat, green
+ * `tone="success"` — rendered by the HOST's React tree through the
+ * primitive's own body portal. Failure notices hold ~6 s: the primitive's
+ * docblock prescribes longer holds for failures that name what broke.
+ *
+ * @module superd-hub/toast-core
+ */
+/** Failures that name what broke need a longer read than a one-liner. */
+export const TOAST_DEFAULT_HOLD_MS = 6_000;
+/** The exact props the official primitive receives (pure — the unit seam). */
+export function toastProps(text, options = {}) {
+    const props = {
+        text,
+        holdMs: options.holdMs ?? TOAST_DEFAULT_HOLD_MS,
+    };
+    if (options.tone !== undefined)
+        props.tone = options.tone;
+    return props;
+}
+// ---- the module store (last-wins; transient notices never queue) ----------
+let seq = 0;
+let current;
+const listeners = new Set();
+function emit() {
+    for (const fn of [...listeners]) {
+        try {
+            fn(current);
+        }
+        catch { /* a broken listener never breaks the store */ }
+    }
+}
+/** Fire one toast (best-effort: without a mounted owner nothing renders). */
+export function showSuperdToast(text, options = {}) {
+    current = { seq: ++seq, text, options };
+    emit();
+}
+/** Clear a shown toast (the fade's `onDone`); stale sequences are no-ops. */
+export function clearSuperdToast(done) {
+    if (current === undefined || current.seq !== done)
+        return;
+    current = undefined;
+    emit();
+}
+/** Subscribe to the store (the host's effect face); returns unsubscribe. */
+export function onSuperdToast(fn) {
+    listeners.add(fn);
+    // Initial push: an owner mounting after a toast fired still shows it
+    // (the host's effect subscribes post-mount).
+    try {
+        fn(current);
+    }
+    catch { /* a broken listener never breaks the store */ }
+    return () => { listeners.delete(fn); };
+}

package/superd-hub/dist/wire-endpoints.d.ts

@@ -0,0 +1,264 @@
+/**
+ * Session-plane wire vocabulary (mesh P3 Task 1).
+ *
+ * The hub CALLS the native session-plane RPCs through a GatewayFace
+ * (`CarrierGatewayFace.dispatchRpc` / `.openWireStream`, P2 machinery — local
+ * in-process or remote wire). These endpoint strings are exactly the ones the
+ * official browser UI reaches the Host through: the generated
+ * `ctx.remote.session` namespace emits `connection.rpc.call('/api', endpoint,
+ * { args }, signal)` with `endpoint = '<namespace>/<method>'`, and the native
+ * gateway dispatches that same string.
+ *
+ * Every constant below is extracted from the upstream checkout
+ * (`upstream/deepseek-harness` @ `dsh-v0.1.7-rc.1`, read-only). Each JSDoc
+ * block carries the primary anchor (the `@Remote` declaration on the Host
+ * controller) plus the payload-type anchor. Missing methods are `undefined`
+ * with a comment — names are NEVER invented here.
+ *
+ * Wire-arg convention (how a GatewayFace payload is built):
+ *   payload = { args: { <parameterWireName>: <value> } }
+ * The client gateway builds it at
+ * `packages/api/gateway/src/client/index.ts:445` (`{ args: prepared.args }`,
+ * with `args[parameter.wire] = value` at :525); the Host gateway unpacks it at
+ * `packages/api/gateway/src/index.ts:692–704` (`assertExactArguments` +
+ * `resolveParameter` per declared parameter). For every session-plane method
+ * the single business parameter is named `request` — EXCEPT `session/list`,
+ * whose parameter is declared `_request` (the controller ignores it), so its
+ * args key is `_request`. The trailing `signal` parameter never travels in
+ * `args` (it is carried by the envelope/stream carrier, not the payload).
+ *
+ * Namespace binding: `super(ctx, 'sessionController', { namespace: 'session' })`
+ * — packages/api/session-controller/src/index.ts:136 (Cordis service key
+ * `sessionController`, wire namespace `session`).
+ */
+/**
+ * `session/list` — cold Session list (the sidebar's session rows).
+ *
+ * Upstream anchors:
+ * - `@Remote('list')`: packages/api/session-controller/src/index.ts:251
+ *   (method `list(_request: SessionListRequest, signal)` at :252)
+ * - payload type: packages/api/session-controller/src/types.ts:262
+ *   (`SessionListRequest`), value at :267 (`SessionListValue`)
+ * - generated client string: packages/api/session-controller/lib/typert.remote-client.d.ts:47
+ * - wire-arg key quirk: `_request` (declared name, ignored by the Host) —
+ *   typert.remote-client.js `session/list` descriptor, parameter wire `_request`
+ *
+ * Wire payload: `{ args: { _request: SessionListRequestMirror } }`.
+ */
+export declare const WIRE_SESSION_LIST = "session/list";
+/**
+ * `session/create` — create a Session (or adopt an explicit id).
+ *
+ * Upstream anchors:
+ * - `@Remote('create')`: packages/api/session-controller/src/index.ts:272
+ *   (method `create(request: SessionCreateRequest)` at :273)
+ * - payload type: packages/api/session-controller/src/types.ts:283
+ *   (`SessionCreateRequest`), value at :291 (`SessionCreateValue`)
+ * - generated client string: .../typert.remote-client.d.ts:44
+ *
+ * Wire payload: `{ args: { request: SessionCreateRequestMirror } }`.
+ */
+export declare const WIRE_SESSION_CREATE = "session/create";
+/**
+ * `session/rename` — set a Session's title (the dedicated title-set RPC).
+ *
+ * Upstream anchors:
+ * - `@Remote('rename')`: packages/api/session-controller/src/index.ts:384
+ *   (method `rename(request: SessionRenameRequest)` at :385)
+ * - payload type: packages/api/session-controller/src/types.ts:307
+ *   (`SessionRenameRequest`), value at :313 (`SessionRenameValue`)
+ * - generated client string: .../typert.remote-client.d.ts:53
+ * - invalid title → typed error `session/title-invalid`
+ *   (types.ts:223, thrown at commands.ts:204)
+ *
+ * Wire payload: `{ args: { request: SessionRenameRequestMirror } }`.
+ */
+export declare const WIRE_SESSION_TITLE = "session/rename";
+/**
+ * `session/prompt` — submit one user turn into a Session.
+ *
+ * Upstream anchors:
+ * - `@Remote('prompt')`: packages/api/session-controller/src/index.ts:407
+ *   (method `prompt(request: SessionPromptRequest, signal)` at :408)
+ * - payload type: packages/api/session-controller/src/types.ts:331
+ *   (`SessionPromptRequest`), value at :342 (`SessionPromptValue`)
+ * - generated client string: .../typert.remote-client.d.ts:52
+ * - typed rejections: `session/agent-busy` / `session/attachment-invalid` /
+ *   `session/not-found` (commands.ts:366–398)
+ *
+ * Wire payload: `{ args: { request: SessionPromptRequestMirror } }`.
+ */
+export declare const WIRE_PROMPT_SUBMIT = "session/prompt";
+/**
+ * `session/follow` — open the event/log stream the UI renders (logical stream).
+ *
+ * Upstream anchors:
+ * - `@Remote({ mode: 'stream' })`: packages/api/session-controller/src/index.ts:461
+ *   (method `follow(request: SessionFollowRequest, signal): AsyncIterable<SessionFollowFrame>` at :462)
+ * - payload type: packages/api/session-controller/src/types.ts:485
+ *   (`SessionFollowRequest`), frame union at :550 (`SessionFollowFrame`)
+ * - generated client string: .../typert.remote-client.d.ts:45
+ * - UI consumption: packages/api/session-controller/src/client/transport.ts:172
+ *   (`SessionEventStream.follow` → `remote.session.follow({ address, assistantStream: true, ... })`)
+ *
+ * Wire payload: `{ args: { request: SessionFollowRequestMirror } }`, opened
+ * via `openWireStream` (not `dispatchRpc`). The opening frame is
+ * `{ type: 'snapshot', header, cursor, records, hasMore, projections }`; then
+ * ordered `{ type: 'event', event }` entries.
+ */
+export declare const WIRE_STREAM_OPEN = "session/follow";
+/**
+ * `session/cancel` — cancel/interrupt the active Agent turn.
+ *
+ * Upstream anchors:
+ * - `@Remote('cancel')`: packages/api/session-controller/src/index.ts:438
+ *   (method `cancel(request: SessionCancelRequest)` at :439)
+ * - payload type: packages/api/session-controller/src/types.ts:371
+ *   (`SessionCancelRequest`), value at :376 (`SessionCancelValue`)
+ * - generated client string: .../typert.remote-client.d.ts:41
+ *
+ * Wire payload: `{ args: { request: SessionCancelRequestMirror } }`.
+ */
+export declare const WIRE_TURN_CANCEL = "session/cancel";
+/**
+ * `session/close` / session delete — DOES NOT EXIST upstream.
+ *
+ * The session namespace (packages/api/session-controller/src/index.ts:251–501,
+ * complete `@Remote` set: list, search, create, selectModel, modelCatalog,
+ * canOpenWorkspacePath, openWorkspacePath, workspacePathApplications, rename,
+ * fork, prompt, attachment, updateQueue, cancel, page, follow, projections,
+ * control) has no close/dispose/delete/archive method. Session lifetime is
+ * Host-owned (Agent lifecycle + `session/disposed` events); the browser never
+ * closes a session over the wire. The nearest upstream analogues live on a
+ * DIFFERENT namespace (workspace, not session-plane): `workspace/archiveSession`
+ * (packages/api/workspace-controller/src/index.ts:159) and
+ * `workspace/unarchiveSession` (:169). Kept `undefined` per the no-invention
+ * rule; Task 2 must not route a close through the session plane.
+ */
+export declare const WIRE_SESSION_CLOSE: undefined;
+/**
+ * The session-plane endpoint vocabulary (mesh P3 Task 1 deliverable).
+ * Undefined keys = no upstream counterpart (see the constant's JSDoc).
+ */
+export declare const WIRE: {
+    readonly sessionList: "session/list";
+    readonly sessionCreate: "session/create";
+    readonly sessionTitle: "session/rename";
+    readonly promptSubmit: "session/prompt";
+    readonly streamOpen: "session/follow";
+    readonly turnCancel: "session/cancel";
+    readonly sessionClose: undefined;
+};
+/** Opaque branded string ids on the wire are plain JSON strings here. */
+export type SessionIdMirror = string;
+/** Client-minted prompt identity (`Branded<'session-request-id'>` upstream). */
+export type SessionRequestIdMirror = string;
+/**
+ * MIRROR of upstream `SessionListRequest`
+ * (packages/api/session-controller/src/types.ts:262). Reference data for the
+ * wire caller — not an owned contract.
+ */
+export interface SessionListRequestMirror {
+    readonly cursor?: string;
+}
+/**
+ * MIRROR of upstream `SessionCreateRequest` (types.ts:283). `workspaceId` +
+ * `cwd` name the workspace (cwd alone is accepted), `sessionId` adopts an
+ * explicit id, `agentPreset` selects the composition.
+ */
+export interface SessionCreateRequestMirror {
+    readonly workspaceId?: SessionIdMirror;
+    readonly cwd?: string;
+    readonly sessionId?: SessionIdMirror;
+    readonly agentPreset?: string;
+}
+/** MIRROR of upstream `SessionRenameRequest` (types.ts:307). */
+export interface SessionRenameRequestMirror {
+    readonly sessionId: SessionIdMirror;
+    readonly title: string;
+}
+/**
+ * MIRROR of upstream `PromptContentPart` (types.ts:89): browser-submitted
+ * prompt content; the Host promotes image bytes to durable references.
+ */
+export type PromptContentPartMirror = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'image';
+    readonly mediaType: string;
+    readonly data: string;
+    readonly name?: string;
+} | {
+    readonly type: 'file';
+    readonly receiptId: string;
+};
+/**
+ * MIRROR of upstream `SessionPromptRequest` (types.ts:331). `mode` picks
+ * delivery: `'queue'` waits for the live turn, `'steer'` steers it.
+ */
+export interface SessionPromptRequestMirror {
+    readonly requestId: SessionRequestIdMirror;
+    readonly sessionId: SessionIdMirror;
+    readonly mode: 'queue' | 'steer';
+    readonly content: readonly PromptContentPartMirror[];
+    readonly clientTimeZone?: string;
+}
+/**
+ * MIRROR of upstream `SessionAddress` (types.ts:406): one ordinary Session or
+ * one direct subagent child.
+ */
+export type SessionAddressMirror = {
+    readonly kind: 'session';
+    readonly sessionId: SessionIdMirror;
+} | {
+    readonly kind: 'subagent';
+    readonly parentSessionId: SessionIdMirror;
+    readonly childSessionId: SessionIdMirror;
+    readonly mode: 'one-shot' | 'continuable' | 'unknown';
+};
+/**
+ * MIRROR of upstream `SessionFollowRequest` (types.ts:485; page-budget fields
+ * from `SessionPageRequest` at :469–482). The UI always passes
+ * `assistantStream: true` (transport.ts:172–175) to opt into live
+ * assistant-stream frames.
+ */
+export interface SessionFollowRequestMirror {
+    readonly address: SessionAddressMirror;
+    readonly assistantStream?: true;
+    readonly maxMessages?: number;
+    readonly turnWindow?: {
+        readonly minMessages: number;
+        readonly minTurns: number;
+    };
+}
+/** MIRROR of upstream `SessionCancelRequest` (types.ts:371). */
+export interface SessionCancelRequestMirror {
+    readonly sessionId: SessionIdMirror;
+}
+/**
+ * Wire-arg wrapper keys per endpoint, as the native gateway's
+ * `assertExactArguments`/`resolveParameter` expects them
+ * (packages/api/gateway/src/index.ts:692–704; client builds
+ * `{ args: { [parameter.wire]: value } }` at api/gateway/src/client/index.ts:525).
+ * `session/list` alone uses `_request` (its controller parameter is declared
+ * `_request` and ignored).
+ */
+export declare const WIRE_ARGS: {
+    readonly "session/list": "_request";
+    readonly "session/create": "request";
+    readonly "session/rename": "request";
+    readonly "session/prompt": "request";
+    readonly "session/follow": "request";
+    readonly "session/cancel": "request";
+};
+/**
+ * Build the GatewayFace payload (`{ args: { <key>: value } }`) for one
+ * session-plane endpoint.
+ * @param endpoint - one of the defined `WIRE` constants.
+ * @param value - the mirrored request object for that endpoint.
+ * @returns the wire payload accepted by `dispatchRpc`/`openWireStream`.
+ */
+export declare function wireArgsOf(endpoint: string, value: unknown): {
+    args: Record<string, unknown>;
+};