@deepseek-insight/dsi 0.6.12 → 0.6.14

package/build/server/chunks/chunks/{dsh-connection.js-Lnv7PlHw.js → dsh-connection.js-DRtqPR_j.js}

@@ -1,5 +1,5 @@
 import { v as dshBaseUrl } from './config.js-B0w1-uCA.js';
-import { r as readDshPresetEnglishConfig, a as readDshAuthConfig, b as readServerConfig } from './insight-config.js-XUD5BN0g.js';
+import { r as readDshAuthConfig, a as readServerConfig, b as readDshPresetEnglishConfig } from './insight-config.js-CA-iT3lB.js';
 
 //#region src/lib/server/dsh-rpc.ts
 /**
@@ -369,116 +369,436 @@ var DshAuth = class {
 	}
 };
 //#endregion
-//#region src/lib/server/dsh-connection.ts
+//#region src/lib/server/connection/normalize.ts
+/** The follow-<sessionId>-<streamSeq> logical stream id (one per generation). */
+function followStreamId(sessionId, streamSeq) {
+	return `follow-${sessionId}-${String(streamSeq)}`;
+}
 /**
-* dsh-connection — the transport singleton (BC-5) owning every wire byte to
-* the DSH Host (BC-6: it speaks only through dsh-rpc helpers and the two
-* downlink WebSocket paths).
-*
-* State model (PRD §3.5):
-*   mux  frames (session/subscribed, session/event) → per-session ring buffer
-*   host frames (host/session-status)               → per-session running map
-*   running map re-baselines from session.list at every generation open
-*   (2026-08-26): the host pushes status only on TRANSITIONS and sends no
-*   initial snapshot, so a downlink rebuilt mid-turn would otherwise never
-*   learn the session was already running.
-*   ring buffer = freshness only; the ledger (session.history) is the truth —
-*   cold loads and every resync re-read the ledger (BC-4).
-*
-* Generation semantics (guide Part 1): the two downlinks form one generation;
-* if either dies, both are rebuilt after backoff.
+* Expand ONE follow/page event payload into its ring-buffer form
+* (single-element list — ledger v2 serves every record as a plain event).
 */
-/** Live capacity from ~/.dsi/settings.yaml (no cache — runtime edits
-*  apply, same contract as every other config section). */
-function ringCapacity() {
-	return readServerConfig().ringCapacity;
+function expandEntry(e) {
+	return [{
+		type: e.type,
+		seq: typeof e.seq === "number" ? e.seq : -1,
+		time: typeof e.time === "number" ? e.time : 0,
+		data: e.data
+	}];
 }
-var singleton;
-/** The process-wide transport (BC-5). Creates lazily on first use. */
-function getDshConnection(opts = {}) {
-	singleton ??= new DshConnection(opts);
-	return singleton;
+/** Expand one page/snapshot record ({type:'event', event}) into its member
+*  events; a record without an event payload contributes nothing. */
+function expandRecord(record) {
+	if (record === void 0 || record.event === void 0) return [];
+	return expandEntry(record.event);
 }
-var DshConnection = class {
-	baseUrl;
-	fetchFn;
-	wsFactory;
-	auth;
-	rpcIdFactory;
-	backoff;
+/** Expand a records array into a flat event list. */
+function expandRecords(records) {
+	return records.flatMap((record) => expandRecord(record));
+}
+/** The last member time of one compact stream record, or undefined when
+*  the record carries no readable time (malformed members stay silent —
+*  the baseline is presentation seed data, never re-validated truth). */
+function compactRecordTailTime(record) {
+	if (record.type === "chunk") return typeof record.time === "number" ? record.time : void 0;
+	if (record.type === "text-chunks" || record.type === "reasoning-chunks" || record.type === "tool-call-chunks") {
+		const time0 = typeof record.time0 === "number" ? record.time0 : void 0;
+		const dt = Array.isArray(record.dt) ? record.dt : [];
+		if (time0 === void 0 || dt.some((g) => typeof g !== "number")) return void 0;
+		return dt.reduce((t, g) => t + g, time0);
+	}
+}
+function normalizeModelSelection(v) {
+	if (v === null || typeof v !== "object") return null;
+	const sel = v;
+	if (typeof sel.provider !== "string" || typeof sel.model !== "string") return null;
+	return {
+		provider: sel.provider,
+		model: sel.model,
+		...typeof sel.reasoningEffort === "string" ? { reasoningEffort: sel.reasoningEffort } : {}
+	};
+}
+/**
+* Conservative normalize of a SessionModels value: structural reads only,
+* never throws, never invents data (task 3.2-T: a garbage catalog → empty
+* groups + empty failures, honest `routable`/`current` — the selector can
+* still show the current selection and say nothing is listed). Reasoning
+* efforts are flattened to opaque ids (the adapter owns their meaning).
+*/
+function normalizeModelDirectory(raw) {
+	const empty = {
+		current: null,
+		routable: false,
+		groups: [],
+		failures: []
+	};
+	if (raw === null || typeof raw !== "object") return empty;
+	const dir = raw;
+	const groups = Array.isArray(dir.groups) ? modelGroupsOf(dir.groups) : [];
+	const failures = Array.isArray(dir.failures) ? modelFailuresOf(dir.failures) : [];
+	if (dir.current === void 0 && dir.default !== void 0) return {
+		current: normalizeModelSelection(dir.default),
+		routable: Array.isArray(dir.routableProviders) ? dir.routableProviders.length > 0 || groups.length > 0 : true,
+		groups,
+		failures
+	};
+	return {
+		current: normalizeModelSelection(dir.current),
+		routable: dir.routable === true,
+		groups,
+		failures
+	};
+}
+/** ModelCatalog provider groups → DsiModelGroup rows (conservative). */
+function modelGroupsOf(groups) {
+	return groups.flatMap((g) => {
+		if (g === null || typeof g !== "object") return [];
+		const grp = g;
+		if (typeof grp.id !== "string" || grp.id.length === 0) return [];
+		const models = Array.isArray(grp.models) ? grp.models.flatMap((m) => {
+			if (m === null || typeof m !== "object") return [];
+			const mod = m;
+			if (typeof mod.id !== "string" || mod.id.length === 0) return [];
+			return [{
+				id: mod.id,
+				name: typeof mod.name === "string" ? mod.name : null,
+				...Array.isArray(mod.reasoning?.efforts) ? { reasoningEfforts: mod.reasoning.efforts.flatMap((e) => typeof e?.id === "string" ? [e.id] : []) } : {}
+			}];
+		}) : [];
+		return [{
+			id: grp.id,
+			name: typeof grp.name === "string" ? grp.name : null,
+			models
+		}];
+	});
+}
+/** ModelCatalog provider failures → diagnostic rows (conservative). */
+function modelFailuresOf(failures) {
+	return failures.flatMap((f) => {
+		if (f === null || typeof f !== "object") return [];
+		const fail = f;
+		if (typeof fail.id !== "string" || fail.id.length === 0) return [];
+		return [{
+			id: fail.id,
+			name: typeof fail.name === "string" ? fail.name : null,
+			message: typeof fail.message === "string" ? fail.message : null
+		}];
+	});
+}
+function normalizeSessionRow(row) {
+	return {
+		sessionId: row.sessionId,
+		title: row.origin === "subagent" ? readSubagentLabel(row) ?? readTitle(row) : readTitle(row),
+		agentPreset: readAgentPreset(row) ?? row.agentPreset ?? null,
+		running: Boolean(row.running),
+		blank: Boolean(row.blank),
+		updatedAt: row.updatedAt ?? 0,
+		workspace: typeof row.cwd === "string" && row.cwd.length > 0 ? row.cwd : null,
+		turns: readTurns(row),
+		parentSessionId: row.parentSessionId ?? null,
+		origin: row.origin ?? null
+	};
+}
+function readTitle(row) {
+	const title = row.projections?.values?.["title"];
+	return typeof title === "string" && title.length > 0 ? title : null;
+}
+/** projections.values.subagent.label (the child descriptor's creation label;
+*  one-shot children may omit it — structural read, null when unreadable). */
+function readSubagentLabel(row) {
+	const identity = row.projections?.values?.["subagent"];
+	const label = identity !== null && typeof identity === "object" ? identity.label : void 0;
+	return typeof label === "string" && label.length > 0 ? label : null;
+}
+/** projections.values.agentPreset (0.1.2 home of the preset id on list rows). */
+function readAgentPreset(row) {
+	const preset = row.projections?.values?.["agentPreset"];
+	return typeof preset === "string" && preset.length > 0 ? preset : null;
+}
+/** `sessionStats.turns` (0.1.2: projections.values.sessionStats) — integer-strict, null on absent/junk. */
+function readTurns(row) {
+	const stats = row.projections?.values?.["sessionStats"];
+	const turns = stats !== null && typeof stats === "object" ? stats.turns : row.sessionStats?.turns;
+	if (typeof turns !== "number" || !Number.isInteger(turns) || turns < 0) return null;
+	return turns;
+}
+/**
+* English display copy for the host's SHIPPED presets, keyed by the stable
+* preset id. The wire's `name`/`description` are the UNLOCALIZED metadata a
+* preset publishes (DSH `PresetDisplaySource`), and the four built-ins ship
+* Simplified Chinese there — DSH localizes them only inside its own web UI
+* (`packages/preset/agent-presets/src/display.ts` folds trust:'system' + id →
+* locale dictionary keys). This app has no host locale seat, so the overlay
+* mirrors that fold in English: trust:'system' + a known id → the English
+* copy; every other row (user presets, unknown future ids) keeps the host's
+* name verbatim — user metadata is never translated, and an unknown id falls
+* back honestly. Operator-tunable off via ~/.dsi/settings.yaml
+* `dsh.presetEnglish: false` (readDshPresetEnglishConfig — no cache, so the
+* next listPresets fetch picks an edit up). Keep the strings in step with DSH
+* `packages/client/ui-agent-preset/src/client/locales.ts` (the `en` bundle).
+*/
+var SHIPPED_PRESET_ENGLISH = {
+	standard: {
+		name: "Standard mode",
+		description: "Full coding agent with file editing, shell, file and web search, skills, planning, goals, subagents, and workflows."
+	},
+	ptc: {
+		name: "PTC mode",
+		description: "Full coding agent without the workflow tool; other tools are exposed through the PTC mode SDK so the model can combine multi-step operations in one TypeScript program."
+	},
+	minimal: {
+		name: "Minimal mode",
+		description: "Two-tool coding agent with persistent bash and str_replace_editor."
+	},
+	cordis: {
+		name: "Creator mode",
+		description: "Built for creating custom agent presets, with all Standard mode capabilities plus runtime inspection, plugin experiments, and preset-authoring guidance."
+	}
+};
+/**
+* Conservative normalize: unknown shapes keep their id but never invent data.
+* The one English overlay seat (SHIPPED_PRESET_ENGLISH) applies before the
+* host fallbacks — a shipped preset's label is locale-resolved here, never
+* the wire's unlocalized text. Operator-tunable via
+* ~/.dsi/settings.yaml `dsh.presetEnglish` (read live per listPresets
+* call, passed through here): false hands the wire name through untouched.
+*/
+function normalizePreset(row, overlayEnglish = true) {
+	const id = typeof row.id === "string" ? row.id : String(row.id ?? "");
+	const shipped = overlayEnglish && row.trust === "system" ? SHIPPED_PRESET_ENGLISH[id] : void 0;
+	return {
+		id,
+		name: shipped?.name ?? (typeof row.name === "string" ? row.name : null),
+		description: shipped?.description ?? (typeof row.description === "string" ? row.description : null),
+		isDefault: row.isDefault === true
+	};
+}
+//#endregion
+//#region src/lib/server/connection/session-state.ts
+var SessionStateStore = class {
+	deps;
 	log;
 	buffers = /* @__PURE__ */ new Map();
 	running = /* @__PURE__ */ new Map();
-	/**
-	* Live assistant-stream tails (0.1.3-alpha.1): the one in-flight model
-	* attempt per session, folded from the follow's seq-less assistant-stream
-	* frames. Presentation state only — never part of the durable cursor
-	* algebra (lastSeq/gap/coverage), because the frames carry no seq.
-	*/
 	liveTails = /* @__PURE__ */ new Map();
-	/**
-	* Session-ids that received a host/session-status push since the running
-	* re-baseline RPC was ISSUED (2026-08-26). A push is a strictly newer
-	* transition than an in-flight snapshot — the seed must never overwrite
-	* one. Swapped for a fresh set every time a seed is issued; read at
-	* apply time so pushes landing mid-flight are counted.
-	*/
 	runningSeedRaces = /* @__PURE__ */ new Set();
-	wsMux;
-	generation = 0;
-	/** Logical streams by streamId → owning socket (0.1.2 remote.mux). */
-	streamSockets = /* @__PURE__ */ new Map();
-	/** Generation-scoped counter keeping stream ids unique across rebuilds. */
-	streamSeq = 0;
-	/** $events generation clientId (RemoteEventReadyFrame; binds $events/result). */
-	eventClientId = null;
-	/** True once the carrier's OPEN event fired (sends are legal). */
-	opened = false;
-	/** Per-session projection baselines (follow snapshot + control frames; W2). */
-	projections = /* @__PURE__ */ new Map();
-	/** Workspace registry cache from workspace/follow (W2; authority = host). */
-	workspaces = [];
-	/** Waiters resolved by the first workspace/follow baseline (one-shot). */
-	workspaceBaselineWaiters = /* @__PURE__ */ new Set();
-	/** Subscribes parked while the carrier is CONNECTING (flushed on open). */
-	pendingSubscribes = /* @__PURE__ */ new Set();
-	/**
-	* Parent-address hints for subagent-origin sessions (SubagentAddressHint),
-	* folded from session.list rows by rawListSessions.
-	*/
-	subagentHints = /* @__PURE__ */ new Map();
-	/** Session-ids whose hint absence was already probed with a list pass
-	*  (one probe per session lifetime — ordinary sessions never re-probe). */
-	hintProbed = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+		this.log = deps.log;
+	}
+	setRunning(sessionId, running) {
+		this.running.set(sessionId, running);
+	}
+	bufferKeys() {
+		return this.buffers.keys();
+	}
+	dispose() {
+		this.buffers.clear();
+		this.liveTails.clear();
+		this.running.clear();
+		this.runningSeedRaces.clear();
+	}
+	onHostFrame(payload) {
+		const frame = payload;
+		if (frame?.type === "host/session-status" && typeof frame.sessionId === "string") {
+			this.runningSeedRaces.add(frame.sessionId);
+			this.running.set(frame.sessionId, Boolean(frame.running));
+		}
+	}
+	async seedRunning() {
+		const generation = this.deps.generation();
+		this.runningSeedRaces = /* @__PURE__ */ new Set();
+		try {
+			const { items } = await this.deps.listSessions();
+			if (this.deps.disposed() || generation !== this.deps.generation()) return;
+			const races = this.runningSeedRaces;
+			const next = /* @__PURE__ */ new Map();
+			for (const [id, running] of this.running) if (races.has(id)) next.set(id, running);
+			for (const row of items) if (!races.has(row.sessionId)) next.set(row.sessionId, row.running);
+			this.running = next;
+			this.log(`dsh-connection: running map re-baselined (${items.length} sessions)`);
+		} catch (err) {
+			this.log("dsh-connection: running re-baseline failed — pushes stay authoritative", err);
+		}
+	}
+	bufferFor(sessionId) {
+		let buf = this.buffers.get(sessionId);
+		if (!buf) {
+			buf = {
+				entries: [],
+				lastSeq: -1,
+				coverageFloor: -1
+			};
+			this.buffers.set(sessionId, buf);
+		}
+		return buf;
+	}
+	seedBaseline(sessionId, lastSeq) {
+		const buf = this.bufferFor(sessionId);
+		if (lastSeq > buf.lastSeq && buf.entries.length === 0) {
+			buf.lastSeq = lastSeq;
+			buf.coverageFloor = lastSeq;
+			return;
+		}
+		if (buf.lastSeq >= 0 && lastSeq < buf.lastSeq) {
+			buf.entries.length = 0;
+			buf.lastSeq = lastSeq;
+			buf.coverageFloor = lastSeq;
+		}
+	}
+	seedSnapshotCursor(sessionId, cursor) {
+		const buf = this.bufferFor(sessionId);
+		if (cursor > buf.lastSeq) {
+			buf.lastSeq = cursor;
+			buf.coverageFloor = cursor;
+			return;
+		}
+		if (buf.lastSeq >= 0 && cursor < buf.lastSeq) {
+			buf.entries.length = 0;
+			buf.lastSeq = cursor;
+			buf.coverageFloor = cursor;
+		}
+	}
+	appendEvent(sessionId, event) {
+		const buf = this.bufferFor(sessionId);
+		if (event.seq > buf.lastSeq) {
+			if (buf.lastSeq >= 0 && event.seq > buf.lastSeq + 1) {
+				buf.coverageFloor = Math.max(buf.coverageFloor, buf.lastSeq);
+				this.log(`dsh-connection: seq gap for ${sessionId} (${buf.lastSeq} → ${event.seq}) — resync required below ${event.seq}`);
+			}
+			buf.lastSeq = event.seq;
+			buf.entries.push(event);
+			const cap = this.deps.ringCapacity();
+			if (buf.entries.length > cap) buf.entries.splice(0, buf.entries.length - cap);
+		}
+	}
+	onAssistantStreamFrame(sessionId, frame) {
+		if (frame.type === "start") {
+			this.liveTails.set(sessionId, {
+				attemptId: frame.attemptId,
+				turn: frame.turn,
+				step: frame.step,
+				startedAfterSeq: frame.startedAfterSeq,
+				startedAt: Date.now(),
+				lastTime: Date.now(),
+				text: "",
+				reasoning: "",
+				nextIndex: 0
+			});
+			return;
+		}
+		const tail = this.liveTails.get(sessionId);
+		if (tail === void 0) return;
+		if (frame.type === "chunk") {
+			if (frame.attemptId !== tail.attemptId || frame.index !== tail.nextIndex) {
+				this.liveTails.delete(sessionId);
+				return;
+			}
+			const kind = frame.chunk?.type;
+			if (kind === "text-delta" && typeof frame.chunk?.text === "string") tail.text += frame.chunk.text;
+			else if (kind === "reasoning-delta" && typeof frame.chunk?.text === "string") tail.reasoning += frame.chunk.text;
+			tail.nextIndex += 1;
+			if (typeof frame.time === "number") tail.lastTime = frame.time;
+			return;
+		}
+		this.liveTails.delete(sessionId);
+	}
+	seedLiveTailFromBaseline(sessionId, baseline) {
+		const active = baseline?.activeAttempt;
+		if (active === void 0) {
+			this.liveTails.delete(sessionId);
+			return;
+		}
+		const tail = {
+			attemptId: active.attemptId,
+			turn: active.turn,
+			step: active.step,
+			startedAfterSeq: active.startedAfterSeq,
+			startedAt: Date.now(),
+			lastTime: Date.now(),
+			text: "",
+			reasoning: "",
+			nextIndex: active.nextIndex
+		};
+		for (const record of active.stream ?? []) {
+			if (record.type === "text-chunks" || record.type === "reasoning-chunks") {
+				const texts = record.texts;
+				const joined = Array.isArray(texts) ? texts.filter((t) => typeof t === "string").join("") : "";
+				if (record.type === "text-chunks") tail.text += joined;
+				else tail.reasoning += joined;
+			}
+			const times = compactRecordTailTime(record);
+			if (times !== void 0) tail.lastTime = times;
+		}
+		this.liveTails.set(sessionId, tail);
+	}
+	liveAssistantStream(sessionId) {
+		const tail = this.liveTails.get(sessionId);
+		if (tail === void 0) return null;
+		return {
+			id: `a:${String(tail.turn)}:${String(tail.step)}`,
+			turn: tail.turn,
+			step: tail.step,
+			seq: tail.startedAfterSeq,
+			time: tail.lastTime,
+			text: tail.text,
+			reasoning: tail.reasoning
+		};
+	}
+	eventsSince(sessionId, n) {
+		const buf = this.bufferFor(sessionId);
+		const events = buf.entries.filter((e) => e.seq > n);
+		const firstDelta = events[0]?.seq;
+		const gap = firstDelta !== void 0 && firstDelta > n + 1;
+		return {
+			events,
+			lastSeq: buf.lastSeq,
+			running: this.running.get(sessionId) ?? false,
+			gap
+		};
+	}
+	hasBaseline(sessionId) {
+		return this.buffers.has(sessionId) && this.bufferFor(sessionId).lastSeq >= 0;
+	}
+	isRunning(sessionId) {
+		return this.running.get(sessionId) ?? false;
+	}
+};
+//#endregion
+//#region src/lib/server/connection/downlinks.ts
+/**
+* connection/downlinks — the downlink generation lifecycle + frame demux
+* (ADR-0022 W3, ADR-0019 move-whole): the ONE cookie-authenticated remote.mux
+* carrier, its logical streams (session/follow, $events, workspace/follow,
+* session/control), generation rebuild + backoff, the 0.1.2 frame demux,
+* and the per-session projection / workspace-registry caches.
+*/
+var DownlinkManager = class {
+	conn;
+	constructor(conn) {
+		this.conn = conn;
+	}
+	wsMux;
+	generation = 0;
+	/** Logical streams by streamId → owning socket (0.1.2 remote.mux). */
+	streamSockets = /* @__PURE__ */ new Map();
+	/** Generation-scoped counter keeping stream ids unique across rebuilds. */
+	streamSeq = 0;
+	/** $events generation clientId (RemoteEventReadyFrame; binds $events/result). */
+	eventClientId = null;
+	/** True once the carrier's OPEN event fired (sends are legal). */
+	opened = false;
+	/** Per-session projection baselines (follow snapshot + control frames; W2). */
+	projections = /* @__PURE__ */ new Map();
+	/** Workspace registry cache from workspace/follow (W2; authority = host). */
+	workspaces = [];
+	/** Waiters resolved by the first workspace/follow baseline (one-shot). */
+	workspaceBaselineWaiters = /* @__PURE__ */ new Set();
+	/** Subscribes parked while the carrier is CONNECTING (flushed on open). */
+	pendingSubscribes = /* @__PURE__ */ new Set();
 	reconnectTimer;
-	disposed = false;
 	/** Wave 4.2 — consecutive failed generations; drives the backoff ladder. */
 	reconnectAttempt = 0;
-	/** Reap grace (see DshConnectionOptions.answerReapGraceMs). */
-	answerReapGraceMs;
-	answerReapTimer;
-	/** Stale-generation retry deadline (see DshConnectionOptions.staleGenerationRetryMs). */
-	staleGenerationRetryMs;
-	constructor(opts = {}) {
-		this.baseUrl = opts.baseUrl ?? dshBaseUrl();
-		this.fetchFn = opts.fetchFn ?? fetch;
-		this.wsFactory = opts.wsFactory ?? ((url, headers) => new WebSocket(url, headers === void 0 ? void 0 : { headers }));
-		this.auth = opts.auth ?? new DshAuth({
-			baseUrl: this.baseUrl,
-			log: opts.log
-		});
-		this.rpcIdFactory = opts.rpcIdFactory ?? (() => crypto.randomUUID());
-		this.backoff = opts.backoffScheduleMs ?? [
-			1e3,
-			2e3,
-			5e3,
-			1e4,
-			3e4
-		];
-		this.answerReapGraceMs = opts.answerReapGraceMs ?? 3e3;
-		this.staleGenerationRetryMs = opts.staleGenerationRetryMs ?? 5e3;
-		this.log = opts.log ?? (() => {});
-	}
 	/**
 	* Open the stream generation (idempotent): ONE cookie-authenticated
 	* remote.mux socket (0.1.2 — events.mux/events.host are gone), with every
@@ -486,22 +806,22 @@ var DshConnection = class {
 	* the $events forwarded-event stream (approvals/questions).
 	*/
 	ensureDownlinks() {
-		if (this.disposed || this.wsMux) return;
+		if (this.conn.disposed || this.wsMux) return;
 		++this.generation;
-		this.log(`dsh-connection: opening remote.mux generation ${this.generation}`);
+		this.conn.log(`dsh-connection: opening remote.mux generation ${this.generation}`);
 		this.wsMux = this.openDownlink((socket) => this.onMuxOpen(socket));
-		this.seedRunning();
+		this.conn.sessions.seedRunning();
 	}
 	openDownlink(attach) {
-		const url = this.baseUrl.replace(/^http/, "ws") + DSH_REMOTE_MUX_WS_PATH;
-		const headers = this.auth.cookieHeader();
-		const socket = this.wsFactory(url, headers === void 0 ? void 0 : { cookie: headers });
-		this.auth.ensureCookie().catch(() => null);
+		const url = this.conn.baseUrl.replace(/^http/, "ws") + DSH_REMOTE_MUX_WS_PATH;
+		const headers = this.conn.auth.cookieHeader();
+		const socket = this.conn.wsFactory(url, headers === void 0 ? void 0 : { cookie: headers });
+		this.conn.auth.ensureCookie().catch(() => null);
 		socket.addEventListener("message", (e) => {
 			try {
 				this.onStreamFrame(JSON.parse(String(e.data)));
 			} catch (err) {
-				this.log("dsh-connection: dropping malformed frame", err);
+				this.conn.log("dsh-connection: dropping malformed frame", err);
 			}
 		});
 		socket.addEventListener("open", () => {
@@ -516,7 +836,7 @@ var DshConnection = class {
 	onMuxOpen(socket) {
 		this.streamSeq += 1;
 		this.pendingSubscribes.clear();
-		for (const sessionId of this.buffers.keys()) this.openFollowWithProbe(socket, sessionId);
+		for (const sessionId of this.conn.sessions.bufferKeys()) this.openFollowWithProbe(socket, sessionId);
 		this.openEventStream(socket);
 		this.openStateStream(socket, `workspaces-${String(this.streamSeq)}`, "workspace/follow");
 		this.openStateStream(socket, `control-${String(this.streamSeq)}`, "session/control");
@@ -527,7 +847,7 @@ var DshConnection = class {
 	}
 	openFollowStream(socket, sessionId) {
 		this.sendStreamOpen(socket, followStreamId(sessionId, this.streamSeq), "session/follow", { args: { request: {
-			address: this.addressFor(sessionId),
+			address: this.conn.relay.addressFor(sessionId),
 			maxMessages: 200,
 			assistantStream: true
 		} } });
@@ -547,20 +867,20 @@ var DshConnection = class {
 	}
 	/** Either socket dying rebuilds the whole generation (guide Part 1). */
 	onDownlinkClosed() {
-		if (this.disposed) return;
+		if (this.conn.disposed) return;
 		if (!this.wsMux) return;
-		this.log("dsh-connection: remote.mux died — rebuilding generation");
-		this.fireCatalogInvalidated("all");
+		this.conn.log("dsh-connection: remote.mux died — rebuilding generation");
+		this.conn.relay.fireCatalogInvalidated("all");
 		this.teardownSockets();
 		this.scheduleReconnect();
 	}
 	scheduleReconnect() {
-		if (this.disposed) return;
-		const rung = Math.min(this.reconnectAttempt, this.backoff.length - 1);
-		const delay = this.backoff[rung];
+		if (this.conn.disposed) return;
+		const rung = Math.min(this.reconnectAttempt, this.conn.backoff.length - 1);
+		const delay = this.conn.backoff[rung];
 		if (this.reconnectTimer !== void 0) clearTimeout(this.reconnectTimer);
 		this.reconnectTimer = setTimeout(() => {
-			if (this.disposed) return;
+			if (this.conn.disposed) return;
 			this.reconnectAttempt += 1;
 			this.ensureDownlinks();
 		}, delay);
@@ -598,7 +918,7 @@ var DshConnection = class {
 			else if (frame.streamId.startsWith("control-")) this.onControlItem(value);
 			return;
 		}
-		if (frame.type === "error") this.log(`dsh-connection: stream ${frame.streamId} failed`, frame.error?.code, frame.error?.message);
+		if (frame.type === "error") this.conn.log(`dsh-connection: stream ${frame.streamId} failed`, frame.error?.code, frame.error?.message);
 		this.streamSockets.delete(frame.streamId);
 	}
 	/** session/follow item: snapshot seeds the baseline; events append; the
@@ -610,30 +930,30 @@ var DshConnection = class {
 			if (sessionId === null) return;
 			const snapshot = value;
 			const events = expandRecords(snapshot.records ?? []);
-			for (const event of events) this.appendEvent(sessionId, event);
-			this.seedSnapshotCursor(sessionId, snapshot.cursor);
+			for (const event of events) this.conn.sessions.appendEvent(sessionId, event);
+			this.conn.sessions.seedSnapshotCursor(sessionId, snapshot.cursor);
 			if (snapshot.projections !== null && typeof snapshot.projections === "object") this.projections.set(sessionId, snapshot.projections);
-			this.seedLiveTailFromBaseline(sessionId, snapshot.assistantStream);
+			this.conn.sessions.seedLiveTailFromBaseline(sessionId, snapshot.assistantStream);
 			return;
 		}
 		if (value.type === "assistant-stream") {
 			const sessionId = this.sessionIdOfStream(streamId);
 			const frame = value.frame;
-			if (sessionId !== null && frame !== void 0) this.onAssistantStreamFrame(sessionId, frame);
+			if (sessionId !== null && frame !== void 0) this.conn.sessions.onAssistantStreamFrame(sessionId, frame);
 			return;
 		}
 		if (value.type === "event") {
 			const sessionId = this.sessionIdOfStream(streamId);
 			const entry = value;
-			if (sessionId !== null && entry.event !== void 0) for (const event of expandEntry(entry.event)) this.appendEvent(sessionId, event);
+			if (sessionId !== null && entry.event !== void 0) for (const event of expandEntry(entry.event)) this.conn.sessions.appendEvent(sessionId, event);
 		}
 	}
 	/** $events item: forwarded Cordis event frames (waterfall = answerable). */
 	onEventItem(value) {
 		if (value.type === "ready") {
 			if (typeof value.clientId === "string") this.eventClientId = value.clientId;
-			this.log("dsh-connection: $events stream ready");
-			this.armAnswerReap();
+			this.conn.log("dsh-connection: $events stream ready");
+			this.conn.relay.armAnswerReap();
 			return;
 		}
 		if (value.type === "waterfall") {
@@ -643,7 +963,7 @@ var DshConnection = class {
 			const request = value.request !== null && typeof value.request === "object" ? value.request : {};
 			if (eventId === void 0) return;
 			if (event === "approval/request") {
-				this.registerPending({
+				this.conn.relay.registerPending({
 					type: "approval/requested",
 					sessionId: sessionId ?? "",
 					...request
@@ -651,43 +971,43 @@ var DshConnection = class {
 				return;
 			}
 			if (event === "user-questions/request") {
-				this.registerPending({
+				this.conn.relay.registerPending({
 					type: "question/requested",
 					sessionId: sessionId ?? "",
 					...request
 				}, eventId);
 				return;
 			}
-			this.log("dsh-connection: forwarded waterfall ignored", event);
+			this.conn.log("dsh-connection: forwarded waterfall ignored", event);
 			return;
 		}
 		if (value.type === "cancel") {
 			const eventId = typeof value.eventId === "string" ? value.eventId : void 0;
-			if (eventId !== void 0) this.withdrawPending(eventId);
-			this.log("dsh-connection: forwarded waterfall cancelled");
+			if (eventId !== void 0) this.conn.relay.withdrawPending(eventId);
+			this.conn.log("dsh-connection: forwarded waterfall cancelled");
 			return;
 		}
 		if (value.type === "settle") {
 			const eventId = typeof value.eventId === "string" ? value.eventId : void 0;
 			const outcome = typeof value.outcome === "string" ? value.outcome : "unknown";
-			if (eventId !== void 0) this.withdrawPending(eventId, outcome);
+			if (eventId !== void 0) this.conn.relay.withdrawPending(eventId, outcome);
 			return;
 		}
 		if (value.type === "emit") {
 			if (value.event === "api-session/status" && Array.isArray(value.args)) {
 				const [sessionId, running] = value.args;
-				if (typeof sessionId === "string") this.running.set(sessionId, running === true);
+				if (typeof sessionId === "string") this.conn.sessions.setRunning(sessionId, running === true);
 				return;
 			}
 			if (value.event === "commands/change") {
-				this.fireCatalogInvalidated("all");
+				this.conn.relay.fireCatalogInvalidated("all");
 				return;
 			}
 			if (value.event === "agent-preset/selected" && typeof value.agentId === "string") {
-				this.fireCatalogInvalidated(value.agentId);
+				this.conn.relay.fireCatalogInvalidated(value.agentId);
 				return;
 			}
-			this.log("dsh-connection: forwarded emit ignored", value.event);
+			this.conn.log("dsh-connection: forwarded emit ignored", value.event);
 			return;
 		}
 	}
@@ -712,7 +1032,7 @@ var DshConnection = class {
 			});
 			for (const waiter of this.workspaceBaselineWaiters) waiter.resolve();
 			this.workspaceBaselineWaiters.clear();
-			this.log(`dsh-connection: workspace baseline (${this.workspaces.length} rows)`);
+			this.conn.log(`dsh-connection: workspace baseline (${this.workspaces.length} rows)`);
 			return;
 		}
 		if (value.type === "upsert") {
@@ -743,7 +1063,7 @@ var DshConnection = class {
 		if (value.type === "baseline") {
 			const baseline = value.value ?? {};
 			for (const [sessionId, block] of Object.entries(baseline.projections ?? {})) if (block !== null && typeof block === "object") this.projections.set(sessionId, block);
-			this.log(`dsh-connection: control baseline (${this.projections.size} sessions)`);
+			this.conn.log(`dsh-connection: control baseline (${this.projections.size} sessions)`);
 			return;
 		}
 		if (value.type === "projection" && typeof value.sessionId === "string" && typeof value.key === "string") {
@@ -766,264 +1086,26 @@ var DshConnection = class {
 		const cut = rest.lastIndexOf("-");
 		return cut > 0 ? rest.slice(0, cut) : null;
 	}
-	pendingAnswers = /* @__PURE__ */ new Map();
-	/** Settlement ring: last outcome per rpcId, delivered-then-pruned. */
-	settledAnswers = /* @__PURE__ */ new Map();
-	/** Catalog-invalidation registry (Slash Menu W1) — listeners see every arm. */
-	catalogInvalidated = /* @__PURE__ */ new Set();
-	/** Subscribe to catalog invalidations ($events arms + socket reset). */
-	onCatalogInvalidated(listener) {
-		this.catalogInvalidated.add(listener);
-		return () => this.catalogInvalidated.delete(listener);
-	}
-	fireCatalogInvalidated(scope) {
-		for (const listener of this.catalogInvalidated) listener(scope);
-	}
-	onMuxFrame(payload, rpcId) {
-		this.reconnectAttempt = 0;
-		const frame = payload;
-		switch (frame?.type) {
-			case "session/subscribed":
-				if (typeof frame.sessionId === "string") this.seedBaseline(frame.sessionId, frame.lastSeq ?? -1);
-				return;
-			case "session/event":
-				if (frame.sessionId && frame.event) this.appendEvent(frame.sessionId, frame.event);
-				return;
-			case "approval/requested":
-			case "question/requested":
-				this.registerPending(frame, rpcId);
-				return;
-			case "approval/resolved":
-			case "question/resolved":
-				this.registerSettlement(frame);
-				return;
-			default: this.log("dsh-connection: mux frame ignored", frame?.type);
-		}
-	}
-	onHostFrame(payload) {
-		const frame = payload;
-		if (frame?.type === "host/session-status" && typeof frame.sessionId === "string") {
-			this.runningSeedRaces.add(frame.sessionId);
-			this.running.set(frame.sessionId, Boolean(frame.running));
-		}
-	}
-	/**
-	* 2026-08-26 running re-baseline: DSH pushes host/session-status only on
-	* transitions and the host stream sends no initial snapshot on (re)open —
-	* a downlink rebuilt mid-turn never sees the running:true flip that
-	* happened before it existed (the live bug: events kept flowing on the
-	* mux while the streaming indicator said idle). session.list is the host's
-	* documented reconnect baseline, so every generation opens with ONE list
-	* RPC seeding the whole map — which also prunes entries for sessions that
-	* died while disconnected. Pushes that land while the RPC is in flight win
-	* over the snapshot (they are strictly newer transitions); a seed from a
-	* superseded generation is dropped entirely.
-	*/
-	async seedRunning() {
-		const generation = this.generation;
-		this.runningSeedRaces = /* @__PURE__ */ new Set();
-		try {
-			const { items } = await this.listSessions();
-			if (this.disposed || generation !== this.generation) return;
-			const races = this.runningSeedRaces;
-			const next = /* @__PURE__ */ new Map();
-			for (const [id, running] of this.running) if (races.has(id)) next.set(id, running);
-			for (const row of items) if (!races.has(row.sessionId)) next.set(row.sessionId, row.running);
-			this.running = next;
-			this.log(`dsh-connection: running map re-baselined (${items.length} sessions)`);
-		} catch (err) {
-			this.log("dsh-connection: running re-baseline failed — pushes stay authoritative", err);
-		}
-	}
-	bufferFor(sessionId) {
-		let buf = this.buffers.get(sessionId);
-		if (!buf) {
-			buf = {
-				entries: [],
-				lastSeq: -1,
-				coverageFloor: -1
-			};
-			this.buffers.set(sessionId, buf);
-		}
-		return buf;
-	}
-	seedBaseline(sessionId, lastSeq) {
-		const buf = this.bufferFor(sessionId);
-		if (lastSeq > buf.lastSeq && buf.entries.length === 0) {
-			buf.lastSeq = lastSeq;
-			buf.coverageFloor = lastSeq;
-			return;
-		}
-		if (buf.lastSeq >= 0 && lastSeq < buf.lastSeq) {
-			buf.entries.length = 0;
-			buf.lastSeq = lastSeq;
-			buf.coverageFloor = lastSeq;
-		}
-	}
-	/**
-	* Snapshot cursor seed (0.1.2). A snapshot BELOW the buffered high-water
-	* mark means the upstream was rebuilt (stream restart): stale entries
-	* belong to the dead instance — reset the buffer to the snapshot truth
-	* (Wave 2 parity with the 0.1.1 rewound-baseline semantics).
-	*/
-	seedSnapshotCursor(sessionId, cursor) {
-		const buf = this.bufferFor(sessionId);
-		if (cursor > buf.lastSeq) {
-			buf.lastSeq = cursor;
-			buf.coverageFloor = cursor;
-			return;
-		}
-		if (buf.lastSeq >= 0 && cursor < buf.lastSeq) {
-			buf.entries.length = 0;
-			buf.lastSeq = cursor;
-			buf.coverageFloor = cursor;
-		}
-	}
-	appendEvent(sessionId, event) {
-		const buf = this.bufferFor(sessionId);
-		if (event.seq > buf.lastSeq) {
-			if (buf.lastSeq >= 0 && event.seq > buf.lastSeq + 1) {
-				buf.coverageFloor = Math.max(buf.coverageFloor, buf.lastSeq);
-				this.log(`dsh-connection: seq gap for ${sessionId} (${buf.lastSeq} → ${event.seq}) — resync required below ${event.seq}`);
-			}
-			buf.lastSeq = event.seq;
-			buf.entries.push(event);
-			const cap = ringCapacity();
-			if (buf.entries.length > cap) buf.entries.splice(0, buf.entries.length - cap);
-		}
-	}
-	/**
-	* Fold one assistant-stream frame into the session's live tail. Seq-less
-	* presentation state: never touches lastSeq/coverage — the durable
-	* cursor algebra stays event-entry-only. The host keeps ONE active
-	* attempt per session and drops its own accumulator on any continuity
-	* break (foreign attemptId, dense-index gap), so mirrors do the same.
-	*/
-	onAssistantStreamFrame(sessionId, frame) {
-		if (frame.type === "start") {
-			this.liveTails.set(sessionId, {
-				attemptId: frame.attemptId,
-				turn: frame.turn,
-				step: frame.step,
-				startedAfterSeq: frame.startedAfterSeq,
-				startedAt: Date.now(),
-				lastTime: Date.now(),
-				text: "",
-				reasoning: "",
-				nextIndex: 0
-			});
-			return;
-		}
-		const tail = this.liveTails.get(sessionId);
-		if (tail === void 0) return;
-		if (frame.type === "chunk") {
-			if (frame.attemptId !== tail.attemptId || frame.index !== tail.nextIndex) {
-				this.liveTails.delete(sessionId);
-				return;
-			}
-			const kind = frame.chunk?.type;
-			if (kind === "text-delta" && typeof frame.chunk?.text === "string") tail.text += frame.chunk.text;
-			else if (kind === "reasoning-delta" && typeof frame.chunk?.text === "string") tail.reasoning += frame.chunk.text;
-			tail.nextIndex += 1;
-			if (typeof frame.time === "number") tail.lastTime = frame.time;
-			return;
-		}
-		this.liveTails.delete(sessionId);
-	}
-	/**
-	* Seed the live tail from a follow-opening snapshot's assistantStream
-	* baseline (mux-drop reopen mid-attempt): expand the compact stream
-	* records' text/reasoning runs into the tail. No activeAttempt → clear
-	* any remembered tail — the fresh opening is authoritative for what is
-	* still in flight.
-	*/
-	seedLiveTailFromBaseline(sessionId, baseline) {
-		const active = baseline?.activeAttempt;
-		if (active === void 0) {
-			this.liveTails.delete(sessionId);
-			return;
-		}
-		const tail = {
-			attemptId: active.attemptId,
-			turn: active.turn,
-			step: active.step,
-			startedAfterSeq: active.startedAfterSeq,
-			startedAt: Date.now(),
-			lastTime: Date.now(),
-			text: "",
-			reasoning: "",
-			nextIndex: active.nextIndex
-		};
-		for (const record of active.stream ?? []) {
-			if (record.type === "text-chunks" || record.type === "reasoning-chunks") {
-				const texts = record.texts;
-				const joined = Array.isArray(texts) ? texts.filter((t) => typeof t === "string").join("") : "";
-				if (record.type === "text-chunks") tail.text += joined;
-				else tail.reasoning += joined;
-			}
-			const times = compactRecordTailTime(record);
-			if (times !== void 0) tail.lastTime = times;
-		}
-		this.liveTails.set(sessionId, tail);
-	}
-	/**
-	* The session's live tail for the events poll, or null when no attempt
-	* is in flight. Served with the FULL accumulated text each poll — the
-	* client replaces its streaming bubble wholesale (no cross-poll fragment
-	* bookkeeping, so reconnects/retries converge from the served truth).
-	*/
-	liveAssistantStream(sessionId) {
-		const tail = this.liveTails.get(sessionId);
-		if (tail === void 0) return null;
-		return {
-			id: `a:${String(tail.turn)}:${String(tail.step)}`,
-			turn: tail.turn,
-			step: tail.step,
-			seq: tail.startedAfterSeq,
-			time: tail.lastTime,
-			text: tail.text,
-			reasoning: tail.reasoning
-		};
-	}
-	/**
-	* Delta slice: events with seq > n, plus current lastSeq/running.
-	* Wave 4.2: `gap` is true when the caller's `since` mark fell into a hole
-	* the buffer no longer covers (mux drop). The response then carries the
-	* resync flag so the client re-reads from the ledger instead of trusting
-	* a partial delta (BC-4).
-	*/
-	eventsSince(sessionId, n) {
-		const buf = this.bufferFor(sessionId);
-		const events = buf.entries.filter((e) => e.seq > n);
-		const firstDelta = events[0]?.seq;
-		const gap = firstDelta !== void 0 && firstDelta > n + 1;
-		return {
-			events,
-			lastSeq: buf.lastSeq,
-			running: this.running.get(sessionId) ?? false,
-			gap
-		};
-	}
-	/**
-	* Subscribe one session (0.1.2): create its buffer and open a
-	* session/follow logical stream on the live carrier (or mark it for the
-	* next generation). Idempotent; the snapshot frame seeds the baseline.
-	* A repeat call while THIS generation already holds the session's follow
-	* stream is a no-op — the api-dsh events route calls subscribe on every
-	* poll, and reopening would replace the stream (same streamId → fresh
-	* snapshot) on every tick. A stream 'end'/'error' frame drops the
-	* tracking entry so the next poll reopens and self-heals.
-	*/
-	subscribe(sessionId) {
-		this.bufferFor(sessionId);
-		const socket = this.wsMux;
-		if (socket === void 0) return;
-		if (this.opened === false) {
-			this.pendingSubscribes.add(sessionId);
-			return;
-		}
-		if (this.streamSockets.has(followStreamId(sessionId, this.streamSeq))) return;
-		this.openFollowWithProbe(socket, sessionId);
+	/**
+	* Subscribe one session (0.1.2): create its buffer and open a
+	* session/follow logical stream on the live carrier (or mark it for the
+	* next generation). Idempotent; the snapshot frame seeds the baseline.
+	* A repeat call while THIS generation already holds the session's follow
+	* stream is a no-op — the api-dsh events route calls subscribe on every
+	* poll, and reopening would replace the stream (same streamId → fresh
+	* snapshot) on every tick. A stream 'end'/'error' frame drops the
+	* tracking entry so the next poll reopens and self-heals.
+	*/
+	subscribe(sessionId) {
+		this.conn.sessions.bufferFor(sessionId);
+		const socket = this.wsMux;
+		if (socket === void 0) return;
+		if (this.opened === false) {
+			this.pendingSubscribes.add(sessionId);
+			return;
+		}
+		if (this.streamSockets.has(followStreamId(sessionId, this.streamSeq))) return;
+		this.openFollowWithProbe(socket, sessionId);
 	}
 	/**
 	* Open the follow stream with the best-known address NOW (sync, the
@@ -1033,8 +1115,8 @@ var DshConnection = class {
 	*/
 	openFollowWithProbe(socket, sessionId) {
 		this.openFollowStream(socket, sessionId);
-		if (!this.subagentHints.has(sessionId) && !this.hintProbed.has(sessionId)) {
-			this.hintProbed.add(sessionId);
+		if (!this.conn.relay.subagentHints.has(sessionId) && !this.conn.relay.hintProbed.has(sessionId)) {
+			this.conn.relay.hintProbed.add(sessionId);
 			this.probeHintThenSubscribe(sessionId, socket);
 		}
 	}
@@ -1046,10 +1128,10 @@ var DshConnection = class {
 	*  reopens every buffer with the then-current addresses. */
 	async probeHintThenSubscribe(sessionId, socket) {
 		try {
-			if (!this.subagentHints.has(sessionId)) await this.rawListSessions();
+			if (!this.conn.relay.subagentHints.has(sessionId)) await this.conn.relay.rawListSessions();
 		} catch {}
-		if (this.disposed || this.wsMux !== socket || this.opened === false) return;
-		if (this.subagentHints.has(sessionId)) this.openFollowStream(socket, sessionId);
+		if (this.conn.disposed || this.wsMux !== socket || this.opened === false) return;
+		if (this.conn.relay.subagentHints.has(sessionId)) this.openFollowStream(socket, sessionId);
 	}
 	/**
 	* Per-session projection value (W2): follow-snapshot + control-baseline
@@ -1096,55 +1178,131 @@ var DshConnection = class {
 		this.workspaceBaselineWaiters.delete(waiter);
 		return this.workspaces.length > 0;
 	}
-	/** True when the session has a live baseline (subscribed at least once). */
-	hasBaseline(sessionId) {
-		return this.buffers.has(sessionId) && this.bufferFor(sessionId).lastSeq >= 0;
-	}
-	isRunning(sessionId) {
-		return this.running.get(sessionId) ?? false;
+	/** The workspace registry (2026-08-23 registry parity) — the AUTHORITY
+	*  for DSI's workspace pills/chips: a deleted workspace disappears, and
+	*  sessions outside every registry entry render cue-less (DSH's
+	*  Ungrouped). Membership is sessionIds, not cwd matching. */
+	async listWorkspaces() {
+		if (!await this.awaitWorkspaceBaseline()) this.conn.log("dsh-connection: workspace baseline did not land in time — honest empty");
+		return { items: [...this.workspaces] };
 	}
-	/** approval/requested | question/requested → registry (idempotent by rpcId). */
-	registerPending(frame, rpcId) {
-		const sessionId = typeof frame.sessionId === "string" ? frame.sessionId : "";
-		if (!sessionId) {
-			this.log("dsh-connection: answerable frame without sessionId — ignored", frame?.type);
-			return;
-		}
-		if (typeof rpcId !== "string" || rpcId.length === 0) {
-			this.log("dsh-connection: answerable frame without rpcId — ignored", frame?.type);
-			return;
+	/** Cancel a scheduled reconnect (stale-generation answer retry path, W4). */
+	cancelReconnect() {
+		if (this.reconnectTimer !== void 0) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = void 0;
 		}
-		const kind = frame.type === "approval/requested" ? "approval" : "question";
-		this.pendingAnswers.set(rpcId, {
-			rpcId,
-			sessionId,
-			kind,
-			body: frame,
-			receivedAt: Date.now(),
-			deliveredGen: this.generation
-		});
-		this.log(`dsh-connection: pending ${kind} registered (${rpcId}) for ${sessionId}`);
 	}
-	/**
-	* Withdraw one pending answer (0.1.2 $events settle/cancel): remove the
-	* registry entry and record the outcome in the settlement ring. Unknown
-	* ids settle nothing (answered before we subscribed — honest no-op).
-	*/
-	withdrawPending(eventId, outcome) {
-		const pending = this.pendingAnswers.get(eventId);
-		if (pending === void 0) {
-			this.log(`dsh-connection: settlement with no matching pending (${eventId}) — ignored`);
-			return;
-		}
-		this.pendingAnswers.delete(eventId);
-		this.settledAnswers.set(eventId, {
-			rpcId: eventId,
-			sessionId: pending.sessionId,
-			kind: pending.kind,
-			outcome: outcome ?? "cancelled",
-			settledAt: Date.now()
-		});
-		this.log(`dsh-connection: ${pending.kind} settled (${eventId}) outcome=${outcome ?? "cancelled"}`);
+};
+//#endregion
+//#region src/lib/server/connection/rpc-relay.ts
+/**
+* connection/rpc-relay — the RPC relay + answer registry (ADR-0022 W4,
+* ADR-0019 move-whole): the POC-3 pending-answer/settlement registries and
+* their replay reap, the catalog-invalidation listener registry, the
+* subagent parent-address hints, and every unary RPC forward (all bytes via
+* dsh-rpc helpers; the transport POST itself stays in the shell's rpc()).
+*/
+var RpcRelay = class {
+	conn;
+	ringCapacity;
+	answerReapTimer;
+	answerReapGraceMs;
+	staleGenerationRetryMs;
+	constructor(conn, ringCapacity, opts) {
+		this.conn = conn;
+		this.ringCapacity = ringCapacity;
+		this.answerReapGraceMs = opts.answerReapGraceMs;
+		this.staleGenerationRetryMs = opts.staleGenerationRetryMs;
+	}
+	/**
+	* POC-3 W1 — answerable frames arrive as ServerRequest pushes with a
+	* stable rpcId. Mux-open REPLAYS still-pending requested frames with the
+	* same rpcId (api-proxy.ts replay loop), so the registry must be
+	* idempotent by rpcId (BC-C): a replay overwrites, never duplicates.
+	*/
+	pendingAnswers = /* @__PURE__ */ new Map();
+	/** Settlement ring: last outcome per rpcId, delivered-then-pruned. */
+	settledAnswers = /* @__PURE__ */ new Map();
+	/** Catalog-invalidation registry (Slash Menu W1) — listeners see every arm. */
+	catalogInvalidated = /* @__PURE__ */ new Set();
+	/**
+	* Parent-address hints for subagent-origin sessions (SubagentAddressHint),
+	* folded from session.list rows by rawListSessions.
+	*/
+	subagentHints = /* @__PURE__ */ new Map();
+	/** Session-ids whose hint absence was already probed with a list pass
+	*  (one probe per session lifetime — ordinary sessions never re-probe). */
+	hintProbed = /* @__PURE__ */ new Set();
+	/**
+	* Fork-child display titles healed off the wire (2026-09-14, host gap
+	* DSI-side): the host's session.list serves NO projections column for a
+	* cold seeded (fork child) row — session-controller list.ts
+	* projectionsFor short-circuits isSeeded headers because the projection
+	* cache is keyed by the inherited cut a listed header does not carry.
+	* The real title (what the panel shows once the session attaches) lives
+	* in the child's ledger: a child that ran its own turns carries a NEW
+	* session/title event near the tail, so ONE bounded tail-page read per
+	* untitled fork row recovers it. The result caches for the process
+	* lifetime (a retitle lands through the normal rename/live paths, which
+	* serve the title directly). The parent row's title is the FALLBACK for
+	* children the tail page shows never retitled — the inherited title IS
+	* the parent's at fork time; stale only when the parent was renamed
+	* after the fork. Absent hints and absent parents leave the row
+	* honestly untitled.
+	*/
+	forkTitleHints = /* @__PURE__ */ new Map();
+	forkTitleInFlight = /* @__PURE__ */ new Set();
+	/** Subscribe to catalog invalidations ($events arms + socket reset). */
+	onCatalogInvalidated(listener) {
+		this.catalogInvalidated.add(listener);
+		return () => this.catalogInvalidated.delete(listener);
+	}
+	fireCatalogInvalidated(scope) {
+		for (const listener of this.catalogInvalidated) listener(scope);
+	}
+	/** approval/requested | question/requested → registry (idempotent by rpcId). */
+	registerPending(frame, rpcId) {
+		const sessionId = typeof frame.sessionId === "string" ? frame.sessionId : "";
+		if (!sessionId) {
+			this.conn.log("dsh-connection: answerable frame without sessionId — ignored", frame?.type);
+			return;
+		}
+		if (typeof rpcId !== "string" || rpcId.length === 0) {
+			this.conn.log("dsh-connection: answerable frame without rpcId — ignored", frame?.type);
+			return;
+		}
+		const kind = frame.type === "approval/requested" ? "approval" : "question";
+		this.pendingAnswers.set(rpcId, {
+			rpcId,
+			sessionId,
+			kind,
+			body: frame,
+			receivedAt: Date.now(),
+			deliveredGen: this.conn.downlinks.generation
+		});
+		this.conn.log(`dsh-connection: pending ${kind} registered (${rpcId}) for ${sessionId}`);
+	}
+	/**
+	* Withdraw one pending answer (0.1.2 $events settle/cancel): remove the
+	* registry entry and record the outcome in the settlement ring. Unknown
+	* ids settle nothing (answered before we subscribed — honest no-op).
+	*/
+	withdrawPending(eventId, outcome) {
+		const pending = this.pendingAnswers.get(eventId);
+		if (pending === void 0) {
+			this.conn.log(`dsh-connection: settlement with no matching pending (${eventId}) — ignored`);
+			return;
+		}
+		this.pendingAnswers.delete(eventId);
+		this.settledAnswers.set(eventId, {
+			rpcId: eventId,
+			sessionId: pending.sessionId,
+			kind: pending.kind,
+			outcome: outcome ?? "cancelled",
+			settledAt: Date.now()
+		});
+		this.conn.log(`dsh-connection: ${pending.kind} settled (${eventId}) outcome=${outcome ?? "cancelled"}`);
 	}
 	/**
 	* Schedule the still-pending replay reap for this generation (ready
@@ -1163,8 +1321,8 @@ var DshConnection = class {
 	/** Withdraw every pending answer not re-delivered by the current generation. */
 	reapUnconfirmedPending() {
 		for (const [eventId, pending] of [...this.pendingAnswers]) {
-			if (pending.deliveredGen >= this.generation) continue;
-			this.log(`dsh-connection: reap unconfirmed pending (${eventId}) from generation ${pending.deliveredGen} — not in generation ${this.generation} replay`);
+			if (pending.deliveredGen >= this.conn.downlinks.generation) continue;
+			this.conn.log(`dsh-connection: reap unconfirmed pending (${eventId}) from generation ${pending.deliveredGen} — not in generation ${this.conn.downlinks.generation} replay`);
 			this.withdrawPending(eventId);
 		}
 	}
@@ -1182,7 +1340,7 @@ var DshConnection = class {
 	registerSettlement(frame) {
 		const sessionId = typeof frame.sessionId === "string" ? frame.sessionId : "";
 		if (!sessionId) {
-			this.log("dsh-connection: settlement frame without sessionId — ignored", frame?.type);
+			this.conn.log("dsh-connection: settlement frame without sessionId — ignored", frame?.type);
 			return;
 		}
 		const kind = frame.type === "approval/resolved" ? "approval" : "question";
@@ -1199,8 +1357,8 @@ var DshConnection = class {
 				outcome,
 				settledAt: Date.now()
 			});
-			this.log(`dsh-connection: ${kind} settled (${rpcId}) outcome=${outcome}`);
-		} else this.log(`dsh-connection: settlement with no matching pending (${frame?.type}) — ignored`);
+			this.conn.log(`dsh-connection: ${kind} settled (${rpcId}) outcome=${outcome}`);
+		} else this.conn.log(`dsh-connection: settlement with no matching pending (${frame?.type}) — ignored`);
 	}
 	/** Pending answers for a session (for the PollResponse extension). */
 	pendingFor(sessionId) {
@@ -1217,25 +1375,6 @@ var DshConnection = class {
 			if (s && s.sessionId === sessionId) this.settledAnswers.delete(id);
 		}
 	}
-	/**
-	* Fork-child display titles healed off the wire (2026-09-14, host gap
-	* DSI-side): the host's session.list serves NO projections column for a
-	* cold seeded (fork child) row — session-controller list.ts
-	* projectionsFor short-circuits isSeeded headers because the projection
-	* cache is keyed by the inherited cut a listed header does not carry.
-	* The real title (what the panel shows once the session attaches) lives
-	* in the child's ledger: a child that ran its own turns carries a NEW
-	* session/title event near the tail, so ONE bounded tail-page read per
-	* untitled fork row recovers it. The result caches for the process
-	* lifetime (a retitle lands through the normal rename/live paths, which
-	* serve the title directly). The parent row's title is the FALLBACK for
-	* children the tail page shows never retitled — the inherited title IS
-	* the parent's at fork time; stale only when the parent was renamed
-	* after the fork. Absent hints and absent parents leave the row
-	* honestly untitled.
-	*/
-	forkTitleHints = /* @__PURE__ */ new Map();
-	forkTitleInFlight = /* @__PURE__ */ new Set();
 	async listSessions() {
 		const items = (await this.rawListSessions()).map(normalizeSessionRow);
 		const titleById = new Map(items.map((s) => [s.sessionId, s.title]));
@@ -1272,10 +1411,10 @@ var DshConnection = class {
 	*/
 	async healForkTitle(sessionId) {
 		try {
-			const title = (await this.waitForProjections(sessionId))?.values?.["title"];
+			const title = (await this.conn.downlinks.waitForProjections(sessionId))?.values?.["title"];
 			if (typeof title === "string" && title.length > 0) this.forkTitleHints.set(sessionId, title);
 		} catch (error) {
-			this.log("dsh-connection: fork-title follow-baseline read failed for " + sessionId, error);
+			this.conn.log("dsh-connection: fork-title follow-baseline read failed for " + sessionId, error);
 		} finally {
 			this.forkTitleInFlight.delete(sessionId);
 		}
@@ -1303,7 +1442,7 @@ var DshConnection = class {
 	}
 	/** Raw session/list rows (0.1.2) — projections.asOfSeq drives page calls. */
 	async rawListSessions() {
-		const raw = await this.rpc(DSH_METHODS.list, DSH_ARGS.list());
+		const raw = await this.conn.rpc(DSH_METHODS.list, DSH_ARGS.list());
 		const rows = Array.isArray(raw?.items) ? raw.items : [];
 		for (const row of rows) this.foldSubagentHint(row);
 		return rows;
@@ -1371,7 +1510,7 @@ var DshConnection = class {
 	* "no served cursor", not "below the ledger head".
 	*/
 	async pageCursorFor(sessionId) {
-		const live = this.bufferFor(sessionId).lastSeq;
+		const live = this.conn.sessions.bufferFor(sessionId).lastSeq;
 		if (live >= 0) return live;
 		const throughSeq = (await this.rawListSessions()).find((r) => r.sessionId === sessionId)?.projections?.asOfSeq;
 		if (typeof throughSeq === "number" && throughSeq >= 0) return throughSeq;
@@ -1385,7 +1524,7 @@ var DshConnection = class {
 	*/
 	async history(sessionId) {
 		const throughSeq = await this.pageCursorFor(sessionId);
-		return this.pageAsHistory(await this.rpc(DSH_METHODS.page, DSH_ARGS.page({
+		return this.pageAsHistory(await this.conn.rpc(DSH_METHODS.page, DSH_ARGS.page({
 			address: this.addressFor(sessionId),
 			throughSeq
 		})));
@@ -1394,37 +1533,21 @@ var DshConnection = class {
 	*  workspace button's host call. Raw view passthrough — DSI renders
 	*  only title/path; ordering and session membership stay host-owned. */
 	async createWorkspace(path) {
-		return await this.rpc(DSH_METHODS.workspaceCreate, DSH_ARGS.workspaceCreate({ path }));
+		return await this.conn.rpc(DSH_METHODS.workspaceCreate, DSH_ARGS.workspaceCreate({ path }));
 	}
 	/** Workspace rename (Chip Menu ADR D3): {request:{workspaceId,title}}
 	*  → the updated Workspace view. Refusals throw DshRpcError
 	*  (workspace/not-found, workspace/name-conflict). No cache mutation —
 	*  the workspace/follow upsert frame owns the registry (ADR D6). */
 	async renameWorkspace(workspaceId, title) {
-		return await this.rpc(DSH_METHODS.workspaceRename, DSH_ARGS.workspaceRename(workspaceId, title));
+		return await this.conn.rpc(DSH_METHODS.workspaceRename, DSH_ARGS.workspaceRename(workspaceId, title));
 	}
 	/** Workspace delete (Chip Menu ADR D3): {request:{workspaceId}} → the
 	*  removed id. The host removes ONLY the registry row (sessions survive,
 	*  ungrouped); the workspace/follow remove frame owns the registry
 	*  (ADR D6) — no local mutation here. */
 	async deleteWorkspace(workspaceId) {
-		return await this.rpc(DSH_METHODS.workspaceDelete, DSH_ARGS.workspaceDelete(workspaceId));
-	}
-	/** Goal Bar (2026-09-08, ADR amendment): one goal mutation through the
-	*  host's Goal Remotes — goals/pause | goals/resume | goals/clear |
-	*  goals/edit with the CAS ref {id, revision} (a stale revision loses
-	*  host-side). goals/edit additionally carries the changed-fields
-	*  request {objective?, maxGoalRounds?} (Goal Editor, 2026-09-09). The
-	*  raw RemoteResult passes through; the route maps refusals. */
-	async goalVerb(verb, sessionId, ref, request) {
-		return this.rpc(`goals/${verb}`, request === void 0 ? {
-			agentId: sessionId,
-			ref
-		} : {
-			agentId: sessionId,
-			ref,
-			request
-		});
+		return await this.conn.rpc(DSH_METHODS.workspaceDelete, DSH_ARGS.workspaceDelete(workspaceId));
 	}
 	/**
 	* workspaceFiles/read — one page of a UTF-8 text file inside the
@@ -1440,22 +1563,22 @@ var DshConnection = class {
 	* @param range - line window; omitted fields take the host's page defaults.
 	*/
 	async readWorkspaceFile(sessionId, path, range) {
-		return await this.rpc(DSH_METHODS.workspaceFileRead, DSH_ARGS.workspaceFileRead(sessionId, path, range));
+		return await this.conn.rpc(DSH_METHODS.workspaceFileRead, DSH_ARGS.workspaceFileRead(sessionId, path, range));
 	}
 	/**
 	* workspaceFiles/readBytes — one byte window of a workspace file, raw
 	* bytes (base64 receipt), no text decoding and no binary refusal
-	* (2026-09-10: binary previews such as images read through this; `read`
+	* (2026-09-10: binary previews such as images read through this; read
 	* refuses them workspace-file/not-text).
 	*
 	* @param sessionId - owning session; the host confines the read to its
-	workspace root by containment.
+	*                    workspace root by containment.
 	* @param path - workspace path, absolute or root-relative.
 	* @param range - byte window {offset, length}; omitted fields take the
-	host's window defaults.
+	*                    host's window defaults.
 	*/
 	async readWorkspaceFileBytes(sessionId, path, range) {
-		return await this.rpc(DSH_METHODS.workspaceFileReadBytes, DSH_ARGS.workspaceFileReadBytes(sessionId, path, range));
+		return await this.conn.rpc(DSH_METHODS.workspaceFileReadBytes, DSH_ARGS.workspaceFileReadBytes(sessionId, path, range));
 	}
 	/**
 	* workspaceFiles/list — one directory level inside the session's
@@ -1465,15 +1588,7 @@ var DshConnection = class {
 	* {workspaceFileScopeId, path}; path is workspace-relative, '' = the root.
 	*/
 	async listWorkspaceDirectory(sessionId, path) {
-		return await this.rpc(DSH_METHODS.workspaceFileList, DSH_ARGS.workspaceFileList(sessionId, path));
-	}
-	/** The workspace registry (2026-08-23 registry parity) — the AUTHORITY
-	*  for DSI's workspace pills/chips: a deleted workspace disappears, and
-	*  sessions outside every registry entry render cue-less (DSH's
-	*  Ungrouped). Membership is sessionIds, not cwd matching. */
-	async listWorkspaces() {
-		if (!await this.awaitWorkspaceBaseline()) this.log("dsh-connection: workspace baseline did not land in time — honest empty");
-		return { items: [...this.workspaces] };
+		return await this.conn.rpc(DSH_METHODS.workspaceFileList, DSH_ARGS.workspaceFileList(sessionId, path));
 	}
 	/**
 	* host.listDirectory — one browsed directory level for the Add-workspace
@@ -1482,7 +1597,7 @@ var DshConnection = class {
 	* garbage rows drop out, never throw, never invent data.
 	*/
 	async listDirectory(path) {
-		const raw = await this.rpc(DSH_METHODS.listDirectory, DSH_ARGS.listDirectory(path));
+		const raw = await this.conn.rpc(DSH_METHODS.listDirectory, DSH_ARGS.listDirectory(path));
 		const entry = (v) => {
 			if (v === null || typeof v !== "object") return null;
 			const e = v;
@@ -1521,13 +1636,13 @@ var DshConnection = class {
 	* @param attachmentId - durable content-addressed id from an ImageBlock.
 	*/
 	async readAttachment(sessionId, attachmentId) {
-		return await this.rpc(DSH_METHODS.attachment, DSH_ARGS.attachment({
+		return await this.conn.rpc(DSH_METHODS.attachment, DSH_ARGS.attachment({
 			sessionId,
 			attachmentId
 		}));
 	}
 	async pickDirectory(signal) {
-		const raw = await this.rpc(DSH_METHODS.pickDirectory, DSH_ARGS.pickDirectory(), signal);
+		const raw = await this.conn.rpc(DSH_METHODS.pickDirectory, DSH_ARGS.pickDirectory(), signal);
 		return { path: typeof raw === "string" && raw.length > 0 ? raw : null };
 	}
 	/**
@@ -1538,7 +1653,7 @@ var DshConnection = class {
 	*/
 	async historyPage(sessionId, beforeSeq) {
 		const throughSeq = await this.pageCursorFor(sessionId);
-		return this.pageAsHistory(await this.rpc(DSH_METHODS.page, DSH_ARGS.page({
+		return this.pageAsHistory(await this.conn.rpc(DSH_METHODS.page, DSH_ARGS.page({
 			address: this.addressFor(sessionId),
 			throughSeq,
 			beforeSeq
@@ -1558,7 +1673,7 @@ var DshConnection = class {
 	* Live-probed round-trip 2026-08-21 (probe7 → real session id).
 	*/
 	async createSession(cwd, agentPreset) {
-		return await this.rpc(DSH_METHODS.create, DSH_ARGS.create({
+		return await this.conn.rpc(DSH_METHODS.create, DSH_ARGS.create({
 			...cwd === void 0 ? {} : { cwd },
 			...agentPreset === void 0 ? {} : { agentPreset }
 		}));
@@ -1571,7 +1686,7 @@ var DshConnection = class {
 	* contract and refusals).
 	*/
 	async forkSession(sessionId, atSeq) {
-		return await this.rpc(DSH_METHODS.fork, DSH_ARGS.fork({
+		return await this.conn.rpc(DSH_METHODS.fork, DSH_ARGS.fork({
 			sessionId,
 			...atSeq === void 0 ? {} : { atSeq }
 		}));
@@ -1585,7 +1700,7 @@ var DshConnection = class {
 	*/
 	async listPresets() {
 		const overlayEnglish = readDshPresetEnglishConfig().presetEnglish;
-		const raw = await this.rpc(DSH_METHODS.presets, DSH_ARGS.presets());
+		const raw = await this.conn.rpc(DSH_METHODS.presets, DSH_ARGS.presets());
 		return { presets: (Array.isArray(raw?.presets) ? raw.presets : []).map((row) => normalizePreset(row, overlayEnglish)) };
 	}
 	/**
@@ -1600,8 +1715,8 @@ var DshConnection = class {
 			type: "text",
 			text: payload
 		}] : payload;
-		return await this.rpc(DSH_METHODS.prompt, DSH_ARGS.prompt({
-			requestId: this.rpcIdFactory(),
+		return await this.conn.rpc(DSH_METHODS.prompt, DSH_ARGS.prompt({
+			requestId: this.conn.rpcIdFactory(),
 			sessionId,
 			mode,
 			content,
@@ -1619,7 +1734,7 @@ var DshConnection = class {
 	* receipt callers must distinguish from a success.
 	*/
 	async executeCommand(sessionId, line) {
-		return await this.rpc(DSH_METHODS.commandExecute, DSH_ARGS.commandExecute(sessionId, line, [])) ?? null;
+		return await this.conn.rpc(DSH_METHODS.commandExecute, DSH_ARGS.commandExecute(sessionId, line, [])) ?? null;
 	}
 	/**
 	* commands/list (Slash Menu W1, task 1.2) — the host's command catalog,
@@ -1629,7 +1744,7 @@ var DshConnection = class {
 	* open, never on panel mount (ADR §3.3).
 	*/
 	async listCommands(sessionId) {
-		return await this.rpc(DSH_METHODS.commandsList, DSH_ARGS.commandsList(sessionId));
+		return await this.conn.rpc(DSH_METHODS.commandsList, DSH_ARGS.commandsList(sessionId));
 	}
 	/**
 	* skills/list (Slash Menu W1, task 1.2) — the session's user-invocable
@@ -1638,11 +1753,11 @@ var DshConnection = class {
 	* read it freely on first open.
 	*/
 	async listSkills(sessionId) {
-		return await this.rpc(DSH_METHODS.skillsList, DSH_ARGS.skillsList(sessionId));
+		return await this.conn.rpc(DSH_METHODS.skillsList, DSH_ARGS.skillsList(sessionId));
 	}
 	/** session.cancel */
 	async cancel(sessionId) {
-		return await this.rpc(DSH_METHODS.cancel, DSH_ARGS.cancel({ sessionId }));
+		return await this.conn.rpc(DSH_METHODS.cancel, DSH_ARGS.cancel({ sessionId }));
 	}
 	/**
 	* POC-3 W3 (3.1) — session.rename {sessionId, title}.
@@ -1653,7 +1768,7 @@ var DshConnection = class {
 	* RpcError → 502 upstream). Session-backed subagents reject `agent-busy`.
 	*/
 	async renameSession(sessionId, title) {
-		return await this.rpc(DSH_METHODS.rename, DSH_ARGS.rename({
+		return await this.conn.rpc(DSH_METHODS.rename, DSH_ARGS.rename({
 			sessionId,
 			title
 		}));
@@ -1667,7 +1782,7 @@ var DshConnection = class {
 	* below never throws (task 3.2-T: garbage catalog → empty, not an error).
 	*/
 	async listModels(_sessionId) {
-		return normalizeModelDirectory(await this.rpc(DSH_METHODS.modelCatalog, DSH_ARGS.modelCatalog()));
+		return normalizeModelDirectory(await this.conn.rpc(DSH_METHODS.modelCatalog, DSH_ARGS.modelCatalog()));
 	}
 	/**
 	* POC-3 W3 (3.2) — session.selectModel {sessionId, provider, model,
@@ -1676,7 +1791,7 @@ var DshConnection = class {
 	* effort. Subagents reject `session/agent-busy` (RpcError → 502 upstream).
 	*/
 	async selectModel(sessionId, provider, model, reasoningEffort) {
-		return normalizeModelSelection((await this.rpc(DSH_METHODS.selectModel, DSH_ARGS.selectModel({
+		return normalizeModelSelection((await this.conn.rpc(DSH_METHODS.selectModel, DSH_ARGS.selectModel({
 			sessionId,
 			provider,
 			model,
@@ -1705,7 +1820,7 @@ var DshConnection = class {
 	* the wire carries the host's contract, not the panel's convenience.
 	*/
 	async respond(rpcId, payload) {
-		if (this.eventClientId === null) throw new Error("dsh-connection: no $events generation to answer through yet");
+		if (this.conn.downlinks.eventClientId === null) throw new Error("dsh-connection: no $events generation to answer through yet");
 		const { sessionId, ...rest } = payload;
 		const value = rest.outcome !== void 0 ? rest.outcome : rest.answer !== void 0 ? rest.answer : rest.answers !== void 0 ? { answers: rest.answers } : rest;
 		try {
@@ -1717,7 +1832,7 @@ var DshConnection = class {
 				reason: "not-pending"
 			};
 			if (err instanceof DshRpcError && err.code === "gateway/internal" && err.message.includes("no active event stream")) {
-				const previous = this.eventClientId;
+				const previous = this.conn.downlinks.eventClientId;
 				if (previous !== null && await this.refreshEventGeneration(previous)) {
 					await this.sendEventResult(rpcId, value);
 					this.forgetAnswered(rpcId, value);
@@ -1736,8 +1851,8 @@ var DshConnection = class {
 	*/
 	async fetchHostPath(path, signal) {
 		const attempt = async () => {
-			const cookie = await this.auth.ensureCookie();
-			return this.fetchFn(`${this.baseUrl}${path}`, {
+			const cookie = await this.conn.auth.ensureCookie();
+			return this.conn.fetchFn(`${this.conn.baseUrl}${path}`, {
 				method: "GET",
 				headers: cookie === null ? {} : { cookie },
 				...signal !== void 0 ? { signal } : {}
@@ -1745,15 +1860,15 @@ var DshConnection = class {
 		};
 		let response = await attempt();
 		if (response.status === 401) {
-			this.auth.invalidate();
+			this.conn.auth.invalidate();
 			response = await attempt();
 		}
 		return response;
 	}
 	/** One $events/result answer under the CURRENT generation's clientId. */
 	sendEventResult(rpcId, value) {
-		return this.rpc(REMOTE_EVENT_RESULT_ENDPOINT, {
-			clientId: this.eventClientId,
+		return this.conn.rpc(REMOTE_EVENT_RESULT_ENDPOINT, {
+			clientId: this.conn.downlinks.eventClientId,
 			eventId: rpcId,
 			outcome: {
 				kind: "result",
@@ -1768,16 +1883,13 @@ var DshConnection = class {
 	* caller may retry an answer against it.
 	*/
 	async refreshEventGeneration(previousClientId) {
-		this.log("dsh-connection: $events generation stale — rebuilding for the answer retry");
-		if (this.reconnectTimer !== void 0) {
-			clearTimeout(this.reconnectTimer);
-			this.reconnectTimer = void 0;
-		}
-		this.teardownSockets();
-		this.ensureDownlinks();
+		this.conn.log("dsh-connection: $events generation stale — rebuilding for the answer retry");
+		this.conn.downlinks.cancelReconnect();
+		this.conn.downlinks.teardownSockets();
+		this.conn.downlinks.ensureDownlinks();
 		const deadline = Date.now() + this.staleGenerationRetryMs;
-		while (!this.disposed && this.eventClientId === previousClientId && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 25));
-		return this.eventClientId !== previousClientId && this.eventClientId !== null;
+		while (!this.conn.disposed && this.conn.downlinks.eventClientId === previousClientId && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 25));
+		return this.conn.downlinks.eventClientId !== previousClientId && this.conn.downlinks.eventClientId !== null;
 	}
 	/**
 	* Resync: replace the ring buffer with the ledger's tail page (BC-4).
@@ -1785,12 +1897,166 @@ var DshConnection = class {
 	*/
 	async resyncFromLedger(sessionId) {
 		const events = ((await this.history(sessionId)).events ?? []).map((h) => h.event);
-		const buf = this.bufferFor(sessionId);
-		buf.entries = [...events].slice(-ringCapacity());
+		const buf = this.conn.sessions.bufferFor(sessionId);
+		buf.entries = [...events].slice(-this.ringCapacity());
 		buf.lastSeq = events.length > 0 ? events[events.length - 1].seq : -1;
 		buf.coverageFloor = buf.entries[0]?.seq ?? buf.lastSeq;
 		return buf.entries;
 	}
+	/** Teardown hook: transient registries never leak entries. */
+	dispose() {
+		clearTimeout(this.answerReapTimer);
+		this.pendingAnswers.clear();
+		this.settledAnswers.clear();
+	}
+};
+//#endregion
+//#region src/lib/server/dsh-connection.ts
+/**
+* dsh-connection — the transport singleton (BC-5) owning every wire byte to
+* the DSH Host (BC-6: it speaks only through dsh-rpc helpers and the two
+* downlink WebSocket paths).
+*
+* State model (PRD §3.5):
+*   mux  frames (session/subscribed, session/event) → per-session ring buffer
+*   host frames (host/session-status)               → per-session running map
+*   running map re-baselines from session.list at every generation open
+*   (2026-08-26): the host pushes status only on TRANSITIONS and sends no
+*   initial snapshot, so a downlink rebuilt mid-turn would otherwise never
+*   learn the session was already running.
+*   ring buffer = freshness only; the ledger (session.history) is the truth —
+*   cold loads and every resync re-read the ledger (BC-4).
+*
+* Generation semantics (guide Part 1): the two downlinks form one generation;
+* if either dies, both are rebuilt after backoff.
+*/
+/** Live capacity from ~/.dsi/settings.yaml (no cache — runtime edits
+*  apply, same contract as every other config section). */
+function ringCapacity() {
+	return readServerConfig().ringCapacity;
+}
+var singleton;
+/** The process-wide transport (BC-5). Creates lazily on first use. */
+function getDshConnection(opts = {}) {
+	singleton ??= new DshConnection(opts);
+	return singleton;
+}
+var DshConnection = class {
+	baseUrl;
+	fetchFn;
+	wsFactory;
+	auth;
+	rpcIdFactory;
+	backoff;
+	log;
+	/**
+	* ADR-0022 W2 (move-whole): the session state machines — ring buffers,
+	* running map + seed races, live assistant-stream tails — live in
+	* connection/session-state.ts; the shell delegates.
+	*/
+	sessions;
+	/** ADR-0022 W3 (move-whole): the downlink generation lifecycle + frame
+	*  demux live in connection/downlinks.ts; the shell delegates. */
+	downlinks;
+	/** ADR-0022 W4 (move-whole): the RPC relay + answer registry live in
+	*  connection/rpc-relay.ts; the shell delegates. */
+	relay;
+	disposed = false;
+	constructor(opts = {}) {
+		this.baseUrl = opts.baseUrl ?? dshBaseUrl();
+		this.fetchFn = opts.fetchFn ?? fetch;
+		this.wsFactory = opts.wsFactory ?? ((url, headers) => new WebSocket(url, headers === void 0 ? void 0 : { headers }));
+		this.auth = opts.auth ?? new DshAuth({
+			baseUrl: this.baseUrl,
+			log: opts.log
+		});
+		this.rpcIdFactory = opts.rpcIdFactory ?? (() => crypto.randomUUID());
+		this.backoff = opts.backoffScheduleMs ?? [
+			1e3,
+			2e3,
+			5e3,
+			1e4,
+			3e4
+		];
+		const answerReapGraceMs = opts.answerReapGraceMs ?? 3e3;
+		const staleGenerationRetryMs = opts.staleGenerationRetryMs ?? 5e3;
+		this.log = opts.log ?? (() => {});
+		this.sessions = new SessionStateStore({
+			log: this.log,
+			ringCapacity,
+			listSessions: () => this.listSessions(),
+			generation: () => this.downlinks.generation,
+			disposed: () => this.disposed
+		});
+		this.downlinks = new DownlinkManager(this);
+		this.relay = new RpcRelay(this, ringCapacity, {
+			answerReapGraceMs,
+			staleGenerationRetryMs
+		});
+	}
+	/** Open the stream generation (idempotent) — see DownlinkManager. */
+	ensureDownlinks() {
+		this.downlinks.ensureDownlinks();
+	}
+	/** Subscribe one session (0.1.2) — see DownlinkManager. */
+	subscribe(sessionId) {
+		this.downlinks.subscribe(sessionId);
+	}
+	/** Per-session projection value (W2) — see DownlinkManager. */
+	projectionValue(sessionId, key) {
+		return this.downlinks.projectionValue(sessionId, key);
+	}
+	/** The whole stored block for one session (null when absent). */
+	projectionBlock(sessionId) {
+		return this.downlinks.projectionBlock(sessionId);
+	}
+	/** Bounded wait for the session's FIRST projection baseline. */
+	async waitForProjections(sessionId, timeoutMs = 2500) {
+		return this.downlinks.waitForProjections(sessionId, timeoutMs);
+	}
+	/** The workspace registry — the AUTHORITY for DSI's workspace pills/chips. */
+	async listWorkspaces() {
+		return this.downlinks.listWorkspaces();
+	}
+	onMuxFrame(payload, rpcId) {
+		this.downlinks.reconnectAttempt = 0;
+		const frame = payload;
+		switch (frame?.type) {
+			case "session/subscribed":
+				if (typeof frame.sessionId === "string") this.sessions.seedBaseline(frame.sessionId, frame.lastSeq ?? -1);
+				return;
+			case "session/event":
+				if (frame.sessionId && frame.event) this.sessions.appendEvent(frame.sessionId, frame.event);
+				return;
+			case "approval/requested":
+			case "question/requested":
+				this.relay.registerPending(frame, rpcId);
+				return;
+			case "approval/resolved":
+			case "question/resolved":
+				this.relay.registerSettlement(frame);
+				return;
+			default: this.log("dsh-connection: mux frame ignored", frame?.type);
+		}
+	}
+	/** The session's live tail for the events poll, or null when no attempt
+	*  is in flight (0.1.3-alpha.1 live assistant-stream tail). */
+	liveAssistantStream(sessionId) {
+		return this.sessions.liveAssistantStream(sessionId);
+	}
+	/** Delta slice: events with seq > n, plus current lastSeq/running. Wave 4.2:
+	*  the gap flag is true when the caller's since mark fell into a hole the
+	*  buffer no longer covers (mux drop) — the response carries the resync flag. */
+	eventsSince(sessionId, n) {
+		return this.sessions.eventsSince(sessionId, n);
+	}
+	/** True when the session has a live baseline (subscribed at least once). */
+	hasBaseline(sessionId) {
+		return this.sessions.hasBaseline(sessionId);
+	}
+	isRunning(sessionId) {
+		return this.sessions.isRunning(sessionId);
+	}
 	async rpc(method, payload, signal) {
 		const body = JSON.stringify({
 			type: "client-request",
@@ -1820,220 +2086,161 @@ var DshConnection = class {
 		const rpcId = JSON.parse(body).rpcId;
 		return parseResponse(await response.text(), rpcId);
 	}
-	dispose() {
-		this.disposed = true;
-		clearTimeout(this.answerReapTimer);
-		this.teardownSockets();
-		this.pendingAnswers.clear();
-		this.settledAnswers.clear();
-		this.buffers.clear();
-		this.liveTails.clear();
-		this.running.clear();
+	/** Subscribe to catalog invalidations ($events arms + socket reset). */
+	onCatalogInvalidated(listener) {
+		return this.relay.onCatalogInvalidated(listener);
 	}
-};
-/** The follow-<sessionId>-<streamSeq> logical stream id (one per generation). */
-function followStreamId(sessionId, streamSeq) {
-	return `follow-${sessionId}-${String(streamSeq)}`;
-}
-/**
-* Expand ONE follow/page event payload into its ring-buffer form
-* (single-element list — ledger v2 serves every record as a plain event).
-*/
-function expandEntry(e) {
-	return [{
-		type: e.type,
-		seq: typeof e.seq === "number" ? e.seq : -1,
-		time: typeof e.time === "number" ? e.time : 0,
-		data: e.data
-	}];
-}
-/** Expand one page/snapshot record ({type:'event', event}) into its member
-*  events; a record without an event payload contributes nothing. */
-function expandRecord(record) {
-	if (record === void 0 || record.event === void 0) return [];
-	return expandEntry(record.event);
-}
-/** Expand a records array into a flat event list. */
-function expandRecords(records) {
-	return records.flatMap((record) => expandRecord(record));
-}
-/** The last member time of one compact stream record, or undefined when
-*  the record carries no readable time (malformed members stay silent —
-*  the baseline is presentation seed data, never re-validated truth). */
-function compactRecordTailTime(record) {
-	if (record.type === "chunk") return typeof record.time === "number" ? record.time : void 0;
-	if (record.type === "text-chunks" || record.type === "reasoning-chunks" || record.type === "tool-call-chunks") {
-		const time0 = typeof record.time0 === "number" ? record.time0 : void 0;
-		const dt = Array.isArray(record.dt) ? record.dt : [];
-		if (time0 === void 0 || dt.some((g) => typeof g !== "number")) return void 0;
-		return dt.reduce((t, g) => t + g, time0);
+	/** Pending answers for a session (PollResponse extension). */
+	pendingFor(sessionId) {
+		return this.relay.pendingFor(sessionId);
 	}
-}
-function normalizeModelSelection(v) {
-	if (v === null || typeof v !== "object") return null;
-	const sel = v;
-	if (typeof sel.provider !== "string" || typeof sel.model !== "string") return null;
-	return {
-		provider: sel.provider,
-		model: sel.model,
-		...typeof sel.reasoningEffort === "string" ? { reasoningEffort: sel.reasoningEffort } : {}
-	};
-}
-/**
-* Conservative normalize of a SessionModels value: structural reads only,
-* never throws, never invents data (task 3.2-T: a garbage catalog → empty
-* groups + empty failures, honest `routable`/`current` — the selector can
-* still show the current selection and say nothing is listed). Reasoning
-* efforts are flattened to opaque ids (the adapter owns their meaning).
-*/
-function normalizeModelDirectory(raw) {
-	const empty = {
-		current: null,
-		routable: false,
-		groups: [],
-		failures: []
-	};
-	if (raw === null || typeof raw !== "object") return empty;
-	const dir = raw;
-	const groups = Array.isArray(dir.groups) ? modelGroupsOf(dir.groups) : [];
-	const failures = Array.isArray(dir.failures) ? modelFailuresOf(dir.failures) : [];
-	if (dir.current === void 0 && dir.default !== void 0) return {
-		current: normalizeModelSelection(dir.default),
-		routable: Array.isArray(dir.routableProviders) ? dir.routableProviders.length > 0 || groups.length > 0 : true,
-		groups,
-		failures
-	};
-	return {
-		current: normalizeModelSelection(dir.current),
-		routable: dir.routable === true,
-		groups,
-		failures
-	};
-}
-/** ModelCatalog provider groups → DsiModelGroup rows (conservative). */
-function modelGroupsOf(groups) {
-	return groups.flatMap((g) => {
-		if (g === null || typeof g !== "object") return [];
-		const grp = g;
-		if (typeof grp.id !== "string" || grp.id.length === 0) return [];
-		const models = Array.isArray(grp.models) ? grp.models.flatMap((m) => {
-			if (m === null || typeof m !== "object") return [];
-			const mod = m;
-			if (typeof mod.id !== "string" || mod.id.length === 0) return [];
-			return [{
-				id: mod.id,
-				name: typeof mod.name === "string" ? mod.name : null,
-				...Array.isArray(mod.reasoning?.efforts) ? { reasoningEfforts: mod.reasoning.efforts.flatMap((e) => typeof e?.id === "string" ? [e.id] : []) } : {}
-			}];
-		}) : [];
-		return [{
-			id: grp.id,
-			name: typeof grp.name === "string" ? grp.name : null,
-			models
-		}];
-	});
-}
-/** ModelCatalog provider failures → diagnostic rows (conservative). */
-function modelFailuresOf(failures) {
-	return failures.flatMap((f) => {
-		if (f === null || typeof f !== "object") return [];
-		const fail = f;
-		if (typeof fail.id !== "string" || fail.id.length === 0) return [];
-		return [{
-			id: fail.id,
-			name: typeof fail.name === "string" ? fail.name : null,
-			message: typeof fail.message === "string" ? fail.message : null
-		}];
-	});
-}
-function normalizeSessionRow(row) {
-	return {
-		sessionId: row.sessionId,
-		title: row.origin === "subagent" ? readSubagentLabel(row) ?? readTitle(row) : readTitle(row),
-		agentPreset: readAgentPreset(row) ?? row.agentPreset ?? null,
-		running: Boolean(row.running),
-		blank: Boolean(row.blank),
-		updatedAt: row.updatedAt ?? 0,
-		workspace: typeof row.cwd === "string" && row.cwd.length > 0 ? row.cwd : null,
-		turns: readTurns(row),
-		parentSessionId: row.parentSessionId ?? null,
-		origin: row.origin ?? null
-	};
-}
-function readTitle(row) {
-	const title = row.projections?.values?.["title"];
-	return typeof title === "string" && title.length > 0 ? title : null;
-}
-/** projections.values.subagent.label (the child descriptor's creation label;
-*  one-shot children may omit it — structural read, null when unreadable). */
-function readSubagentLabel(row) {
-	const identity = row.projections?.values?.["subagent"];
-	const label = identity !== null && typeof identity === "object" ? identity.label : void 0;
-	return typeof label === "string" && label.length > 0 ? label : null;
-}
-/** projections.values.agentPreset (0.1.2 home of the preset id on list rows). */
-function readAgentPreset(row) {
-	const preset = row.projections?.values?.["agentPreset"];
-	return typeof preset === "string" && preset.length > 0 ? preset : null;
-}
-/** `sessionStats.turns` (0.1.2: projections.values.sessionStats) — integer-strict, null on absent/junk. */
-function readTurns(row) {
-	const stats = row.projections?.values?.["sessionStats"];
-	const turns = stats !== null && typeof stats === "object" ? stats.turns : row.sessionStats?.turns;
-	if (typeof turns !== "number" || !Number.isInteger(turns) || turns < 0) return null;
-	return turns;
-}
-/**
-* English display copy for the host's SHIPPED presets, keyed by the stable
-* preset id. The wire's `name`/`description` are the UNLOCALIZED metadata a
-* preset publishes (DSH `PresetDisplaySource`), and the four built-ins ship
-* Simplified Chinese there — DSH localizes them only inside its own web UI
-* (`packages/preset/agent-presets/src/display.ts` folds trust:'system' + id →
-* locale dictionary keys). This app has no host locale seat, so the overlay
-* mirrors that fold in English: trust:'system' + a known id → the English
-* copy; every other row (user presets, unknown future ids) keeps the host's
-* name verbatim — user metadata is never translated, and an unknown id falls
-* back honestly. Operator-tunable off via ~/.dsi/settings.yaml
-* `dsh.presetEnglish: false` (readDshPresetEnglishConfig — no cache, so the
-* next listPresets fetch picks an edit up). Keep the strings in step with DSH
-* `packages/client/ui-agent-preset/src/client/locales.ts` (the `en` bundle).
-*/
-var SHIPPED_PRESET_ENGLISH = {
-	standard: {
-		name: "Standard mode",
-		description: "Full coding agent with file editing, shell, file and web search, skills, planning, goals, subagents, and workflows."
-	},
-	ptc: {
-		name: "PTC mode",
-		description: "Full coding agent without the workflow tool; other tools are exposed through the PTC mode SDK so the model can combine multi-step operations in one TypeScript program."
-	},
-	minimal: {
-		name: "Minimal mode",
-		description: "Two-tool coding agent with persistent bash and str_replace_editor."
-	},
-	cordis: {
-		name: "Creator mode",
-		description: "Built for creating custom agent presets, with all Standard mode capabilities plus runtime inspection, plugin experiments, and preset-authoring guidance."
+	/** Recent settlements for a session (ring: delivered-then-pruned). */
+	settlementsFor(sessionId) {
+		return this.relay.settlementsFor(sessionId);
+	}
+	/** Delivery hook: drop settlements the client has already seen. */
+	pruneSettlements(sessionId, seenRpcIds) {
+		this.relay.pruneSettlements(sessionId, seenRpcIds);
+	}
+	/** Normalized session/list with fork-title healing. */
+	async listSessions() {
+		return this.relay.listSessions();
+	}
+	/** The workspace-RPC OWNER for a session (parent-chain walk). */
+	async workspaceOwnerSessionId(sessionId) {
+		return this.relay.workspaceOwnerSessionId(sessionId);
+	}
+	/** The session/page + session/follow address for one session id. */
+	addressFor(sessionId) {
+		return this.relay.addressFor(sessionId);
+	}
+	/** session.history successor (0.1.2 session/page tail). */
+	async history(sessionId) {
+		return this.relay.history(sessionId);
+	}
+	/** Workspace registry adoption (Add-workspace button's host call). */
+	async createWorkspace(path) {
+		return this.relay.createWorkspace(path);
+	}
+	/** Workspace rename (Chip Menu ADR D3). */
+	async renameWorkspace(workspaceId, title) {
+		return this.relay.renameWorkspace(workspaceId, title);
+	}
+	/** Workspace delete (Chip Menu ADR D3). */
+	async deleteWorkspace(workspaceId) {
+		return this.relay.deleteWorkspace(workspaceId);
+	}
+	/**
+	* Goal Bar (2026-09-08, ADR amendment): one goal mutation through the
+	* host's Goal Remotes — goals/pause | goals/resume | goals/clear |
+	* goals/edit with the CAS ref {id, revision} (a stale revision loses
+	* host-side). goals/edit additionally carries the changed-fields
+	* request {objective?, maxGoalRounds?} (Goal Editor, 2026-09-09). The
+	* raw RemoteResult passes through; the route maps refusals.
+	* Kept self-contained in the shell: tests pin it via
+	* DshConnection.prototype.goalVerb.call(fakeRpcThis, …).
+	*/
+	async goalVerb(verb, sessionId, ref, request) {
+		return this.rpc(`goals/${verb}`, request === void 0 ? {
+			agentId: sessionId,
+			ref
+		} : {
+			agentId: sessionId,
+			ref,
+			request
+		});
+	}
+	/** workspaceFiles/read — one page of a UTF-8 text file. */
+	async readWorkspaceFile(sessionId, path, range) {
+		return this.relay.readWorkspaceFile(sessionId, path, range);
+	}
+	/** workspaceFiles/readBytes — one byte window, raw bytes. */
+	async readWorkspaceFileBytes(sessionId, path, range) {
+		return this.relay.readWorkspaceFileBytes(sessionId, path, range);
+	}
+	/** workspaceFiles/list — one directory level. */
+	async listWorkspaceDirectory(sessionId, path) {
+		return this.relay.listWorkspaceDirectory(sessionId, path);
+	}
+	/** host.listDirectory — the folder picker browse. */
+	async listDirectory(path) {
+		return this.relay.listDirectory(path);
+	}
+	/** session.attachment — session-authorized durable image read. */
+	async readAttachment(sessionId, attachmentId) {
+		return this.relay.readAttachment(sessionId, attachmentId);
+	}
+	/** host.pickDirectory — the NATIVE directory chooser. */
+	async pickDirectory(signal) {
+		return this.relay.pickDirectory(signal);
+	}
+	/** session.history PAGE ending at beforeSeq−1 (ledger truth, BC-4). */
+	async historyPage(sessionId, beforeSeq) {
+		return this.relay.historyPage(sessionId, beforeSeq);
+	}
+	/** session.create {cwd?, agentPreset?}. */
+	async createSession(cwd, agentPreset) {
+		return this.relay.createSession(cwd, agentPreset);
+	}
+	/** session/fork — the fork child. */
+	async forkSession(sessionId, atSeq) {
+		return this.relay.forkSession(sessionId, atSeq);
+	}
+	/** agentPreset.list — the picker's only source of truth. */
+	async listPresets() {
+		return this.relay.listPresets();
+	}
+	/** session.prompt — returns after the receipt only (BC-3). */
+	async prompt(sessionId, payload, mode = "queue") {
+		return this.relay.prompt(sessionId, payload, mode);
+	}
+	/** commands/execute — the NATIVE slash-command surface. */
+	async executeCommand(sessionId, line) {
+		return this.relay.executeCommand(sessionId, line);
+	}
+	/** commands/list — the host's command catalog. */
+	async listCommands(sessionId) {
+		return this.relay.listCommands(sessionId);
+	}
+	/** skills/list — the session's user-invocable skill catalog. */
+	async listSkills(sessionId) {
+		return this.relay.listSkills(sessionId);
+	}
+	/** session.cancel */
+	async cancel(sessionId) {
+		return this.relay.cancel(sessionId);
+	}
+	/** session.rename {sessionId, title}. */
+	async renameSession(sessionId, title) {
+		return this.relay.renameSession(sessionId, title);
+	}
+	/** session.models → the model directory. */
+	async listModels(_sessionId) {
+		return this.relay.listModels(_sessionId);
+	}
+	/** session.selectModel → {selected: ModelSelection}. */
+	async selectModel(sessionId, provider, model, reasoningEffort) {
+		return this.relay.selectModel(sessionId, provider, model, reasoningEffort);
+	}
+	/** Answer a pending approval/question via $events/result. */
+	async respond(rpcId, payload) {
+		return this.relay.respond(rpcId, payload);
+	}
+	/** Authenticated GET of one Host path (cookie ladder). */
+	async fetchHostPath(path, signal) {
+		return this.relay.fetchHostPath(path, signal);
+	}
+	/** Resync: replace the ring buffer with the ledger's tail page (BC-4). */
+	async resyncFromLedger(sessionId) {
+		return this.relay.resyncFromLedger(sessionId);
+	}
+	dispose() {
+		this.disposed = true;
+		this.downlinks.teardownSockets();
+		this.relay.dispose();
+		this.sessions.dispose();
 	}
 };
-/**
-* Conservative normalize: unknown shapes keep their id but never invent data.
-* The one English overlay seat (SHIPPED_PRESET_ENGLISH) applies before the
-* host fallbacks — a shipped preset's label is locale-resolved here, never
-* the wire's unlocalized text. Operator-tunable via
-* ~/.dsi/settings.yaml `dsh.presetEnglish` (read live per listPresets
-* call, passed through here): false hands the wire name through untouched.
-*/
-function normalizePreset(row, overlayEnglish = true) {
-	const id = typeof row.id === "string" ? row.id : String(row.id ?? "");
-	const shipped = overlayEnglish && row.trust === "system" ? SHIPPED_PRESET_ENGLISH[id] : void 0;
-	return {
-		id,
-		name: shipped?.name ?? (typeof row.name === "string" ? row.name : null),
-		description: shipped?.description ?? (typeof row.description === "string" ? row.description : null),
-		isDefault: row.isDefault === true
-	};
-}
 
 export { DshRpcError as D, isPromptImageMediaType as a, buildPromptContent as b, getDshConnection as g, isSubagentRejection as i, mapRpcFailure as m, statusFor as s };
-//# sourceMappingURL=dsh-connection.js-Lnv7PlHw.js.map
+//# sourceMappingURL=dsh-connection.js-DRtqPR_j.js.map