@fractalsynapse/dsh-chapters 0.0.0-stage → 0.2.21

package/lib/client.js

@@ -0,0 +1,1419 @@
+window.__ModuleLoader__.load({
+	id: "@fractalsynapse/dsh-chapters",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		// src/client/tooltip.ts
+		/**
+		* The host's Tooltip seat, resolved OPTIONALLY (#194-compat — measured on 0.2.1-rc.5, not guessed):
+		*
+		* `@deepseek-ai/dsh-client-ui-primitives` exists in the 0.2.0-rc.2 host tree and is ABSENT from the
+		* entire 0.2.1-rc.5 install tree — no successor package exports `Tooltip`. Our bundle's static
+		* import becomes a LAZY require in the built CJS: the bundle loads and components run, but the
+		* first render that touches `Tooltip` throws, and React's error boundary swallows the subtree
+		* silently. Measured symptoms on 0.2.1: door registration fully healthy (inject returned a
+		* disposer; the factory ran; both register effects are functions) yet the assistant-actions region
+		* renders ZERO entries, and the dock renders no row — because both wrap their buttons in Tooltip.
+		*
+		* The fix keeps one resolution point and one fallback (#59 — never per-component try/catch):
+		* probe the module once; when it is absent, buttons carry the platform's own `title` tooltip, so
+		* hover text survives on every host and the fancy tooltip survives where it exists.
+		*/
+		/**
+		* The tooltip recipe, field for field the goal bar's own (GoalBar.tsx:101-142: `portal`,
+		* `side="bottom"`, `delayMs={500}`) — the shipped occupant of the same dock strip, whose tooltips
+		* are NOT covered by the composer. `portal` is the load-bearing one: it renders the popup at
+		* document level instead of inside our dock's stacking context, which is exactly the maintainer's
+		* report (#210: "the hoverover tooltips are covered by the main chat input container"). Our old
+		* compile-time types rejected portal/delayMs at the overload; the runtime host always accepted
+		* them, and since the seat is typed by us, the recipe is pinned by a row instead of by luck.
+		*/
+		function tooltipPropsFor(label) {
+			return {
+				label,
+				side: "bottom",
+				portal: true,
+				delayMs: 500
+			};
+		}
+		let resolved;
+		function resolveTooltip() {
+			if (resolved !== void 0) return resolved;
+			resolved = null;
+			try {
+				if (typeof require === "function") {
+					const T = require("@deepseek-ai/dsh-client-ui-primitives")?.Tooltip;
+					if (typeof T === "function" || typeof T === "object") resolved = T;
+				}
+			} catch {
+				resolved = null;
+			}
+			return resolved;
+		}
+		/** Wrap in the host Tooltip when it exists; otherwise return the child (which must carry `title`). */
+		function withTooltip(label, child) {
+			const T = resolveTooltip();
+			return T !== null ? (0, react.createElement)(T, {
+				...tooltipPropsFor(label),
+				children: child
+			}) : child;
+		}
+		/** The native-tooltip attribute, present ONLY when the host seat is absent — no double tooltips. */
+		function nativeTitle(label) {
+			return resolveTooltip() === null ? { title: label } : {};
+		}
+		// src/prompt-keys.ts
+		/**
+		* Identifiers shared by BOTH planes of the push transport (#194). One module, one spelling: the
+		* server registers the projection under this key and the client reads `useProjection(key)` — two
+		* literals in two planes would be exactly the drift #59 forbids. No node imports (the client
+		* compiles this), no DOM (the server imports this).
+		*/
+		const PROMPT_PROJECTION_KEY = "chaptersPrompt";
+		// src/client/prompt-bar.ts
+		function initialBarState(autorun = "disarmed") {
+			return {
+				status: "off",
+				text: null,
+				turnSeq: null,
+				error: null,
+				note: "",
+				intent: "worker-step",
+				goalPhase: "none",
+				goal: null,
+				autorun,
+				expanded: false,
+				running: false,
+				hiddenTurnSeq: null
+			};
+		}
+		function promptBarReducer(state, ev) {
+			if (ev.t === "note") return {
+				...state,
+				note: ev.note
+			};
+			const next = baseBarReducer(state, ev);
+			return ev.t === "polled" && (next.turnSeq !== state.turnSeq || next.text !== state.text) ? {
+				...next,
+				note: ""
+			} : next;
+		}
+		function baseBarReducer(state, ev) {
+			switch (ev.t) {
+				case "polled":
+					if (ev.status === "off") return {
+						...state,
+						status: "off",
+						text: null,
+						turnSeq: null,
+						error: null,
+						expanded: false,
+						autorun: "disarmed"
+					};
+					if (ev.status === "analyzing") return {
+						...state,
+						status: "analyzing",
+						text: null,
+						error: null
+					};
+					return {
+						...state,
+						status: ev.status,
+						text: ev.status === "ready" ? ev.text ?? null : null,
+						intent: ev.status === "ready" ? ev.intent ?? "worker-step" : "worker-step",
+						turnSeq: ev.turnSeq ?? state.turnSeq,
+						error: ev.status === "failed" ? ev.error ?? "the suggestion call failed" : null
+					};
+				case "expand": return {
+					...state,
+					expanded: true
+				};
+				case "collapse": return {
+					...state,
+					expanded: false
+				};
+				case "autorun": return {
+					...state,
+					autorun: ev.on ? "armed" : "disarmed"
+				};
+				case "running": return {
+					...state,
+					running: ev.running
+				};
+				case "human/prompt": return {
+					...state,
+					autorun: "disarmed",
+					hiddenTurnSeq: state.turnSeq,
+					expanded: false
+				};
+				case "off": return {
+					...state,
+					status: "off",
+					text: null,
+					turnSeq: null,
+					error: null,
+					expanded: false,
+					autorun: "disarmed"
+				};
+				case "goal": return {
+					...state,
+					goalPhase: ev.phase,
+					autorun: ev.phase === "complete" || ev.phase === "blocked" ? "disarmed" : state.autorun
+				};
+			}
+			return state;
+		}
+		/** The status label. `failed` keeps the ready label so the error span is the delta, not a mystery row. */
+		function barLabel(s) {
+			if (s.status === "analyzing") return "Analyzing situation…";
+			if (s.status === "ready" || s.status === "failed") return "Recommended Next Step";
+			return null;
+		}
+		/**
+		* #193: the pull cadence, as a decision instead of an interval constant. Every pull is two recorded
+		* host lifecycle events (`command/run` + `command/done`) the UI renders as history nodes — cadence
+		* IS the litter, so it belongs in this module with a row for every arm. Active = the state can
+		* plausibly change on a short clock (generation in flight, an armed loop to fire, a turn running
+		* that will end into an offer). Quiet = stable; one pull a minute is plenty for a state that only
+		* changes at turn boundaries. Hidden-and-quiet = pull NOTHING (a background tab should write zero
+		* history); hidden-and-active still pulls, because walking away from a running loop is the point of
+		* autorun and pausing it silently would be the loop dying with nobody told.
+		*/
+		const ACTIVE_POLL_MS = 1e4;
+		/**
+		* #229: the quiet heartbeat is CONFIG-GATED (`promptQuietHeartbeatSec`) and defaults to ZERO.
+		* Measured on the maintainer's live log after 0.2.11 installed correctly (gaps exactly 60.0s): every
+		* pull is two durable nodes — a host `command/run` + `command/done` pair — and the user's rule is
+		* absolute: never repeated chapters-prompt executions. The sanctioned moments (mount discovery once
+		* per page load, the turn-end pulse, visibility return with an untrusted cache, forced confirms)
+		* remain; the ambient drumbeat does not exist unless configured. This module is client-safe (no node
+		* builtins), so the wiring injects the config value at boot via `configureQuietHeartbeat`.
+		*/
+		let QUIET_POLL_MS = 0;
+		function configureQuietHeartbeat(seconds) {
+			QUIET_POLL_MS = typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0 ? Math.trunc(seconds * 1e3) : 0;
+		}
+		function pollSpacingFor(s) {
+			if (s.turnEndPulse === true) return ACTIVE_POLL_MS;
+			if (s.edges) {
+				if (s.status === "analyzing" || s.autorun === "armed") return ACTIVE_POLL_MS;
+				return null;
+			}
+			const active = s.status === "analyzing" || s.autorun === "armed";
+			if (!active && s.hidden) return null;
+			if (!active) return QUIET_POLL_MS > 0 ? QUIET_POLL_MS : null;
+			return ACTIVE_POLL_MS;
+		}
+		/**
+		* #203: whether a freshly mounted bar pulls, or renders its cache and stays silent. The maintainer's
+		* rule: generate or read AFTER THE TURN ENDS, never when you activate a session. So a mount pulls
+		* only when the cache cannot be trusted — absent (first mount after a page load), stale (a turn
+		* could have ended since; this guarded pull is what keeps Run honest, because clicking a stale
+		* offer would submit the row's newer text while showing the old), mid-generation, or armed. A
+		* cached `off` never pulls: off is a human/config switch, and only an explicit `on` revisits it.
+		*/
+		function mountPullDecision(c) {
+			if (!c.hasCache) return true;
+			if (c.status === "off") return false;
+			if (c.autorun === "armed" || c.status === "analyzing") return true;
+			return QUIET_POLL_MS > 0 && c.ageMs > QUIET_POLL_MS;
+		}
+		/**
+		* #203: fold a cached wire event back into row state through the SAME reducer the live path uses —
+		* one fold, no second implementation to drift (the #59 rule).
+		*/
+		function stateFromCache(ev, autorun) {
+			const folded = promptBarReducer(initialBarState(), ev);
+			return autorun === null ? folded : promptBarReducer(folded, {
+				t: "autorun",
+				on: autorun === "armed"
+			});
+		}
+		function barVisible(s) {
+			if (s.status === "off") return false;
+			if (s.status === "ready" && (s.text === null || s.text === "")) return false;
+			if (s.hiddenTurnSeq !== null && s.hiddenTurnSeq === s.turnSeq) return false;
+			return true;
+		}
+		/** May the bar submit its own offer? Armed, present, idle, not dismissed, and still serving a purpose. */
+		function shouldAutoFire(s) {
+			if (s.status !== "ready") return false;
+			if (s.text === null || s.text === "") return false;
+			if (s.intent === "goal-edit") return false;
+			if (s.goal !== null && s.goal.phase === "active" && s.goal.activation === "armed") return false;
+			if (s.autorun !== "armed") return false;
+			if (s.running) return false;
+			if (s.goalPhase === "complete" || s.goalPhase === "blocked") return false;
+			if (s.hiddenTurnSeq !== null && s.hiddenTurnSeq === s.turnSeq) return false;
+			return true;
+		}
+		/** The command the bar pulls. One string, so the client and the command plane cannot drift silently. */
+		const BAR_STATE_COMMAND = "/chapters-prompt state";
+		/** The bar's Run button: the server submits the on-screen offer as the human's own turn. */
+		const BAR_RUN_COMMAND = "/chapters-prompt run";
+		/**
+		* Parse the `state` verb's `k: v` lines into a pull event.
+		*
+		* One output serving the human and the component is the design (see `docs/contract.md`); this function is
+		* the cost of that choice, and it is kept honest: an unrecognised line is IGNORED, not guessed at, and a
+		* payload that yields no `status` is `null` so the caller keeps its last state rather than inventing `off`
+		* (which would hide a bar that is merely mid-reply). Indentation and the prompt's own lines are the reason
+		* the prompt is collected separately from the scalar fields — it is the only multi-line value.
+		*/
+		function parseBarState(text) {
+			const lines = text.split("\n");
+			const head = lines[0] ?? "";
+			const statusWord = head.startsWith("suggested next step:") ? head.slice(20).trim() : "";
+			const status = statusWord === "off" ? "off" : statusWord === "idle" ? "idle" : statusWord === "analyzing" ? "analyzing" : statusWord === "ready" ? "ready" : statusWord === "failed" ? "failed" : null;
+			if (status === null) return null;
+			const scalars = {};
+			const prompt = [];
+			let inPrompt = false;
+			for (const line of lines.slice(1)) {
+				if (inPrompt) {
+					prompt.push(line.replace(/^ {4}/, ""));
+					continue;
+				}
+				const m = /^ {2}([a-z]+): ?(.*)$/.exec(line);
+				if (m === null) continue;
+				const key = m[1], value = m[2].trim();
+				if (key === "prompt") {
+					inPrompt = true;
+					continue;
+				}
+				scalars[key] !== void 0 ? scalars[key] += ` ${value}` : scalars[key] = value;
+			}
+			configureQuietHeartbeat(Number.parseInt((scalars["heartbeat"] ?? "").trim(), 10) || 0);
+			const turnRaw = scalars["turn"] ?? "";
+			const turnSeq = /^\d+$/.test(turnRaw) ? Number(turnRaw) : null;
+			const errorRaw = scalars["error"] ?? "";
+			return {
+				t: "polled",
+				intent: ((scalars["intent"] ?? "").split(" ")[0] ?? "") === "goal-edit" ? "goal-edit" : "worker-step",
+				status,
+				...status === "ready" ? {
+					text: prompt.join("\n"),
+					turnSeq
+				} : {},
+				...status === "failed" ? {
+					error: errorRaw,
+					turnSeq
+				} : {}
+			};
+		}
+		/** The autorun flag, read from the same payload — the row is durable, the flag is not. */
+		function parseBarAutorun(text) {
+			const m = /^ {2}autorun: (armed|disarmed)\b/m.exec(text);
+			return m === null ? null : m[1];
+		}
+		/**
+		* Does the host say this session is busy right now?
+		*
+		* The dock's props are HOOKS (`useSessionStatus`, `useChat`, `useInput`, …) — documented in
+		* docs/contract.md § "What a dock component is handed" — so a component that waits for a scalar
+		* `props.running` waits forever, which is precisely why Autorun declared itself unavailable while the host
+		* was publishing the signal one field away. Shapes differ across hosts and versions, so every form is folded
+		* here, in one pure function, with `undefined` (unknown) kept distinct from `false` (idle): the loop refuses
+		* to start a turn on an unknown, and that distinction is the whole safety property.
+		*/
+		function deriveRunning(status) {
+			if (status === void 0 || status === null) return void 0;
+			if (typeof status === "boolean") return status;
+			if (typeof status === "string") {
+				if (/^(running|streaming|busy|active)$/i.test(status)) return true;
+				if (/^(idle|done|stopped|finished|ready|waiting)$/i.test(status)) return false;
+				return;
+			}
+			if (typeof status === "object") {
+				const s = status;
+				if (s.running !== void 0) return typeof s.running === "boolean" ? s.running : void 0;
+				return deriveRunning(s.status ?? s.state ?? s.phase);
+			}
+		}
+		/**
+		* #208: the plane-wide relevance fact, read from the `state` block's own model line. `model: unset`
+		* means the feature does not exist on this plane — one discovery reply carrying it silences EVERY
+		* dock on the page (the pull transport cannot do better than one discovery; the push transport
+		* (#194) removes even that). An unrecognised block is false, never a guess.
+		*/
+		function parseModelAbsent(text) {
+			return /^\s*model:\s*unset\b/m.test(text);
+		}
+		/**
+		* A pushed payload becomes the SAME events the pull path dispatches — one fold, one reducer, no
+		* second implementation to drift (#59). Null when the payload is not ours or not trustworthy: an
+		* unrecognised push is ignored, never guessed at, and the pull schedule underneath keeps running
+		* until a payload this function accepts actually arrives.
+		*/
+		function pushEventsOf(payload) {
+			if (payload === null || payload === void 0 || typeof payload !== "object") return null;
+			const p = payload;
+			if (p.v !== 1 || typeof p.status !== "string") return null;
+			const status = p.status;
+			if (status !== "off" && status !== "idle" && status !== "analyzing" && status !== "ready" && status !== "failed") return null;
+			return {
+				polled: {
+					t: "polled",
+					status,
+					...status === "ready" ? {
+						text: typeof p.text === "string" ? p.text : "",
+						turnSeq: p.turnSeq ?? null,
+						intent: p.intent ?? "worker-step"
+					} : {},
+					...status === "failed" ? { error: p.error ?? "the suggestion call failed" } : {}
+				},
+				autorun: {
+					t: "autorun",
+					on: p.autorun === "armed"
+				}
+			};
+		}
+		/**
+		* The running signal's resolution order (scalar prop → `useSession` snapshot via `deriveRunning` →
+		* unknown) lives in the dock as `props.running ?? deriveRunning(sessionSnapshot)` — ONE expression,
+		* pinned by a source-scan row, folded by the deriveRunning rows that already cover every shape.
+		* A second pure helper for the same decision would be exactly the drift #59 forbids; the draft of
+		* #194 shipped one and this comment is its headstone.
+		*/
+		/** The staleness-confirm's one question: did a push arrive after the edge that scheduled it? */
+		function pushIsFresher(lastPushAt, edgeAt) {
+			return lastPushAt !== null && lastPushAt > edgeAt;
+		}
+		/**
+		* #218: a DEAD-PUSH HEARTBEAT, not a staleness confirm — 20s fired mid-turn before the turn's
+		* record could exist (turns outlast 20s), which was confirm spam wearing a safety hat. 5 minutes:
+		* during normal work a record arrives every turn and the push effect retires the pending timer, so
+		* a healthy push NEVER fires it; only a push silent for a whole 5 minutes pulls once — a frozen
+		* bar is the failure this bounds, and it is worth one node every 5 minutes, not one every 20
+		* seconds.
+		* within moments (the runner writes it BEFORE calling the model). If no push arrived this long
+		* after the edge, the push is presumed dead and ONE confirm pull runs — a silently dead push
+		* degrades to one pull per turn, never to a frozen bar.
+		*/
+		const PUSH_CONFIRM_GRACE_MS = 3e5;
+		/**
+		* #211 — the edge kick's delay, measured on the maintainer's host the hard way: some hosts publish
+		* `running` at STEP granularity (it flickers at every tool call and thinking block), and an
+		* immediate kick per falling edge was a rendered `chapters-prompt` node per tool call — all waste,
+		* because the server row changes ONLY at turn boundaries. So: a falling edge schedules its pull
+		* after the debounce, a rising edge cancels it (step flicker coalesces to zero pulls), and the rate
+		* floor bounds even a host that holds `running` low through long tool calls. A real turn end — a
+		* falling edge with no rising edge after it — pulls exactly once.
+		*/
+		const EDGE_DEBOUNCE_MS = 2e3;
+		const EDGE_FLOOR_MS = 15e3;
+		function edgeKickDelayMs(msSinceLastPull) {
+			return Math.max(EDGE_DEBOUNCE_MS, EDGE_FLOOR_MS - msSinceLastPull);
+		}
+		/**
+		* #221: the turn-end pulse, derived from the host's own turn-boundary projection — no plugin
+		* record API needed, so it works on 0.2.0 hosts (where appendPluginRecord is absent) exactly as
+		* on newer ones. The host maintains a `turnBoundary` projection (the agent loop reads its
+		* lastTurn for its own bookkeeping); reading what the host already folds costs zero writes and
+		* delivers reactively through the same standard useProjection seat as any other projection.
+		* Returns true when a NEW turn ended since the last observation; the dock calls it once per
+		* render and stores the returned stamp back into `seen`.
+		*/
+		function turnEndPulse(lastTurn, seen) {
+			const cur = typeof lastTurn === "number" && Number.isFinite(lastTurn) ? lastTurn : 0;
+			if (cur > seen) return {
+				pulse: true,
+				seen: cur
+			};
+			return {
+				pulse: false,
+				seen
+			};
+		}
+		// src/client/prompt-dock.ts
+		/**
+		* The Suggested Next Step dock row (#113) — thin by design.
+		*
+		* Every decision lives in `prompt-bar.ts` where a row can pin it; this file only moves pixels and bytes
+		* between the host slot and that reducer. That split is the reason it exists: the ghost was rejected for
+		* behaviour that had no home, and "one turn, one offer" cannot be tested in a component.
+		*
+		* Placement is measured, not styled: `conversation.input.dock` is the host's full-width stack rendered
+		* ABOVE the composer card (todo `order: 0`, goal `10`, queue `20`), so `order: 30` puts this row under every
+		* other dock entry and directly above the input — and because it is a docked row rather than an overlay, it
+		* can neither cover the placeholder nor collide with the send buttons. The ghost's ugliest defect was
+		* structural, and the structure fixes it.
+		*
+		* The bar is PUSH-SHAPED, PULL-FED. A registrant can own a reactive observable (`hooks: { x }` → prop
+		* `useX`) — that is how the goal bar gets its `activation` — but a plugin cannot publish a projection, and
+		* the only plugin-reachable call path is `remote.commands.execute`. So the component pulls the `state` verb
+		* on edges it can actually observe. Stated here because the alternative is a reader assuming a subscription
+		* that does not exist.
+		*
+		* @module dsh-chapters/src/client/prompt-dock
+		*/
+		const CSS$1 = [
+			".dsh-chapters_promptDock{box-sizing:border-box;width:calc(100% - 2 * var(--dsh-composer-side-clearance) - 4 * var(--dsh-composer-dock-inset));max-width:calc(var(--dsh-composer-card-max-width) - 4 * var(--dsh-composer-dock-inset));margin:0 auto}",
+			".dsh-chapters_promptBar{isolation:isolate;box-sizing:border-box;width:100%;border-radius:var(--dsw-radius-md);height:36px;box-shadow:var(--dsw-elevation-panel);border:0;align-items:center;gap:10px;padding:4px 5px 4px 12px;display:flex;position:relative}",
+			".dsh-chapters_promptBar::before{z-index:-1;border-radius:inherit;background:var(--dsw-specific-menu);backdrop-filter:var(--dsw-menu-backdrop-filter);content:\"\";pointer-events:none;position:absolute;inset:0}",
+			".dsh-chapters_promptExpanded::before{align-items:flex-start;position:absolute;inset:0}",
+			".dsh-chapters_promptExpanded{height:auto;min-height:36px;padding-top:8px;padding-bottom:8px}",
+			".dsh-chapters_promptGlyph{color:var(--dsw-alias-label-tertiary);flex:none;display:inline-flex}",
+			".dsh-chapters_promptLabel{color:var(--dsw-alias-label-primary);flex:none;font-size:13px;font-weight:500;line-height:24px}",
+			".dsh-chapters_promptText{min-width:0;color:var(--dsw-alias-label-primary-dimmed);font-size:13px;line-height:20px;cursor:pointer;border:0;background:0 0;padding:0;text-align:left;flex:1 1 100%}",
+			".dsh-chapters_promptEllipsis{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;display:block}",
+			".dsh-chapters_promptFull{white-space:pre-wrap;overflow-wrap:break-word;word-break:normal;line-height:20px;font-size:13px;color:var(--dsw-alias-label-primary);display:block;max-height:9rem;overflow-y:auto}",
+			".dsh-chapters_promptError{color:var(--dsw-alias-state-error-primary);font-size:12px;line-height:20px;flex:none;max-width:34%}",
+			".dsh-chapters_promptNote{color:var(--dsw-alias-label-secondary);font-size:12px;line-height:20px;min-width:0}",
+			".dsh-chapters_promptIntent{color:var(--dsw-alias-label-tertiary);font-size:12px;line-height:20px}",
+			".dsh-chapters_promptActions{flex:none;align-items:center;gap:10px;display:flex}",
+			".dsh-chapters_promptBtn{corner-shape:round;width:28px;height:28px;color:var(--dsw-alias-label-tertiary);cursor:pointer;background:0 0;border:none;border-radius:999px;justify-content:center;align-items:center;padding:0;display:inline-flex;font-size:13px}",
+			".dsh-chapters_promptBtn:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary)}",
+			".dsh-chapters_promptBtn:disabled{opacity:.4;cursor:default}"
+		].join("\n");
+		const CSS_ID = "dsh-chapters/prompt-dock.css";
+		const ensureCss = () => {
+			if (typeof document === "undefined") return;
+			if (document.getElementById(CSS_ID) !== null) return;
+			const style = document.createElement("style");
+			style.id = CSS_ID;
+			style.setAttribute("data-plugin-css", CSS_ID);
+			style.textContent = CSS$1;
+			document.head.appendChild(style);
+		};
+		/** The analysis glyph, drawn to the goal icon's metric (16 viewBox, stroke currentColor, width 1).
+		*  A prism-and-arrow: the feature reads the situation and points at the next move. */
+		const Glyph = () => (0, react.createElement)("svg", {
+			viewBox: "0 0 16 16",
+			width: 14,
+			height: 14,
+			fill: "none",
+			"aria-hidden": "true",
+			"stroke-width": "1"
+		}, (0, react.createElement)("path", {
+			d: "M2.5 3.5h11L8 9.5 2.5 3.5Z",
+			stroke: "currentColor"
+		}), (0, react.createElement)("path", {
+			d: "M8 9.5V14",
+			stroke: "currentColor"
+		}), (0, react.createElement)("path", {
+			d: "M6 12l2 2 2-2",
+			stroke: "currentColor"
+		}));
+		/** One action button, labelled through the host tooltip exactly as the goal bar labels its own. */
+		const Action = (props) => {
+			const button = (0, react.createElement)("button", {
+				type: "button",
+				className: "dsh-chapters_promptBtn",
+				"aria-label": props.label,
+				...props.disabled === true ? { disabled: true } : {},
+				...props.title !== void 0 ? { title: props.title } : nativeTitle(props.label),
+				onClick: props.onClick
+			}, props.glyph);
+			return withTooltip(props.label, button);
+		};
+		/** Run is allowed whenever there is an offer; AUTORUN is what the intent and the goal gate. Keeping the
+		* human's own button enabled is deliberate — the point of the protocol is to route a goal edit to a keystroke,
+		* never to disable the human's ability to send it. */
+		/**
+		* The words the collapsed row shows, per state. `idle` and `analyzing` must say something, because an empty
+		* row is indistinguishable from a broken one — the whole reason this feature took a day to read: the bar was
+		* live, enabled, and rendering nothing but whitespace.
+		*/
+		function lineFor(state) {
+			if (state.status === "ready") return state.text ?? "";
+			if (state.status === "analyzing") return "Analyzing the session…";
+			if (state.status === "failed") return state.error !== null && state.error !== "" ? `Cannot recommend: ${state.error}` : "Cannot recommend a next step right now";
+			return "No suggestion yet — I will recommend one after your next turn";
+		}
+		const copyToClipboard = (text) => {
+			try {
+				navigator.clipboard?.writeText(text);
+				return true;
+			} catch {
+				return false;
+			}
+		};
+		const canRunHere = (state) => state.text !== null && state.text !== "";
+		/** How long a state pull may take before we call it failed. Generous on purpose: this is a local RPC that
+		* answers in milliseconds when the session is attachable, and the failure it guards against is a hang. */
+		const PULL_TIMEOUT_MS = 15e3;
+		const stateCache = /* @__PURE__ */ new Map();
+		/**
+		* #251: the memory cache dies with the page, and the maintainer's rule is absolute — a reload must
+		* cost ZERO chapters-prompt commands. Two page loads producing two visible `state` nodes still reads
+		* as "the same shit" from the chair, sanctioned or not. So the last-known truth persists per session
+		* in localStorage (the host's own convention for composer state — `dsh.sessions.current`, persisted
+		* drafts), and activation reads memory first, then storage. A cold tab renders the last offer with
+		* no command at all; turn boundaries refresh it through the pulse/confirm paths that already exist.
+		*/
+		const PERSIST_PREFIX = "dsh.chapters.promptState.";
+		const PERSIST_MAX = 50;
+		const persistKey = (sessionId) => `${PERSIST_PREFIX}${sessionId}`;
+		function readPersisted(sessionId) {
+			try {
+				const raw = window.localStorage.getItem(persistKey(sessionId));
+				if (raw === null) return null;
+				const p = JSON.parse(raw);
+				if (typeof p.at !== "number" || p.ev === null || typeof p.ev !== "object") return null;
+				if (p.ev.t !== "polled") return null;
+				const autorun = p.autorun === "armed" || p.autorun === "disarmed" ? p.autorun : null;
+				return {
+					ev: p.ev,
+					autorun,
+					at: p.at
+				};
+			} catch {
+				return null;
+			}
+		}
+		function writePersisted(sessionId, entry) {
+			try {
+				window.localStorage.setItem(persistKey(sessionId), JSON.stringify(entry));
+				const keys = [];
+				for (let i = 0; i < window.localStorage.length; i++) {
+					const k = window.localStorage.key(i);
+					if (k !== null && k.startsWith(PERSIST_PREFIX)) keys.push(k);
+				}
+				if (keys.length <= PERSIST_MAX) return;
+				const aged = keys.map((k) => {
+					let at = 0;
+					try {
+						at = Number(JSON.parse(window.localStorage.getItem(k) ?? "{}").at ?? 0);
+					} catch {
+						at = 0;
+					}
+					return {
+						k,
+						at
+					};
+				}).sort((x, y) => x.at - y.at);
+				for (const old of aged.slice(0, keys.length - PERSIST_MAX)) window.localStorage.removeItem(old.k);
+			} catch {}
+		}
+		/** Memory first, then disk — one reader so every decision sees the same truth (#59). */
+		function cachedState(sessionId) {
+			if (sessionId === void 0) return void 0;
+			const mem = stateCache.get(sessionId);
+			if (mem !== void 0) return mem;
+			const disk = readPersisted(sessionId);
+			if (disk !== null) {
+				stateCache.set(sessionId, disk);
+				return disk;
+			}
+		}
+		/**
+		* #208: set by the first reply reporting the plane-wide `model: unset` — the feature does not
+		* exist here, so NO dock on this page pulls again for anything: not mounts, not idle edges, not
+		* timers, not visibility. One discovery per page load is the pull transport's floor; a page reload
+		* is the only revival, and the enabling commands say so.
+		*/
+		let featureAbsent = false;
+		/** Retry ceiling for the FIRST pull only, in attempts and spacing. A mount-time race must not be able to
+		* starve the bar forever, and a real `off` answer stops the loop on the first reply either way. */
+		function execWithTimeout(exec, line, ms) {
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					reject(/* @__PURE__ */ new Error(`no answer within ${String(ms)}ms`));
+				}, ms);
+				exec(line).then((text) => {
+					clearTimeout(timer);
+					resolve(text);
+				}, (error) => {
+					clearTimeout(timer);
+					reject(error instanceof Error ? error : new Error(String(error)));
+				});
+			});
+		}
+		function PromptDock(props) {
+			const { sessionId, inputActions, exec } = props;
+			const sessionSnapshot = (props.useSession ?? (() => void 0))((snapshot) => snapshot);
+			const running = props.running ?? deriveRunning(sessionSnapshot);
+			const useProjectionHook = props.useProjection ?? (() => void 0);
+			const pushed = useProjectionHook(PROMPT_PROJECTION_KEY);
+			const turnBoundary = useProjectionHook("turnBoundary");
+			const [state, dispatch] = (0, react.useReducer)(promptBarReducer, initialBarState(), (s) => {
+				const pushEvs = pushEventsOf(pushed);
+				if (pushEvs !== null) return {
+					...promptBarReducer(promptBarReducer(s, pushEvs.polled), pushEvs.autorun),
+					running: running ?? true
+				};
+				const c = cachedState(sessionId);
+				return {
+					...c !== void 0 ? stateFromCache(c.ev, c.autorun) : s,
+					running: running ?? true
+				};
+			});
+			const pulling = (0, react.useRef)(false);
+			const probed = (0, react.useRef)(false);
+			const pulled = (0, react.useRef)(false);
+			const alive = (0, react.useRef)(true);
+			(0, react.useEffect)(() => () => {
+				alive.current = false;
+			}, []);
+			const [busy, setBusy] = (0, react.useState)(false);
+			const kick = (0, react.useRef)(void 0);
+			const lastPullAt = (0, react.useRef)(null);
+			const edgeTimer = (0, react.useRef)(void 0);
+			const pushLiveRef = (0, react.useRef)(false);
+			const seenTurnRef = (0, react.useRef)(0);
+			const lastPushAt = (0, react.useRef)(null);
+			const answered = (0, react.useRef)(false);
+			const replyStatus = (0, react.useRef)("unknown");
+			const stateRef = (0, react.useRef)(initialBarState());
+			stateRef.current = state;
+			const edgesRef = (0, react.useRef)(props.running !== void 0);
+			edgesRef.current = props.running !== void 0;
+			if (!probed.current) {
+				probed.current = true;
+				console.info(`[client:prompt] inputActions keys: ${Object.keys(inputActions ?? {}).join(",") || "NONE"}`);
+			}
+			const refresh = (0, react.useCallback)(async () => {
+				if (exec === void 0 || pulling.current) return;
+				pulling.current = true;
+				lastPullAt.current = Date.now();
+				try {
+					const text = await execWithTimeout(exec, BAR_STATE_COMMAND, PULL_TIMEOUT_MS);
+					try {
+						window.__dshPromptReply = text;
+					} catch {}
+					const ev = parseBarState(text);
+					if (ev !== null) {
+						answered.current = true;
+						replyStatus.current = ev.status ?? replyStatus.current;
+						dispatch(ev);
+					}
+					const autorun = parseBarAutorun(text);
+					if (autorun !== null) dispatch({
+						t: "autorun",
+						on: autorun === "armed"
+					});
+					if (parseModelAbsent(text)) featureAbsent = true;
+					if (ev !== null && sessionId !== void 0) {
+						stateCache.set(sessionId, {
+							ev,
+							autorun: autorun === "armed" || autorun === "disarmed" ? autorun : null,
+							at: Date.now()
+						});
+						writePersisted(sessionId, {
+							ev,
+							autorun: autorun === "armed" || autorun === "disarmed" ? autorun : null,
+							at: Date.now()
+						});
+					}
+				} catch (error) {
+					console.warn(`[client:prompt] pull failed: ${String(error?.message ?? error).slice(0, 180)}`);
+				} finally {
+					pulling.current = false;
+				}
+			}, [exec]);
+			(0, react.useEffect)(() => {
+				const evs = pushEventsOf(pushed);
+				if (evs === null) return;
+				pushLiveRef.current = true;
+				lastPushAt.current = Date.now();
+				dispatch(evs.polled);
+				dispatch(evs.autorun);
+				if (edgeTimer.current !== void 0) {
+					clearTimeout(edgeTimer.current);
+					edgeTimer.current = void 0;
+				}
+			}, [pushed]);
+			(0, react.useEffect)(() => {
+				ensureCss();
+				if (pulled.current) return;
+				pulled.current = true;
+				let timer;
+				const effectiveStatus = () => replyStatus.current === "unknown" ? stateRef.current.status : replyStatus.current;
+				const spacingNow = () => {
+					if (stateRef.current.autorun === "armed") return ACTIVE_POLL_MS;
+					const pe = turnEndPulse(turnBoundary?.lastTurn, seenTurnRef.current);
+					if (pe.pulse) seenTurnRef.current = pe.seen;
+					return pollSpacingFor({
+						status: effectiveStatus(),
+						autorun: stateRef.current.autorun,
+						running: stateRef.current.running,
+						hidden: typeof document !== "undefined" && document.hidden === true,
+						edges: edgesRef.current,
+						turnEndPulse: pe.pulse
+					});
+				};
+				const duePull = () => {
+					const c = cachedState(sessionId);
+					return mountPullDecision({
+						hasCache: c !== void 0,
+						ageMs: c !== void 0 ? Date.now() - c.at : Number.MAX_SAFE_INTEGER,
+						status: effectiveStatus(),
+						autorun: stateRef.current.autorun
+					});
+				};
+				const tick = async (opts) => {
+					if (pushLiveRef.current && opts?.force !== true) return;
+					if (featureAbsent) return;
+					if (effectiveStatus() === "off") {
+						if (!(opts?.mount === true && duePull())) return;
+					}
+					const spacing = spacingNow();
+					const mountDiscovery = opts?.mount === true && duePull();
+					if (opts?.force === true || mountDiscovery || spacing !== null && opts?.mount !== true) await refresh();
+					if (replyStatus.current === "off") return;
+					const next = spacingNow();
+					if (next !== null) timer = setTimeout(() => {
+						tick();
+					}, next);
+				};
+				kick.current = () => {
+					if (timer !== void 0) clearTimeout(timer);
+					tick({ force: true });
+				};
+				const onVisible = () => {
+					if (typeof document !== "undefined" && !document.hidden && duePull()) kick.current?.();
+				};
+				if (typeof document !== "undefined") document.addEventListener("visibilitychange", onVisible);
+				tick({ mount: true });
+				return () => {
+					if (timer !== void 0) clearTimeout(timer);
+					if (edgeTimer.current !== void 0) {
+						clearTimeout(edgeTimer.current);
+						edgeTimer.current = void 0;
+					}
+					kick.current = void 0;
+					if (typeof document !== "undefined") document.removeEventListener("visibilitychange", onVisible);
+				};
+			}, [refresh]);
+			const prevRunning = (0, react.useRef)(running ?? true);
+			(0, react.useEffect)(() => {
+				const next = running ?? true;
+				const prev = prevRunning.current;
+				prevRunning.current = next;
+				dispatch({
+					t: "running",
+					running: next
+				});
+				if (prev && !next) {
+					if (edgeTimer.current !== void 0) clearTimeout(edgeTimer.current);
+					const since = lastPullAt.current === null ? Number.MAX_SAFE_INTEGER : Date.now() - lastPullAt.current;
+					const delay = pushLiveRef.current ? Math.max(PUSH_CONFIRM_GRACE_MS, edgeKickDelayMs(since)) : edgeKickDelayMs(since);
+					const edgeAt = Date.now();
+					edgeTimer.current = setTimeout(() => {
+						edgeTimer.current = void 0;
+						if (pushLiveRef.current && pushIsFresher(lastPushAt.current, edgeAt)) return;
+						kick.current?.();
+					}, delay);
+				} else if (!prev && next) {
+					if (edgeTimer.current !== void 0) {
+						clearTimeout(edgeTimer.current);
+						edgeTimer.current = void 0;
+					}
+				}
+			}, [running]);
+			const run = (0, react.useCallback)(() => {
+				if (state.text === null || state.text === "" || exec === void 0) return;
+				setBusy(true);
+				exec(BAR_RUN_COMMAND).then((out) => {
+					if (!alive.current) return;
+					if (/^cannot run:/i.test(out.trim())) dispatch({
+						t: "polled",
+						status: "failed",
+						text: state.text,
+						error: out.trim().slice(0, 200),
+						turnSeq: state.turnSeq
+					});
+					else dispatch({ t: "collapse" });
+				}).catch((error) => {
+					console.warn(`[client:prompt] run failed: ${String(error?.message ?? error).slice(0, 160)}`);
+				}).finally(() => {
+					if (alive.current) setBusy(false);
+				});
+			}, [
+				exec,
+				state.text,
+				state.turnSeq
+			]);
+			(0, react.useEffect)(() => {
+				if (!shouldAutoFire(state)) return;
+				run();
+			}, [state, run]);
+			const autorunDisabled = running === void 0;
+			if (sessionId === void 0 || !barVisible(state)) return null;
+			const populate = () => {
+				console.info(`[client:prompt] populate expanded=${String(state.expanded)} hasInsertText=${String(typeof inputActions?.insertText)} hasSetDraft=${String(typeof inputActions?.setDraft)} textLen=${String(state.text?.length ?? -1)}`);
+				if (!state.expanded) {
+					dispatch({ t: "expand" });
+					return;
+				}
+				if (state.text === null || state.text === "") return;
+				if (typeof inputActions?.insertText === "function") {
+					try {
+						document.querySelector("[contenteditable=\"true\"][role=\"textbox\"]")?.focus();
+					} catch {}
+					const refuse = (why) => {
+						console.warn(`[client:prompt] click-to-draft refused: ${why}`);
+						const copied = copyToClipboard(state.text ?? "");
+						dispatch({
+							t: "note",
+							note: copied ? "The composer refused this write (" + why.slice(0, 60) + ") — the prompt is COPIED: paste it into the input to edit, or press Run ▶ to send as-is." : "The composer refused this write (" + why.slice(0, 60) + ") — press Run ▶ to send the offer as-is, or copy the text above."
+						});
+					};
+					let wrote = false;
+					try {
+						const span = typeof inputActions.captureInsertion === "function" ? inputActions.captureInsertion() : null;
+						if (span !== null && span !== void 0) wrote = inputActions.insertText(state.text, span) === true;
+					} catch {
+						wrote = false;
+					}
+					if (!wrote && typeof inputActions.setDraft === "function") try {
+						inputActions.setDraft(state.text);
+						wrote = true;
+					} catch {
+						wrote = false;
+					}
+					if (!wrote) {
+						refuse("neither insertText nor setDraft was accepted");
+						return;
+					}
+					const head = state.text.slice(0, 24);
+					setTimeout(() => {
+						try {
+							const dom = (document.querySelector("[contenteditable=\"true\"][role=\"textbox\"]")?.innerText ?? "").includes(head);
+							const stored = Object.entries(localStorage).some(([, v]) => String(v).includes(head));
+							if (!dom && !stored) refuse("the write was accepted but nothing holds the text");
+						} catch {}
+					}, 400);
+					return;
+				}
+				if (typeof inputActions?.setDraft === "function") {
+					inputActions.setDraft(state.text);
+					return;
+				}
+				console.warn("[client:prompt] click-to-draft refused: this host exposes neither insertText nor setDraft");
+			};
+			return (0, react.createElement)("div", {
+				className: "dsh-chapters_promptDock",
+				"data-prompt-bar": "true"
+			}, (0, react.createElement)("div", { className: `dsh-chapters_promptBar${state.expanded ? " dsh-chapters_promptExpanded" : ""}` }, (0, react.createElement)("span", { className: "dsh-chapters_promptGlyph" }, (0, react.createElement)(Glyph)), (0, react.createElement)("span", { className: "dsh-chapters_promptLabel" }, barLabel(state) ?? ""), ...state.intent === "goal-edit" ? [(0, react.createElement)("span", {
+				key: "intent",
+				className: "dsh-chapters_promptIntent",
+				"aria-label": "This step edits the goal"
+			}, "edits the goal · run it yourself")] : [], (0, react.createElement)("button", {
+				type: "button",
+				className: "dsh-chapters_promptText",
+				"aria-label": state.expanded ? "Put this suggested prompt in the input box" : "Show the full suggested prompt",
+				onClick: populate
+			}, state.expanded ? (0, react.createElement)("span", { className: "dsh-chapters_promptFull" }, state.text ?? "") : (0, react.createElement)("span", {
+				className: "dsh-chapters_promptEllipsis",
+				title: state.text ?? void 0
+			}, lineFor(state))), ...state.note === "" ? [] : [(0, react.createElement)("span", {
+				key: "note",
+				className: "dsh-chapters_promptNote",
+				role: "status"
+			}, state.note)], ...state.error === "" ? [] : [(0, react.createElement)("span", {
+				key: "err",
+				className: "dsh-chapters_promptError",
+				role: "alert"
+			}, state.error)], (0, react.createElement)("div", { className: "dsh-chapters_promptActions" }, (0, react.createElement)(Action, {
+				label: "Run the suggested next step",
+				glyph: "▶",
+				onClick: run,
+				disabled: busy,
+				...state.text === null || state.text === "" || !canRunHere(state) ? { disabled: true } : {},
+				...state.intent === "goal-edit" ? { title: "Goal edits need a human turn. Run still works; autorun will never do this one." } : {}
+			}), (0, react.createElement)(Action, {
+				label: state.autorun === "armed" ? "Autorun off" : "Autorun",
+				glyph: state.autorun === "armed" ? "⟳" : "⟲",
+				disabled: autorunDisabled,
+				...autorunDisabled ? { title: "Autorun needs the host to publish an idle signal; this build does not, so nothing would fire safely." } : {},
+				onClick: () => {
+					(async () => {
+						const arm = state.autorun !== "armed";
+						if (exec !== void 0) await exec(`/chapters-prompt autorun ${arm ? "on" : "off"}`);
+						dispatch({
+							t: "autorun",
+							on: arm
+						});
+						if (!pushLiveRef.current) await refresh();
+					})();
+				}
+			}), (0, react.createElement)(Action, {
+				label: "Turn prompt suggestions off for this session",
+				glyph: "✕",
+				onClick: () => {
+					(async () => {
+						if (exec !== void 0) await exec("/chapters-prompt off");
+						dispatch({ t: "off" });
+						if (sessionId !== void 0) {
+							const offEntry = {
+								ev: {
+									t: "polled",
+									status: "off"
+								},
+								autorun: null,
+								at: Date.now()
+							};
+							stateCache.set(sessionId, offEntry);
+							writePersisted(sessionId, offEntry);
+						}
+					})();
+				}
+			}))));
+		}
+		// src/client/doors.ts
+		const DOOR_ACTIONS = [{
+			id: "chapters-fork",
+			order: 30,
+			label: "Fork with chapters",
+			command: "/chapters-fork",
+			noun: "branch",
+			iconPath: "M5 3.25a2.25 2.25 0 1 0-1.5 2.12v5.26a2.25 2.25 0 1 0 1.5 0V9h5a2.25 2.25 0 0 0 2.25-2.25v-1.4a2.25 2.25 0 1 0-1.5 0v1.4A.75.75 0 0 1 10 7.5H5V5.37A2.25 2.25 0 0 0 5 3.25Z"
+		}, {
+			id: "chapters-continue",
+			order: 31,
+			label: "Continue with chapters",
+			command: "/chapters-continue",
+			noun: "continuation",
+			iconPath: "M1 8a.75.75 0 0 1 0-1.5h9.44L7.72 3.28a.75.75 0 1 1 1.06-1.06l3.5 3.5.53.53-.53.53-3.5 3.5a.75.75 0 1 1-1.06-1.06L10.44 9.5H1Zm13-5.25v10.5a.75.75 0 0 1-1.5 0v-10.5a.75.75 0 0 1 1.5 0Z"
+		}];
+		/** Pull the child id out of either door's durable success text — both end in
+		* `… is session ch-…` (src/tools.ts), so this regex is door-agnostic. */
+		/**
+		* Which build of THIS file produced a door note (#77). When the live probe reported a roster
+		* trace of `missing → missing → missing` — meaning adoption should have fired three times — while
+		* showing no adoption outcome at all, the first question stopped being "why did the client refuse"
+		* and became "did the browser run the code I am reading?". A note that names its own build makes
+		* that a glance instead of an archaeology session into symlinked plugin trees.
+		*/
+		const DOOR_BUILD = "2026-10-22T23:55 door-build-stamp";
+		const CHILD_ID = /is session (ch-[\w-]+)/;
+		/** The quoted title the door gave the child, matched by its OWN noun so a
+		* refusal or an unrelated quote cannot pass for it. */
+		const doorTitle = (noun) => new RegExp(`${noun} \\u201C([^\\u201D]+)\\u201D is session`);
+		/**
+		* A refusal reason that can never render as nothing. `String(err.message ?? err)` is `''` for a
+		* host error built with an empty message, and an empty reason disappears from the note — the
+		* reader then concludes "no refusal happened", which is the opposite of the truth (#77).
+		*/
+		function refusalReason(error) {
+			const trimmed = (error instanceof Error ? error.message : String(error)).trim();
+			const named = trimmed === "" ? error instanceof Error && error.name.trim() !== "" ? error.name : "" : trimmed;
+			return (named === "" ? error === null ? "null thrown" : typeof error : named).replace(/\s+/g, " ").slice(0, 90);
+		}
+		/**
+		* Is the child in the client's OWN roster? This is the question that separates two very
+		* different failures, and the door used to report the symptom without it:
+		*  - the client never learned the session exists (roster: missing) → the fix is server-side
+		*    publication, and no amount of clicking `open` will ever work;
+		*  - the client knows it and `open` still did nothing (roster: contains) → a navigation bug.
+		* Measured host 0.2.0-rc.2: the sessions service exposes `projectList`, `refresh`, `retain`,
+		* `handleSessionAdded` — the roster is a projection the client fills from control frames.
+		*/
+		/**
+		* The client's own session ids, or `null` when the store cannot be read. ONE reader for both
+		* the note and the adoption decision, so the door never acts on a verdict it did not report.
+		*/
+		function rosterIds(sessions) {
+			const store = sessions?.list;
+			if (typeof store?.getSnapshot !== "function") return null;
+			const snap = store.getSnapshot();
+			const ids = /* @__PURE__ */ new Set();
+			if (Array.isArray(snap?.ids)) for (const id of snap.ids) ids.add(String(id));
+			else if (snap?.byId !== void 0) for (const k of Object.keys(snap.byId)) ids.add(k);
+			else return null;
+			return ids;
+		}
+		function rosterNote(sessions, child) {
+			try {
+				const ids = rosterIds(sessions);
+				if (ids === null) return ` (roster: ${typeof (sessions?.list)?.getSnapshot !== "function" ? "no list store on the service" : "snapshot unreadable"} — presence of ${child.slice(0, 11)}… is UNKNOWN, not absent)`;
+				if (ids.size === 0) return ` (roster: empty — presence of ${child.slice(0, 11)}… is UNKNOWN, not absent)`;
+				const n = ids.size;
+				return ids.has(child) ? ` (roster: contains ${child.slice(0, 11)}…, ${String(n)} sessions — open() is the failure)` : ` (roster: MISSING, ${String(n)} sessions — the client never catalogued this session)`;
+			} catch {
+				return "";
+			}
+		}
+		/** The service's own method names, as a hint attached to a failure note (never a guess). */
+		function verbsNote(sessions) {
+			try {
+				const svc = sessions;
+				if (svc === null || svc === void 0 || typeof svc !== "object") return " (sessions service: absent)";
+				const found = /* @__PURE__ */ new Set();
+				let node = svc;
+				for (let depth = 0; depth < 6 && node !== null && node !== void 0 && node !== Object.prototype; depth++) {
+					for (const key of Object.getOwnPropertyNames(node)) {
+						if (key === "constructor") continue;
+						try {
+							if (typeof svc[key] === "function") found.add(key);
+						} catch {}
+					}
+					node = Object.getPrototypeOf(node);
+				}
+				const verbs = [...found].sort().slice(0, 24);
+				return verbs.length === 0 ? " (sessions service: no methods on the chain)" : ` (sessions verbs: ${verbs.join(", ")})`;
+			} catch {
+				return " (sessions service: unreadable)";
+			}
+		}
+		function openByService(sessions, sessionId, adopt, nav) {
+			return (async () => {
+				const svc = sessions;
+				if (svc === void 0) return false;
+				const navigate = typeof nav?.openSession === "function" ? (id) => nav.openSession(id) : typeof svc?.open === "function" ? (id) => svc.open(id) : null;
+				if (navigate === null) {
+					adopt?.onStep?.("no-verb");
+					return false;
+				}
+				try {
+					await svc.refresh?.();
+				} catch {}
+				try {
+					svc.projectList?.();
+				} catch {}
+				if (adopt?.needed === true && typeof svc.create === "function") {
+					adopt.onStep?.("enter-create");
+					try {
+						await svc.create({ sessionId });
+						adopt.onStep?.("settle-create");
+						try {
+							svc.projectList?.();
+						} catch {}
+						const after = rosterIds(sessions);
+						adopt.onAfter?.(after === null ? null : after.has(sessionId));
+					} catch (error) {
+						adopt.onStep?.("refuse-create");
+						adopt.onRefused(refusalReason(error));
+					}
+				}
+				if (adopt?.needed === true && typeof svc.using === "function" && rosterIds(sessions)?.has(sessionId) === false) {
+					adopt.onStep?.("enter-using");
+					try {
+						await svc.using(sessionId, { source: "dsh-chapters-door" }, async () => void 0);
+						adopt.onStep?.("settle-using");
+						try {
+							svc.projectList?.();
+						} catch {}
+						const seen = rosterIds(sessions);
+						adopt.onAfter?.(seen === null ? null : seen.has(sessionId));
+					} catch (error) {
+						adopt.onStep?.("refuse-using");
+						adopt.onSubscribeRefused?.(refusalReason(error));
+					}
+				}
+				const started = Date.now();
+				for (;;) try {
+					navigate(sessionId);
+					return true;
+				} catch {
+					if (Date.now() - started > 4e3) return false;
+					await new Promise((r) => setTimeout(r, 250));
+				}
+			})();
+		}
+		/**
+		* Fallback path: expand collapsed groups / show-more buttons, then click the
+		* newest treeitem whose label contains the child title (newest-updated sorts
+		* first, so the first match is the fresh child).
+		*/
+		async function openBranchRow(title, budgetMs = 4e3) {
+			if (typeof document === "undefined") return false;
+			const needle = title.toLowerCase();
+			const tryClick = () => {
+				const hit = Array.from(document.querySelectorAll("[role=\"treeitem\"]")).find((row) => (row.textContent ?? "").toLowerCase().includes(needle));
+				if (hit === void 0) return false;
+				hit.click();
+				return true;
+			};
+			const clickMore = () => {
+				const buttons = Array.from(document.querySelectorAll("button")).filter((b) => /more sessions|ungrouped/i.test(b.textContent ?? "") && b.getAttribute("aria-expanded") !== "true");
+				for (const b of buttons) b.click();
+				return buttons.length;
+			};
+			const started = Date.now();
+			let expansions = 0;
+			while (Date.now() - started < budgetMs) {
+				if (tryClick()) return true;
+				if (expansions < 4 && clickMore() > 0) {
+					expansions += 1;
+					await new Promise((r) => setTimeout(r, 250));
+					continue;
+				}
+				await new Promise((resolve) => setTimeout(resolve, 150));
+			}
+			return tryClick();
+		}
+		function makeDoorRunner(remote, sessions, door, verifySwitched, opts) {
+			return async function run(sessionId, anchorSeq) {
+				try {
+					if (remote.commands?.execute === void 0) return {
+						ok: false,
+						message: "commands remote unavailable"
+					};
+					const line = typeof anchorSeq === "number" && Number.isFinite(anchorSeq) ? `${door.command} ${String(Math.trunc(anchorSeq))}` : door.command;
+					const res = await remote.commands.execute(sessionId, line, []);
+					if (res.ok !== true) return {
+						ok: false,
+						message: (res.error?.message ?? `the ${door.noun} call failed`).slice(0, 90)
+					};
+					const result = res.value?.result;
+					const text = typeof result?.text === "string" ? result.text : "";
+					if (result?.kind !== "success") return {
+						ok: false,
+						message: (text || `the ${door.noun} was refused — see the command result`).slice(0, 90)
+					};
+					const child = CHILD_ID.exec(text)?.[1];
+					if (child === void 0) return {
+						ok: true,
+						message: `${door.noun} created — appearing in the sidebar`
+					};
+					const switchedOnce = async () => {
+						if (verifySwitched === void 0) return true;
+						try {
+							return await verifySwitched(child);
+						} catch {
+							return false;
+						}
+					};
+					const maxAttempts = typeof sessions?.refresh === "function" ? opts?.attempts ?? 3 : 1;
+					let tried = 0;
+					let adoptRefusal = "";
+					let subscribeRefusal = "";
+					const rosterTrace = [];
+					const steps = [];
+					let adoptSaw;
+					for (let i = 0; i < maxAttempts; i++) {
+						tried += 1;
+						const ids = rosterIds(sessions);
+						const needed = ids !== null && !ids.has(child);
+						const svcShape = sessions;
+						rosterTrace.push(`${ids === null ? "unknown" : ids.size === 0 ? "empty" : ids.has(child) ? "has" : "missing"}${typeof svcShape?.create === "function" ? "+c" : "-c"}${typeof svcShape?.using === "function" ? "+u" : "-u"}${typeof svcShape?.open === "function" ? "+o" : "-o"}${typeof opts?.navigator?.openSession === "function" ? "+w" : "-w"}`);
+						if (await openByService(sessions, child, {
+							needed,
+							onRefused: (reason) => {
+								adoptRefusal = reason;
+							},
+							onSubscribeRefused: (reason) => {
+								subscribeRefusal = reason;
+							},
+							onAfter: (seen) => {
+								adoptSaw = seen;
+							},
+							onStep: (step) => {
+								if (!steps.includes(step)) steps.push(step);
+							}
+						}, opts?.navigator) && await switchedOnce()) return {
+							ok: true,
+							message: ""
+						};
+						if (i + 1 < maxAttempts) await new Promise((r) => {
+							setTimeout(r, opts?.attemptPauseMs ?? 300).unref?.();
+						});
+					}
+					const title = doorTitle(door.noun).exec(text)?.[1];
+					if (title !== void 0 && await openBranchRow(title) && await switchedOnce()) return {
+						ok: true,
+						message: ""
+					};
+					return verifySwitched === void 0 ? {
+						ok: true,
+						message: `${door.noun} created — open it in the sidebar`
+					} : {
+						ok: true,
+						message: `${door.noun} created — the app did not switch after ${String(tried)} attempt${tried === 1 ? "" : "s"}; open it from the sidebar [roster per attempt: ${rosterTrace.join(" → ")}] [tried: ${steps.length === 0 ? "none" : steps.includes("no-verb") ? "no open or openSession verb on any injected service" : steps.join(", ")}] (build: ${DOOR_BUILD})${adoptRefusal === "" ? "" : ` (adoption refused: ${adoptRefusal})`}${subscribeRefusal === "" ? "" : ` (subscribe refused: ${subscribeRefusal})`}${adoptSaw === void 0 ? "" : ` (right after adopt: ${adoptSaw ? "contains" : "missing"} ${child.slice(0, 15)})`}${rosterNote(sessions, child)}${verbsNote(sessions)}`
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						message: String(error?.message ?? error).slice(0, 90)
+					};
+				}
+			};
+		}
+		/**
+		* Execute a host command line for one session and return its text, or '' when the command plane is
+		* unavailable. The bar's `state` pull and `off` write ride this, because it is the ONE place the client
+		* talks to the wire: the guard row "there is no second runner body in the client chrome" exists to keep
+		* `index.ts` as registration chrome, and a duplicated `commands.execute` in two files is how a wire
+		* behaviour drifts from its own test (#59's one-predicate rule, applied to the transport).
+		*/
+		async function runCommandText(remote, sessionId, line) {
+			const exec = remote?.commands?.execute;
+			if (exec === void 0) return "";
+			const res = await exec(sessionId, line, []);
+			if (res.ok !== true) return "";
+			return res.value?.result?.text ?? "";
+		}
+		// src/client/index.ts
+		/**
+		* dsh-chapters client entry: the per-message door buttons.
+		*
+		* Registers the two deterministic archive doors into the assistant action row
+		* (`conversation.chat.assistant-actions` — the slot the official feedback
+		* package populates beside copy/branch). Clicking one executes its host
+		* command — `/chapters-fork`, `/chapters-continue` — through `remote.commands`,
+		* the exact wire the composer's input line rides, then SWITCHES the app to the
+		* fresh child:
+		*
+		*   1. `sessions.open(child)` — the client sessions service carries open() on
+		*      its prototype (Playwright-verified against this host; a keys-dump alone
+		*      hid it, which is why an earlier round wrongly gave up on this path);
+		*   2. fallback: click the child's sidebar row after expanding collapsed
+		*      groups (plugin children can render under collapsed 'Ungrouped' heads);
+		*   3. last resort: an inline note — the child is durable either way.
+		*
+		* There is deliberately NO second implementation of door logic here: the
+		* buttons are mouths for the host commands (watermark, segmentation, budget,
+		* titles, refusal-with-numbers all server-side, all tested), and the runner
+		* they share is `src/client/doors.ts` — one body, one row per door. The purity
+		* gate in tsdown.client.config.ts keeps this file cross-plugin-free.
+		*
+		* @module dsh-chapters/src/client
+		*/
+		const inject = [
+			"slots",
+			"remote",
+			"remote.commands",
+			"sessions",
+			"uiWorkspace"
+		];
+		/**
+		* Style parity with the native IconActions row: rules copied verbatim from the
+		* host's MessageIconActions module (`._xzv4MW_action` in dsh-client-ui-chat's
+		* compiled client + the feedback package's :disabled) — same metrics, tokens,
+		* hover. Update this string if the host restyles its action row. Both doors
+		* share these metrics.
+		*
+		* The final rule hides the native branch action IN THE MESSAGE ROW only
+		* (user-approved cosmetic decision, docs/architecture.md): built-in chrome, so
+		* the selector is its accessible label scoped to action-row buttons; both
+		* locale spellings covered. If the host rewords the label the button simply
+		* reappears — fails open, visibly.
+		*/
+		const CSS = [
+			".dsh-chapters_forkAction{width:calc(28px + var(--dsh-content-font-delta,0px));height:calc(28px + var(--dsh-content-font-delta,0px));color:var(--dsw-alias-label-tertiary);cursor:pointer;background:0 0;border:none;border-radius:28px;justify-content:center;align-items:center;padding:6px;display:inline-flex}",
+			".dsh-chapters_forkAction svg{width:calc(15px + var(--dsh-content-font-delta,0px));height:calc(15px + var(--dsh-content-font-delta,0px))}",
+			".dsh-chapters_forkAction:hover{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-secondary)}",
+			".dsh-chapters_forkAction:disabled{cursor:default;opacity:.4}",
+			".dsh-chapters_forkNote{color:var(--dsw-alias-label-tertiary);padding-left:4px;font-size:13px;line-height:20px}",
+			"button[class*=\"_action\"][aria-label=\"Branch into a new conversation\"],button[class*=\"_action\"][aria-label=\"在新对话中分支\"]{display:none !important}"
+		].join("\n");
+		const CSS_TAG_ID = "dsh-chapters/assistant-action.css";
+		function injectStyles() {
+			try {
+				if (typeof document === "undefined" || document.querySelector(`style[data-plugin-css=${JSON.stringify(CSS_TAG_ID)}]`) !== null) return;
+				const tag = document.createElement("style");
+				tag.dataset.plugin = "dsh-chapters";
+				tag.dataset.pluginCss = CSS_TAG_ID;
+				tag.textContent = CSS;
+				document.head.appendChild(tag);
+			} catch {}
+		}
+		/** One component body for every door row; only the label and glyph differ. */
+		function makeDoorAction(door) {
+			return function ChaptersDoorAction({ run }) {
+				const [busy, setBusy] = (0, react.useState)(false);
+				const [note, setNote] = (0, react.useState)(null);
+				const alive = (0, react.useRef)(true);
+				(0, react.useEffect)(() => () => {
+					alive.current = false;
+				}, []);
+				const onClick = (0, react.useCallback)(() => {
+					if (busy) return;
+					setBusy(true);
+					setNote(null);
+					run().then((result) => {
+						if (!alive.current) return;
+						setBusy(false);
+						setNote(result.message === "" ? null : result.message);
+						setTimeout(() => {
+							if (alive.current) setNote(null);
+						}, 8e3);
+					});
+				}, [busy, run]);
+				const button = (0, react.createElement)("button", {
+					type: "button",
+					"aria-label": door.label,
+					...nativeTitle(door.label),
+					disabled: busy,
+					onClick,
+					className: "dsh-chapters_forkAction"
+				}, (0, react.createElement)("svg", {
+					viewBox: "0 0 16 16",
+					width: "15",
+					height: "15",
+					fill: "currentColor",
+					"aria-hidden": "true"
+				}, (0, react.createElement)("path", { d: door.iconPath })));
+				return (0, react.createElement)("span", { style: {
+					display: "inline-flex",
+					alignItems: "center",
+					gap: "4px"
+				} }, withTooltip(door.label, button), note !== null ? (0, react.createElement)("span", { className: "dsh-chapters_forkNote" }, note) : null);
+			};
+		}
+		function apply(ctx) {
+			injectStyles();
+			const slots = ctx.slots;
+			const remote = ctx.get("remote") ?? {};
+			let sessions;
+			try {
+				sessions = ctx.get("sessions");
+			} catch {
+				sessions = void 0;
+			}
+			let uiWorkspace;
+			try {
+				uiWorkspace = ctx.get("uiWorkspace");
+			} catch {
+				uiWorkspace = void 0;
+			}
+			const currentSessionId = () => {
+				try {
+					const raw = window.localStorage.getItem("dsh.sessions.current");
+					if (raw === null) return null;
+					return JSON.parse(raw)?.sessionId ?? null;
+				} catch {
+					return null;
+				}
+			};
+			const rows = DOOR_ACTIONS.map((door) => ({
+				door,
+				run: makeDoorRunner(remote, sessions, door, async (child) => {
+					for (let i = 0; i < 8; i++) {
+						if (currentSessionId() === child) return true;
+						await new Promise((r) => setTimeout(r, 250));
+					}
+					return currentSessionId() === child;
+				}, { ...uiWorkspace !== void 0 ? { navigator: uiWorkspace } : {} }),
+				component: makeDoorAction(door)
+			}));
+			console.info(`[client:chapters] injecting ${String(rows.length)} assistant-actions door(s)`);
+			const disposeDoors = slots.inject("conversation.chat.assistant-actions", () => {
+				const effects = rows.map(({ door, run, component }) => slots.register({
+					name: "conversation.chat.assistant-actions",
+					id: door.id,
+					label: door.label,
+					inject: (sessionId, owner) => ({ run: async () => {
+						let anchor = null;
+						const mid = typeof owner?.messageId === "string" ? owner.messageId : "";
+						if (mid !== "") try {
+							const out = await runCommandText(remote, sessionId, `/chapters-anchor ${mid}`);
+							const n = Number.parseInt(out.trim(), 10);
+							if (Number.isFinite(n) && n > 0) anchor = n;
+						} catch {}
+						return run(sessionId, anchor);
+					} })
+				}, component));
+				console.info(`[client:chapters] door factory ran: ${String(effects.length)} register effect(s), types: ${effects.map((e) => typeof e).join(",")}`);
+				return effects;
+			});
+			console.info(`[client:chapters] assistant-actions inject returned ${typeof disposeDoors}`);
+			slots.inject("conversation.input.dock", () => slots.register({
+				name: "conversation.input.dock",
+				id: "chapters-prompt",
+				order: 30,
+				inject: (sessionId) => ({ exec: (line) => runCommandText(remote, sessionId, line) })
+			}, PromptDock));
+		}
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map