@xrkseek/harness-cli 0.1.1 → 0.1.3

package/product-web/plugins/@xrkseek/client-connection/client.js

@@ -4,8 +4,6 @@ window.__ModuleLoader__.load({
 		var module = { exports: {} };
 		var exports = module.exports;
 		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-		let _xrkseek_xrk_llm_message = require("@xrkseek/xrk-llm/message");
-		let _xrkseek_xrk_llm_brand = require("@xrkseek/xrk-llm/brand");
 		//#region src/client/connection.ts
 		const CONNECTION_DEFAULTS = {
 			backoffBaseMs: 500,
@@ -147,16 +145,155 @@ window.__ModuleLoader__.load({
 			}
 		};
 		//#endregion
-		//#region ../../stubs/xrk-session/lib/types/surface.js
+		//#region ../../stubs/xrk-llm/src/brand.ts
 		/**
-		* Surface layer on top of the session event log: an ordered view of events
-		* that produce LLM messages. The append-only log remains the source of truth.
-		*
-		* Browser-safe: web clients consume this subpath export, so it must stay free
-		* of `node:` imports (they break the vite bundle).
-		*
-		* @module @xrkseek/xrk-session/surface
+		* Brand a message identifier.
+		* @param id - the opaque message identifier.
+		* @returns the same string, branded; no validation is performed.
+		*/
+		function MessageId(id) {
+			return id;
+		}
+		/**
+		* Brand a string as a {@link CallId}.
+		* @param id - the provider-issued (or synthesized) call id.
+		* @returns the same string, branded; no validation is performed.
+		*/
+		function CallId(id) {
+			return id;
+		}
+		//#endregion
+		//#region ../../stubs/xrk-llm/src/call-config.ts
+		/**
+		* Deep-freeze a value in place with an iterative traversal, guarding cycles,
+		* so later mutation throws without imposing a JavaScript call-stack depth cap.
+		* {@link AbortSignal} objects are deliberately skipped because they are the
+		* request's live cancellation channel and freezing them breaks abort.
+		* @param value - the value to freeze in place.
+		* @returns the same value, frozen.
+		*/
+		function deepFreeze(value) {
+			const seen = /* @__PURE__ */ new WeakSet();
+			const pending = [{
+				kind: "visit",
+				node: value
+			}];
+			while (pending.length > 0) {
+				const task = pending.pop();
+				/* v8 ignore next -- the loop condition guarantees one pending task. */
+				if (task === void 0) continue;
+				if (task.kind === "property") {
+					pending.push({
+						kind: "visit",
+						node: task.source[task.key]
+					});
+					continue;
+				}
+				const node = task.node;
+				if (node === null || typeof node !== "object") continue;
+				if (node instanceof AbortSignal) continue;
+				if (seen.has(node)) continue;
+				seen.add(node);
+				Object.freeze(node);
+				const keys = Object.keys(node);
+				for (let index = keys.length - 1; index >= 0; index--) {
+					const key = keys[index];
+					/* v8 ignore next -- the loop is bounded by the captured key count. */
+					if (key === void 0) continue;
+					pending.push({
+						kind: "property",
+						source: node,
+						key
+					});
+				}
+			}
+			return value;
+		}
+		//#endregion
+		//#region ../../stubs/xrk-llm/src/message.ts
+		/** Message value types, identity, and immutable construction helpers. */
+		/**
+		* Detach and deep-freeze a message whose identity already exists.
+		* @param message - complete message, including its stable identity.
+		* @returns an immutable snapshot that preserves the identity.
+		*/
+		function freezeMessage(message) {
+			return deepFreeze(structuredClone(message));
+		}
+		/**
+		* Create one identified message and freeze it before publication.
+		* @param input - complete role, content, and source for a new message.
+		* @returns an immutable message with a fresh stable identity.
+		*/
+		function createMessage(input) {
+			return freezeMessage({
+				...input,
+				id: MessageId(crypto.randomUUID())
+			});
+		}
+		/**
+		* Create one identified user-role message and freeze it before publication.
+		* @param input - complete content and source for a new user message.
+		* @returns an immutable user message with a fresh stable identity.
+		*/
+		function createUserMessage(input) {
+			return createMessage({
+				...input,
+				role: "user"
+			});
+		}
+		/**
+		* Create one identified model-produced assistant message and freeze it before publication.
+		* @param input - complete content plus the provider, model, and optional replay state for a new assistant message.
+		* @returns an immutable assistant message with fixed role/source tags and a fresh stable identity.
+		*/
+		function createAssistantMessage(input) {
+			return createMessage({
+				role: "assistant",
+				content: input.content,
+				source: {
+					kind: "model",
+					...input.source
+				}
+			});
+		}
+		/**
+		* Create and freeze one identified tool-result message.
+		* @param input - call identity, raw result blocks, and outcome.
+		* @returns an immutable user-role tool-result message.
 		*/
+		function createToolResultMessage(input) {
+			return createUserMessage({
+				source: {
+					kind: "tool",
+					callId: input.callId
+				},
+				content: [{
+					type: "tool-result",
+					toolCallId: input.callId,
+					content: input.content,
+					isError: input.isError
+				}]
+			});
+		}
+		/**
+		* Whether a stream chunk carries visible model output (the first-token
+		* boundary shared by client step timing and the whole-log sessionStats
+		* projection). Empty deltas (heartbeats, empty tool-call frames) do not count
+		* as a first token.
+		* @param chunk - the stream chunk to test.
+		* @returns true when the chunk contains a non-empty text/reasoning/tool delta.
+		*/
+		function isTokenDelta(chunk) {
+			switch (chunk.type) {
+				case "text-delta":
+				case "reasoning-delta": return chunk.text !== "";
+				case "tool-call-delta": return chunk.argumentsDelta !== "" || chunk.name !== void 0;
+				default: return false;
+			}
+		}
+		//#endregion
+		//#region ../../stubs/xrk-session/src/surface.ts
 		/** Runtime counterpart of the message-producing event union. */
 		const SURFACE_EVENT_TYPES = /* @__PURE__ */ new Set([
 			"user/message",
@@ -363,13 +500,7 @@ window.__ModuleLoader__.load({
 			};
 		}
 		//#endregion
-		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/rpc.js
-		/**
-		* Four-quadrant RPC message model. Channels and messages are decoupled: HTTP,
-		* WebSocket, and in-process SSE are physical carriers, while logical messages
-		* are channel-independent and form a four-member discriminated union.
-		* api/ contract layer: zero Node dependencies, importable from the browser.
-		*/
+		//#region ../../stubs/xrk-host-apiproxy/src/api/rpc.ts
 		/**
 		* Brands a string as RpcId (same precedent as core `SessionId()`). Minted by the initiator:
 		* client-request → client mints; server-request → host mints (answerable frames get a stable
@@ -4735,7 +4866,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			return /* @__PURE__ */ _superRefine(fn, params);
 		}
 		//#endregion
-		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/rpc.schema.js
+		//#region ../../stubs/xrk-host-apiproxy/src/api/rpc.schema.ts
 		/**
 		* Message-layer zod schemas: the four wire full forms + error body +
 		* carrier receipt. The payload slot is unknown in the full-form schemas — business payloads
@@ -4748,9 +4879,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* here would only turn a correlatable error report into a client-side parse
 		* failure (the handler substitutes a sentinel when a request's id is unreadable).
 		*/
-		const rpcIdSchema = string();
+		const rpcIdSchema$1 = string();
 		/** Error body: discriminated by code, per-branch details aligned to RpcErrorDetailsMap; details is required. */
-		const rpcErrorSchema = discriminatedUnion("code", [
+		const rpcErrorSchema$1 = discriminatedUnion("code", [
 			object({
 				code: literal("bad-request"),
 				message: string(),
@@ -5000,59 +5131,58 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* @param value - Schema for the business value.
 		* @returns Schema for RpcResult<T>.
 		*/
-		function rpcResultSchema(value) {
+		function rpcResultSchema$1(value) {
 			return union([object({
 				ok: literal(true),
 				value
 			}), object({
 				ok: literal(false),
-				error: rpcErrorSchema
+				error: rpcErrorSchema$1
 			})]);
 		}
 		/** ClientRequest full form (payload stays wide — the business layer runs the second parse). */
-		const clientRequestSchema = object({
+		const clientRequestSchema$1 = object({
 			type: literal("client-request"),
-			rpcId: rpcIdSchema,
+			rpcId: rpcIdSchema$1,
 			method: string(),
 			payload: unknown()
 		});
 		/** ServerResponse full form (result.value stays wide). */
-		const serverResponseSchema = object({
+		const serverResponseSchema$1 = object({
 			type: literal("server-response"),
-			rpcId: rpcIdSchema,
-			result: rpcResultSchema(unknown().optional())
+			rpcId: rpcIdSchema$1,
+			result: rpcResultSchema$1(unknown().optional())
 		});
 		/** ServerRequest full form (payload stays wide). */
-		const serverRequestSchema = object({
+		const serverRequestSchema$1 = object({
 			type: literal("server-request"),
-			rpcId: rpcIdSchema,
+			rpcId: rpcIdSchema$1,
 			method: string(),
 			payload: unknown()
 		});
 		discriminatedUnion("type", [
-			clientRequestSchema,
-			serverResponseSchema,
-			serverRequestSchema,
+			clientRequestSchema$1,
+			serverResponseSchema$1,
+			serverRequestSchema$1,
 			object({
 				type: literal("client-response"),
-				rpcId: rpcIdSchema,
-				result: rpcResultSchema(unknown().optional())
+				rpcId: rpcIdSchema$1,
+				result: rpcResultSchema$1(unknown().optional())
 			})
 		]);
-		/** Carrier receipt schema. */
-		const rpcReceiptSchema = union([object({ accepted: literal(true) }), object({
+		union([object({ accepted: literal(true) }), object({
 			accepted: literal(false),
 			reason: union([literal("not-pending"), literal("bad-response")])
 		})]);
 		//#endregion
-		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/session-search.js
+		//#region ../../stubs/xrk-host-apiproxy/src/api/session-search.ts
 		/**
 		* Return the longest prefix containing at most `maximum` Unicode code points.
 		* @param value - text to bound.
 		* @param maximum - non-negative code-point limit.
 		* @returns `value` unchanged when it fits, otherwise a code-point-safe prefix.
 		*/
-		function truncateUnicodeCodePoints(value, maximum) {
+		function truncateUnicodeCodePoints$1(value, maximum) {
 			let count = 0;
 			let end = 0;
 			for (const codePoint of value) {
@@ -5063,210 +5193,556 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			return value;
 		}
 		//#endregion
-		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/sessions.schema.js
+		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/rpc.js
 		/**
-		* sessions domain zod schemas (names derived from map keys: sessionListRequestSchema /
-		* sessionListValueSchema). SessionEvent passthrough = strict envelope (type/seq/time) + wide
-		* data: the merge-extensible event API keeps an unknown-type branch at the union level,
-		* with no field-level passthrough. SessionId brand cast point: sessionIdSchema, and only there.
+		* Four-quadrant RPC message model. Channels and messages are decoupled: HTTP,
+		* WebSocket, and in-process SSE are physical carriers, while logical messages
+		* are channel-independent and form a four-member discriminated union.
+		* api/ contract layer: zero Node dependencies, importable from the browser.
 		*/
-		/** SessionId: one brand cast after schema validation (the only cast point in this domain). */
-		const sessionIdSchema = string().min(1);
-		/** MessageId: one brand cast after non-empty string validation. */
-		const messageIdSchema$1 = string().min(1);
 		/**
-		* WorkspaceId: the workspace domain's one brand cast. Hosted here rather
-		* than in workspace.schema because session.create references it while
-		* workspace.schema references sessionIdSchema — schema modules must stay a
-		* DAG (both casts used at module top level; a cycle is a load-time TDZ).
+		* Brands a string as RpcId (same precedent as core `SessionId()`). Minted by the initiator:
+		* client-request → client mints; server-request → host mints (answerable frames get a stable
+		* logical id, pure pushes mint a fresh one each time).
+		* @param id - Raw id string (implementations mint UUIDs; tests may pass fixtures).
+		* @returns The same string, branded (compile-time cast, zero runtime cost).
 		*/
-		const workspaceIdSchema = string().min(1);
-		/** SessionEvent passthrough: strict envelope, wide data (the client fold handles unknown types via its documented default). */
-		const sessionEventSchema = object({
-			type: string(),
-			seq: number().int().nonnegative(),
-			time: number(),
-			data: unknown(),
-			sourceEventSeqs: array(number()).optional(),
-			surfaceOp: unknown().optional(),
-			ignorable: literal(true).optional()
-		});
-		/** SessionSummary row of session.list (`projections` reuses the history block's shape and schema). */
-		const sessionSummarySchema = object({
-			sessionId: sessionIdSchema,
-			updatedAt: number(),
-			running: boolean(),
-			blank: boolean(),
-			parentSessionId: sessionIdSchema.optional(),
-			origin: literal("subagent").optional(),
-			cwd: string().optional(),
-			agentPreset: string().optional(),
-			projections: lazy(() => sessionProjectionsBlockSchema).optional()
-		});
-		object({ cursor: string().optional() });
-		/** session.list response value. */
-		const sessionListValueSchema = object({ items: array(sessionSummarySchema) });
-		object({ query: string().trim().min(1).max(500).refine((query) => !query.includes("\0"), { message: "search query must not contain NUL" }) });
-		/** session.search response value. */
-		const sessionSearchValueSchema = object({
-			items: array(object({
-				sessionId: sessionIdSchema,
-				snippet: string().refine((snippet) => truncateUnicodeCodePoints(snippet, 240) === snippet, { message: `search snippet must contain at most 240 Unicode code points` })
-			})).max(20),
-			hasMore: boolean()
-		});
-		object({
-			workspaceId: workspaceIdSchema.optional(),
-			cwd: string().optional(),
-			sessionId: sessionIdSchema.optional(),
-			agentPreset: string().optional()
-		}).refine((payload) => payload.workspaceId === void 0 || payload.cwd === void 0, { message: "session.create accepts workspaceId or cwd, not both" });
-		/** session.create response value. */
-		const sessionCreateValueSchema = object({
-			sessionId: sessionIdSchema,
-			agentPreset: string().optional()
-		});
-		object({
-			sessionId: sessionIdSchema,
-			title: string()
-		});
-		/** session.rename response value (the normalized accepted title and its event seq). */
-		const sessionRenameValueSchema = object({
-			title: string().min(1),
-			seq: number().int().nonnegative()
-		});
-		object({
-			sessionId: sessionIdSchema,
-			atSeq: number().int().nonnegative().optional()
-		});
-		/** session.fork response value (the child session id). */
-		const sessionForkValueSchema = object({ sessionId: sessionIdSchema });
-		object({
-			sessionId: sessionIdSchema,
-			beforeSeq: number().int().nonnegative().optional(),
-			maxMessages: number().int().positive().optional()
-		});
-		/** Complete provider/model selection. */
-		const modelSelectionSchema = object({
-			provider: string().min(1),
-			model: string().min(1),
-			reasoningEffort: string().min(1).optional()
-		});
-		/** Exact-model reasoning metadata. */
-		const modelReasoningSchema = object({
-			efforts: array(object({
-				id: string().min(1),
-				name: string().min(1),
-				description: string().optional()
-			})).min(1),
-			defaultEffort: string().min(1).optional()
-		});
-		/** One advisory model entry inside a provider group. */
-		const modelCatalogModelSchema = object({
-			id: string().min(1),
-			name: string().min(1),
-			description: string().optional(),
-			reasoning: modelReasoningSchema.optional()
-		});
-		/** One successfully loaded provider group. */
-		const modelProviderGroupSchema = object({
-			id: string().min(1),
-			name: string().min(1),
-			models: array(modelCatalogModelSchema)
-		});
-		/** One provider-local catalog failure. */
-		const modelCatalogFailureSchema = object({
-			id: string().min(1),
-			name: string().min(1),
-			message: string()
-		});
+		function RpcId$1(id) {
+			return id;
+		}
+		//#endregion
+		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/rpc.schema.js
 		/**
-		* ToolEventView passthrough: lock only the `for` discriminant and the presence
-		* of a card-tagged `view` object. The view interior is a host-computed product
-		* the client reads without echoing back; deep-validating it would hand-copy
-		* the dsh-tools vocabulary into this schema and drift with it.
+		* Message-layer zod schemas: the four wire full forms + error body +
+		* carrier receipt. The payload slot is unknown in the full-form schemas — business payloads
+		* get a second parse dispatched by method (two-level parse discipline).
+		* Brand cast point: rpcIdSchema, and only there.
 		*/
-		const toolEventViewSchema = discriminatedUnion("for", [object({
-			for: literal("call"),
-			view: looseObject({ card: string() })
-		}), object({
-			for: literal("result"),
-			view: looseObject({ card: string() })
-		})]);
-		/** One session.history item: the session event plus its optional host-computed tool view. */
-		const historyEntrySchema = object({
-			event: sessionEventSchema,
-			view: toolEventViewSchema.optional()
-		});
 		/**
-		* Projection baseline passthrough: `values` stays a wide record — each value
-		* was already parsed by its provider's own schema on the host side, and
-		* deep-validating here would import every domain's schema into the carrier.
+		* RpcId: one brand cast after schema validation (the only cast point in this
+		* file). No min-length: the id is an opaque echo token, and rejecting values
+		* here would only turn a correlatable error report into a client-side parse
+		* failure (the handler substitutes a sentinel when a request's id is unreadable).
 		*/
-		const sessionProjectionsBlockSchema = object({
-			asOfSeq: number().int().min(-1),
-			values: record(string(), unknown())
-		});
-		object({
-			blank: boolean(),
-			lastPromptAt: number().nullable()
-		});
-		object({
-			maxImageBytes: number().int().positive(),
-			maxImagesPerMessage: number().int().positive(),
-			maxMessageImageBytes: number().int().positive(),
-			maxImagePixels: number().int().positive(),
-			mediaTypes: array(string())
-		});
-		/** session.history response value (projections rides the tail page only). */
-		const sessionHistoryValueSchema = object({
-			events: array(historyEntrySchema),
-			hasMore: boolean(),
-			projections: sessionProjectionsBlockSchema.optional()
-		});
-		object({ sessionId: sessionIdSchema });
-		/** session.models response value. */
-		const sessionModelsValueSchema = object({
-			current: modelSelectionSchema,
-			routable: boolean(),
-			groups: array(modelProviderGroupSchema),
-			failures: array(modelCatalogFailureSchema)
-		});
-		object({
-			sessionId: sessionIdSchema,
-			provider: string().min(1),
+		const rpcIdSchema = string();
+		/** Error body: discriminated by code, per-branch details aligned to RpcErrorDetailsMap; details is required. */
+		const rpcErrorSchema = discriminatedUnion("code", [
+			object({
+				code: literal("bad-request"),
+				message: string(),
+				details: object({ issues: array(custom()) })
+			}),
+			object({
+				code: literal("cancelled"),
+				message: string(),
+				details: object({})
+			}),
+			object({
+				code: literal("session-not-found"),
+				message: string(),
+				details: object({ sessionId: string() })
+			}),
+			object({
+				code: literal("model-unavailable"),
+				message: string(),
+				details: object({
+					provider: string(),
+					model: string()
+				})
+			}),
+			object({
+				code: literal("session-conflict"),
+				message: string(),
+				details: object({
+					sessionId: string(),
+					requestedCwd: string(),
+					existingCwd: string().optional()
+				})
+			}),
+			object({
+				code: literal("invalid-time-zone"),
+				message: string(),
+				details: object({ value: string() })
+			}),
+			object({
+				code: literal("workspace-attach-failed"),
+				message: string(),
+				details: object({
+					sessionId: string(),
+					workspaceId: string()
+				})
+			}),
+			object({
+				code: literal("workspace-not-found"),
+				message: string(),
+				details: object({ workspaceId: string() })
+			}),
+			object({
+				code: literal("workspace-invalid-path"),
+				message: string(),
+				details: object({ path: string() })
+			}),
+			object({
+				code: literal("workspace-name-conflict"),
+				message: string(),
+				details: object({ name: string() })
+			}),
+			object({
+				code: literal("workspace-move-invalid"),
+				message: string(),
+				details: object({
+					workspaceId: string(),
+					sessionId: string(),
+					beforeSessionId: string().optional()
+				})
+			}),
+			object({
+				code: literal("directory-unreadable"),
+				message: string(),
+				details: object({ path: string() })
+			}),
+			object({
+				code: literal("directory-exists"),
+				message: string(),
+				details: object({ path: string() })
+			}),
+			object({
+				code: literal("directory-create-failed"),
+				message: string(),
+				details: object({ path: string() })
+			}),
+			object({
+				code: literal("directory-picker-unavailable"),
+				message: string(),
+				details: object({ capability: string() })
+			}),
+			object({
+				code: literal("agent-preset-read-only"),
+				message: string(),
+				details: object({
+					agentPreset: string(),
+					reason: string()
+				})
+			}),
+			object({
+				code: literal("agent-preset-locked"),
+				message: string(),
+				details: object({
+					sessionId: string(),
+					agentPreset: string()
+				})
+			}),
+			object({
+				code: literal("agent-preset-conflict"),
+				message: string(),
+				details: object({
+					sessionId: string(),
+					requestedPreset: string(),
+					existingPreset: string().optional()
+				})
+			}),
+			object({
+				code: literal("agent-preset-not-found"),
+				message: string(),
+				details: object({
+					agentPreset: string(),
+					available: array(string())
+				})
+			}),
+			object({
+				code: literal("agent-preset-invalid"),
+				message: string(),
+				details: object({
+					agentPreset: string(),
+					reason: string()
+				})
+			}),
+			object({
+				code: literal("agent-busy"),
+				message: string(),
+				details: object({ reason: string() })
+			}),
+			object({
+				code: literal("attachment-error"),
+				message: string(),
+				details: object({ reason: string() })
+			}),
+			object({
+				code: literal("queue-item-not-found"),
+				message: string(),
+				details: object({ itemId: string() })
+			}),
+			object({
+				code: literal("steer-unavailable"),
+				message: string(),
+				details: object({ itemId: string() })
+			}),
+			object({
+				code: literal("command-error"),
+				message: string(),
+				details: object({})
+			}),
+			object({
+				code: literal("unknown-command"),
+				message: string(),
+				details: object({})
+			}),
+			object({
+				code: literal("settings-rejected"),
+				message: string(),
+				details: object({ ns: string() })
+			}),
+			object({
+				code: literal("settings-conflict"),
+				message: string(),
+				details: object({
+					ns: string(),
+					expected: number(),
+					actual: number()
+				})
+			}),
+			object({
+				code: literal("credential-rejected"),
+				message: string(),
+				details: object({ ref: string() })
+			}),
+			object({
+				code: literal("model-discovery-failed"),
+				message: string(),
+				details: object({
+					settingsNs: string(),
+					baseURL: string().optional()
+				})
+			}),
+			object({
+				code: literal("title-invalid"),
+				message: string(),
+				details: object({ sessionId: string() })
+			}),
+			object({
+				code: literal("fork-unavailable"),
+				message: string(),
+				details: object({ sessionId: string() })
+			}),
+			object({
+				code: literal("subagent-parent-unavailable"),
+				message: string(),
+				details: object({ parentSessionId: string() })
+			}),
+			object({
+				code: literal("subagent-not-found"),
+				message: string(),
+				details: object({
+					parentSessionId: string(),
+					childSessionId: string()
+				})
+			}),
+			object({
+				code: literal("subagent-catalog-diagnostic"),
+				message: string(),
+				details: object({
+					parentSessionId: string(),
+					childSessionId: string(),
+					reason: union([
+						literal("corrupt"),
+						literal("unsupported"),
+						literal("unavailable")
+					])
+				})
+			}),
+			object({
+				code: literal("subagent-not-resumable"),
+				message: string(),
+				details: object({ childSessionId: string() })
+			}),
+			object({
+				code: literal("subagent-unauthorized"),
+				message: string(),
+				details: object({ childSessionId: string() })
+			}),
+			object({
+				code: literal("subagent-delivery-unavailable"),
+				message: string(),
+				details: object({ childSessionId: string() })
+			}),
+			object({
+				code: literal("internal"),
+				message: string(),
+				details: object({})
+			})
+		]);
+		/**
+		* Business success/failure result schema (generic, reusable).
+		* @param value - Schema for the business value.
+		* @returns Schema for RpcResult<T>.
+		*/
+		function rpcResultSchema(value) {
+			return union([object({
+				ok: literal(true),
+				value
+			}), object({
+				ok: literal(false),
+				error: rpcErrorSchema
+			})]);
+		}
+		/** ClientRequest full form (payload stays wide — the business layer runs the second parse). */
+		const clientRequestSchema = object({
+			type: literal("client-request"),
+			rpcId: rpcIdSchema,
+			method: string(),
+			payload: unknown()
+		});
+		/** ServerResponse full form (result.value stays wide). */
+		const serverResponseSchema = object({
+			type: literal("server-response"),
+			rpcId: rpcIdSchema,
+			result: rpcResultSchema(unknown().optional())
+		});
+		/** ServerRequest full form (payload stays wide). */
+		const serverRequestSchema = object({
+			type: literal("server-request"),
+			rpcId: rpcIdSchema,
+			method: string(),
+			payload: unknown()
+		});
+		discriminatedUnion("type", [
+			clientRequestSchema,
+			serverResponseSchema,
+			serverRequestSchema,
+			object({
+				type: literal("client-response"),
+				rpcId: rpcIdSchema,
+				result: rpcResultSchema(unknown().optional())
+			})
+		]);
+		/** Carrier receipt schema. */
+		const rpcReceiptSchema = union([object({ accepted: literal(true) }), object({
+			accepted: literal(false),
+			reason: union([literal("not-pending"), literal("bad-response")])
+		})]);
+		//#endregion
+		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/session-search.js
+		/**
+		* Return the longest prefix containing at most `maximum` Unicode code points.
+		* @param value - text to bound.
+		* @param maximum - non-negative code-point limit.
+		* @returns `value` unchanged when it fits, otherwise a code-point-safe prefix.
+		*/
+		function truncateUnicodeCodePoints(value, maximum) {
+			let count = 0;
+			let end = 0;
+			for (const codePoint of value) {
+				if (count === maximum) return value.slice(0, end);
+				count++;
+				end += codePoint.length;
+			}
+			return value;
+		}
+		//#endregion
+		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/sessions.schema.js
+		/**
+		* sessions domain zod schemas (names derived from map keys: sessionListRequestSchema /
+		* sessionListValueSchema). SessionEvent passthrough = strict envelope (type/seq/time) + wide
+		* data: the merge-extensible event API keeps an unknown-type branch at the union level,
+		* with no field-level passthrough. SessionId brand cast point: sessionIdSchema, and only there.
+		*/
+		/** SessionId: one brand cast after schema validation (the only cast point in this domain). */
+		const sessionIdSchema$1 = string().min(1);
+		/** MessageId: one brand cast after non-empty string validation. */
+		const messageIdSchema$2 = string().min(1);
+		/**
+		* WorkspaceId: the workspace domain's one brand cast. Hosted here rather
+		* than in workspace.schema because session.create references it while
+		* workspace.schema references sessionIdSchema — schema modules must stay a
+		* DAG (both casts used at module top level; a cycle is a load-time TDZ).
+		*/
+		const workspaceIdSchema$1 = string().min(1);
+		/** SessionEvent passthrough: strict envelope, wide data (the client fold handles unknown types via its documented default). */
+		const sessionEventSchema$1 = object({
+			type: string(),
+			seq: number().int().nonnegative(),
+			time: number(),
+			data: unknown(),
+			sourceEventSeqs: array(number()).optional(),
+			surfaceOp: unknown().optional(),
+			ignorable: literal(true).optional()
+		});
+		/** SessionSummary row of session.list (`projections` reuses the history block's shape and schema). */
+		const sessionSummarySchema$1 = object({
+			sessionId: sessionIdSchema$1,
+			updatedAt: number(),
+			running: boolean(),
+			blank: boolean(),
+			parentSessionId: sessionIdSchema$1.optional(),
+			origin: literal("subagent").optional(),
+			cwd: string().optional(),
+			agentPreset: string().optional(),
+			projections: lazy(() => sessionProjectionsBlockSchema$1).optional()
+		});
+		object({ cursor: string().optional() });
+		/** session.list response value. */
+		const sessionListValueSchema$1 = object({ items: array(sessionSummarySchema$1) });
+		object({ query: string().trim().min(1).max(500).refine((query) => !query.includes("\0"), { message: "search query must not contain NUL" }) });
+		/** session.search response value. */
+		const sessionSearchValueSchema$1 = object({
+			items: array(object({
+				sessionId: sessionIdSchema$1,
+				snippet: string().refine((snippet) => truncateUnicodeCodePoints(snippet, 240) === snippet, { message: `search snippet must contain at most 240 Unicode code points` })
+			})).max(20),
+			hasMore: boolean()
+		});
+		object({
+			workspaceId: workspaceIdSchema$1.optional(),
+			cwd: string().optional(),
+			sessionId: sessionIdSchema$1.optional(),
+			agentPreset: string().optional()
+		}).refine((payload) => payload.workspaceId === void 0 || payload.cwd === void 0, { message: "session.create accepts workspaceId or cwd, not both" });
+		/** session.create response value. */
+		const sessionCreateValueSchema$1 = object({
+			sessionId: sessionIdSchema$1,
+			agentPreset: string().optional()
+		});
+		object({
+			sessionId: sessionIdSchema$1,
+			title: string()
+		});
+		/** session.rename response value (the normalized accepted title and its event seq). */
+		const sessionRenameValueSchema$1 = object({
+			title: string().min(1),
+			seq: number().int().nonnegative()
+		});
+		object({
+			sessionId: sessionIdSchema$1,
+			atSeq: number().int().nonnegative().optional()
+		});
+		/** session.fork response value (the child session id). */
+		const sessionForkValueSchema$1 = object({ sessionId: sessionIdSchema$1 });
+		object({
+			sessionId: sessionIdSchema$1,
+			beforeSeq: number().int().nonnegative().optional(),
+			maxMessages: number().int().positive().optional()
+		});
+		/** Complete provider/model selection. */
+		const modelSelectionSchema$1 = object({
+			provider: string().min(1),
+			model: string().min(1),
+			reasoningEffort: string().min(1).optional()
+		});
+		/** Exact-model reasoning metadata. */
+		const modelReasoningSchema$1 = object({
+			efforts: array(object({
+				id: string().min(1),
+				name: string().min(1),
+				description: string().optional()
+			})).min(1),
+			defaultEffort: string().min(1).optional()
+		});
+		/** One advisory model entry inside a provider group. */
+		const modelCatalogModelSchema$1 = object({
+			id: string().min(1),
+			name: string().min(1),
+			description: string().optional(),
+			reasoning: modelReasoningSchema$1.optional()
+		});
+		/** One successfully loaded provider group. */
+		const modelProviderGroupSchema$1 = object({
+			id: string().min(1),
+			name: string().min(1),
+			models: array(modelCatalogModelSchema$1)
+		});
+		/** One provider-local catalog failure. */
+		const modelCatalogFailureSchema$1 = object({
+			id: string().min(1),
+			name: string().min(1),
+			message: string()
+		});
+		/**
+		* ToolEventView passthrough: lock only the `for` discriminant and the presence
+		* of a card-tagged `view` object. The view interior is a host-computed product
+		* the client reads without echoing back; deep-validating it would hand-copy
+		* the dsh-tools vocabulary into this schema and drift with it.
+		*/
+		const toolEventViewSchema$1 = discriminatedUnion("for", [object({
+			for: literal("call"),
+			view: looseObject({ card: string() })
+		}), object({
+			for: literal("result"),
+			view: looseObject({ card: string() })
+		})]);
+		/** One session.history item: the session event plus its optional host-computed tool view. */
+		const historyEntrySchema$1 = object({
+			event: sessionEventSchema$1,
+			view: toolEventViewSchema$1.optional()
+		});
+		/**
+		* Projection baseline passthrough: `values` stays a wide record — each value
+		* was already parsed by its provider's own schema on the host side, and
+		* deep-validating here would import every domain's schema into the carrier.
+		*/
+		const sessionProjectionsBlockSchema$1 = object({
+			asOfSeq: number().int().min(-1),
+			values: record(string(), unknown())
+		});
+		object({
+			blank: boolean(),
+			lastPromptAt: number().nullable()
+		});
+		object({
+			maxImageBytes: number().int().positive(),
+			maxImagesPerMessage: number().int().positive(),
+			maxMessageImageBytes: number().int().positive(),
+			maxImagePixels: number().int().positive(),
+			mediaTypes: array(string())
+		});
+		/** session.history response value (projections rides the tail page only). */
+		const sessionHistoryValueSchema$1 = object({
+			events: array(historyEntrySchema$1),
+			hasMore: boolean(),
+			projections: sessionProjectionsBlockSchema$1.optional()
+		});
+		object({ sessionId: sessionIdSchema$1 });
+		/** session.models response value. */
+		const sessionModelsValueSchema$1 = object({
+			current: modelSelectionSchema$1,
+			routable: boolean(),
+			groups: array(modelProviderGroupSchema$1),
+			failures: array(modelCatalogFailureSchema$1)
+		});
+		object({
+			sessionId: sessionIdSchema$1,
+			provider: string().min(1),
 			model: string().min(1),
 			reasoningEffort: string().min(1).optional()
 		});
 		/** session.selectModel response value. */
-		const sessionSelectModelValueSchema = object({ selected: modelSelectionSchema });
+		const sessionSelectModelValueSchema$1 = object({ selected: modelSelectionSchema$1 });
 		/** ContentBlock passthrough: core is merge-extensible — the type discriminant envelope is strict, the rest stays wide. */
-		const contentBlockSchema = looseObject({ type: string() });
+		const contentBlockSchema$1 = looseObject({ type: string() });
 		/** Raster image media types accepted by the version-one browser wire. */
-		const imageMediaTypeSchema = union([
+		const imageMediaTypeSchema$1 = union([
 			literal("image/png"),
 			literal("image/jpeg"),
 			literal("image/webp"),
 			literal("image/gif")
 		]);
 		/** Prompt wire content is intentionally narrower than merge-extensible durable core content. */
-		const promptContentPartSchema = discriminatedUnion("type", [object({
+		const promptContentPartSchema$1 = discriminatedUnion("type", [object({
 			type: literal("text"),
 			text: string()
 		}), object({
 			type: literal("image"),
-			mediaType: imageMediaTypeSchema,
+			mediaType: imageMediaTypeSchema$1,
 			data: string(),
 			name: string().optional()
 		})]);
 		object({
-			sessionId: sessionIdSchema,
+			sessionId: sessionIdSchema$1,
 			mode: union([literal("queue"), literal("steer")]),
-			content: array(promptContentPartSchema),
+			content: array(promptContentPartSchema$1),
 			clientTimeZone: string().optional()
 		});
 		/** session.prompt response value (the command slot appears only when the prompt dispatched a slash command). */
-		const sessionPromptValueSchema = object({
+		const sessionPromptValueSchema$1 = object({
 			accepted: literal(true),
 			command: object({
 				kind: literal("success"),
@@ -5274,42 +5750,42 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}).optional()
 		});
 		/** Opaque attachment id after string-shape validation. */
-		const attachmentIdSchema = string().min(1);
+		const attachmentIdSchema$1 = string().min(1);
 		/** Durable image reference returned from the authenticated session lookup. */
-		const imageAttachmentRefSchema = object({
-			attachmentId: attachmentIdSchema,
-			mediaType: imageMediaTypeSchema,
+		const imageAttachmentRefSchema$1 = object({
+			attachmentId: attachmentIdSchema$1,
+			mediaType: imageMediaTypeSchema$1,
 			bytes: number().int().positive(),
 			width: number().int().positive(),
 			height: number().int().positive(),
 			name: string().optional()
 		});
 		object({
-			sessionId: sessionIdSchema,
-			attachmentId: attachmentIdSchema
+			sessionId: sessionIdSchema$1,
+			attachmentId: attachmentIdSchema$1
 		});
 		/** session.attachment response value. */
-		const sessionAttachmentValueSchema = object({
-			attachment: imageAttachmentRefSchema,
+		const sessionAttachmentValueSchema$1 = object({
+			attachment: imageAttachmentRefSchema$1,
 			data: string()
 		});
 		object({
-			sessionId: sessionIdSchema,
-			itemId: messageIdSchema$1,
+			sessionId: sessionIdSchema$1,
+			itemId: messageIdSchema$2,
 			action: discriminatedUnion("kind", [
 				object({
 					kind: literal("edit"),
-					content: array(contentBlockSchema)
+					content: array(contentBlockSchema$1)
 				}),
 				object({ kind: literal("remove") }),
 				object({ kind: literal("steer") })
 			])
 		});
 		/** session.updateQueue response value. */
-		const sessionUpdateQueueValueSchema = object({ accepted: literal(true) });
-		object({ sessionId: sessionIdSchema });
+		const sessionUpdateQueueValueSchema$1 = object({ accepted: literal(true) });
+		object({ sessionId: sessionIdSchema$1 });
 		/** session.cancel response value. */
-		const sessionCancelValueSchema = object({ accepted: literal(true) });
+		const sessionCancelValueSchema$1 = object({ accepted: literal(true) });
 		//#endregion
 		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/approvals.schema.js
 		/**
@@ -5318,10 +5794,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* ApprovalRequestId brand cast point: one.
 		*/
 		/** ApprovalRequestId: one brand cast after schema validation (the only cast point in this domain). */
-		const approvalRequestIdSchema = string().min(1);
+		const approvalRequestIdSchema$1 = string().min(1);
 		object({
-			sessionId: sessionIdSchema,
-			approvalId: approvalRequestIdSchema,
+			sessionId: sessionIdSchema$1,
+			approvalId: approvalRequestIdSchema$1,
 			outcome: union([literal("allowed-once"), literal("rejected")])
 		});
 		/**
@@ -5329,7 +5805,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* extend the registry's kind map by declaration merging, so the closed set is
 		* not knowable at this boundary.
 		*/
-		const taskViewSchema = object({
+		const taskViewSchema$1 = object({
 			id: string().min(1),
 			kind: string().min(1),
 			label: string().min(1),
@@ -5352,51 +5828,51 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* is re-exported here as the domain-local name.
 		*/
 		/** WorkspaceView row of every workspace.* response. */
-		const workspaceViewSchema = object({
-			workspaceId: workspaceIdSchema,
+		const workspaceViewSchema$1 = object({
+			workspaceId: workspaceIdSchema$1,
 			path: string(),
 			title: string(),
-			sessionIds: array(sessionIdSchema),
+			sessionIds: array(sessionIdSchema$1),
 			createdAt: string(),
 			updatedAt: string()
 		});
 		object({});
 		/** workspace.list response value. */
-		const workspaceListValueSchema = object({
-			items: array(workspaceViewSchema),
-			archivedSessionIds: array(sessionIdSchema)
+		const workspaceListValueSchema$1 = object({
+			items: array(workspaceViewSchema$1),
+			archivedSessionIds: array(sessionIdSchema$1)
 		});
 		object({ path: string() });
 		/** workspace.create response value. */
-		const workspaceCreateValueSchema = object({
-			workspace: workspaceViewSchema,
+		const workspaceCreateValueSchema$1 = object({
+			workspace: workspaceViewSchema$1,
 			created: boolean()
 		});
 		object({
-			workspaceId: workspaceIdSchema,
+			workspaceId: workspaceIdSchema$1,
 			title: string()
 		}).refine((payload) => payload.title.trim() !== "", { message: "workspace.rename requires a non-blank title" });
 		/** workspace.rename response value. */
-		const workspaceRenameValueSchema = object({ workspace: workspaceViewSchema });
-		object({ workspaceId: workspaceIdSchema });
+		const workspaceRenameValueSchema$1 = object({ workspace: workspaceViewSchema$1 });
+		object({ workspaceId: workspaceIdSchema$1 });
 		/** workspace.delete response value. */
-		const workspaceDeleteValueSchema = object({ deleted: literal(true) });
+		const workspaceDeleteValueSchema$1 = object({ deleted: literal(true) });
 		object({
-			workspaceId: workspaceIdSchema,
-			beforeWorkspaceId: workspaceIdSchema.optional()
+			workspaceId: workspaceIdSchema$1,
+			beforeWorkspaceId: workspaceIdSchema$1.optional()
 		});
 		/** workspace.insertBefore response value: the complete durable display order. */
-		const workspaceInsertBeforeValueSchema = object({ workspaceIds: array(workspaceIdSchema) });
+		const workspaceInsertBeforeValueSchema$1 = object({ workspaceIds: array(workspaceIdSchema$1) });
 		object({
-			workspaceId: workspaceIdSchema,
-			sessionId: sessionIdSchema,
-			beforeSessionId: sessionIdSchema.optional()
+			workspaceId: workspaceIdSchema$1,
+			sessionId: sessionIdSchema$1,
+			beforeSessionId: sessionIdSchema$1.optional()
 		});
 		/** workspace.insertSessionBefore response value. */
-		const workspaceInsertSessionBeforeValueSchema = object({ workspace: workspaceViewSchema });
-		object({ sessionId: sessionIdSchema });
+		const workspaceInsertSessionBeforeValueSchema$1 = object({ workspace: workspaceViewSchema$1 });
+		object({ sessionId: sessionIdSchema$1 });
 		/** workspace.archiveSession response value: the full updated archive set. */
-		const workspaceArchiveSessionValueSchema = object({ archivedSessionIds: array(sessionIdSchema) });
+		const workspaceArchiveSessionValueSchema$1 = object({ archivedSessionIds: array(sessionIdSchema$1) });
 		//#endregion
 		//#region ../../stubs/xrk-host-apiproxy/lib/types/api/events.schema.js
 		/**
@@ -5405,7 +5881,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* a session/event frame reuses sessions.schema's strict-envelope + wide-data passthrough branch.
 		*/
 		/** Question fields validated strictly against core dsh-user-questions. */
-		const askUserQuestionItemSchema = object({
+		const askUserQuestionItemSchema$1 = object({
 			id: string(),
 			question: string(),
 			header: string().optional(),
@@ -5421,41 +5897,41 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			})]).optional()
 		});
 		/** Unified message envelope carried by transient queue frames. */
-		const messageSchema = object({
+		const messageSchema$1 = object({
 			id: string().min(1),
 			role: union([
 				literal("system"),
 				literal("user"),
 				literal("assistant")
 			]),
-			content: array(contentBlockSchema),
+			content: array(contentBlockSchema$1),
 			source: looseObject({ kind: string() })
 		});
 		/** MuxFrame union (payload slot of a mux-stream ServerRequest). */
-		const muxFrameSchema = discriminatedUnion("type", [
+		const muxFrameSchema$1 = discriminatedUnion("type", [
 			object({
 				type: literal("session/event"),
-				sessionId: sessionIdSchema,
-				event: sessionEventSchema,
-				view: toolEventViewSchema.optional()
+				sessionId: sessionIdSchema$1,
+				event: sessionEventSchema$1,
+				view: toolEventViewSchema$1.optional()
 			}),
 			object({
 				type: literal("session/subscribed"),
-				sessionId: sessionIdSchema,
+				sessionId: sessionIdSchema$1,
 				lastSeq: number().int()
 			}),
 			object({
 				type: literal("approval/requested"),
-				sessionId: sessionIdSchema,
-				approvalId: approvalRequestIdSchema,
+				sessionId: sessionIdSchema$1,
+				approvalId: approvalRequestIdSchema$1,
 				toolName: string(),
 				callId: string().optional(),
 				reason: string().optional()
 			}),
 			object({
 				type: literal("approval/resolved"),
-				sessionId: sessionIdSchema,
-				approvalId: approvalRequestIdSchema,
+				sessionId: sessionIdSchema$1,
+				approvalId: approvalRequestIdSchema$1,
 				outcome: union([
 					literal("allowed-once"),
 					literal("rejected"),
@@ -5465,36 +5941,36 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}),
 			object({
 				type: literal("question/requested"),
-				sessionId: sessionIdSchema,
-				questions: array(askUserQuestionItemSchema).min(1)
+				sessionId: sessionIdSchema$1,
+				questions: array(askUserQuestionItemSchema$1).min(1)
 			}),
 			object({
 				type: literal("question/resolved"),
-				sessionId: sessionIdSchema,
+				sessionId: sessionIdSchema$1,
 				questionRpcId: rpcIdSchema,
 				outcome: union([literal("answered"), literal("cancelled")])
 			}),
 			object({
 				type: literal("session/queue"),
-				sessionId: sessionIdSchema,
+				sessionId: sessionIdSchema$1,
 				items: array(object({
-					id: messageIdSchema$1,
+					id: messageIdSchema$2,
 					placement: union([
 						literal("queued"),
 						literal("steering"),
 						literal("context")
 					]),
-					message: messageSchema
+					message: messageSchema$1
 				}))
 			}),
 			object({
 				type: literal("session/jobs"),
-				sessionId: sessionIdSchema,
-				jobs: array(taskViewSchema)
+				sessionId: sessionIdSchema$1,
+				jobs: array(taskViewSchema$1)
 			}),
 			object({
 				type: literal("session/projection"),
-				sessionId: sessionIdSchema,
+				sessionId: sessionIdSchema$1,
 				key: string().min(1),
 				value: unknown(),
 				seq: number().int().nonnegative()
@@ -5505,45 +5981,45 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			})
 		]);
 		/** HostFrame union (payload slot of a host-stream ServerRequest). */
-		const hostFrameSchema = discriminatedUnion("type", [
+		const hostFrameSchema$1 = discriminatedUnion("type", [
 			object({
 				type: literal("host/session-added"),
-				sessionId: sessionIdSchema,
+				sessionId: sessionIdSchema$1,
 				blank: boolean(),
-				parentSessionId: sessionIdSchema.optional(),
+				parentSessionId: sessionIdSchema$1.optional(),
 				origin: literal("subagent").optional(),
 				cwd: string().optional(),
 				agentPreset: string().optional()
 			}),
 			object({
 				type: literal("host/session-removed"),
-				sessionId: sessionIdSchema
+				sessionId: sessionIdSchema$1
 			}),
 			object({
 				type: literal("host/session-status"),
-				sessionId: sessionIdSchema,
+				sessionId: sessionIdSchema$1,
 				running: boolean()
 			}),
 			object({
 				type: literal("host/agent-error"),
-				sessionId: sessionIdSchema,
+				sessionId: sessionIdSchema$1,
 				message: string()
 			}),
 			object({
 				type: literal("host/workspace-changed"),
-				workspace: workspaceViewSchema
+				workspace: workspaceViewSchema$1
 			}),
 			object({
 				type: literal("host/workspace-removed"),
-				workspaceId: workspaceIdSchema
+				workspaceId: workspaceIdSchema$1
 			}),
 			object({
 				type: literal("host/workspace-order-changed"),
-				workspaceIds: array(workspaceIdSchema)
+				workspaceIds: array(workspaceIdSchema$1)
 			}),
 			object({
 				type: literal("host/archived-sessions-changed"),
-				archivedSessionIds: array(sessionIdSchema)
+				archivedSessionIds: array(sessionIdSchema$1)
 			}),
 			object({
 				type: literal("host/remote-event"),
@@ -5605,7 +6081,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			whenToUse: string().optional(),
 			modelInvocable: boolean()
 		});
-		object({ sessionId: sessionIdSchema });
+		object({ sessionId: sessionIdSchema$1 });
 		/** skill.list response value. */
 		const skillListValueSchema = object({ skills: array(skillEntrySchema) });
 		//#endregion
@@ -5631,7 +6107,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			hasDocument: boolean()
 		});
 		object({
-			sessionId: sessionIdSchema,
+			sessionId: sessionIdSchema$1,
 			agentPreset: string().min(1)
 		});
 		/** agentPreset.select response value. */
@@ -5825,8 +6301,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		object({});
 		/** llm.models response value. */
 		const llmModelsValueSchema = object({
-			groups: array(modelProviderGroupSchema),
-			failures: array(modelCatalogFailureSchema)
+			groups: array(modelProviderGroupSchema$1),
+			failures: array(modelCatalogFailureSchema$1)
 		});
 		/** DiscoveredModelView row of llm.discoverModels. */
 		const discoveredModelViewSchema = object({
@@ -5851,7 +6327,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		const subagentListEntrySchema = union([
 			object({
 				kind: literal("child"),
-				id: sessionIdSchema,
+				id: sessionIdSchema$1,
 				mode: literal("one-shot"),
 				activity: union([literal("running"), literal("inactive")]),
 				hasChildren: boolean(),
@@ -5859,7 +6335,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}),
 			object({
 				kind: literal("child"),
-				id: sessionIdSchema,
+				id: sessionIdSchema$1,
 				mode: literal("continuable"),
 				activity: union([literal("running"), literal("inactive")]),
 				hasChildren: boolean(),
@@ -5867,7 +6343,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}),
 			object({
 				kind: literal("diagnostic"),
-				id: sessionIdSchema,
+				id: sessionIdSchema$1,
 				reason: union([
 					literal("corrupt"),
 					literal("unsupported"),
@@ -5875,35 +6351,35 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				])
 			})
 		]);
-		object({ parentSessionId: sessionIdSchema });
+		object({ parentSessionId: sessionIdSchema$1 });
 		/** subagent.list response value. */
 		const subagentListValueSchema = object({
 			entries: array(subagentListEntrySchema),
 			parentAvailable: boolean()
 		});
 		object({
-			parentSessionId: sessionIdSchema,
-			childSessionId: sessionIdSchema,
+			parentSessionId: sessionIdSchema$1,
+			childSessionId: sessionIdSchema$1,
 			mode: union([literal("one-shot"), literal("continuable")]),
 			beforeSeq: number().int().nonnegative().optional(),
 			maxMessages: number().int().positive().optional()
 		});
 		/** subagent.history response value. */
 		const subagentHistoryValueSchema = object({
-			events: array(historyEntrySchema),
+			events: array(historyEntrySchema$1),
 			hasMore: boolean(),
-			projections: sessionProjectionsBlockSchema.optional()
+			projections: sessionProjectionsBlockSchema$1.optional()
 		});
 		object({
-			parentSessionId: sessionIdSchema,
-			childSessionId: sessionIdSchema,
+			parentSessionId: sessionIdSchema$1,
+			childSessionId: sessionIdSchema$1,
 			mode: literal("continuable"),
-			content: array(contentBlockSchema),
+			content: array(contentBlockSchema$1),
 			clientTimeZone: string().optional()
 		});
 		object({
-			parentSessionId: sessionIdSchema,
-			childSessionId: sessionIdSchema,
+			parentSessionId: sessionIdSchema$1,
+			childSessionId: sessionIdSchema$1,
 			mode: literal("continuable")
 		});
 		/** subagent.interrupt response value. */
@@ -5921,18 +6397,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* mirror of the handler's request table; key coverage compiler-enforced against RpcMethodMap).
 		*/
 		const UNARY_VALUE_SCHEMAS = {
-			"session.list": sessionListValueSchema,
-			"session.search": sessionSearchValueSchema,
-			"session.create": sessionCreateValueSchema,
-			"session.history": sessionHistoryValueSchema,
-			"session.models": sessionModelsValueSchema,
-			"session.selectModel": sessionSelectModelValueSchema,
-			"session.rename": sessionRenameValueSchema,
-			"session.fork": sessionForkValueSchema,
-			"session.prompt": sessionPromptValueSchema,
-			"session.attachment": sessionAttachmentValueSchema,
-			"session.updateQueue": sessionUpdateQueueValueSchema,
-			"session.cancel": sessionCancelValueSchema,
+			"session.list": sessionListValueSchema$1,
+			"session.search": sessionSearchValueSchema$1,
+			"session.create": sessionCreateValueSchema$1,
+			"session.history": sessionHistoryValueSchema$1,
+			"session.models": sessionModelsValueSchema$1,
+			"session.selectModel": sessionSelectModelValueSchema$1,
+			"session.rename": sessionRenameValueSchema$1,
+			"session.fork": sessionForkValueSchema$1,
+			"session.prompt": sessionPromptValueSchema$1,
+			"session.attachment": sessionAttachmentValueSchema$1,
+			"session.updateQueue": sessionUpdateQueueValueSchema$1,
+			"session.cancel": sessionCancelValueSchema$1,
 			"subagent.list": subagentListValueSchema,
 			"subagent.history": subagentHistoryValueSchema,
 			"subagent.prompt": object({ messageId: string() }),
@@ -5942,13 +6418,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"host.listDirectory": hostListDirectoryValueSchema,
 			"host.createDirectory": hostCreateDirectoryValueSchema,
 			"host.openPath": hostOpenPathValueSchema,
-			"workspace.list": workspaceListValueSchema,
-			"workspace.create": workspaceCreateValueSchema,
-			"workspace.rename": workspaceRenameValueSchema,
-			"workspace.delete": workspaceDeleteValueSchema,
-			"workspace.insertBefore": workspaceInsertBeforeValueSchema,
-			"workspace.insertSessionBefore": workspaceInsertSessionBeforeValueSchema,
-			"workspace.archiveSession": workspaceArchiveSessionValueSchema,
+			"workspace.list": workspaceListValueSchema$1,
+			"workspace.create": workspaceCreateValueSchema$1,
+			"workspace.rename": workspaceRenameValueSchema$1,
+			"workspace.delete": workspaceDeleteValueSchema$1,
+			"workspace.insertBefore": workspaceInsertBeforeValueSchema$1,
+			"workspace.insertSessionBefore": workspaceInsertSessionBeforeValueSchema$1,
+			"workspace.archiveSession": workspaceArchiveSessionValueSchema$1,
 			"skill.list": skillListValueSchema,
 			"agentPreset.list": agentPresetListValueSchema,
 			"agentPreset.select": agentPresetSelectValueSchema,
@@ -6032,7 +6508,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				return loc?.origin !== void 0 && loc.origin !== "null" ? loc.origin : INTERNAL_BASE$1;
 			}
 			mintRpcId() {
-				return RpcId(crypto.randomUUID());
+				return RpcId$1(crypto.randomUUID());
 			}
 			/**
 			* Shared POST leg of both C→S carriers (callUnary/respond): JSON body,
@@ -6081,11 +6557,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}
 			/** Mux stream opener; virtual for the same override reason as callUnary. */
 			openMux(_payload, signal, onOpen) {
-				return this.readSse("/api/events.mux", signal, muxFrameSchema, onOpen);
+				return this.readSse("/api/events.mux", signal, muxFrameSchema$1, onOpen);
 			}
 			/** Host stream opener; virtual. */
 			openHost(_payload, signal, onOpen) {
-				return this.readSse("/api/events.host", signal, hostFrameSchema, onOpen);
+				return this.readSse("/api/events.host", signal, hostFrameSchema$1, onOpen);
 			}
 			/**
 			* SSE protocol path: streaming fetch (not EventSource), '\n\n' framing, ServerRequest envelope +
@@ -6243,13 +6719,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}];
 		}
 		function userMessage(content, source = { kind: "user" }) {
-			return (0, _xrkseek_xrk_llm_message.createUserMessage)({
+			return createUserMessage({
 				content,
 				source
 			});
 		}
 		function assistantMessage(content, model = "fx-1") {
-			return (0, _xrkseek_xrk_llm_message.createAssistantMessage)({
+			return createAssistantMessage({
 				content,
 				source: {
 					provider: "fixture",
@@ -6258,8 +6734,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			});
 		}
 		function toolResultMessage(callId, content, isError) {
-			return (0, _xrkseek_xrk_llm_message.createToolResultMessage)({
-				callId: (0, _xrkseek_xrk_llm_brand.CallId)(callId),
+			return createToolResultMessage({
+				callId: CallId(callId),
 				content,
 				isError
 			});
@@ -7358,7 +7834,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					};
 					break;
 				case "assistant/chunk":
-					if (openStep !== null && openStep.turn === event.data.turn && openStep.step === event.data.step && openStep.firstTokenTime === null && (0, _xrkseek_xrk_llm_message.isTokenDelta)(event.data.chunk)) openStep.firstTokenTime = event.time;
+					if (openStep !== null && openStep.turn === event.data.turn && openStep.step === event.data.step && openStep.firstTokenTime === null && isTokenDelta(event.data.chunk)) openStep.firstTokenTime = event.time;
 					break;
 				case "assistant/message":
 					if (openStep === null || openStep.turn !== event.data.turn || openStep.step !== event.data.step) break;
@@ -9838,6 +10314,480 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			};
 		}
 		//#endregion
+		//#region ../../stubs/xrk-host-apiproxy/src/api/sessions.schema.ts
+		/**
+		* sessions domain zod schemas (names derived from map keys: sessionListRequestSchema /
+		* sessionListValueSchema). SessionEvent passthrough = strict envelope (type/seq/time) + wide
+		* data: the merge-extensible event API keeps an unknown-type branch at the union level,
+		* with no field-level passthrough. SessionId brand cast point: sessionIdSchema, and only there.
+		*/
+		/** SessionId: one brand cast after schema validation (the only cast point in this domain). */
+		const sessionIdSchema = string().min(1);
+		/** MessageId: one brand cast after non-empty string validation. */
+		const messageIdSchema = string().min(1);
+		/**
+		* WorkspaceId: the workspace domain's one brand cast. Hosted here rather
+		* than in workspace.schema because session.create references it while
+		* workspace.schema references sessionIdSchema — schema modules must stay a
+		* DAG (both casts used at module top level; a cycle is a load-time TDZ).
+		*/
+		const workspaceIdSchema = string().min(1);
+		/** SessionEvent passthrough: strict envelope, wide data (the client fold handles unknown types via its documented default). */
+		const sessionEventSchema = object({
+			type: string(),
+			seq: number().int().nonnegative(),
+			time: number(),
+			data: unknown(),
+			sourceEventSeqs: array(number()).optional(),
+			surfaceOp: unknown().optional(),
+			ignorable: literal(true).optional()
+		});
+		/** SessionSummary row of session.list (`projections` reuses the history block's shape and schema). */
+		const sessionSummarySchema = object({
+			sessionId: sessionIdSchema,
+			updatedAt: number(),
+			running: boolean(),
+			blank: boolean(),
+			parentSessionId: sessionIdSchema.optional(),
+			origin: literal("subagent").optional(),
+			cwd: string().optional(),
+			agentPreset: string().optional(),
+			projections: lazy(() => sessionProjectionsBlockSchema).optional()
+		});
+		object({ cursor: string().optional() });
+		object({ items: array(sessionSummarySchema) });
+		object({ query: string().trim().min(1).max(500).refine((query) => !query.includes("\0"), { message: "search query must not contain NUL" }) });
+		object({
+			items: array(object({
+				sessionId: sessionIdSchema,
+				snippet: string().refine((snippet) => truncateUnicodeCodePoints$1(snippet, 240) === snippet, { message: `search snippet must contain at most 240 Unicode code points` })
+			})).max(20),
+			hasMore: boolean()
+		});
+		object({
+			workspaceId: workspaceIdSchema.optional(),
+			cwd: string().optional(),
+			sessionId: sessionIdSchema.optional(),
+			agentPreset: string().optional()
+		}).refine((payload) => payload.workspaceId === void 0 || payload.cwd === void 0, { message: "session.create accepts workspaceId or cwd, not both" });
+		object({
+			sessionId: sessionIdSchema,
+			agentPreset: string().optional()
+		});
+		object({
+			sessionId: sessionIdSchema,
+			title: string()
+		});
+		object({
+			title: string().min(1),
+			seq: number().int().nonnegative()
+		});
+		object({
+			sessionId: sessionIdSchema,
+			atSeq: number().int().nonnegative().optional()
+		});
+		object({ sessionId: sessionIdSchema });
+		object({
+			sessionId: sessionIdSchema,
+			beforeSeq: number().int().nonnegative().optional(),
+			maxMessages: number().int().positive().optional()
+		});
+		/** Complete provider/model selection. */
+		const modelSelectionSchema = object({
+			provider: string().min(1),
+			model: string().min(1),
+			reasoningEffort: string().min(1).optional()
+		});
+		/** Exact-model reasoning metadata. */
+		const modelReasoningSchema = object({
+			efforts: array(object({
+				id: string().min(1),
+				name: string().min(1),
+				description: string().optional()
+			})).min(1),
+			defaultEffort: string().min(1).optional()
+		});
+		/** One advisory model entry inside a provider group. */
+		const modelCatalogModelSchema = object({
+			id: string().min(1),
+			name: string().min(1),
+			description: string().optional(),
+			reasoning: modelReasoningSchema.optional()
+		});
+		/** One successfully loaded provider group. */
+		const modelProviderGroupSchema = object({
+			id: string().min(1),
+			name: string().min(1),
+			models: array(modelCatalogModelSchema)
+		});
+		/** One provider-local catalog failure. */
+		const modelCatalogFailureSchema = object({
+			id: string().min(1),
+			name: string().min(1),
+			message: string()
+		});
+		/**
+		* ToolEventView passthrough: lock only the `for` discriminant and the presence
+		* of a card-tagged `view` object. The view interior is a host-computed product
+		* the client reads without echoing back; deep-validating it would hand-copy
+		* the dsh-tools vocabulary into this schema and drift with it.
+		*/
+		const toolEventViewSchema = discriminatedUnion("for", [object({
+			for: literal("call"),
+			view: looseObject({ card: string() })
+		}), object({
+			for: literal("result"),
+			view: looseObject({ card: string() })
+		})]);
+		/** One session.history item: the session event plus its optional host-computed tool view. */
+		const historyEntrySchema = object({
+			event: sessionEventSchema,
+			view: toolEventViewSchema.optional()
+		});
+		/**
+		* Projection baseline passthrough: `values` stays a wide record — each value
+		* was already parsed by its provider's own schema on the host side, and
+		* deep-validating here would import every domain's schema into the carrier.
+		*/
+		const sessionProjectionsBlockSchema = object({
+			asOfSeq: number().int().min(-1),
+			values: record(string(), unknown())
+		});
+		object({
+			blank: boolean(),
+			lastPromptAt: number().nullable()
+		});
+		object({
+			maxImageBytes: number().int().positive(),
+			maxImagesPerMessage: number().int().positive(),
+			maxMessageImageBytes: number().int().positive(),
+			maxImagePixels: number().int().positive(),
+			mediaTypes: array(string())
+		});
+		object({
+			events: array(historyEntrySchema),
+			hasMore: boolean(),
+			projections: sessionProjectionsBlockSchema.optional()
+		});
+		object({ sessionId: sessionIdSchema });
+		object({
+			current: modelSelectionSchema,
+			routable: boolean(),
+			groups: array(modelProviderGroupSchema),
+			failures: array(modelCatalogFailureSchema)
+		});
+		object({
+			sessionId: sessionIdSchema,
+			provider: string().min(1),
+			model: string().min(1),
+			reasoningEffort: string().min(1).optional()
+		});
+		object({ selected: modelSelectionSchema });
+		/** ContentBlock passthrough: core is merge-extensible — the type discriminant envelope is strict, the rest stays wide. */
+		const contentBlockSchema = looseObject({ type: string() });
+		/** Raster image media types accepted by the version-one browser wire. */
+		const imageMediaTypeSchema = union([
+			literal("image/png"),
+			literal("image/jpeg"),
+			literal("image/webp"),
+			literal("image/gif")
+		]);
+		/** Prompt wire content is intentionally narrower than merge-extensible durable core content. */
+		const promptContentPartSchema = discriminatedUnion("type", [object({
+			type: literal("text"),
+			text: string()
+		}), object({
+			type: literal("image"),
+			mediaType: imageMediaTypeSchema,
+			data: string(),
+			name: string().optional()
+		})]);
+		object({
+			sessionId: sessionIdSchema,
+			mode: union([literal("queue"), literal("steer")]),
+			content: array(promptContentPartSchema),
+			clientTimeZone: string().optional()
+		});
+		object({
+			accepted: literal(true),
+			command: object({
+				kind: literal("success"),
+				text: string().optional()
+			}).optional()
+		});
+		/** Opaque attachment id after string-shape validation. */
+		const attachmentIdSchema = string().min(1);
+		/** Durable image reference returned from the authenticated session lookup. */
+		const imageAttachmentRefSchema = object({
+			attachmentId: attachmentIdSchema,
+			mediaType: imageMediaTypeSchema,
+			bytes: number().int().positive(),
+			width: number().int().positive(),
+			height: number().int().positive(),
+			name: string().optional()
+		});
+		object({
+			sessionId: sessionIdSchema,
+			attachmentId: attachmentIdSchema
+		});
+		object({
+			attachment: imageAttachmentRefSchema,
+			data: string()
+		});
+		object({
+			sessionId: sessionIdSchema,
+			itemId: messageIdSchema,
+			action: discriminatedUnion("kind", [
+				object({
+					kind: literal("edit"),
+					content: array(contentBlockSchema)
+				}),
+				object({ kind: literal("remove") }),
+				object({ kind: literal("steer") })
+			])
+		});
+		object({ accepted: literal(true) });
+		object({ sessionId: sessionIdSchema });
+		object({ accepted: literal(true) });
+		//#endregion
+		//#region ../../stubs/xrk-host-apiproxy/src/api/approvals.schema.ts
+		/**
+		* approvals domain zod schemas (respond is a client-response; the payload schema serves
+		* the /api/respond endpoint's second parse after routing via the pending table).
+		* ApprovalRequestId brand cast point: one.
+		*/
+		/** ApprovalRequestId: one brand cast after schema validation (the only cast point in this domain). */
+		const approvalRequestIdSchema = string().min(1);
+		object({
+			sessionId: sessionIdSchema,
+			approvalId: approvalRequestIdSchema,
+			outcome: union([literal("allowed-once"), literal("rejected")])
+		});
+		/**
+		* One wire task view. `kind` stays an open string because producer plugins
+		* extend the registry's kind map by declaration merging, so the closed set is
+		* not knowable at this boundary.
+		*/
+		const taskViewSchema = object({
+			id: string().min(1),
+			kind: string().min(1),
+			label: string().min(1),
+			status: union([
+				literal("running"),
+				literal("stopping"),
+				literal("completed"),
+				literal("killed"),
+				literal("failed")
+			]),
+			detail: string().optional(),
+			startedAt: number().int().nonnegative(),
+			finishedAt: number().int().nonnegative().optional()
+		});
+		//#endregion
+		//#region ../../stubs/xrk-host-apiproxy/src/api/workspace.schema.ts
+		/**
+		* workspace domain zod schemas (names derived from map keys). The
+		* WorkspaceId brand cast lives in sessions.schema (see the note there) and
+		* is re-exported here as the domain-local name.
+		*/
+		/** WorkspaceView row of every workspace.* response. */
+		const workspaceViewSchema = object({
+			workspaceId: workspaceIdSchema,
+			path: string(),
+			title: string(),
+			sessionIds: array(sessionIdSchema),
+			createdAt: string(),
+			updatedAt: string()
+		});
+		object({});
+		object({
+			items: array(workspaceViewSchema),
+			archivedSessionIds: array(sessionIdSchema)
+		});
+		object({ path: string() });
+		object({
+			workspace: workspaceViewSchema,
+			created: boolean()
+		});
+		object({
+			workspaceId: workspaceIdSchema,
+			title: string()
+		}).refine((payload) => payload.title.trim() !== "", { message: "workspace.rename requires a non-blank title" });
+		object({ workspace: workspaceViewSchema });
+		object({ workspaceId: workspaceIdSchema });
+		object({ deleted: literal(true) });
+		object({
+			workspaceId: workspaceIdSchema,
+			beforeWorkspaceId: workspaceIdSchema.optional()
+		});
+		object({ workspaceIds: array(workspaceIdSchema) });
+		object({
+			workspaceId: workspaceIdSchema,
+			sessionId: sessionIdSchema,
+			beforeSessionId: sessionIdSchema.optional()
+		});
+		object({ workspace: workspaceViewSchema });
+		object({ sessionId: sessionIdSchema });
+		object({ archivedSessionIds: array(sessionIdSchema) });
+		//#endregion
+		//#region ../../stubs/xrk-host-apiproxy/src/api/events.schema.ts
+		/**
+		* events domain zod schemas: MuxFrame / HostFrame unions (discriminatedUnion('type')).
+		* A frame is the payload slot of the ServerRequest full form; the SessionEvent inside
+		* a session/event frame reuses sessions.schema's strict-envelope + wide-data passthrough branch.
+		*/
+		/** Question fields validated strictly against core dsh-user-questions. */
+		const askUserQuestionItemSchema = object({
+			id: string(),
+			question: string(),
+			header: string().optional(),
+			detail: string().optional(),
+			options: array(object({
+				label: string(),
+				description: string().optional()
+			})).optional(),
+			multiSelect: boolean().optional(),
+			intent: discriminatedUnion("kind", [object({
+				kind: literal("plan-review"),
+				approve: string()
+			})]).optional()
+		});
+		/** Unified message envelope carried by transient queue frames. */
+		const messageSchema = object({
+			id: string().min(1),
+			role: union([
+				literal("system"),
+				literal("user"),
+				literal("assistant")
+			]),
+			content: array(contentBlockSchema),
+			source: looseObject({ kind: string() })
+		});
+		/** MuxFrame union (payload slot of a mux-stream ServerRequest). */
+		const muxFrameSchema = discriminatedUnion("type", [
+			object({
+				type: literal("session/event"),
+				sessionId: sessionIdSchema,
+				event: sessionEventSchema,
+				view: toolEventViewSchema.optional()
+			}),
+			object({
+				type: literal("session/subscribed"),
+				sessionId: sessionIdSchema,
+				lastSeq: number().int()
+			}),
+			object({
+				type: literal("approval/requested"),
+				sessionId: sessionIdSchema,
+				approvalId: approvalRequestIdSchema,
+				toolName: string(),
+				callId: string().optional(),
+				reason: string().optional()
+			}),
+			object({
+				type: literal("approval/resolved"),
+				sessionId: sessionIdSchema,
+				approvalId: approvalRequestIdSchema,
+				outcome: union([
+					literal("allowed-once"),
+					literal("rejected"),
+					literal("cancelled"),
+					literal("unavailable")
+				])
+			}),
+			object({
+				type: literal("question/requested"),
+				sessionId: sessionIdSchema,
+				questions: array(askUserQuestionItemSchema).min(1)
+			}),
+			object({
+				type: literal("question/resolved"),
+				sessionId: sessionIdSchema,
+				questionRpcId: rpcIdSchema$1,
+				outcome: union([literal("answered"), literal("cancelled")])
+			}),
+			object({
+				type: literal("session/queue"),
+				sessionId: sessionIdSchema,
+				items: array(object({
+					id: messageIdSchema,
+					placement: union([
+						literal("queued"),
+						literal("steering"),
+						literal("context")
+					]),
+					message: messageSchema
+				}))
+			}),
+			object({
+				type: literal("session/jobs"),
+				sessionId: sessionIdSchema,
+				jobs: array(taskViewSchema)
+			}),
+			object({
+				type: literal("session/projection"),
+				sessionId: sessionIdSchema,
+				key: string().min(1),
+				value: unknown(),
+				seq: number().int().nonnegative()
+			}),
+			object({
+				type: literal("stream/error"),
+				error: rpcErrorSchema$1
+			})
+		]);
+		/** HostFrame union (payload slot of a host-stream ServerRequest). */
+		const hostFrameSchema = discriminatedUnion("type", [
+			object({
+				type: literal("host/session-added"),
+				sessionId: sessionIdSchema,
+				blank: boolean(),
+				parentSessionId: sessionIdSchema.optional(),
+				origin: literal("subagent").optional(),
+				cwd: string().optional(),
+				agentPreset: string().optional()
+			}),
+			object({
+				type: literal("host/session-removed"),
+				sessionId: sessionIdSchema
+			}),
+			object({
+				type: literal("host/session-status"),
+				sessionId: sessionIdSchema,
+				running: boolean()
+			}),
+			object({
+				type: literal("host/agent-error"),
+				sessionId: sessionIdSchema,
+				message: string()
+			}),
+			object({
+				type: literal("host/workspace-changed"),
+				workspace: workspaceViewSchema
+			}),
+			object({
+				type: literal("host/workspace-removed"),
+				workspaceId: workspaceIdSchema
+			}),
+			object({
+				type: literal("host/workspace-order-changed"),
+				workspaceIds: array(workspaceIdSchema)
+			}),
+			object({
+				type: literal("host/archived-sessions-changed"),
+				archivedSessionIds: array(sessionIdSchema)
+			}),
+			object({
+				type: literal("host/remote-event"),
+				event: string().min(1),
+				args: array(unknown())
+			}),
+			object({
+				type: literal("stream/error"),
+				error: rpcErrorSchema$1
+			})
+		]);
+		//#endregion
 		//#region src/api-path.ts
 		/**
 		* The /api URL prefix — single source for both halves of the web transport.
@@ -9882,7 +10832,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					let frame;
 					try {
 						if (typeof event.data !== "string") throw new Error("binary WebSocket frame");
-						full = serverRequestSchema.parse(JSON.parse(event.data));
+						full = serverRequestSchema$1.parse(JSON.parse(event.data));
 						frame = frameSchema.parse(full.payload);
 					} catch (error) {
 						console.error(`[client-connection] dropping malformed WebSocket frame on ${path}:`, error);
@@ -9955,7 +10905,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					...signal === void 0 ? {} : { signal }
 				});
 				if (!response.ok) throw new Error(`transport failure for ${channel}/${endpoint}: HTTP ${response.status}`);
-				const full = serverResponseSchema.parse(await response.json());
+				const full = serverResponseSchema$1.parse(await response.json());
 				if (full.rpcId !== rpcId) throw new Error(`rpcId mismatch for ${endpoint}: sent ${rpcId}, got ${full.rpcId}`);
 				return full.result;
 			} };