@xmoon76/dsh-pi-tui 0.4.7-alpha.1 → 0.4.7-alpha.2

package/dist/{src-D-4-xTUd.mjs → src-5aY9svZj.mjs}

@@ -1,4 +1,4 @@
-import { TUI_STARTUP_SERVICE } from "./startup.mjs";
+import { n as TUI_STARTUP_SERVICE } from "./startup-CGeJ1k1B.mjs";
 import { createRequire } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
 import { StringDecoder } from "node:string_decoder";
@@ -65,7 +65,8 @@ async function resolvePresetRequest(presets, requestedId, signal) {
 //#endregion
 //#region src/runtime/direct/session-preset-direct.ts
 /**
-* Direct session-preset adapter for DSH 0.1.6-alpha.1+.
+* Direct session-preset adapter for the DSH 0.1.6 session-projection API
+* (introduced in `0.1.6-alpha.1`).
 *
 * The Harness owns the `agentPreset` projection. TUI callers must not fold the
 * session log themselves: the projection initializes from the creation header
@@ -5867,6 +5868,19 @@ function invokeTask(task) {
 	}
 }
 /**
+* Observe the settlement of an ALREADY-OWNED promise without taking ownership.
+* The callback runs on fulfilment or rejection and its own result is dropped,
+* so bookkeeping (for example removing a promise from a teardown-drained set)
+* never adds a second, unhandled rejection branch next to the real owner's
+* failure handling. Never use this to START work — that is `runDetached` /
+* `runOwned`.
+* @param promise - the promise whose failure semantics already have an owner.
+* @param onSettled - runs once, on either settlement.
+*/
+function observeSettled(promise, onSettled) {
+	promise.then(onSettled, onSettled);
+}
+/**
 * Attach rejection handling to a fire-and-forget task. The factory is
 * invoked synchronously (a synchronous throw is a rejection like any
 * other); every rejection is caught and classified:
@@ -19746,6 +19760,7 @@ var TuiAltScreen = class extends TuiBase {
 	onRightClickPaste;
 	copyOnSelect;
 	copySelection;
+	selectionLineText;
 	onCellClick;
 	onCellPress;
 	onFramePainted;
@@ -19778,6 +19793,7 @@ var TuiAltScreen = class extends TuiBase {
 		this.onRightClickPaste = options.onRightClickPaste;
 		this.copyOnSelect = options.copyOnSelect ?? true;
 		this.copySelection = options.copySelection;
+		this.selectionLineText = options.selectionLineText;
 		this.onCellClick = options.onCellClick;
 		this.onCellPress = options.onCellPress;
 		this.onFramePainted = options.onFramePainted;
@@ -20957,8 +20973,14 @@ var TuiAltScreen = class extends TuiBase {
 		const lines = [];
 		for (let row = selection.start.row; row <= selection.end.row; row++) {
 			const line = sourceLines[row] ?? "";
+			const override = this.selectionLineText?.({
+				row,
+				line,
+				...selection.start.scrollView === void 0 ? {} : { scrollView: selection.start.scrollView }
+			});
+			const copyLine = override === void 0 ? line : override;
 			const columns = this.getSelectionColumns(line, row, selection);
-			const sliced = stripTerminalSequences(sliceByColumn(line, columns.start, Math.max(0, columns.end - columns.start), true)).trimEnd();
+			const sliced = stripTerminalSequences(sliceByColumn(copyLine, columns.start, Math.max(0, columns.end - columns.start), true)).trimEnd();
 			lines.push(columns.start === 0 ? sliced.replace(/^ {1,3}/, "") : sliced);
 		}
 		const text = lines.join("\n");
@@ -40848,6 +40870,7 @@ var UserBubbleComponent = class {
 	lastWidth = -1;
 	cached;
 	lastCompactMarkerRow;
+	lastCollapseEligible = false;
 	constructor(child, marker, bg, compactOptions) {
 		this.child = child;
 		this.marker = marker;
@@ -40868,6 +40891,13 @@ var UserBubbleComponent = class {
 	compactMarkerRow() {
 		return this.lastCompactMarkerRow;
 	}
+	/** Whether the current render is an EXPANDED compact-capable bubble: the
+	* visual rows exceed the threshold, so the caller must place a tail
+	* collapse control after the body (the spacer row when one follows, or one
+	* dedicated presentation row for the final block). */
+	showsCollapseControl() {
+		return this.lastCollapseEligible;
+	}
 	render(width) {
 		const inner = Math.max(1, width - this.markerWidth);
 		const child = this.child.render(inner);
@@ -40886,11 +40916,17 @@ var UserBubbleComponent = class {
 	/** Collapse the child's FULL visual rows to head + marker + tail when the
 	* row-count threshold is exceeded. The decision and the slice both run on
 	* the rows the current width actually produces, so a resize re-decides
-	* (no baked compact count/marker position). */
+	* (no baked compact count/marker position). An EXPANDED bubble keeps the
+	* full rows and only records that it is collapse-eligible. */
 	compactRows(child, inner) {
 		this.lastCompactMarkerRow = void 0;
+		this.lastCollapseEligible = false;
 		const options = this.compactOptions;
 		if (options === void 0 || child.length <= options.thresholdRows) return child;
+		if (options.expanded) {
+			this.lastCollapseEligible = true;
+			return child;
+		}
 		const head = Math.min(options.headRows, child.length);
 		const tail = Math.min(options.tailRows, Math.max(0, child.length - head));
 		if (head + tail >= child.length) return child;
@@ -40909,15 +40945,36 @@ var UserBubbleComponent = class {
 * The ephemeral pending user-input row: the SAME floating user bubble as a
 * durable human message, plus one dim pending-status line so it reads as
 * accepted-but-not-yet-materialized rather than as durable transcript content.
-* `pendingUserComponent` is presentation-only and is never inserted into the
-* transcript folder.
-*/
-function pendingUserComponent(row, running) {
-	const container = new Container();
-	container.addChild(new UserBubbleComponent(new Text(row.text, 0, 0), `${color.roleUser("❯")} `, color.roleUserBg));
-	container.addChild(new Text(color.textDim(`  ${pendingUserStatusText(row, running)}`), 0, 0));
-	return container;
-}
+* `PendingUserComponent` is presentation-only and is never inserted into the
+* transcript folder. It exposes the same disclosure geometry as the durable
+* bubble (the compact marker row and the expanded collapse-control
+* eligibility) so the row map shares ONE hit model for both.
+*/
+var PendingUserComponent = class {
+	container;
+	bubble;
+	constructor(row, running, compactOptions) {
+		this.bubble = new UserBubbleComponent(new Text(row.text, 0, 0), `${color.roleUser("❯")} `, color.roleUserBg, compactOptions);
+		this.container = new Container();
+		this.container.addChild(this.bubble);
+		this.container.addChild(new Text(color.textDim(`  ${pendingUserStatusText(row, running)}`), 0, 0));
+	}
+	render(width) {
+		return this.container.render(width);
+	}
+	invalidate() {
+		this.container.invalidate?.();
+	}
+	dispose() {
+		this.container.dispose?.();
+	}
+	compactMarkerRow() {
+		return this.bubble.compactMarkerRow();
+	}
+	showsCollapseControl() {
+		return this.bubble.showsCollapseControl();
+	}
+};
 /**
 * The presentation-only pending status label. An accepted steer whose subject
 * is RUNNING reads `steering…`. When an AUTHORITATIVE steering occurrence's
@@ -41264,6 +41321,14 @@ function approvalOverlayGeometry(columns, rows) {
 		contentWidth: Math.max(1, width - 8)
 	};
 }
+/** The stable presentation identity of one pending-user row: the rpc
+* correlation when present (a local echo and its authoritative occurrence
+* share it), the occurrence/request id otherwise. Never text, and never the
+* entry index — a projection update must not transfer disclosure state (or a
+* stale click) to a different pending row. */
+function pendingUserDisclosureKey(row) {
+	return row.rpcId !== void 0 ? `rpc:${row.rpcId}` : `id:${row.id}`;
+}
 /**
 * The interactive surface: header, transcript, editor, footer. Owns the
 * TUI lifecycle, mode switching, folding, approval dialogs, and settings
@@ -41292,6 +41357,14 @@ function deepFreeze(value) {
 	for (const key of Object.keys(value)) deepFreeze(value[key]);
 	return Object.freeze(value);
 }
+/** The Host-owned long-user disclosure geometry. Only the two Host bubbles
+* implement it, and the row map never reaches into their children. The brand
+* is EXPLICIT (`instanceof`): a plugin renderer that happens to expose
+* same-named methods must never be mistaken for a Host disclosure component
+* (the M7 plugin-owned `kind: 'user'` contract). */
+function userDisclosureComponentOf(component) {
+	if (component instanceof UserBubbleComponent || component instanceof PendingUserComponent) return component;
+}
 var TuiApp = class TuiApp {
 	terminal;
 	/** The extension surface host (M2), when the runner attached one. */
@@ -41763,6 +41836,11 @@ var TuiApp = class TuiApp {
 	* regardless of the fold or the override.
 	*/
 	expandedOverride = /* @__PURE__ */ new Map();
+	/** Per-pending-row long-user disclosure overrides, keyed by the stable
+	* {@link pendingUserDisclosureKey}. Presentation-only ephemeral state: it
+	* never enters the transcript folder, persistence, or the session, and it
+	* is pruned to the live pending keys on every presentation update. */
+	pendingUserExpanded = /* @__PURE__ */ new Map();
 	/** PTC sub-call bodies the user expanded by subCallId (stable across
 	* live updates, replay and sibling insertion — never an array index). */
 	subCallExpanded = /* @__PURE__ */ new Set();
@@ -42346,6 +42424,7 @@ var TuiApp = class TuiApp {
 		}
 		this.terminalSchemeListeners.clear();
 		this.expandedOverride.clear();
+		this.pendingUserExpanded.clear();
 		this.disposeMessageComponents();
 		this.localMessages.length = 0;
 		this.pendingUserRows = [];
@@ -42859,19 +42938,19 @@ var TuiApp = class TuiApp {
 			toggleTranscriptExpand: () => {
 				if (this.fullscreen !== void 0 && this.focusModeEnabled) {
 					if (this.hasVisibleExpandedFocusRoots()) {
-						this.clearUserMessageDisclosureOverrides();
+						this.clearUserDisclosureOverrides();
 						this.toggleFullscreenFocusRoots();
-					} else if (this.hasVisibleExpandedUserMessage()) {
-						this.clearUserMessageDisclosureOverrides();
-						this.rebuildMessages();
-					} else this.toggleFullscreenFocusRoots();
+					} else if (this.hasVisibleExpandedUserDisclosure()) this.mutateTranscriptDisclosure(() => this.clearUserDisclosureOverrides());
+					else this.toggleFullscreenFocusRoots();
 					return true;
 				}
-				if (this.toolOutputExpanded || this.hasVisibleExpandedUserMessage()) {
+				if (this.toolOutputExpanded || this.hasVisibleExpandedUserDisclosure()) this.mutateTranscriptDisclosure(() => {
 					this.toolOutputExpanded = false;
-					this.clearUserMessageDisclosureOverrides();
-				} else this.toolOutputExpanded = true;
-				this.rebuildMessages();
+					this.clearUserDisclosureOverrides();
+				});
+				else this.mutateTranscriptDisclosure(() => {
+					this.toolOutputExpanded = true;
+				});
 				return true;
 			},
 			toggleThinking: () => {
@@ -43271,7 +43350,7 @@ var TuiApp = class TuiApp {
 		this.clearExitConfirmation();
 		this.keybindings.cancelLeader();
 		if (enabled === (this.fullscreen !== void 0)) return;
-		if (enabled && !this.userDisclosureAffordanceAvailable()) this.clearUserMessageDisclosureOverrides();
+		if (enabled && !this.userDisclosureAffordanceAvailable()) this.clearUserDisclosureOverrides();
 		this.clearFocusLiveHeightState();
 		this.disposeTrackedKeybindingEditors();
 		for (const close of [...this.footerConfiguratorClosers]) close();
@@ -43309,6 +43388,7 @@ var TuiApp = class TuiApp {
 				shouldShowScrollToEndIndicator: () => this.transcriptWindow?.mode === "history",
 				onScrollToEndIndicator: () => this.events.onTranscriptJumpLatest?.() === true,
 				copySelection: this.copySelection,
+				selectionLineText: (context) => this.selectionLineText(context),
 				openUrl: this.openExternalUrl,
 				onRightClickPaste: this.readClipboardText === void 0 ? void 0 : () => {
 					this.rightClickPasteFromClipboard();
@@ -43725,30 +43805,38 @@ var TuiApp = class TuiApp {
 		}
 		return entry.rendererId === void 0;
 	}
-	/** Whether the CURRENT projection shows a long user message that is
+	/** Whether the CURRENT projection shows a long user disclosure that is
 	* ACTUALLY compacted and explicitly expanded (the Ctrl+O user-collapse
-	* target, plan §6.4/§21.7). Only VISIBLE, HOST-rendered, compact-capable
-	* messages count: a parked override on a windowed-away message, a stale
-	* override on a short/resized-short bubble with no visible effect, or an
-	* override on a plugin-owned presentation must not consume the Ctrl+O
-	* press and wedge the toggle into a no-op. */
-	hasVisibleExpandedUserMessage() {
+	* target, plan §6.4/§21.7) — a durable message OR an ephemeral pending row.
+	* Only VISIBLE, HOST-rendered, compact-capable entries count: a parked
+	* override on a windowed-away message, a stale override on a
+	* short/resized-short bubble with no visible effect, or an override on a
+	* plugin-owned presentation must not consume the Ctrl+O press and wedge the
+	* toggle into a no-op. */
+	hasVisibleExpandedUserDisclosure() {
 		for (const message of this.messages) {
 			if (!isUserMessageDisclosureCandidate(message)) continue;
 			if (this.expandedOverride.get(message) !== true) continue;
 			if (!this.isHostUserDisclosure(message)) continue;
 			if (this.userMessageCompactsAtCurrentWidth(message)) return true;
 		}
+		for (const row of this.pendingUserRows) {
+			if (row.foldableText !== true) continue;
+			if (this.pendingUserExpanded.get(pendingUserDisclosureKey(row)) !== true) continue;
+			if (this.pendingUserCompactsAtCurrentWidth(row)) return true;
+		}
 		return false;
 	}
 	/** Clear every long-user disclosure override (the Ctrl+O user-collapse
-	* pass). It filters by the user-disclosure classification ONLY — thinking,
-	* tool, system and compaction overrides are never touched. */
-	clearUserMessageDisclosureOverrides() {
+	* pass): durable message overrides AND ephemeral pending-row overrides. It
+	* filters by the user-disclosure classification ONLY — thinking, tool,
+	* system and compaction overrides are never touched. */
+	clearUserDisclosureOverrides() {
 		for (const message of [...this.expandedOverride.keys()]) {
 			if (!isUserMessageDisclosureCandidate(message)) continue;
 			this.expandedOverride.delete(message);
 		}
+		this.pendingUserExpanded.clear();
 	}
 	/** The eligible Focus roots for Ctrl+O bulk expansion: turns with a
 	* real TurnActivity that are CURRENTLY PROJECTED (present in the folded
@@ -43925,6 +44013,27 @@ var TuiApp = class TuiApp {
 		const welcomeHeight = this.welcomeCard.render(width).length;
 		this.fullscreenScroll.scrollTo(welcomeHeight + transcriptRow - 1, { disableFollow: true });
 	}
+	/** The single long-user disclosure transition (plan §10): capture the
+	* fullscreen viewport intent, mutate the disclosure state, rebuild once, and
+	* restore the SAME visual intent. A user who was following the live tail
+	* keeps following it (never a historical browse); a historical reader is
+	* restored to the SAME semantic row (durable message identity or the stable
+	* pending key) and viewport offset — never a raw delta-height scrollTop.
+	* Regular mode (no fullscreen scroll view) just rebuilds. Focus root
+	* transitions own their own `anchor-turn` contract and never route here. */
+	mutateTranscriptDisclosure(mutate) {
+		const scroll = this.fullscreenScroll;
+		const wasFollowingEnd = scroll?.isFollowingEnd === true;
+		const anchor = scroll === void 0 || wasFollowingEnd ? void 0 : this.captureTranscriptViewportAnchor();
+		mutate();
+		this.clearFocusLiveHeightState();
+		this.rebuildMessages();
+		if (scroll !== void 0) {
+			if (wasFollowingEnd) this.applyFullscreenFollowEndViewport();
+			else if (anchor !== void 0) this.restoreTranscriptViewportAnchor(anchor, "top");
+		}
+		this.requestRender();
+	}
 	/** The projected transcript row (in `messageRows` coordinates, welcome
 	* card excluded) where a turn's Thought header starts. Returns undefined
 	* when the turn is not currently projected (e.g. Focus off, or the turn
@@ -44176,7 +44285,7 @@ var TuiApp = class TuiApp {
 			let attachments = [];
 			let subCallHits;
 			let workflowHits;
-			let userDisclosureRow;
+			let userDisclosureHit;
 			const collapseFocusOwnerOnClick = this.focusOwnerForRenderBlock(block);
 			if (block.kind === "activity") {
 				component = this.focusActivityComponentFor(block.activity, projectionExpanded.has(block.activity.turn), this.focusToolDisplayFor(block.activity), this.focusModeEnabled && !projectionExpanded.has(block.activity.turn) ? focusPreparingSummary(this.streamingToolPreviewsForTurn(block.activity.turn)) : void 0);
@@ -44185,14 +44294,21 @@ var TuiApp = class TuiApp {
 				component = this.streamingToolPreviewComponent(block.previews, width);
 				rendered = component.render(width);
 			} else if (block.kind === "pending-user") {
-				component = pendingUserComponent(block.row, this.queueRunning);
+				component = this.pendingUserComponentFor(block.row);
 				rendered = component.render(width);
+				userDisclosureHit = this.userDisclosureHitFor(component, rendered, truncatedMarker, {
+					kind: "pending",
+					key: pendingUserDisclosureKey(block.row)
+				});
 			} else {
 				component = this.componentForMessage(block.message, boundary, width, userBoundary);
 				rendered = component.render(width);
 				truncatedMarker = block.truncated === true;
 				attachments = this.attachmentRangesOf(component, width);
-				if (component instanceof UserBubbleComponent) userDisclosureRow = component.compactMarkerRow();
+				if (isUserMessageDisclosureCandidate(block.message)) userDisclosureHit = this.userDisclosureHitFor(component, rendered, truncatedMarker, {
+					kind: "durable",
+					message: block.message
+				});
 				const subCallInfo = this.subCallHitsByMessage.get(block.message);
 				subCallHits = subCallInfo === void 0 ? void 0 : subCallInfo.hits.map((hit) => ({
 					...hit,
@@ -44213,10 +44329,36 @@ var TuiApp = class TuiApp {
 				...collapseFocusOwnerOnClick === void 0 ? {} : { collapseFocusOwnerOnClick },
 				...subCallHits === void 0 ? {} : { subCallHits },
 				...workflowHits === void 0 ? {} : { workflowHits },
-				...userDisclosureRow === void 0 ? {} : { userDisclosureRow }
+				...userDisclosureHit === void 0 ? {} : { userDisclosureHit }
 			};
 		});
 	}
+	/** The ONE bidirectional disclosure control of a long-user bubble (durable
+	* or pending): the compact marker while collapsed, the tail row while an
+	* expanded compact-capable bubble needs one. The tail is FULLSCREEN-only:
+	* regular draws into the terminal main screen, where an app-owned copy
+	* filter cannot exist, so a visible label there WOULD be copied by the
+	* terminal's native selection — Ctrl+O stays the regular collapse owner. In
+	* fullscreen the tail row is the trailing separator row when one follows,
+	* or one dedicated presentation row charged to the final block (the height
+	* rule mirrors it). */
+	userDisclosureHitFor(component, rendered, truncatedMarker, target) {
+		const bubble = userDisclosureComponentOf(component);
+		if (bubble === void 0) return void 0;
+		const markerRow = bubble.compactMarkerRow();
+		if (markerRow !== void 0) return {
+			row: markerRow,
+			action: "expand",
+			target
+		};
+		if (this.fullscreen === void 0) return void 0;
+		if (!bubble.showsCollapseControl()) return void 0;
+		return {
+			row: rendered.length + (truncatedMarker ? 1 : 0),
+			action: "collapse",
+			target
+		};
+	}
 	/**
 	* Re-measure an already-mounted transcript batch without touching component
 	* lifecycle: the SAME `entry.component` instances are re-rendered at the
@@ -44227,12 +44369,26 @@ var TuiApp = class TuiApp {
 	remeasureTranscriptBlocks(mounted, width) {
 		return mounted.map((entry) => {
 			const rendered = entry.component.render(width);
+			if (entry.block.kind === "pending-user") {
+				const userDisclosureHit = this.userDisclosureHitFor(entry.component, rendered, entry.truncatedMarker, {
+					kind: "pending",
+					key: pendingUserDisclosureKey(entry.block.row)
+				});
+				return {
+					...entry,
+					rendered,
+					...userDisclosureHit === void 0 ? { userDisclosureHit: void 0 } : { userDisclosureHit }
+				};
+			}
 			if (entry.block.kind !== "message") return {
 				...entry,
 				rendered
 			};
 			const attachments = this.attachmentRangesOf(entry.component, width);
-			const userDisclosureRow = entry.component instanceof UserBubbleComponent ? entry.component.compactMarkerRow() : void 0;
+			const userDisclosureHit = isUserMessageDisclosureCandidate(entry.block.message) ? this.userDisclosureHitFor(entry.component, rendered, entry.truncatedMarker, {
+				kind: "durable",
+				message: entry.block.message
+			}) : void 0;
 			const subCallInfo = this.subCallHitsByMessage.get(entry.block.message);
 			const subCallHits = subCallInfo === void 0 ? void 0 : subCallInfo.hits.map((hit) => ({
 				...hit,
@@ -44249,7 +44405,7 @@ var TuiApp = class TuiApp {
 				attachments,
 				...subCallHits === void 0 ? { subCallHits: void 0 } : { subCallHits },
 				...workflowHits === void 0 ? { workflowHits: void 0 } : { workflowHits },
-				...userDisclosureRow === void 0 ? { userDisclosureRow: void 0 } : { userDisclosureRow }
+				...userDisclosureHit === void 0 ? { userDisclosureHit: void 0 } : { userDisclosureHit }
 			};
 		});
 	}
@@ -44263,10 +44419,16 @@ var TuiApp = class TuiApp {
 		return "turn" in block.message ? block.message.turn : void 0;
 	}
 	/** The normal physical height charged to one rendered block, preserving the
-	* existing zero-row and original-index Spacer rules exactly. */
+	* existing zero-row and original-index Spacer rules exactly. An expanded
+	* long-user tail control REUSES the trailing separator row when one
+	* follows; for the final block it is one dedicated presentation row, so the
+	* height must charge it here (the row map and the mounted tree share this
+	* single rule). */
 	normalTranscriptBlockHeight(entry, index, total) {
 		if (entry.rendered.length === 0 && !entry.truncatedMarker) return 0;
-		return entry.rendered.length + (entry.truncatedMarker ? 1 : 0) + (index < total - 1 ? 1 : 0);
+		const trailing = index < total - 1 ? 1 : 0;
+		const tailControl = entry.userDisclosureHit?.action === "collapse" && trailing === 0 ? 1 : 0;
+		return entry.rendered.length + (entry.truncatedMarker ? 1 : 0) + trailing + tailControl;
 	}
 	/** Drop presentation floors and their measured padding. */
 	clearFocusLiveHeightState() {
@@ -44341,12 +44503,13 @@ var TuiApp = class TuiApp {
 		const block = entry.block;
 		return {
 			...block.kind === "message" ? { message: block.message } : block.kind === "activity" ? { activity: block.activity } : {},
+			...block.kind === "pending-user" ? { pendingKey: pendingUserDisclosureKey(block.row) } : {},
 			...entry.collapseFocusOwnerOnClick === void 0 ? {} : { collapseFocusOwnerOnClick: entry.collapseFocusOwnerOnClick },
 			height,
 			attachments: entry.attachments,
 			...entry.subCallHits === void 0 ? {} : { subCallHits: entry.subCallHits },
 			...entry.workflowHits === void 0 ? {} : { workflowHits: entry.workflowHits },
-			...entry.userDisclosureRow === void 0 ? {} : { userDisclosureRow: entry.userDisclosureRow },
+			...entry.userDisclosureHit === void 0 ? {} : { userDisclosureHit: entry.userDisclosureHit },
 			hasTrailingSpacer
 		};
 	}
@@ -44372,7 +44535,8 @@ var TuiApp = class TuiApp {
 				}
 				const hasTrailingSpacer = index < renderedBlocks.length - 1;
 				rows.push(this.fullscreenRowEntry(entry, height, hasTrailingSpacer));
-				if (hasTrailingSpacer) this.messagesView.addChild(new Spacer());
+				if (entry.userDisclosureHit?.action === "collapse") this.messagesView.addChild(new TranscriptGutterComponent(this.userCollapseControlText(width)));
+				else if (hasTrailingSpacer) this.messagesView.addChild(new Spacer());
 			}
 			const padding = paddingRows.get(index) ?? 0;
 			if (padding > 0) {
@@ -44575,19 +44739,20 @@ var TuiApp = class TuiApp {
 			let rowTop = welcomeHeight;
 			let candidate;
 			for (const entry of this.messageRows) {
-				const rowKind = entry.activity === void 0 ? "message" : "activity";
-				const turn = entry.message !== void 0 && "turn" in entry.message ? entry.message.turn : entry.activity?.turn;
-				const occurrenceKey = turn === void 0 ? void 0 : `${rowKind}:${turn}`;
+				const rowKind = entry.pendingKey !== void 0 ? "pending-user" : entry.activity === void 0 ? "message" : "activity";
+				const turn = entry.pendingKey !== void 0 ? void 0 : entry.message !== void 0 && "turn" in entry.message ? entry.message.turn : entry.activity?.turn;
+				const occurrenceKey = entry.pendingKey !== void 0 ? `pending-user:${entry.pendingKey}` : turn === void 0 ? void 0 : `${rowKind}:${turn}`;
 				const occurrence = occurrenceKey === void 0 ? 0 : occurrences.get(occurrenceKey) ?? 0;
 				if (occurrenceKey !== void 0) occurrences.set(occurrenceKey, occurrence + 1);
-				if (entry.height > 0 && rowTop + entry.height > viewportTop && rowTop <= viewportBottom && turn !== void 0) {
+				if (entry.height > 0 && rowTop + entry.height > viewportTop && rowTop <= viewportBottom && (turn !== void 0 || entry.pendingKey !== void 0)) {
 					const line = fromTop ? Math.max(viewportTop, rowTop) : Math.min(viewportBottom, rowTop + entry.height - 1);
 					const point = {
-						turn,
 						rowKind,
+						...turn === void 0 ? {} : { turn },
 						occurrence,
 						...entry.message === void 0 ? {} : { message: entry.message },
 						...entry.activity === void 0 ? {} : { activity: entry.activity },
+						...entry.pendingKey === void 0 ? {} : { pendingKey: entry.pendingKey },
 						rowOffset: line - rowTop,
 						viewportOffset: line - viewportTop
 					};
@@ -44621,9 +44786,9 @@ var TuiApp = class TuiApp {
 			const occurrences = /* @__PURE__ */ new Map();
 			let rowTop = welcomeHeight;
 			for (const entry of this.messageRows) {
-				const rowKind = entry.activity === void 0 ? "message" : "activity";
-				const turn = entry.message !== void 0 && "turn" in entry.message ? entry.message.turn : entry.activity?.turn;
-				const occurrenceKey = turn === void 0 ? void 0 : `${rowKind}:${turn}`;
+				const rowKind = entry.pendingKey !== void 0 ? "pending-user" : entry.activity === void 0 ? "message" : "activity";
+				const turn = entry.pendingKey !== void 0 ? void 0 : entry.message !== void 0 && "turn" in entry.message ? entry.message.turn : entry.activity?.turn;
+				const occurrenceKey = entry.pendingKey !== void 0 ? `pending-user:${entry.pendingKey}` : turn === void 0 ? void 0 : `${rowKind}:${turn}`;
 				const occurrence = occurrenceKey === void 0 ? 0 : occurrences.get(occurrenceKey) ?? 0;
 				if (occurrenceKey !== void 0) occurrences.set(occurrenceKey, occurrence + 1);
 				if (entry.height <= 0) {
@@ -44634,20 +44799,28 @@ var TuiApp = class TuiApp {
 					top: rowTop,
 					height: entry.height
 				};
+				if (point.rowKind === "pending-user") {
+					if (entry.pendingKey !== void 0 && entry.pendingKey === point.pendingKey) return located;
+					rowTop += entry.height;
+					continue;
+				}
 				if (point.rowKind === rowKind && (point.message !== void 0 ? entry.message === point.message : point.activity !== void 0 && entry.activity === point.activity)) return located;
 				if (turn === point.turn && rowKind === point.rowKind && occurrence === point.occurrence) return located;
 				rowTop += entry.height;
 			}
 		};
 		const points = edge === "top" ? [anchor.top, anchor.bottom] : [anchor.bottom, anchor.top];
+		let sawPendingPoint = false;
 		for (const point of points) {
 			if (point === void 0) continue;
+			if (point.rowKind === "pending-user") sawPendingPoint = true;
 			const row = rowFor(point);
 			if (row === void 0) continue;
 			const rowOffset = Math.max(0, Math.min(row.height - 1, point.rowOffset));
 			scroll.scrollTo(row.top + rowOffset - point.viewportOffset, { disableFollow: true });
 			return true;
 		}
+		if (sawPendingPoint) return false;
 		scroll.scrollTo(anchor.scrollTop, { disableFollow: true });
 		return false;
 	}
@@ -44765,11 +44938,19 @@ var TuiApp = class TuiApp {
 		const scroll = this.fullscreenScroll;
 		const paintedHeight = (component) => this.fullscreen?.getPaintedBox(component)?.height ?? 0;
 		this.refreshMessageRows();
+		const welcomeHeight = this.welcomeCard.lastRenderedHeight;
+		const copyBlankRows = /* @__PURE__ */ new Set();
+		let rowTop = welcomeHeight;
+		for (const entry of this.messageRows) {
+			const hit = entry.userDisclosureHit;
+			if (hit !== void 0 && hit.action === "collapse") copyBlankRows.add(rowTop + hit.row);
+			rowTop += entry.height;
+		}
 		this.fullscreenPaintSnapshot = {
 			columns: this.terminal.columns,
 			termRows: this.terminal.rows,
 			headerHeight: paintedHeight(this.header),
-			welcomeHeight: this.welcomeCard.lastRenderedHeight,
+			welcomeHeight,
 			footerHeight: paintedHeight(this.footer),
 			editorHeight: paintedHeight(this.editorSeat),
 			workingHeight: paintedHeight(this.working),
@@ -44783,7 +44964,8 @@ var TuiApp = class TuiApp {
 				ownerId: this.fullscreenRowOwnerId(entry, index),
 				height: entry.height,
 				hits: this.fullscreenRowHits(entry, index)
-			}))
+			})),
+			copyBlankRows
 		};
 	}
 	/** The per-row SEMANTIC hit identities of one painted transcript block
@@ -44809,13 +44991,16 @@ var TuiApp = class TuiApp {
 	}
 	/** The per-row SEMANTIC hit identity of one transcript row (mouse
 	* parity): the row's ACTUAL action target, following the click-path
-	* priority EXACTLY (blank-row escape hatch > Focus activity > PTC
-	* sub-call > Workflow > attachment > Focus-secondary/card). A row
-	* inside a Workflow card that matches no hit is INERT (the card
-	* consumes every click — it must never fall through to the owner/card
-	* branch). Shared by the paint-snapshot commit and the release-click
-	* validation so both sides compute the EXACT same identity string. */
+	* priority EXACTLY (long-user disclosure > blank-row escape hatch > Focus
+	* activity > PTC sub-call > Workflow > attachment > Focus-secondary/card).
+	* The long-user control wins first because it shares the trailing separator
+	* row with the blank-row escape hatch; a row inside a Workflow card that
+	* matches no hit is INERT (the card consumes every click — it must never
+	* fall through to the owner/card branch). Shared by the paint-snapshot
+	* commit and the release-click validation so both sides compute the EXACT
+	* same identity string. */
 	fullscreenRowHitIdentity(entry, inMessage, nextVisible) {
+		if (entry.userDisclosureHit !== void 0) return inMessage === entry.userDisclosureHit.row ? this.userDisclosureHitIdentity(entry.userDisclosureHit) : "inert";
 		if (entry.hasTrailingSpacer && inMessage === entry.height - 1) {
 			const owner = this.blankRowFocusCollapseOwner(entry, nextVisible);
 			return owner !== void 0 ? `focus:collapse:${owner}` : "inert";
@@ -44834,13 +45019,21 @@ var TuiApp = class TuiApp {
 			return "inert";
 		}
 		for (const attachment of entry.attachments) if (inMessage >= attachment.start && inMessage < attachment.end) return `attachment:${token}:${attachment.imageIndex}`;
-		if (entry.userDisclosureRow !== void 0) return inMessage === entry.userDisclosureRow ? `user:expand:${token}` : "inert";
 		if (entry.collapseFocusOwnerOnClick !== void 0) {
 			if (isFocusSecondaryDisclosure(message)) return `message:toggle:${token}`;
 			return `focus:collapse:${entry.collapseFocusOwnerOnClick}`;
 		}
 		return `message:toggle:${token}`;
 	}
+	/** The press/release semantic identity of one long-user disclosure control:
+	* the durable message token or the stable pending key, ALWAYS qualified by
+	* the direction. A stale press must never transfer an expand target to a
+	* collapse target (or to a different pending row) that repainted onto the
+	* same cell. */
+	userDisclosureHitIdentity(hit) {
+		if (hit.target.kind === "durable") return `user:${hit.action}:${this.identityToken(hit.target.message)}`;
+		return `pending-user:${hit.action}:${hit.target.key}`;
+	}
 	/** The semantic identity of one Workflow card row hit (the durable
 	* run/phase/member/agents target the click acts on). */
 	workflowHitIdentity(hit) {
@@ -44874,12 +45067,12 @@ var TuiApp = class TuiApp {
 		return token;
 	}
 	/** The press-time semantic identity of a transcript row (mouse parity):
-	* the message/activity owner (kind + turn + the per-object identity
-	* token, or the entry index for ownerless rows). Shared by the
-	* paint-snapshot commit and the release-click validation so both sides
-	* compute the EXACT same identity string. */
+	* the message/activity/pending-user owner (kind + turn + the per-object
+	* identity token, the stable pending key, or the entry index for truly
+	* ownerless rows). Shared by the paint-snapshot commit and the release-click
+	* validation so both sides compute the EXACT same identity string. */
 	fullscreenRowOwnerId(entry, entryIndex) {
-		return entry.message !== void 0 ? `msg:${entry.message.kind}:${"turn" in entry.message ? entry.message.turn : 0}:${this.identityToken(entry.message)}` : entry.activity !== void 0 ? `activity:${entry.activity.turn}:${this.identityToken(entry.activity)}` : `entry:${entryIndex}`;
+		return entry.message !== void 0 ? `msg:${entry.message.kind}:${"turn" in entry.message ? entry.message.turn : 0}:${this.identityToken(entry.message)}` : entry.activity !== void 0 ? `activity:${entry.activity.turn}:${this.identityToken(entry.activity)}` : entry.pendingKey !== void 0 ? `pending-user:${entry.pendingKey}` : `entry:${entryIndex}`;
 	}
 	/** Resolve a fullscreen physical row to a transcript cell (the entry
 	* index + its block-relative row) against a GIVEN projection — a pure
@@ -45055,6 +45248,10 @@ var TuiApp = class TuiApp {
 		}
 		this.fullscreenCellGesture = void 0;
 		{
+			if (entry.userDisclosureHit !== void 0) {
+				if (inMessage === entry.userDisclosureHit.row) this.applyUserDisclosureHit(entry.userDisclosureHit);
+				return;
+			}
 			if (entry.hasTrailingSpacer && inMessage === entry.height - 1) {
 				if (this.terminal.columns !== this.lastPaintColumns || this.terminal.rows !== this.lastPaintRows) return;
 				let next;
@@ -45075,10 +45272,6 @@ var TuiApp = class TuiApp {
 			}
 			const message = entry.message;
 			if (message === void 0) return;
-			if (entry.userDisclosureRow !== void 0) {
-				if (inMessage === entry.userDisclosureRow) this.expandUserMessage(message);
-				return;
-			}
 			if (entry.subCallHits !== void 0) {
 				const hit = entry.subCallHits.find((candidate) => inMessage >= candidate.top && inMessage < candidate.top + candidate.height);
 				if (hit !== void 0) {
@@ -45124,15 +45317,22 @@ var TuiApp = class TuiApp {
 		if (turn === void 0 || !this.focusExpandedTurns.has(turn)) return void 0;
 		return (next?.activity?.turn ?? next?.collapseFocusOwnerOnClick) === turn ? turn : void 0;
 	}
-	/** Expand one collapsed long user message (fullscreen compact-marker
-	* click). The marker only exists while collapsed, so this is expand-only;
-	* the override reuses the same per-message disclosure state as every other
-	* card, and the canonical `message.text` is never touched. */
-	expandUserMessage(message) {
-		if (this.expandedOverride.get(message) === true) return;
-		this.expandedOverride.set(message, true);
-		this.clearFocusLiveHeightState();
-		this.rebuildMessages();
+	/** Apply one bidirectional long-user disclosure control click (fullscreen
+	* compact marker → expand, expanded tail control → collapse). The durable
+	* override reuses the per-message disclosure state; the pending override is
+	* presentation-only ephemeral state keyed by the stable pending identity.
+	* The canonical `message.text` is never touched. */
+	applyUserDisclosureHit(hit) {
+		const expanded = hit.action === "expand";
+		this.mutateTranscriptDisclosure(() => {
+			if (hit.target.kind === "durable") {
+				if (this.expandedOverride.get(hit.target.message) === expanded) return;
+				this.expandedOverride.set(hit.target.message, expanded);
+			} else {
+				if (this.pendingUserExpanded.get(hit.target.key) === expanded) return;
+				this.pendingUserExpanded.set(hit.target.key, expanded);
+			}
+		});
 	}
 	/** Toggle one collapsible message's individual expansion (mouse click).
 	* The same foldable set as the render rule (plan §32 — never two
@@ -45371,6 +45571,7 @@ var TuiApp = class TuiApp {
 	clearSessionOverrides() {
 		this.clearFocusLiveHeightState();
 		this.expandedOverride.clear();
+		this.pendingUserExpanded.clear();
 		this.fullscreenCellGesture = void 0;
 		this.todoClickCoalesceUntil = 0;
 		this.focusExpandedTurns.clear();
@@ -46819,7 +47020,7 @@ var TuiApp = class TuiApp {
 	messageRenderState(message, boundary, userBoundary) {
 		const expanded = this.effectiveMessageExpanded(message, boundary, userBoundary);
 		const insideFocusSecondary = "turn" in message && this.isInsideExpandedFocus(message, boundary) && isFocusSecondaryDisclosure(message);
-		const expandHint = message.kind === "thinking" ? this.fullscreen !== void 0 ? "click" : "thinking" : isUserMessageDisclosureCandidate(message) ? this.fullscreen === void 0 ? "fold" : this.focusModeEnabled ? "click" : "click-fold" : insideFocusSecondary ? this.fullscreen !== void 0 ? "click" : void 0 : "fold";
+		const expandHint = message.kind === "thinking" ? this.fullscreen !== void 0 ? "click" : "thinking" : isUserMessageDisclosureCandidate(message) ? this.userFoldHint() : insideFocusSecondary ? this.fullscreen !== void 0 ? "click" : void 0 : "fold";
 		return {
 			expanded,
 			fullReveal: this.expandedOverride.get(message) === true || this.fullscreen === void 0 && insideFocusSecondary,
@@ -47093,12 +47294,13 @@ var TuiApp = class TuiApp {
 	renderMessage(message, expanded, expandHint, fullReveal, width) {
 		if (message.kind === "user") {
 			if (message.content !== void 0 && message.content.some((block) => block.type !== "text")) return this.renderUserBlocks(message.content, message);
-			if (!expanded && this.userDisclosureAffordanceAvailable()) {
+			if (this.userDisclosureAffordanceAvailable()) {
 				const hint = expandHint;
 				return new UserBubbleComponent(new Text(message.text, 0, 0), `${color.roleUser("❯")} `, color.roleUserBg, {
 					thresholdRows: USER_MESSAGE_COMPACT_THRESHOLD_ROWS,
 					headRows: USER_MESSAGE_HEAD_ROWS,
 					tailRows: USER_MESSAGE_TAIL_ROWS,
+					expanded,
 					compactMarker: (hiddenRows, available) => this.userCompactMarker(hiddenRows, available, hint)
 				});
 			}
@@ -48451,6 +48653,10 @@ var TuiApp = class TuiApp {
 		this.queueItems = presentation.queued;
 		this.pendingUserRows = presentation.steering;
 		this.queueRunning = presentation.running;
+		if (this.pendingUserExpanded.size > 0) {
+			const liveKeys = new Set(presentation.steering.map(pendingUserDisclosureKey));
+			for (const key of [...this.pendingUserExpanded.keys()]) if (!liveKeys.has(key)) this.pendingUserExpanded.delete(key);
+		}
 		this.projectActivity();
 		this.renderQueuePane();
 		this.rebuildMessages();
@@ -48864,6 +49070,63 @@ var TuiApp = class TuiApp {
 		if (visibleWidth(full) <= availableWidth) return color.textDim(full);
 		return color.textDim(`── ${hiddenRows} rows compacted ──`);
 	}
+	/** The long-user fold-hint owner for the CURRENT surface: regular is the
+	* Ctrl+O recent-turn master; fullscreen without Focus offers the compact
+	* marker click AND the effective expand key; fullscreen Focus is click-only
+	* (Ctrl+O owns the Thought-root bulk there). Shared by the durable bubble
+	* and the ephemeral pending lane so their labels never diverge. */
+	userFoldHint() {
+		return this.fullscreen === void 0 ? "fold" : this.focusModeEnabled ? "click" : "click-fold";
+	}
+	/** The expanded long-user tail control: presentation chrome naming the
+	* collapse affordance of the CURRENT surface. Right-aligned within the
+	* transcript content width; a narrow width truncates instead of wrapping. */
+	userCollapseControlText(width) {
+		const label = `▴ Collapse · ${this.expandHint(this.userFoldHint())}`;
+		const clipped = visibleWidth(label) <= width ? label : truncateToWidth(label, width, "…");
+		const pad = " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+		return new Text(color.textDim(pad + clipped), 0, 0);
+	}
+	/** The copy-source filter of one selected row: the expanded long-user tail
+	* control is presentation chrome that must never reach the clipboard, and
+	* its visual row copies as the blank separator it replaced (fork seam
+	* X057). Paint, search, word/line selection and the mouse hit map are
+	* untouched — only the copy source is filtered. The decision comes from the
+	* LAST-PAINTED snapshot (the same epoch that produced the ScrollView's
+	* `scrollContentLines`), never the live `messageRows`: a rebuild that has
+	* not repainted yet must not reinterpret a painted row — otherwise the
+	* painted tail chrome would leak, or a painted real row the newer
+	* projection calls chrome would be wrongly blanked. */
+	selectionLineText(context) {
+		if (context.scrollView === void 0 || context.scrollView !== this.fullscreenScroll) return void 0;
+		return this.fullscreenPaintSnapshot?.copyBlankRows.has(context.row) === true ? "" : void 0;
+	}
+	/** The effective disclosure state of one ephemeral pending-user row: the
+	* explicit per-row override wins, otherwise the surface rule — fullscreen
+	* Focus is compact-by-default (Ctrl+O owns the Thought roots there), every
+	* other surface follows the Ctrl+O master exactly like a recent durable
+	* user prompt. */
+	pendingUserExpandedState(row) {
+		const override = this.pendingUserExpanded.get(pendingUserDisclosureKey(row));
+		if (override !== void 0) return override;
+		if (this.fullscreen !== void 0 && this.focusModeEnabled) return false;
+		return this.toolOutputExpanded;
+	}
+	/** Build the ephemeral pending-user component for this surface. A text-only
+	* pending row joins the SAME visual-row compaction as a durable text-only
+	* user bubble when this surface has a disclosure affordance; otherwise it
+	* renders in full (never a dead marker). */
+	pendingUserComponentFor(row) {
+		if (row.foldableText !== true || !this.userDisclosureAffordanceAvailable()) return new PendingUserComponent(row, this.queueRunning);
+		const hint = this.userFoldHint();
+		return new PendingUserComponent(row, this.queueRunning, {
+			thresholdRows: USER_MESSAGE_COMPACT_THRESHOLD_ROWS,
+			headRows: USER_MESSAGE_HEAD_ROWS,
+			tailRows: USER_MESSAGE_TAIL_ROWS,
+			expanded: this.pendingUserExpandedState(row),
+			compactMarker: (hiddenRows, available) => this.userCompactMarker(hiddenRows, available, hint)
+		});
+	}
 	/** Whether the long-user fold has a usable expand affordance on THIS
 	* surface. Fullscreen always does (the compact-marker click); regular needs
 	* the effective `app.transcript.toggleExpand` key — compacting without one
@@ -48880,6 +49143,13 @@ var TuiApp = class TuiApp {
 		const inner = Math.max(1, this.transcriptRenderWidth() - visibleWidth(`${color.roleUser("❯")} `));
 		return new Text(message.text, 0, 0).render(inner).length > USER_MESSAGE_COMPACT_THRESHOLD_ROWS;
 	}
+	/** Whether one pending-user row ACTUALLY compacts at the current transcript
+	* width (the same visual-row threshold the pending bubble renderer applies),
+	* so a stale override on a short row never consumes the Ctrl+O press. */
+	pendingUserCompactsAtCurrentWidth(row) {
+		const inner = Math.max(1, this.transcriptRenderWidth() - visibleWidth(`${color.roleUser("❯")} `));
+		return new Text(row.text, 0, 0).render(inner).length > USER_MESSAGE_COMPACT_THRESHOLD_ROWS;
+	}
 	/**
 	* Install slash-command + file-path autocompletion on the editor, plus
 	* `@`-file mentions through the Host-file port (migration M1.10 — the
@@ -54073,306 +54343,6 @@ var SessionOperationBarrier = class {
 	}
 };
 //#endregion
-//#region src/rewind.ts
-/** Whether one user/message event is a DIRECT human prompt (the transcript's
-* classification: `source.kind === 'user'`). Injected context, skill bodies,
-* system reminders and goal continuations answer false. The single helper
-* every rewind consumer must use — never scatter source-kind checks. */
-function isHumanTurnMessage(event) {
-	return event.data.source.kind === "user";
-}
-/** Whether a message is empty for rewind purposes: mirror the
-* transcript's finalized user-content visibility rule. */
-function isEmptyMessage(blocks) {
-	return !userBlocksVisibleNow(blocks);
-}
-/** One-line, width-bounded preview of a prompt (whitespace collapsed). */
-function singleLinePreview(text) {
-	const flat = text.replace(/\s+/g, " ").trim();
-	return flat.length > 120 ? `${flat.slice(0, 117)}…` : flat;
-}
-/**
-* Derive the rewind candidates from a session's event log.
-*
-* Guarantees (plan §6.1):
-* - only COMPLETED turns (a `turn/end` closed the span) are listed; the
-*   open turn is never a candidate;
-* - newest turn first;
-* - one candidate per turn (the turn's primary — first non-empty human
-*   `user/message`); injected/steer messages never form extra rows;
-* - a malformed span (a new `turn/start` while one is open, an end without
-*   a start) is skipped, never thrown to the UI;
-* - the first turn is a legal candidate (seed length 0);
-* - no persistence, no side effects, no agent creation.
-* @param events - the session log (chronological).
-* @returns candidates newest-first.
-*/
-function collectRewindCandidates(events) {
-	const candidates = [];
-	let open;
-	for (const event of events) if (event.type === "turn/start") open = {
-		turn: event.data.turn,
-		startSeq: event.seq
-	};
-	else if (event.type === "turn/end") {
-		const primary = open?.primary;
-		if (primary !== void 0) {
-			const blocks = primary.blocks;
-			candidates.push({
-				turnStartSeq: open.startSeq,
-				turn: open.turn,
-				messageSeq: primary.seq,
-				editorText: textOf(blocks),
-				preview: singleLinePreview(textOf(blocks)),
-				hasNonTextContent: blocks.some((block) => block.type !== "text")
-			});
-		}
-		open = void 0;
-	} else if (event.type === "user/message" && open !== void 0 && open.primary === void 0) {
-		const blocks = event.data.content;
-		if (isHumanTurnMessage(event) && !isEmptyMessage(blocks)) open.primary = {
-			seq: event.seq,
-			blocks
-		};
-	}
-	return candidates.reverse();
-}
-/**
-* The seed for one candidate: EVERY event before the selected `turn/start`
-* — including log-only state events between turns (a `todo/write`, a
-* `permission/preset` record) — but never the `turn/start` itself.
-* @param events - the session log the candidate was collected from.
-* @param candidate - the selected rewind point.
-* @returns the child session's seed events.
-* @throws when the point no longer exists, or when the seed would end on
-*   an OPEN `turn/start` (malformed log — the fork boundary must be a
-*   completed turn).
-*/
-function rewindSeed(events, candidate) {
-	const index = events.findIndex((event) => event.seq === candidate.turnStartSeq && event.type === "turn/start");
-	if (index < 0) throw new Error("rewind point no longer exists");
-	const seed = events.slice(0, index);
-	for (let i = seed.length - 1; i >= 0; i -= 1) {
-		const type = seed[i]?.type;
-		if (type === "turn/end") break;
-		if (type === "turn/start") throw new Error("rewind point is inside an open turn");
-	}
-	return seed;
-}
-/** One picker row for a candidate. The value is the `turnStartSeq` string;
-* the selection resolves against the candidate list captured at open time
-* (stale selections are rejected by the workflow's generation gates). */
-function rewindPickerItem(candidate) {
-	const tag = candidate.hasNonTextContent ? "[attachment] " : "";
-	const preview = candidate.preview === "" && candidate.hasNonTextContent ? "(attachment only)" : candidate.preview;
-	return {
-		value: String(candidate.turnStartSeq),
-		label: `turn ${candidate.turn} · ${tag}${preview}`,
-		...candidate.hasNonTextContent ? { description: "non-text content is not re-staged on rewind" } : {}
-	};
-}
-//#endregion
-//#region src/runtime/session-lifecycle-port.ts
-/** A lifecycle outcome that must ABORT the caller's transition, carrying the
-*  two independent axes so a Remote caller never has to parse a string. */
-var LifecycleError = class extends Error {
-	settlement;
-	ownership;
-	publishedSessionId;
-	/** CORRELATION ONLY for an indeterminate create — never publication proof. */
-	requestedSessionId;
-	constructor(settlement, ownership, message, publishedSessionId, requestedSessionId) {
-		super(message);
-		this.name = "LifecycleError";
-		this.settlement = settlement;
-		this.ownership = ownership;
-		this.publishedSessionId = publishedSessionId;
-		this.requestedSessionId = requestedSessionId;
-	}
-};
-/** Unwrap a CREATE result for the runner's transition: a `created` result that
-*  still owns the surface yields the handle; everything else aborts with a
-*  machine-readable `LifecycleError` (a superseded create is NOT committed to
-*  the local surface, though its identity stays available). */
-function requireCreated(result) {
-	const { ownership, outcome } = result;
-	switch (outcome.kind) {
-		case "created":
-			if (ownership === "superseded") throw new LifecycleError("superseded", ownership, `Session "${outcome.handle.session.id}" was created, but the local surface was superseded — do not retry creation`, outcome.handle.session.id);
-			return outcome.handle;
-		case "published-with-error": throw new LifecycleError(outcome.kind, ownership, `Session "${outcome.sessionId}" was published, but workspace attach/reconcile failed: ${outcome.error.message} (${outcome.error.code}) — do not retry creation`, outcome.sessionId);
-		case "indeterminate": throw new LifecycleError(outcome.kind, ownership, `the create is indeterminate — do not retry: ${outcome.error.message} (${outcome.error.code})`, void 0, outcome.requestedSessionId);
-		case "rejected": throw new LifecycleError(outcome.kind, ownership, `${outcome.error.message} (${outcome.error.code})`, void 0);
-		case "cancelled": throw new LifecycleError("cancelled", ownership, "the Session creation was cancelled before dispatch", void 0);
-	}
-}
-/** Unwrap an OPEN result for the runner's transition. */
-function requireOpened(result) {
-	const { ownership, outcome } = result;
-	switch (outcome.kind) {
-		case "opened":
-			if (ownership === "superseded") throw new LifecycleError("superseded", ownership, "the Session was opened but the local surface was superseded", outcome.handle.session.id);
-			return outcome.handle;
-		case "unavailable": throw new LifecycleError("unavailable", ownership, outcome.message, void 0);
-		case "cancelled": throw new LifecycleError("cancelled", ownership, "the Session open was cancelled before selection", void 0);
-	}
-}
-/** Extract the Direct ownership handle (the real AgentHandle with
-* `dispose()`) from a lifecycle result. Accepts both the converged
-* SessionHandle and a legacy AgentHandle so transition code cannot lose the
-* ownership capability. Remote handles lack `direct` and yield undefined. */
-function ownerHandleOf(next) {
-	const handle = next;
-	if (handle.direct?.ownerHandle !== void 0) return handle.direct.ownerHandle;
-	if (typeof handle.dispose === "function") return handle;
-}
-/** Extract the live in-process agent from a lifecycle result (the Direct
-* SessionHandle via `direct.agent`, or a legacy AgentHandle's `agent`).
-* Remote handles yield undefined. */
-function directAgentOf(next) {
-	const handle = next;
-	return handle.direct?.agent ?? handle.agent;
-}
-//#endregion
-//#region src/session-fork.ts
-/**
-* Shared forked-agent creation for `/fork` and conversation rewind.
-*
-* Both features create a child session from a seed through ONE chain
-* (plan §6.2): resolve the source's recorded preset → compose → agents.create
-* with `parentSession` + `isSeeded`/`inheritedEventCount` metadata → the
-* caller swaps to it.
-* Only the seed computation differs (`forkSeed` for `/fork`, `rewindSeed`
-* for rewind), so the metadata, preset/base provider-model options and cwd
-* rules can never drift between the two surfaces. Effective Session model
-* selection is inherited separately through the transition seam.
-*
-* `commitRewind` is the rewind selection workflow (stale check → create →
-* swap COMMIT → restore the prompt), with ONE authoritative pre-create
-* stale gate: it MUST run inside the caller's session-transition gate, so
-* no other transition can interleave and a stale selection never creates a
-* child at all — once the create succeeds, the child is committed (no
-* post-create disposal of a "ghost" child exists).
-* @module @xmoon76/dsh-pi-tui/session-fork
-*/
-/**
-* Create one forked agent: the source's projected preset, the source's
-* workspace cwd, and `parentSession` + `isSeeded` + `inheritedEventCount`
-* metadata (the exact chain `/fork` used before the extraction). Ordinary
-* create no longer carries provider/model inputs (D2.3). The effective Session model selection, when
-* needed, is applied by the transition caller after the inherited seed. The
-* child's session id is PRE-GENERATED by the caller so
-* the transition can publish the durable child under a known identity
-* (review round 6: every fallible operation happens before the durable
-* child exists).
-*
-* The preset rides the semantic create request as the CONCRETE preset id
-* (migration M1.11): the Direct adapter composes the setup internally from
-* that id — a composition/setup callback never crosses this seam. `undefined`
-* = the deployment default (a rosterless deployment records no preset).
-* @param host - the fork host surface.
-* @param source - the session being forked from (never modified).
-* @param seed - the child's seed events (completed-turn prefix).
-* @param sessionId - the pre-generated child session id.
-* @param presetId - the concrete preset id the child composes on.
-* @returns the created agent handle (NOT yet committed).
-*/
-async function createForkedAgent(host, source, seed, sessionId, presetId) {
-	const cwd = source.session.header.cwd || host.sessionCwd();
-	const inheritedPreset = presetId ?? host.sessionPreset?.(source.session);
-	return host.agents.create({
-		sessionId: String(sessionId),
-		meta: {
-			cwd,
-			...inheritedPreset === void 0 ? {} : { agentPreset: inheritedPreset },
-			parentSession: source.session.id,
-			isSeeded: true
-		},
-		inheritedEventCount: seed.length,
-		agentPreset: inheritedPreset,
-		seed
-	});
-}
-/** Whether a captured rewind identity still matches the live surface: a
-* sessionless surface (`sessionId: undefined`) can never match a captured
-* source, so a surface that became sessionless is refused just like a
-* switched one. Pure so the race is unit-testable without the runner. */
-function isRewindIdentityCurrent(live, expected) {
-	return live.sessionId === expected.sessionId && live.generation === expected.generation;
-}
-/**
-* Commit one rewind selection: fork the source before the candidate's turn,
-* commit the child, then restore the selected prompt into the editor.
-*
-* Transaction contract (review round 2 — the durable-ghost blocker): the
-* stale check and the seed derivation run BEFORE anything is created; the
-* create itself happens inside the runner's unified transaction, which
-* flushes the old session first, commits synchronously, and never rolls a
-* published child back. A stale selection therefore never creates a child
-* at all, a failed create leaves the source untouched, and once the child
-* exists it IS the surface. The source session is never modified at any
-* point.
-*
-* MUST run inside the caller's session-transition gate (the runner wraps
-* the commit in the gate): with the gate held, no other transition can
-* interleave, so the pre-create stale check is authoritative.
-*
-* @param host - the commit host.
-* @param source - the live agent whose session the picker listed.
-* @param candidate - the selected rewind point.
-* @param expected - the source identity captured when the picker opened
-*   (a selection must not commit into a surface another path has switched
-*   away from).
-* @param sourceSelection - the source's current effective selection, applied
-*   after the historical seed when defined.
-* @returns the outcome; `stale` when the source no longer owns the surface
-*   (detected before any child is created).
-*/
-async function commitRewind(host, source, candidate, expected, sourceSelection) {
-	if (!isRewindIdentityCurrent(host.liveIdentity(), expected)) return { kind: "stale" };
-	let seed;
-	try {
-		seed = rewindSeed(source.session.snapshotEvents(), candidate);
-	} catch (error) {
-		return {
-			kind: "failed",
-			message: safeErrorMessage$1(error)
-		};
-	}
-	const sessionId = SessionId(`session-${randomUUID()}`);
-	let composition;
-	try {
-		composition = await host.compose(host.sessionPreset?.(source.session));
-	} catch (error) {
-		return {
-			kind: "failed",
-			message: safeErrorMessage$1(error)
-		};
-	}
-	const result = await host.transitionTo({
-		target: {
-			id: String(sessionId),
-			header: { cwd: source.session.header.cwd || host.sessionCwd() }
-		},
-		...sourceSelection === void 0 ? {} : { inheritSelection: sourceSelection },
-		create: () => createForkedAgent(host, source, seed, sessionId, composition.agentPreset)
-	});
-	if (!result.ok) {
-		if (result.error instanceof LifecycleError && result.error.ownership === "superseded") return { kind: "superseded" };
-		return {
-			kind: "failed",
-			message: result.message
-		};
-	}
-	host.replaceDraft(candidate.editorText);
-	return {
-		kind: "rewound",
-		sessionId: result.next.session.id,
-		turn: candidate.turn,
-		hasNonTextContent: candidate.hasNonTextContent
-	};
-}
-//#endregion
 //#region src/steer.ts
 /**
 * The Ctrl+S steer-all orchestration with re-validation. Extracted
@@ -58090,6 +58060,68 @@ var ModelPicker = class {
 	}
 };
 //#endregion
+//#region src/runtime/session-lifecycle-port.ts
+/** A lifecycle outcome that must ABORT the caller's transition, carrying the
+*  two independent axes so a Remote caller never has to parse a string. */
+var LifecycleError = class extends Error {
+	settlement;
+	ownership;
+	publishedSessionId;
+	/** CORRELATION ONLY for an indeterminate create — never publication proof. */
+	requestedSessionId;
+	constructor(settlement, ownership, message, publishedSessionId, requestedSessionId) {
+		super(message);
+		this.name = "LifecycleError";
+		this.settlement = settlement;
+		this.ownership = ownership;
+		this.publishedSessionId = publishedSessionId;
+		this.requestedSessionId = requestedSessionId;
+	}
+};
+/** Unwrap a CREATE result for the runner's transition: a `created` result that
+*  still owns the surface yields the handle; everything else aborts with a
+*  machine-readable `LifecycleError` (a superseded create is NOT committed to
+*  the local surface, though its identity stays available). */
+function requireCreated(result) {
+	const { ownership, outcome } = result;
+	switch (outcome.kind) {
+		case "created":
+			if (ownership === "superseded") throw new LifecycleError("superseded", ownership, `Session "${outcome.handle.session.id}" was created, but the local surface was superseded — do not retry creation`, outcome.handle.session.id);
+			return outcome.handle;
+		case "published-with-error": throw new LifecycleError(outcome.kind, ownership, `Session "${outcome.sessionId}" was published, but workspace attach/reconcile failed: ${outcome.error.message} (${outcome.error.code}) — do not retry creation`, outcome.sessionId);
+		case "indeterminate": throw new LifecycleError(outcome.kind, ownership, `the create is indeterminate — do not retry: ${outcome.error.message} (${outcome.error.code})`, void 0, outcome.requestedSessionId);
+		case "rejected": throw new LifecycleError(outcome.kind, ownership, `${outcome.error.message} (${outcome.error.code})`, void 0);
+		case "cancelled": throw new LifecycleError("cancelled", ownership, "the Session creation was cancelled before dispatch", void 0);
+	}
+}
+/** Unwrap an OPEN result for the runner's transition. */
+function requireOpened(result) {
+	const { ownership, outcome } = result;
+	switch (outcome.kind) {
+		case "opened":
+			if (ownership === "superseded") throw new LifecycleError("superseded", ownership, "the Session was opened but the local surface was superseded", outcome.handle.session.id);
+			return outcome.handle;
+		case "unavailable": throw new LifecycleError("unavailable", ownership, outcome.message, void 0);
+		case "cancelled": throw new LifecycleError("cancelled", ownership, "the Session open was cancelled before selection", void 0);
+	}
+}
+/** Extract the Direct ownership handle (the real AgentHandle with
+* `dispose()`) from a lifecycle result. Accepts both the converged
+* SessionHandle and a legacy AgentHandle so transition code cannot lose the
+* ownership capability. Remote handles lack `direct` and yield undefined. */
+function ownerHandleOf(next) {
+	const handle = next;
+	if (handle.direct?.ownerHandle !== void 0) return handle.direct.ownerHandle;
+	if (typeof handle.dispose === "function") return handle;
+}
+/** Extract the live in-process agent from a lifecycle result (the Direct
+* SessionHandle via `direct.agent`, or a legacy AgentHandle's `agent`).
+* Remote handles yield undefined. */
+function directAgentOf(next) {
+	const handle = next;
+	return handle.direct?.agent ?? handle.agent;
+}
+//#endregion
 //#region src/runtime/read-error.ts
 /**
 * A typed semantic READ failure: the read was superseded by a connection or
@@ -58262,19 +58294,22 @@ function sessionLabelParts(label) {
 * fork children, rewind branches AND subagents alike (plan §20: `origin`
 * only decides the badge, `parentSession` decides the hierarchy) — hangs
 * under its parent chain (depth = distance to the nearest root). Orphans —
-* a parent outside the shown window, or a missing parent id — sit at
-* depth 1. The input order (newest first) is preserved per level; a
-* `placed` set guards against parent cycles in corrupt data.
+* a parent outside the shown window, or a missing parent id — degrade to root
+* depth 0. The input order (newest first) is preserved per level; a `placed`
+* set guards against parent cycles in corrupt data, which are emitted from
+* root depth when no ordinary root reaches them.
 * @param rows - the picker rows, newest first.
 * @returns rows in display order with their tree depth.
 */
 function buildSessionTree(rows) {
+	const known = new Set(rows.map((row) => row.id));
 	const children = /* @__PURE__ */ new Map();
-	for (const row of rows) if (row.parentSession !== void 0) {
+	const roots = [];
+	for (const row of rows) if (row.parentSession !== void 0 && known.has(row.parentSession)) {
 		const list = children.get(row.parentSession);
 		if (list === void 0) children.set(row.parentSession, [row]);
 		else list.push(row);
-	}
+	} else roots.push(row);
 	const result = [];
 	const placed = /* @__PURE__ */ new Set();
 	const place = (row, depth) => {
@@ -58286,8 +58321,8 @@ function buildSessionTree(rows) {
 		});
 		for (const child of children.get(row.id) ?? []) place(child, depth + 1);
 	};
-	for (const row of rows) if (row.parentSession === void 0) place(row, 0);
-	for (const row of rows) if (row.parentSession !== void 0) place(row, 1);
+	for (const root of roots) place(root, 0);
+	for (const row of rows) if (!placed.has(row.id)) place(row, 0);
 	return result;
 }
 /**
@@ -59010,19 +59045,10 @@ function sortCommands(commands) {
 * temp/20260907/dsh-pi-tui-search-sessions-direct-boundary-plan.md).
 * @module @xmoon76/dsh-pi-tui/commands
 */
-/** A balanced completed-turn prefix for forking: the log up to (and including)
-* the last `turn/end`. Undefined when no turn has completed yet.
-* @param events - the session log.
-* @returns the fork seed events, or undefined.
-*/
-function forkSeed(events) {
-	for (let index = events.length - 1; index >= 0; index -= 1) if (events[index]?.type === "turn/end") return events.slice(0, index + 1);
-}
 /** Shorten a session id for read-only display rows, capped at 28 characters. */
 function displaySessionId(id) {
 	return id.length > 28 ? `${id.slice(0, 28)}…` : id;
 }
-/** Session meta for a fresh/forked session: the cwd plus the preset id when composed. */
 /**
 * The `/sessions` category tabs (the 2026-08-22 plan, item 3): the session
 * picker is a HUMAN surface, so subagent children never appear in either
@@ -59152,8 +59178,8 @@ function presetDisplayText(preset) {
 }
 /**
 * Resolve one submission's delivery mode — the DSH WEB
-* `ComposerSubmissionPolicy.resolve()` contract (baseline 0.1.6-alpha.1,
-* shared by every UI client):
+* `ComposerSubmissionPolicy.resolve()` contract (baseline established in DSH
+* `0.1.6-alpha.1`, shared by every UI client):
 *
 * ```text
 * !running              -> queue
@@ -61058,7 +61084,6 @@ function registerTuiCommands(runner, initial) {
 			text: `skill "${name}" is not invocable by the user`
 		};
 		const line = args.trim() === "" ? "/" + skill.name : "/" + skill.name + " " + args.trimStart();
-		const releasePin = pinDraftAttachments(line, runner.imageStore, runner.fileStore);
 		const hostLoadsSkillBody = runner.catalog.skills.hostLoadsSkillBody(agent.session.id);
 		const fallbackBody = !hostLoadsSkillBody ? (() => {
 			const body = typeof skill.content === "string" && skill.content !== "" ? skill.content : skill.description;
@@ -61080,6 +61105,7 @@ function registerTuiCommands(runner, initial) {
 				}
 			});
 		})() : void 0;
+		const releasePin = pinDraftAttachments(line, runner.imageStore, runner.fileStore);
 		let userMessage;
 		try {
 			userMessage = await runner.prepareDraftMessage(line);
@@ -61546,7 +61572,7 @@ function registerTuiCommands(runner, initial) {
 					await runner.awaitPendingDefaultWrite(signal);
 					return runner.agents.create({
 						sessionId: String(sessionId),
-						meta: { cwd },
+						cwd,
 						agentPreset: resolved.id
 					});
 				}
@@ -62146,48 +62172,19 @@ function registerTuiCommands(runner, initial) {
 	});
 	commands.register({
 		name: "fork",
-		description: "Fork this session at the last completed turn",
-		handler: () => runner.withSessionTransition(async () => {
+		description: "Fork this session at the Host-selected completed-turn boundary",
+		handler: async () => {
 			const source = runner.liveAgent;
-			const seed = source === void 0 ? void 0 : forkSeed(source.session.snapshotEvents());
-			if (seed === void 0 || source === void 0) return {
+			if (source === void 0) return {
 				kind: "error",
-				text: "no completed turn to fork from"
+				text: "no conversation to fork from"
 			};
-			const sourceSelection = runner.selected.current;
-			const sessionId = SessionId(`session-${randomUUID()}`);
-			const childCwd = source.session.header.cwd || runner.sessionCwd();
-			const sourcePreset = runner.currentPreset();
-			const result = await runner.transitionTo({
-				target: {
-					id: String(sessionId),
-					header: { cwd: childCwd }
-				},
-				...sourceSelection === void 0 ? {} : { inheritSelection: sourceSelection },
-				create: () => createForkedAgent(runner, source, seed, sessionId, sourcePreset)
-			});
-			if (!result.ok) {
-				if (result.error instanceof LifecycleError) {
-					runner.diag.warn("fork create did not own the surface", {
-						settlement: result.error.settlement,
-						ownership: result.error.ownership,
-						publishedSessionId: result.error.publishedSessionId,
-						requestedSessionId: result.error.requestedSessionId
-					});
-					if (result.error.ownership === "superseded") return { kind: "success" };
-				}
-				return {
-					kind: "error",
-					text: result.message
-				};
-			}
-			runner.imageStore.clearUnpinned();
-			runner.fileStore?.clearUnpinned();
-			return {
-				kind: "success",
-				text: `forked as ${result.next.session.id}`
+			if (runner.forkSession === void 0) return {
+				kind: "error",
+				text: "session fork is unavailable in this backend"
 			};
-		})
+			return runner.forkSession(source.session.id);
+		}
 	});
 	commands.register({
 		name: "rewind",
@@ -64294,7 +64291,8 @@ function isRemoteBusinessRefusalCode(code) {
 /**
 * The interactive subagent viewer's HUMAN PROMPT delivery seam — the pure,
 * dependency-injected layer between TuiApp's semantic submit event and the
-* DSH official subagent control API (plan §17; DSH 0.1.6-alpha.1). It owns
+* DSH official subagent control API (plan §17; introduced in DSH
+* `0.1.6-alpha.1`). It owns
 * validation, the `ctx.subagents.prompt(...)` call, and error
 * classification; the runner owns the surface effects (draft restore,
 * notices, stale-viewer guards).
@@ -65334,6 +65332,23 @@ var DirectPendingInputReader = class {
 };
 //#endregion
 //#region src/runtime/direct/session-lifecycle-direct.ts
+/**
+* The Direct session lifecycle (D2.1–D2.4) — the in-process
+* implementation of `SessionLifecycle` over the dsh `agents` service.
+*
+* D2.3 moved ordinary create/open activation requirements INSIDE the adapter.
+* D2.4 does the same for fork: this adapter maps the official Host fork
+* algorithm (observation, completed-turn boundary, seed, lineage, preset,
+* default model and workspace attachment) without exposing those details
+* through the semantic port.
+*
+* The adapter is the only module in these lifecycle paths that touches `ctx`
+* and the preset composition. It keeps the real AgentHandle ownership escape
+* required by the current Direct runner.
+*
+* Full contract: docs/client-server-migration.md + docs/client-server-coupling.md.
+* @module @xmoon76/dsh-pi-tui/runtime/direct/session-lifecycle-direct
+*/
 /** The Direct backend's session lifecycle: the `ctx.agents` service behind
 * the semantic `SessionLifecycle` interface. The preset composition (and
 * with it the agent-setup callback) is resolved here from the request's
@@ -65343,9 +65358,11 @@ var DirectPendingInputReader = class {
 var DirectSessionLifecycle = class {
 	ctx;
 	compose;
-	constructor(ctx, compose) {
+	ownerPool;
+	constructor(ctx, compose, ownerPool) {
 		this.ctx = ctx;
 		this.compose = compose;
+		this.ownerPool = ownerPool;
 	}
 	/** The in-process activation fallback: the Host global default, never a
 	*  cross-backend request input. */
@@ -65366,18 +65383,14 @@ var DirectSessionLifecycle = class {
 		const agentOptions = this.agentOptions();
 		try {
 			const composition = await this.compose(request.agentPreset);
-			const metaPreset = request.meta.agentPreset;
-			if (metaPreset !== void 0 && composition.agentPreset !== void 0 && metaPreset !== composition.agentPreset) throw new Error(`create meta.agentPreset "${String(metaPreset)}" disagrees with the semantic agentPreset "${composition.agentPreset}"`);
 			const handle = await agents.create({
 				sessionId: SessionId(request.sessionId),
-				meta: composition.agentPreset === void 0 ? request.meta : {
-					...request.meta,
-					agentPreset: composition.agentPreset
+				meta: {
+					...request.cwd === void 0 ? {} : { cwd: request.cwd },
+					...composition.agentPreset === void 0 ? {} : { agentPreset: composition.agentPreset }
 				},
 				agentOptions,
 				setup: composition.setup,
-				seed: request.seed,
-				...request.inheritedEventCount === void 0 ? {} : { inheritedEventCount: SessionLogOffset(request.inheritedEventCount) },
 				signal: request.signal
 			});
 			return {
@@ -65401,11 +65414,50 @@ var DirectSessionLifecycle = class {
 			return currentCreateRejected("session/create-failed", safeErrorMessage$1(error));
 		}
 	}
+	/**
+	* Await a pending Direct owner release, honoring the caller's cancellation.
+	* @returns `true` when the release settled (or there was none), `false` when
+	*   the signal aborted first — the caller then settles as `cancelled`
+	*   instead of staying pending behind a slow retirement.
+	*/
+	async waitForReleaseOrAbort(sessionId, signal) {
+		const release = this.ownerPool?.waitForRelease?.(sessionId);
+		if (release === void 0) return true;
+		if (signal === void 0) {
+			await release;
+			return true;
+		}
+		if (signal.aborted) return false;
+		let onAbort;
+		const aborted = new Promise((resolve) => {
+			onAbort = () => resolve(false);
+			signal.addEventListener("abort", onAbort, { once: true });
+		});
+		try {
+			return await Promise.race([release.then(() => true), aborted]);
+		} finally {
+			if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+		}
+	}
 	async open(request) {
 		if (Boolean(request.signal?.aborted)) return {
 			ownership: "current",
 			outcome: { kind: "cancelled" }
 		};
+		const parked = this.ownerPool?.claim(request.sessionId);
+		if (parked !== void 0) return {
+			ownership: "current",
+			outcome: {
+				kind: "opened",
+				handle: {
+					session: { id: String(parked.agent.session.id) },
+					direct: {
+						agent: parked.agent,
+						ownerHandle: parked
+					}
+				}
+			}
+		};
 		const agents = this.ctx.get("agents");
 		if (agents === void 0) return {
 			ownership: "current",
@@ -65415,6 +65467,10 @@ var DirectSessionLifecycle = class {
 			}
 		};
 		const agentOptions = this.agentOptions();
+		if (!await this.waitForReleaseOrAbort(request.sessionId, request.signal)) return {
+			ownership: "current",
+			outcome: { kind: "cancelled" }
+		};
 		try {
 			const recorded = await recordedSessionPreset(this.ctx, request.sessionId, request.signal);
 			const composition = await this.compose(recorded);
@@ -65451,6 +65507,109 @@ var DirectSessionLifecycle = class {
 			};
 		}
 	}
+	/** Map the official Host fork algorithm into the Direct implementation. The
+	* only raw seed construction in the repository lives here, immediately next
+	* to `agents.create`; commands and the semantic port see only the source id
+	* and optional official anchor. */
+	async fork(request) {
+		const atSeq = request.atSeq;
+		if (atSeq !== void 0 && (!Number.isSafeInteger(atSeq) || atSeq < 0)) return currentForkRejected("gateway/bad-request", "atSeq must be a non-negative safe integer");
+		const agents = this.ctx.get("agents");
+		if (agents === void 0) return currentForkRejected("gateway/internal", "agents service unavailable");
+		const query = this.ctx.get("sessionQuery");
+		if (query === void 0) return currentForkRejected("gateway/internal", "session query service unavailable");
+		let source;
+		try {
+			source = await query.observeSession(SessionId(request.sourceSessionId));
+		} catch (error) {
+			return currentForkRejected((typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0) === "SESSION_QUERY_SESSION_NOT_FOUND" ? "session/not-found" : "gateway/internal", `fork source unavailable: ${safeErrorMessage$1(error)}`);
+		}
+		try {
+			const lastSeq = source.events.at(-1)?.seq ?? -1;
+			const boundary = (atSeq === void 0 ? void 0 : source.events.find((event) => event.type === "turn/end" && Number(event.seq) >= atSeq)) ?? (atSeq === void 0 || atSeq > Number(lastSeq) ? [...source.events].reverse().find((event) => event.type === "turn/end") : void 0);
+			if (boundary === void 0) return currentForkRejected("session/fork-unavailable", atSeq !== void 0 && atSeq <= Number(lastSeq) ? `session "${request.sourceSessionId}" has not completed the turn containing event ${String(atSeq)}` : `session "${request.sourceSessionId}" has no completed turn to fork from`);
+			let workspace;
+			try {
+				workspace = await this.forkWorkspace(source);
+			} catch (error) {
+				return currentForkRejected("gateway/internal", `failed to resolve fork workspace: ${safeErrorMessage$1(error)}`);
+			}
+			const preset = source.projections.values.agentPreset ?? void 0;
+			let composition;
+			try {
+				composition = await this.compose(preset);
+			} catch (error) {
+				return currentForkRejected("gateway/internal", `failed to compose fork session: ${safeErrorMessage$1(error)}`);
+			}
+			const cut = Number(boundary.seq) + 1;
+			const childMeta = {
+				...source.header.cwd === void 0 ? {} : { cwd: source.header.cwd },
+				parentSession: source.header.id,
+				isSeeded: true,
+				...composition.agentPreset === void 0 ? {} : { agentPreset: composition.agentPreset }
+			};
+			let handle;
+			try {
+				handle = await agents.create({
+					sessionId: SessionId(`session-${randomUUID()}`),
+					seed: source.events.slice(0, cut),
+					inheritedEventCount: SessionLogOffset(cut),
+					meta: childMeta,
+					agentOptions: this.agentOptions(),
+					setup: composition.setup
+				});
+			} catch (error) {
+				return currentForkRejected("gateway/internal", `failed to fork session "${request.sourceSessionId}": ${safeErrorMessage$1(error)}`);
+			}
+			const child = {
+				session: { id: String(handle.agent.session.id) },
+				direct: {
+					agent: handle.agent,
+					ownerHandle: handle
+				}
+			};
+			if (workspace !== void 0) try {
+				await workspace.attachSession(SessionId(child.session.id));
+			} catch (error) {
+				return {
+					ownership: "current",
+					outcome: {
+						kind: "published-with-error",
+						sessionId: child.session.id,
+						handle: child,
+						error: {
+							code: "session/workspace-attach-failed",
+							message: `Session "${child.session.id}" was forked but could not attach to workspace "${workspace.id}": ${safeErrorMessage$1(error)}`,
+							details: { workspaceId: workspace.id }
+						}
+					}
+				};
+			}
+			return {
+				ownership: "current",
+				outcome: {
+					kind: "forked",
+					handle: child
+				}
+			};
+		} finally {
+			source[Symbol.dispose]();
+		}
+	}
+	async forkWorkspace(source) {
+		const registry = this.ctx.get("workspaceRegistry");
+		if (registry === void 0) return void 0;
+		const workspaces = registry.list();
+		const direct = workspaces.find((workspace) => workspace.sessionIds.includes(source.header.id));
+		if (direct !== void 0 || source.header.origin !== "subagent") return direct;
+		const query = this.ctx.get("sessionQuery");
+		if (query?.traceSession === void 0) return void 0;
+		const lineage = await query.traceSession(source.header.id);
+		for (const ancestor of lineage.ancestors) {
+			const workspace = workspaces.find((candidate) => candidate.sessionIds.includes(ancestor.header.id));
+			if (workspace !== void 0) return workspace;
+		}
+	}
 };
 /** A Direct create rejection that still owns the local surface. */
 function currentCreateRejected(code, message) {
@@ -65465,6 +65624,18 @@ function currentCreateRejected(code, message) {
 		}
 	};
 }
+function currentForkRejected(code, message) {
+	return {
+		ownership: "current",
+		outcome: {
+			kind: "rejected",
+			error: {
+				code,
+				message
+			}
+		}
+	};
+}
 //#endregion
 //#region src/runtime/direct/interaction-direct.ts
 /** The Direct backend's interaction port: the ctx services/events behind
@@ -67552,24 +67723,112 @@ var CoalescingRefreshGate = class {
 	}
 };
 //#endregion
+//#region src/rewind.ts
+/** Whether one user/message event is a DIRECT human prompt. Injected context,
+* skill bodies, system reminders and goal continuations answer false. */
+function isHumanTurnMessage(event) {
+	return event.data.source.kind === "user";
+}
+/** Whether a message is empty for rewind purposes: mirror the transcript's
+* finalized user-content visibility rule. */
+function isEmptyMessage(blocks) {
+	return !userBlocksVisibleNow(blocks);
+}
+/** One-line, width-bounded preview of a prompt (whitespace collapsed). */
+function singleLinePreview(text) {
+	const flat = text.replace(/\s+/g, " ").trim();
+	return flat.length > 120 ? `${flat.slice(0, 117)}…` : flat;
+}
+/**
+* Derive rewind candidates from a session event log.
+*
+* Only a completed human turn after a valid completed predecessor is
+* rewindable. A non-human closed turn still becomes a legal predecessor; an
+* open or malformed span never does. The first human turn therefore has no
+* candidate because official fork omission would mean "latest boundary", not
+* an empty prefix.
+*/
+function collectRewindCandidates(events) {
+	const candidates = [];
+	let lastValidClosedTurnEndSeq;
+	let open;
+	for (const event of events) {
+		if (event.type === "turn/start") {
+			open = {
+				turn: event.data.turn,
+				startSeq: Number(event.seq),
+				predecessorEndSeq: lastValidClosedTurnEndSeq
+			};
+			continue;
+		}
+		if (event.type === "turn/end") {
+			if (open !== void 0 && event.data.turn !== open.turn) continue;
+			if (open !== void 0) {
+				const primary = open.primary;
+				if (primary !== void 0 && open.predecessorEndSeq !== void 0) {
+					const editorText = textOf(primary.blocks);
+					candidates.push({
+						turnStartSeq: open.startSeq,
+						forkAtSeq: open.predecessorEndSeq,
+						turn: open.turn,
+						messageSeq: primary.seq,
+						editorText,
+						preview: singleLinePreview(editorText),
+						hasNonTextContent: primary.blocks.some((block) => block.type !== "text")
+					});
+				}
+				lastValidClosedTurnEndSeq = Number(event.seq);
+			}
+			open = void 0;
+			continue;
+		}
+		if (event.type === "user/message" && open !== void 0 && open.primary === void 0) {
+			const blocks = event.data.content;
+			if (isHumanTurnMessage(event) && !isEmptyMessage(blocks)) open.primary = {
+				seq: Number(event.seq),
+				blocks
+			};
+		}
+	}
+	return candidates.reverse();
+}
+/** One picker row for a candidate. The value remains the selected turn-start
+* identity; the workflow resolves the captured row before dispatch. */
+function rewindPickerItem(candidate) {
+	const tag = candidate.hasNonTextContent ? "[attachment] " : "";
+	const preview = candidate.preview === "" && candidate.hasNonTextContent ? "(attachment only)" : candidate.preview;
+	return {
+		value: String(candidate.turnStartSeq),
+		label: `turn ${candidate.turn} · ${tag}${preview}`,
+		...candidate.hasNonTextContent ? { description: "non-text content is not re-staged on rewind" } : {}
+	};
+}
+//#endregion
+//#region src/session-fork.ts
+/** A captured fork/rewind intent still owns the visible surface only while all
+* three local identity facts remain unchanged. */
+function isRewindIdentityCurrent(live, expected) {
+	return live.sessionId === expected.sessionId && live.generation === expected.generation && live.navigationEpoch === expected.navigationEpoch;
+}
+//#endregion
 //#region src/transition-gate.ts
 /**
 * The process-local session-transition gate: ONE writer for the live
 * session at a time.
 *
-* Every path that changes which session owns the surface — /new, /fork,
-* conversation rewind, `/sessions` switch/resume, the first-session
-* creation — must run its whole workflow (quiesce old → preflight →
-* create/resume → COMMIT (assign new + generation bump) → retire old)
-* inside {@link SessionTransitionGate.run}. Without it, two interleaved transitions can:
+* Every ordinary path that changes which session owns the surface — /new,
+* `/sessions` switch/resume, and first-session creation — must run its whole
+* workflow (quiesce old → preflight → create/resume → COMMIT (assign new +
+* generation bump) → retire old) inside {@link SessionTransitionGate.run}.
+* Host fork dispatch runs outside this FIFO; only adoption of a returned Direct
+* child enters the gate. Without this gate, two interleaved transitions can:
 *
 * - create a child whose metadata mixes two surfaces (parent captured
 *   before an await, cwd read after a concurrent switch — the P2 "cwd
 *   race");
-* - publish a forked child (session/created → persistence starts writing
-*   its seed) and then detect "stale" only AFTER the create, leaving a
-*   durable ghost branch the user never entered — `handle.dispose()` stops
-*   the agent but does NOT delete the persisted session;
+* - publish an ordinary child (session/created → persistence starts writing
+*   its seed) and then detect a stale surface only AFTER the create, leaving
+*   two live Direct surfaces with no serialized adoption/retirement order;
 * - pass a stale identity check and then yield inside the swap (flush /
 *   old-owner retirement), letting a second transition land in between and
 *   later get overwritten by the first continuation.
@@ -67657,7 +67916,8 @@ var PendingSubmissions = class {
 			text: input.text,
 			createdAt: input.createdAt,
 			...input.sessionId === void 0 ? {} : { sessionId: input.sessionId },
-			...input.generation === void 0 ? {} : { generation: input.generation }
+			...input.generation === void 0 ? {} : { generation: input.generation },
+			...input.foldableText === void 0 ? {} : { foldableText: input.foldableText }
 		});
 	}
 	/** Remove one echo after its durable `user/message` became renderable. */
@@ -67723,7 +67983,8 @@ function buildPendingPresentation(input) {
 			id: item.id,
 			...item.rpcId === void 0 ? {} : { rpcId: item.rpcId },
 			text: input.textOf(item.content),
-			status: "steering"
+			status: "steering",
+			foldableText: isTextOnlyContent(item.content)
 		});
 	}
 	const authoritativeRpcIds = /* @__PURE__ */ new Set();
@@ -67742,7 +68003,8 @@ function buildPendingPresentation(input) {
 			rpcId: echo.requestId,
 			text,
 			local: true,
-			status: echo.placement === "transcript" ? "sending" : "steering"
+			status: echo.placement === "transcript" ? "sending" : "steering",
+			...echo.foldableText === void 0 ? {} : { foldableText: echo.foldableText }
 		});
 	}
 	return {
@@ -67752,6 +68014,17 @@ function buildPendingPresentation(input) {
 	};
 }
 /**
+* Whether an authoritative pending occurrence's structural content is
+* text-only, so the ephemeral row may join the long-user visual-row fold. Any
+* unrecognized block (image/file/attachment/generic non-text) fails open to
+* the FULL presentation — the pending row must never be folded only to
+* materialize as a full mixed-content durable bubble.
+*/
+function isTextOnlyContent(content) {
+	if (content.length === 0) return false;
+	return content.every((block) => typeof block === "object" && block !== null && block.type === "text");
+}
+/**
 * Render one local echo's display text. The Direct ledger carries attachment
 * markers inside `text`; the official Remote pending submission does not, so
 * its structured attachments are appended here — an image-only echo must never
@@ -67780,7 +68053,8 @@ var DirectSubmissionPresentation = class {
 			placement: echo.placement,
 			text: echo.text,
 			createdAt: echo.createdAt,
-			attachments: []
+			attachments: [],
+			...echo.foldableText === void 0 ? {} : { foldableText: echo.foldableText }
 		}));
 	}
 };
@@ -67852,8 +68126,8 @@ var SubmitLatencyTracker = class {
 //#endregion
 //#region src/transition.ts
 /**
-* The session switch transaction — the canonical ordering shared by /new,
-* /fork, conversation rewind and `/sessions` switch/resume:
+* The ordinary session-switch transaction — the canonical ordering shared by
+* /new and `/sessions` switch/resume:
 *
 * ```text
 * 1. quiesce old (whenIdle + final flush)
@@ -68434,8 +68708,8 @@ function packageVersion() {
 }
 /**
 * The welcome card's version line: the installed dsh version plus the
-* bundle's own version (header-badge parity — `dsh-0.1.6-alpha.1 ·
-* tui-v0.4.7-alpha.1`). Without a resolvable dsh launcher it degrades to
+* bundle's own version (header-badge parity — `dsh-0.1.6-alpha.2 ·
+* tui-v0.4.7-alpha.2`). Without a resolvable dsh launcher it degrades to
 * the bundle version alone.
 * @returns the combined version string.
 */
@@ -68793,8 +69067,8 @@ async function composeAgent(ctx, installSelection, presetId, focusState, diag) {
 	};
 }
 /**
-* The preset a persisted session actually runs, read from DSH 0.1.6-alpha.1's
-* V3 session projection (header initialization plus the latest selection event).
+* The preset a persisted session actually runs, read from the DSH 0.1.6 V3
+* session projection (header initialization plus the latest selection event).
 * @param ctx - the runner context.
 * @param sessionId - the persisted session id.
 * @returns the recorded preset id, or undefined to compose the default.
@@ -68904,6 +69178,69 @@ function apply(ctx, config) {
 		}
 		const transitionGate = new SessionTransitionGate();
 		const operationBarrier = new SessionOperationBarrier();
+		const parkedDirectOwners = /* @__PURE__ */ new Map();
+		const pendingOwnerReleases = /* @__PURE__ */ new Map();
+		/** Register a pending release for one session; returns the resolver the
+		*  retirement calls when it has finished. */
+		const beginOwnerRelease = (sessionId) => {
+			let resolve;
+			const promise = new Promise((settle) => {
+				resolve = settle;
+			});
+			const releases = pendingOwnerReleases.get(sessionId) ?? /* @__PURE__ */ new Set();
+			releases.add(promise);
+			pendingOwnerReleases.set(sessionId, releases);
+			return () => {
+				releases.delete(promise);
+				if (releases.size === 0) pendingOwnerReleases.delete(sessionId);
+				resolve();
+			};
+		};
+		const waitForOwnerRelease = async (sessionId) => {
+			while (true) {
+				const releases = pendingOwnerReleases.get(sessionId);
+				if (releases === void 0 || releases.size === 0) return;
+				await Promise.allSettled([...releases]);
+			}
+		};
+		/** Admission-time pin for one `/fork` source. It is held from the moment the
+		*  fork is admitted — before the child is even created — and released when
+		*  the fork settles AND, if it committed, after the source owner's
+		*  retirement finishes. While it is held, an open/resume of that session
+		*  waits for the release instead of resuming a live, lease-held owner. */
+		const beginForkSourcePin = (sessionId) => {
+			const finish = beginOwnerRelease(sessionId);
+			const state = {
+				released: false,
+				retirementOwnsRelease: false
+			};
+			return {
+				state,
+				release: () => {
+					if (state.released) return;
+					state.released = true;
+					finish();
+				}
+			};
+		};
+		const directOwnerPool = {
+			claim: (sessionId) => {
+				const handle = parkedDirectOwners.get(sessionId);
+				if (handle !== void 0) parkedDirectOwners.delete(sessionId);
+				return handle;
+			},
+			park: (handle) => {
+				const sessionId = String(handle.agent.session.id);
+				const previous = parkedDirectOwners.get(sessionId);
+				if (previous !== void 0 && previous !== handle) throw new Error(`duplicate parked Direct owner for session "${sessionId}"`);
+				parkedDirectOwners.set(sessionId, handle);
+			},
+			waitForRelease: waitForOwnerRelease
+		};
+		let navigationEpoch = 0;
+		const pendingForks = /* @__PURE__ */ new Set();
+		const pendingSettlementWork = /* @__PURE__ */ new Set();
+		const pendingSourceRetirements = /* @__PURE__ */ new Set();
 		const pendingQueueRecalls = [];
 		const settlePendingQueueRecalls = (committed) => {
 			const recalls = pendingQueueRecalls.splice(0);
@@ -68915,6 +69252,17 @@ function apply(ctx, config) {
 			if (retirementPromise !== void 0) return retirementPromise;
 			retirementPromise = (async () => {
 				if (transitionGate?.pending === true) liveAgent?.cancel({ kind: "user" });
+				const retireParked = async (agent, handle) => retireDirectOwnedSession({
+					cancel: () => agent.cancel({ kind: "user" }),
+					whenIdle: () => agent.whenIdle(),
+					drainDescendants: async () => {
+						await ctx.get("subagents")?.drainContinuableDescendants?.([agent]);
+					},
+					flush: async () => {
+						await sessions.flush(agent.session);
+					},
+					disposeOwner: () => handle.dispose()
+				});
 				const retire = async () => {
 					const agent = liveAgent;
 					const handle = liveHandle;
@@ -68962,7 +69310,18 @@ function apply(ctx, config) {
 					return report;
 				};
 				try {
-					return await transitionGate.run(() => operationBarrier.runTransition(retire));
+					while (pendingForks.size > 0) await Promise.allSettled([...pendingForks]);
+					while (pendingSettlementWork.size > 0) await Promise.allSettled([...pendingSettlementWork]);
+					while (pendingSourceRetirements.size > 0) await Promise.allSettled([...pendingSourceRetirements]);
+					return await transitionGate.run(() => operationBarrier.runTransition(async () => {
+						const failures = [...(await retire()).failures];
+						for (const [sessionId, parked] of parkedDirectOwners) {
+							parkedDirectOwners.delete(sessionId);
+							const report = await retireParked(parked.agent, parked);
+							failures.push(...report.failures);
+						}
+						return { failures };
+					}));
 				} catch (error) {
 					diag.error("retire barrier failed", { error: safeErrorMessage$1(error) });
 					return { failures: [{
@@ -69125,7 +69484,7 @@ function apply(ctx, config) {
 			flushSession: async (session) => {
 				await sessions.flush(session);
 			}
-		}), directPendingInputReader, directSessionWriter, new DirectSessionLifecycle(ctx, (presetId) => compose(presetId)), new DirectInteractionPort(ctx, (sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0), new DirectCatalogPort(ctx, (sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0, modelSelections, diag), new DirectConfigPort(ctx, tuiSettings, (sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0), new DirectHostFilePort((sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0), new DirectSessionArchive(ctx), new DirectHostCommandPort(ctx, (sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0));
+		}), directPendingInputReader, directSessionWriter, new DirectSessionLifecycle(ctx, (presetId) => compose(presetId), directOwnerPool), new DirectInteractionPort(ctx, (sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0), new DirectCatalogPort(ctx, (sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0, modelSelections, diag), new DirectConfigPort(ctx, tuiSettings, (sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0), new DirectHostFilePort((sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0), new DirectSessionArchive(ctx), new DirectHostCommandPort(ctx, (sessionId) => liveAgent?.session.id === sessionId ? liveAgent : void 0));
 		const userFooterCustomItemsForSave = () => {
 			const raw = backend.config.footerCustomItems.rawForPersistence();
 			if (raw.kind === "unavailable") throw new Error("custom footer definitions unavailable; settings write aborted");
@@ -69312,59 +69671,27 @@ function apply(ctx, config) {
 				...currentPreset() === void 0 ? {} : { preset: currentPreset() }
 			});
 		};
-		/** The ONE writer for the live session: every path that changes which
-		* session owns the surface — /new, /fork, rewind, `/sessions` switch,
-		* the first-session creation — runs its WHOLE workflow (prepare/create
-		* → flush → COMMIT (assign new + generation bump) → retire old) inside
-		* {@link transitionGate}. Without the gate a transition can interleave
-		* with another: a fork child could be created (and its seed published
-		* to persistence) before a stale check sees the surface already moved —
-		* `dispose()` stops the agent but never deletes the persisted session —
-		* and a stale identity check could pass, then yield across an await
-		* inside the commit preparation, letting a concurrent switch land and
-		* later get overwritten. The rewind commit holds the gate from BEFORE
-		* `createForkedAgent` (the create itself is inside the exclusive
-		* section), so a stale rewind never creates a child at all.
+		/** The transition gate protects ordinary session surface changes — `/new`,
+		* `/sessions` switch/open and first-session creation — from interleaving.
+		* Fork dispatch is intentionally outside this destructive queue: Host
+		* publication may outlive local navigation, while the visible adoption and
+		* old-owner retirement use a short gated handoff.
 		* @see SessionTransitionGate */
-		/**
-		* The ONE session-transition transaction, shared by /new, /fork,
-		* conversation rewind and `/sessions` switch/resume. The canonical
-		* ordering lives in `runTransitionTo` (src/transition.ts — unit-tested
-		* against the exact phase order); this is the runner's host adapter.
-		*
-		* The ordering is the whole point (review rounds 2–3):
-		*
-		*   1. QUIESCE OLD — `whenIdle()` then the FINAL flush. `dispose()` is
-		*      an async quiescence and a cancelled RUNNING turn appends its
-		*      closure events (interrupted assistant/message, step/end,
-		*      turn/end) in finally blocks — the old agent must be idle before
-		*      the flush so those closures are never split across the switch.
-		*      Old-idle-then-flush closes that window; may fail → abort with
-		*      ZERO child side effects.
-		*   2. caller `prepare` (rewind's stale gate, switch pre-checks)
-		*      — may fail → abort;
-		*   3. create/resume the CHILD — may fail → abort; once it SUCCEEDS the
-		*      child is published (session/created → persistence may already
-		*      write its seed) and there is NO failure path afterwards that may
-		*      be interpreted as "the child never happened" (`dispose()` stops
-		*      an agent but never deletes a persisted session; dsh has no
-		*      durable rollback);
-		*   4. COMMIT — a synchronous critical section (generation bump, live
-		*      handle/agent replacement) with no awaits between its steps;
-		*   5. RETIRE — retire the old Direct owner in the fixed order
-		*      (cancel → idle → drain continuable descendants → final flush →
-		*      dispose — see src/runtime/direct/owned-session-retirement.ts),
-		*      then child whenIdle, surface rebuild, catalog refresh —
-		*      failures WARN ONLY, the committed child always stands.
-		*
-		* Must be called inside {@link transitionGate} (via
-		* `withSessionTransition` or the rewind commit's own gate wrapper).
-		*/
+		/** The ordinary session-transition transaction. Its canonical ordering
+		* lives in `runTransitionTo` (src/transition.ts — unit-tested): quiesce and
+		* flush the old owner, run caller preflight, create/open the child, commit
+		* the visible handle synchronously, then retire the old Direct owner and
+		* refresh the child surface. Published children are never treated as if
+		* they did not exist, and callers use this only inside the gate. */
 		/** Extract the live in-process agent from a transition next value: the
 		* Direct SessionHandle carries it via direct.agent; an AgentHandle IS the
-		* agent handle. Remote handles carry neither (the client runtime owns the
-		* session there — M2+). */
+		* agent handle. A Remote handle carries no Direct agent: it carries exactly one
+		* Client generation reference (`SessionHandle.client`), which a composing
+		* Remote runner WILL release through `clientOwnerOf()`. This Direct runner does
+		* not take that owner over yet — the Remote caller-side handoff is deferred to
+		* Remote production composition (M2+/M3). */
 		const transitionTo = async (steps) => {
+			navigationEpoch += 1;
 			const from = liveAgent?.session.id;
 			const opening = {
 				id: steps.target.id,
@@ -69390,18 +69717,6 @@ function apply(ctx, config) {
 					liveAgent = directAgentOf(next);
 					if (cleanedUp) return;
 					completionController.setLiveAgent(liveAgent.id);
-					if (steps.inheritSelection !== void 0) {
-						const target = directAgentOf(next);
-						const folded = foldPendingModelSelection(target.session.snapshotEvents());
-						if (!sameModelSelection(folded.pending ?? folded.lastUsed, steps.inheritSelection)) try {
-							modelSelections.selectForNextRequest(target, steps.inheritSelection);
-						} catch (error) {
-							diag.error("transition selection seed failed", {
-								session: target.session.id,
-								error: safeErrorMessage$1(error)
-							});
-						}
-					}
 				},
 				retireOld: async (next) => {
 					const retired = [];
@@ -69432,7 +69747,6 @@ function apply(ctx, config) {
 					} catch (error) {
 						retired.push(`surface rebuild: ${safeErrorMessage$1(error)}`);
 					}
-					if (openingSession === opening) openingSession = void 0;
 					try {
 						await refreshLiveCatalog(directAgentOf(next));
 					} catch (error) {
@@ -69465,15 +69779,18 @@ function apply(ctx, config) {
 		* failure (unknown session, broken log, preset mount) returns an error
 		* string so callers' `.then(error => ...)` need no rejection path. The
 		* whole switch (compose → resume → commit) runs inside the
-		* session-transition gate, so it can never interleave with /new, /fork
-		* or a rewind commit (the single-writer rule). */
-		const switchSession = (sessionId) => transitionGate.run(() => operationBarrier.runTransition(async () => {
-			try {
-				return await switchSessionLocked(sessionId);
-			} finally {
-				settlePendingQueueRecalls(false);
-			}
-		}));
+		* session-transition gate, so it can never interleave with another
+		* ordinary transition (the single-writer rule). */
+		const switchSession = (sessionId) => {
+			navigationEpoch += 1;
+			return transitionGate.run(() => operationBarrier.runTransition(async () => {
+				try {
+					return await switchSessionLocked(sessionId);
+				} finally {
+					settlePendingQueueRecalls(false);
+				}
+			}));
+		};
 		const switchSessionLocked = async (sessionId) => {
 			if (liveAgent !== void 0 && liveAgent.session.id === sessionId) return "already on this session";
 			try {
@@ -69719,6 +70036,249 @@ function apply(ctx, config) {
 				signal
 			}))
 		};
+		let commandExecutionDepth = 0;
+		const deferredSourceRetirements = [];
+		const startSourceRetirement = (sessionId, retire) => {
+			let pending;
+			runOwned("fork source retirement", () => {
+				const task = retire();
+				pending = task;
+				return task;
+			}, {
+				diag,
+				sessionId: () => void 0
+			});
+			if (pending !== void 0) {
+				const tracked = pending;
+				pendingSourceRetirements.add(tracked);
+				const untrack = () => {
+					pendingSourceRetirements.delete(tracked);
+				};
+				observeSettled(tracked, untrack);
+			}
+			return pending;
+		};
+		/** Retire the source owner. A DSH command defers it to its own settlement
+		*  (the executor's `command/done` append must land first) and returns
+		*  `undefined`; outside a command the retirement promise is returned so the
+		*  caller keeps the baseline ordering.
+		*
+		*  `finishRelease` settles the fork's admission pin when the retirement has
+		*  FINISHED — success or a CONTAINED failure. `retireDirectOwnedSession`
+		*  never rejects: a failed phase (notably `disposeOwner`) is recorded in its
+		*  report and diag-logged, and the pin still releases. That is deliberate:
+		*  holding the pin on a failed dispose would leave `open`/`resume` pending
+		*  forever, so the reopen instead proceeds and fails LOUDLY on the official
+		*  exclusive write claim (`session "X" is already owned by an active write
+		*  handle`). A failed dispose is a leaked-handle bug in its own right; the
+		*  retirement helper already contains and reports it. */
+		const retireSourceOwnerAfterSettlement = (sessionId, retire, finishRelease) => {
+			const run = async () => {
+				try {
+					await retire();
+				} finally {
+					finishRelease();
+				}
+			};
+			if (commandExecutionDepth === 0) return startSourceRetirement(sessionId, run);
+			deferredSourceRetirements.push({
+				sessionId,
+				retire: run
+			});
+		};
+		/** Start every retirement queued by the settled command(s) and return the
+		*  started promises so the settlement can WAIT for them. */
+		const flushSourceRetirementsAfterSettlement = () => {
+			const started = [];
+			while (deferredSourceRetirements.length > 0) {
+				const entry = deferredSourceRetirements.shift();
+				if (entry === void 0) continue;
+				const pending = startSourceRetirement(entry.sessionId, entry.retire);
+				if (pending !== void 0) started.push(pending);
+			}
+			return started;
+		};
+		/** Close one command-settlement window EXACTLY once and WAIT for the source
+		*  retirements it queued. The command workflow must not report completion —
+		*  nor release the submit FIFO — while the old owner still holds its write
+		*  lease, or an immediate reopen of that Session would be refused. The
+		*  executor's `command/done` append already happened inside the wrapped
+		*  execution, so this preserves durability AND makes `/fork`'s outward
+		*  completion imply the source is released. */
+		const settleCommandExecution = async () => {
+			commandExecutionDepth -= 1;
+			if (commandExecutionDepth === 0) await Promise.allSettled(flushSourceRetirementsAfterSettlement());
+		};
+		const parkForkOwner = (handle) => {
+			const owner = handle === void 0 ? void 0 : ownerHandleOf(handle);
+			if (owner !== void 0) directOwnerPool.park(owner);
+		};
+		const forkNavigationCurrent = (expected) => isRewindIdentityCurrent({
+			sessionId: liveAgent?.session.id,
+			generation: sessionGeneration,
+			navigationEpoch
+		}, expected);
+		const adoptFork = async (handle, expected, onAdopted, pin) => {
+			let adopted = false;
+			try {
+				await transitionGate.run(() => operationBarrier.runTransition(async () => {
+					if (cleanedUp || !forkNavigationCurrent(expected)) {
+						parkForkOwner(handle);
+						return;
+					}
+					const oldAgent = liveAgent;
+					const oldHandle = liveHandle;
+					const nextAgent = directAgentOf(handle);
+					const nextHandle = ownerHandleOf(handle);
+					if (nextAgent === void 0 || nextHandle === void 0) throw new Error(`forked session "${handle.session.id}" has no Direct owner`);
+					settlePendingQueueRecalls(true);
+					settleLocalSubmitAck("session forked");
+					submitLatencyTracker.reset();
+					bumpSessionGeneration();
+					liveAgent = nextAgent;
+					liveHandle = nextHandle;
+					completionController.setLiveAgent(nextAgent.id);
+					adopted = true;
+					try {
+						onAdopted?.();
+					} catch (error) {
+						diag.error("fork adoption callback failed after child commit", {
+							error: safeErrorMessage$1(error),
+							session: nextAgent.session.id
+						});
+					}
+					if (oldAgent !== void 0 && oldHandle !== void 0) {
+						if (pin !== void 0) pin.state.retirementOwnsRelease = true;
+						const retirement = retireSourceOwnerAfterSettlement(oldAgent.session.id, async () => {
+							const report = await retireDirectOwnedSession({
+								cancel: () => oldAgent.cancel({ kind: "user" }),
+								whenIdle: () => oldAgent.whenIdle(),
+								drainDescendants: async () => {
+									await ctx.get("subagents")?.drainContinuableDescendants?.([oldAgent]);
+								},
+								flush: async () => {
+									await sessions.flush(oldAgent.session);
+								},
+								disposeOwner: () => oldHandle.dispose()
+							});
+							if (report.failures.length > 0) diag.error("fork old-owner retirement failed (child committed)", {
+								from: oldAgent.session.id,
+								failures: report.failures
+							});
+						}, pin?.release ?? (() => {}));
+						if (retirement !== void 0) await retirement;
+					}
+					let aborted = false;
+					try {
+						aborted = await whenIdleOrAbort(nextAgent, lifecycleController.signal);
+					} catch (error) {
+						diag.error("fork child quiescence failed after commit", {
+							error: safeErrorMessage$1(error),
+							session: nextAgent.session.id
+						});
+					}
+					if (!aborted) try {
+						await initLiveSession(nextAgent);
+					} catch (error) {
+						diag.error("fork child initialization failed after commit", {
+							error: safeErrorMessage$1(error),
+							session: nextAgent.session.id
+						});
+					}
+					try {
+						await refreshLiveCatalog(nextAgent);
+					} catch (error) {
+						diag.error("fork child catalog refresh failed after commit", {
+							error: safeErrorMessage$1(error),
+							session: nextAgent.session.id
+						});
+					}
+				}));
+			} catch (error) {
+				if (!adopted) throw error;
+				diag.error("fork post-commit handoff failed", {
+					error: safeErrorMessage$1(error),
+					session: handle.session.id
+				});
+			}
+			return adopted;
+		};
+		const forkSession = async (sourceSessionId, atSeq, onAdopted, pickerIdentity) => {
+			const before = {
+				sessionId: liveAgent?.session.id,
+				generation: sessionGeneration,
+				navigationEpoch
+			};
+			const pickerCurrent = pickerIdentity === void 0 || isRewindIdentityCurrent(before, pickerIdentity);
+			const expectedSessionId = pickerIdentity?.sessionId ?? before.sessionId;
+			if (cleanedUp || !pickerCurrent || expectedSessionId !== sourceSessionId) return {
+				kind: "error",
+				text: "the session changed before fork dispatch"
+			};
+			const expected = {
+				sessionId: expectedSessionId,
+				generation: pickerIdentity?.generation ?? before.generation,
+				navigationEpoch: ++navigationEpoch
+			};
+			const pin = beginForkSourcePin(sourceSessionId);
+			let settleFork;
+			let forkedHandle;
+			const pending = new Promise((resolve) => {
+				settleFork = resolve;
+			});
+			pendingForks.add(pending);
+			try {
+				const result = await backend.sessionLifecycle.fork({
+					sourceSessionId,
+					...atSeq === void 0 ? {} : { atSeq }
+				});
+				const outcome = result.outcome;
+				if (outcome.kind === "unavailable") {
+					if (result.ownership === "superseded" || !forkNavigationCurrent(expected)) return { kind: "success" };
+					return {
+						kind: "error",
+						text: outcome.message
+					};
+				}
+				if (outcome.kind === "rejected" || outcome.kind === "indeterminate" || outcome.kind === "published-with-error") {
+					if (outcome.kind === "published-with-error") parkForkOwner(outcome.handle);
+					if (result.ownership === "superseded" || !forkNavigationCurrent(expected)) return { kind: "success" };
+					return {
+						kind: "error",
+						text: `${outcome.error.message} (${outcome.error.code})`
+					};
+				}
+				if (result.ownership === "superseded" || !forkNavigationCurrent(expected)) {
+					parkForkOwner(outcome.handle);
+					return {
+						kind: "success",
+						text: `forked as ${outcome.handle.session.id}; navigation stayed on the newer session`
+					};
+				}
+				forkedHandle = outcome.handle;
+				if (!await adoptFork(outcome.handle, expected, onAdopted, pin)) return {
+					kind: "success",
+					text: `forked as ${outcome.handle.session.id}`
+				};
+				draftImages.clearUnpinned();
+				draftFiles.clearUnpinned();
+				return {
+					kind: "success",
+					text: `forked as ${outcome.handle.session.id}`
+				};
+			} catch (error) {
+				if (forkedHandle !== void 0) parkForkOwner(forkedHandle);
+				if (!forkNavigationCurrent(expected)) return { kind: "success" };
+				return {
+					kind: "error",
+					text: `fork failed: ${safeErrorMessage$1(error)}`
+				};
+			} finally {
+				settleFork();
+				pendingForks.delete(pending);
+				if (!pin.state.retirementOwnsRelease) pin.release();
+			}
+		};
 		let localShellController;
 		/** Stop the captured live Agent through the SessionWriter seam. The
 		* operation barrier keeps the async outcome inside the same session
@@ -69806,7 +70366,7 @@ function apply(ctx, config) {
 		});
 		if (lifecycleController.signal.aborted) {
 			startupStatus.clear();
-			if (liveAgent !== void 0 && liveHandle !== void 0) await retireOwnedSession();
+			if (liveAgent !== void 0 || liveHandle !== void 0 || parkedDirectOwners.size > 0 || pendingForks.size > 0) await retireOwnedSession();
 			else diag.dispose();
 			return;
 		}
@@ -70099,13 +70659,24 @@ function apply(ctx, config) {
 		};
 		/** The display text of one client-local submission echo: the draft text
 		* with its attachment placeholders expanded to compact markers, so an
-		* attachment-only submission is never an empty pending row. */
-		const localEchoText = (text) => {
+		* attachment-only submission is never an empty pending row. The SAME
+		* expansion decides the foldability fact: a submission carrying any
+		* attachment marker is not text-only and must render in full. */
+		const localEcho = (text) => {
 			const parts = [];
+			let foldableText = true;
 			for (const segment of expandAttachmentPlaceholders(text, draftImages, draftFiles)) if (segment.type === "text") parts.push(segment.text);
-			else if (segment.type === "image") parts.push(`🖼️ ${segment.image.name ?? "image"}`);
-			else parts.push(`📄 ${segment.file.name} · ${formatBytes(segment.file.byteLength)}`);
-			return parts.join(" ");
+			else if (segment.type === "image") {
+				foldableText = false;
+				parts.push(`🖼️ ${segment.image.name ?? "image"}`);
+			} else {
+				foldableText = false;
+				parts.push(`📄 ${segment.file.name} · ${formatBytes(segment.file.byteLength)}`);
+			}
+			return {
+				text: parts.join(" "),
+				foldableText
+			};
 		};
 		/**
 		* Own pending input must become VISIBLE even when the reader deliberately
@@ -70657,10 +71228,12 @@ function apply(ctx, config) {
 		* feedback and the durable row replaces it.
 		*/
 		const beginLocalSubmission = (requestId, text, placement, sessionId, generation, ackToken) => {
+			const echo = localEcho(text);
 			pendingSubmissions.begin({
 				requestId,
 				placement,
-				text: localEchoText(text),
+				text: echo.text,
+				foldableText: echo.foldableText,
 				createdAt: Date.now(),
 				...sessionId === void 0 ? {} : { sessionId },
 				generation
@@ -70835,7 +71408,6 @@ function apply(ctx, config) {
 		*   this submission; bound for the command execution so a TUI-owned
 		*   skill handler accepts it instead of re-deriving it. */
 		const dispatchViaSession = (text, persistHistory, delivery) => {
-			const submitTurn = takeSubmitTurn();
 			const submittedAgent = liveAgent;
 			const submittedGeneration = sessionGeneration;
 			let submitTurnTransferred = false;
@@ -70861,6 +71433,7 @@ function apply(ctx, config) {
 			};
 			let commandHealthRef;
 			let planeAdvertised = false;
+			const submitTurn = takeSubmitTurn();
 			runOwned("submit", () => runReservedSubmit({
 				reserve: (t) => {
 					try {
@@ -70975,28 +71548,42 @@ function apply(ctx, config) {
 							const commandPlaneLine = commandPlaneOwnsLine();
 							planeAdvertised = commandPlaneLine && wasAdvertisedAtSubmit;
 							const tuiOwnedCommand = parsedAtSubmit !== void 0 && (LOCAL_COMMANDS.has(parsedAtSubmit.name) || isSkillWrapperName?.(parsedAtSubmit.name) === true);
-							return withCommandDelivery(delivery, () => {
-								if (!commandPlaneLine || parsedAtSubmit === void 0) return Promise.resolve({
-									kind: "committed",
-									matched: false
-								});
-								if (tuiOwnedCommand) return commands.execute(agent, toggled, submittedAttachments, signal).then((execution) => {
-									return execution === void 0 ? {
+							commandExecutionDepth += 1;
+							let settled;
+							try {
+								settled = Promise.resolve(withCommandDelivery(delivery, () => {
+									if (!commandPlaneLine || parsedAtSubmit === void 0) return Promise.resolve({
 										kind: "committed",
 										matched: false
-									} : {
-										kind: "committed",
-										matched: true,
-										execution
-									};
-								});
-								return operationBarrier.runWriter(agent.session.id, () => backend.hostCommand.execute({
-									sessionId: agent.session.id,
-									line: toggled,
-									attachments: submittedAttachments,
-									signal
+									});
+									if (tuiOwnedCommand) return commands.execute(agent, toggled, submittedAttachments, signal).then((execution) => {
+										return execution === void 0 ? {
+											kind: "committed",
+											matched: false
+										} : {
+											kind: "committed",
+											matched: true,
+											execution
+										};
+									});
+									return operationBarrier.runWriter(agent.session.id, () => backend.hostCommand.execute({
+										sessionId: agent.session.id,
+										line: toggled,
+										attachments: submittedAttachments,
+										signal
+									}));
 								}));
-							});
+							} catch (error) {
+								commandExecutionDepth -= 1;
+								throw error;
+							}
+							settled = settled.finally(settleCommandExecution);
+							pendingSettlementWork.add(settled);
+							const untrackSettlement = () => {
+								pendingSettlementWork.delete(settled);
+							};
+							observeSettled(settled, untrackSettlement);
+							return settled;
 						}, {
 							diag,
 							sessionId: () => agent.session.id,
@@ -71056,95 +71643,106 @@ function apply(ctx, config) {
 									if (sessionUnchanged({
 										agent,
 										generation
-									}, liveAgent, sessionGeneration)) runOwned("image submit", () => runReservedSubmit({
-										reserve: () => fallbackPin,
-										run: async () => {
-											try {
-												await operationBarrier.runWriter(agent.session.id, async () => {
-													if (!localEchoInstalled) {
-														beginLocalSubmission(submitRequestId, text, submissionPlacement("queue", agent.status === "running"), agent.session.id, generation, submitAckToken);
-														localEchoInstalled = true;
-													}
-													const message = await prepareUserMessage(text, draftImages, submitDeps, { requestId: submitRequestId });
-													if (cleanedUp) return;
-													if (!sessionUnchanged({
-														agent,
-														generation
-													}, liveAgent, sessionGeneration)) {
-														const merged = mergeDraft(app.getDraft(), text);
-														app.setEditorText(merged);
-														settleLocalSubmission(submitRequestId);
-														settleLocalSubmitAck("submit stale", {
-															token: submitAckToken,
-															terminal: true
-														});
-														app.notify(merged === text ? "the session changed while sending — try again" : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
-														return;
-													}
-													submitLatencyTracker.mark(agent.session.id, "dispatch");
-													const outcome = await backend.sessionWriter.prompt(agent.session.id, message, "queue");
-													if (cleanedUp) return;
-													if (outcome.kind !== "committed") {
-														if (outcome.kind === "indeterminate") {
+									}, liveAgent, sessionGeneration)) {
+										let nestedSettlement;
+										runOwned("image submit", () => {
+											const task = runReservedSubmit({
+												reserve: () => fallbackPin,
+												run: async () => {
+													try {
+														await operationBarrier.runWriter(agent.session.id, async () => {
+															if (!localEchoInstalled) {
+																beginLocalSubmission(submitRequestId, text, submissionPlacement("queue", agent.status === "running"), agent.session.id, generation, submitAckToken);
+																localEchoInstalled = true;
+															}
+															const message = await prepareUserMessage(text, draftImages, submitDeps, { requestId: submitRequestId });
+															if (cleanedUp) return;
+															if (!sessionUnchanged({
+																agent,
+																generation
+															}, liveAgent, sessionGeneration)) {
+																const merged = mergeDraft(app.getDraft(), text);
+																app.setEditorText(merged);
+																settleLocalSubmission(submitRequestId);
+																settleLocalSubmitAck("submit stale", {
+																	token: submitAckToken,
+																	terminal: true
+																});
+																app.notify(merged === text ? "the session changed while sending — try again" : "the draft changed while sending — review it before submitting again (the earlier text was preserved below)", "error");
+																return;
+															}
+															submitLatencyTracker.mark(agent.session.id, "dispatch");
+															const outcome = await backend.sessionWriter.prompt(agent.session.id, message, "queue");
 															if (cleanedUp) return;
+															if (outcome.kind !== "committed") {
+																if (outcome.kind === "indeterminate") {
+																	if (cleanedUp) return;
+																	settleLocalSubmission(submitRequestId);
+																	settleLocalSubmitAck("session write result indeterminate", {
+																		token: submitAckToken,
+																		terminal: true
+																	});
+																	app.notify("session write result is indeterminate — do not retry automatically", "error");
+																	return;
+																}
+																if (outcome.kind === "cancelled") throw cancellationError("session write cancelled");
+																const failure = outcome.kind === "rejected" ? outcome.error.message : outcome.reason;
+																throw new Error(failure);
+															}
+															consumeDraftAttachments(text, draftImages, draftFiles);
+														});
+													} catch (error) {
+														if (cleanedUp) {
+															fallbackPin();
+															return;
+														}
+														if (error instanceof TransitionInProgressError) {
+															fallbackPin();
 															settleLocalSubmission(submitRequestId);
-															settleLocalSubmitAck("session write result indeterminate", {
+															refuseByTransitionFence(text, () => app.getDraft(), (t) => app.setEditorText(t), (m, k) => app.notify(m, k));
+															settleLocalSubmitAck("submit refused by transition fence", {
 																token: submitAckToken,
 																terminal: true
 															});
-															app.notify("session write result is indeterminate — do not retry automatically", "error");
 															return;
 														}
-														if (outcome.kind === "cancelled") throw cancellationError("session write cancelled");
-														const failure = outcome.kind === "rejected" ? outcome.error.message : outcome.reason;
-														throw new Error(failure);
+														throw error;
 													}
-													consumeDraftAttachments(text, draftImages, draftFiles);
+												},
+												restore: (t) => restoreSubmissionDraft(t)
+											}, text);
+											nestedSettlement = task;
+											const untrackNested = () => {
+												if (nestedSettlement !== void 0) pendingSettlementWork.delete(nestedSettlement);
+											};
+											observeSettled(task, untrackNested);
+											return task;
+										}, {
+											diag,
+											sessionId: () => agent.session.id,
+											onResult: () => {
+												submitTurn.release();
+											},
+											onError: (error) => {
+												submitTurn.release();
+												settleLocalSubmission(submitRequestId);
+												settleLocalSubmitAck("failure", {
+													token: submitAckToken,
+													terminal: true
+												});
+												notifySubmissionFailure(error);
+											},
+											onCancel: () => {
+												submitTurn.release();
+												settleLocalSubmission(submitRequestId);
+												settleLocalSubmitAck("submit cancelled", {
+													token: submitAckToken,
+													terminal: true
 												});
-											} catch (error) {
-												if (cleanedUp) {
-													fallbackPin();
-													return;
-												}
-												if (error instanceof TransitionInProgressError) {
-													fallbackPin();
-													settleLocalSubmission(submitRequestId);
-													refuseByTransitionFence(text, () => app.getDraft(), (t) => app.setEditorText(t), (m, k) => app.notify(m, k));
-													settleLocalSubmitAck("submit refused by transition fence", {
-														token: submitAckToken,
-														terminal: true
-													});
-													return;
-												}
-												throw error;
 											}
-										},
-										restore: (t) => restoreSubmissionDraft(t)
-									}, text), {
-										diag,
-										sessionId: () => agent.session.id,
-										onResult: () => {
-											submitTurn.release();
-										},
-										onError: (error) => {
-											submitTurn.release();
-											settleLocalSubmission(submitRequestId);
-											settleLocalSubmitAck("failure", {
-												token: submitAckToken,
-												terminal: true
-											});
-											notifySubmissionFailure(error);
-										},
-										onCancel: () => {
-											submitTurn.release();
-											settleLocalSubmission(submitRequestId);
-											settleLocalSubmitAck("submit cancelled", {
-												token: submitAckToken,
-												terminal: true
-											});
-										}
-									});
-									else {
+										});
+										if (nestedSettlement !== void 0) pendingSettlementWork.add(nestedSettlement);
+									} else {
 										fallbackPin();
 										submitTurn.release();
 										const merged = mergeDraft(app.getDraft(), text);
@@ -73259,7 +73857,7 @@ function apply(ctx, config) {
 					lifecycleController.signal.throwIfAborted();
 					return requireCreated(await backend.sessionLifecycle.create({
 						sessionId: String(sessionId),
-						meta: { cwd: process.cwd() },
+						cwd: process.cwd(),
 						agentPreset: composition.agentPreset,
 						signal: lifecycleController.signal
 					}));
@@ -73425,9 +74023,9 @@ function apply(ctx, config) {
 		/**
 		* The conversation rewind picker (the ONE entry shared by the idle
 		* empty-editor double-Esc and `/rewind` — plan §22). Lists the completed
-		* user turns of the live session; a selection commits through
-		* `commitRewind` (create → commit → prompt restore) as an OWNED task with
-		* the stale-generation gates. Sessionless (deferred start) it notifies
+		* user turns of the live session; a selection dispatches the semantic Host fork with the candidate's predecessor boundary
+		* as an OWNED task with
+		* the navigation identity gates. Sessionless (deferred start) it notifies
 		* and never creates a session.
 		*/
 		function openRewindPicker() {
@@ -73446,51 +74044,31 @@ function apply(ctx, config) {
 				return;
 			}
 			const sourceId = source.session.id;
-			const sourceGeneration = sessionGeneration;
-			const sourceSelection = selected.current;
-			const commitHost = {
-				sessionCwd: () => sessionCwd(),
-				sessionPreset: (session) => session.id === sourceId ? currentPreset() : sessionPresetOf(ctx, session),
-				compose,
-				agents: lifecycleAgents,
-				liveIdentity: () => ({
-					sessionId: liveAgent?.session.id,
-					generation: sessionGeneration
-				}),
-				transitionTo: (steps) => transitionTo(steps),
-				replaceDraft: (text) => app.setDraft(text)
+			const pickerIdentity = {
+				sessionId: sourceId,
+				generation: sessionGeneration,
+				navigationEpoch
 			};
 			app.openPicker(candidates.map(rewindPickerItem), (value) => {
 				const candidate = candidates.find((item) => String(item.turnStartSeq) === value);
 				if (candidate === void 0) return;
-				runOwned("conversation rewind", () => {
-					return transitionGate.run(() => operationBarrier.runTransition(async () => {
-						try {
-							return await commitRewind(commitHost, source, candidate, {
-								sessionId: sourceId,
-								generation: sourceGeneration
-							}, sourceSelection);
-						} finally {
-							settlePendingQueueRecalls(false);
-						}
-					}));
-				}, {
+				let adopted = false;
+				runOwned("conversation rewind", () => forkSession(sourceId, candidate.forkAtSeq, () => {
+					adopted = true;
+					app.setDraft(candidate.editorText);
+				}, pickerIdentity), {
 					diag,
 					sessionId: () => sourceId,
 					onResult: (outcome) => {
-						if (outcome.kind === "superseded") return;
-						if (outcome.kind === "stale") {
-							app.notify("session changed — rewind cancelled", "info");
+						if (outcome.kind === "success" && adopted) {
+							if (candidate.hasNonTextContent) app.notify(`rewound to turn ${candidate.turn}; original non-text content was not re-staged — review it before sending`, "error");
+							else app.notify(`rewound to turn ${candidate.turn}`, "info");
 							return;
 						}
-						if (outcome.kind === "failed") {
-							app.notify(outcome.message, "error");
-							return;
+						if (outcome.kind === "error") {
+							if (outcome.text === "the session changed before fork dispatch") app.notify("session changed — rewind cancelled", "info");
+							else app.notify(outcome.text, "error");
 						}
-						draftImages.clearUnpinned();
-						draftFiles.clearUnpinned();
-						if (outcome.hasNonTextContent) app.notify(`rewound to turn ${outcome.turn}; original non-text content was not re-staged — review it before sending`, "error");
-						else app.notify(`rewound to turn ${outcome.turn}`, "info");
 					},
 					onError: (error) => {
 						app.notify(safeErrorMessage$1(error), "error");
@@ -73603,6 +74181,7 @@ function apply(ctx, config) {
 				}) : refresh(request);
 			},
 			switchSession,
+			forkSession,
 			transitionTo,
 			currentPreset,
 			sessionBlank,
@@ -73968,4 +74547,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { shouldConsumeAdvertisedMiss as A, name$1 as B, normalizeSkillInvocation as C, resumeCommand as D, resolveSubmitDelivery as E, viewerActionCapability as F, API_VERSION as H, dshVersion as I, forkSeed as L, subagentJobViewHint as M, taskRowSelectionDisposition as N, runningProfile as O, teardownViewerForSessionSwap as P, apply$1 as R, name as S, resolveInitialCatalog as T, describeKey as U, PI_TUI_EXTENSIONS_SERVICE as V, interruptAgent as _, apply as a, isPlainExitPrompt as b, commandRejectsImages as c, contextRefreshKind as d, createViewerOpenToken as f, inject as g, foldQueueRows as h, SESSIONLESS_COMMANDS as i, subagentJobTranscriptId as j, settleCompactionSurface as k, compactingFromLog as l, foldCompactionEvent as m, HOST_COMMAND_CATALOG as n, busyAfterTurnBoundary as o, dangerCommand as p, LOCAL_COMMANDS as r, commandIsLocalForAttachments as s, Config as t, composeAgent as u, isBareCommandLine as v, recordedPreset as w, matchPendingSubagentCall as x, isLocalCommandLine as y, inject$1 as z };
+export { shouldConsumeAdvertisedMiss as A, PI_TUI_EXTENSIONS_SERVICE as B, normalizeSkillInvocation as C, resumeCommand as D, resolveSubmitDelivery as E, viewerActionCapability as F, describeKey as H, dshVersion as I, apply$1 as L, subagentJobViewHint as M, taskRowSelectionDisposition as N, runningProfile as O, teardownViewerForSessionSwap as P, inject$1 as R, name as S, resolveInitialCatalog as T, API_VERSION as V, interruptAgent as _, apply as a, isPlainExitPrompt as b, commandRejectsImages as c, contextRefreshKind as d, createViewerOpenToken as f, inject as g, foldQueueRows as h, SESSIONLESS_COMMANDS as i, subagentJobTranscriptId as j, settleCompactionSurface as k, compactingFromLog as l, foldCompactionEvent as m, HOST_COMMAND_CATALOG as n, busyAfterTurnBoundary as o, dangerCommand as p, LOCAL_COMMANDS as r, commandIsLocalForAttachments as s, Config as t, composeAgent as u, isBareCommandLine as v, recordedPreset as w, matchPendingSubagentCall as x, isLocalCommandLine as y, name$1 as z };