@try-works/dsh-recursive-mode 0.1.2 → 0.1.4

package/lib/client.js

@@ -5,6 +5,27 @@ window.__ModuleLoader__.load({
 		var exports = module.exports;
 		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 		let react = require("react");
+		//#region src/client/contract.ts
+		/**
+		* The client-side preset gate (acceptance #3): the board/strip render ONLY when
+		* the CURRENT session's row reports agentPreset === 'recursive'. A non-recursive
+		* session (or a session whose preset is undefined) shows NOTHING — not an empty
+		* board, not a spinner.
+		*/
+		function isRecursivePreset(sessions) {
+			const snapshot = sessions.list.getSnapshot();
+			const current = snapshot.current;
+			if (current === void 0) return false;
+			return snapshot.byId[current]?.agentPreset === "recursive";
+		}
+		/** The current session's cwd (the client passes it as a fallback hint; the host resolves the root). */
+		function currentSessionCwd(sessions) {
+			const snapshot = sessions.list.getSnapshot();
+			const current = snapshot.current;
+			if (current === void 0) return "";
+			return snapshot.byId[current]?.cwd ?? "";
+		}
+		//#endregion
 		//#region src/client/derive.ts
 		const KANBAN_LANES = [
 			{
@@ -74,17 +95,17 @@ window.__ModuleLoader__.load({
 			"08"
 		];
 		/** Map a group id to its ordinal for stable ordering. */
-		const GROUP_INDEX$1 = new Map(GROUP_ORDER.map((g, i) => [g, i]));
+		const GROUP_INDEX = new Map(GROUP_ORDER.map((g, i) => [g, i]));
 		/** Group id for a phase filename (e.g. '03.5-code-review.md' -> '03.5'); null for non-phase names. */
-		function phaseGroupOf$1(phase) {
+		function phaseGroupOf(phase) {
 			const m = /^(\d{2}(?:\.\d)?)(?:-|$)/.exec(phase);
 			if (m === null) return null;
 			const g = m[1];
-			return GROUP_INDEX$1.has(g) ? g : null;
+			return GROUP_INDEX.has(g) ? g : null;
 		}
 		/** Kanban lane id for a phase filename. */
 		function laneOf(phase) {
-			const g = phaseGroupOf$1(phase);
+			const g = phaseGroupOf(phase);
 			if (g === null) return null;
 			for (const lane of KANBAN_LANES) if (lane.groups.includes(g)) return lane.id;
 			return null;
@@ -97,9 +118,9 @@ window.__ModuleLoader__.load({
 			let best = null;
 			let bestIndex = -1;
 			for (const key of Object.keys(card.phases)) {
-				const g = phaseGroupOf$1(key);
+				const g = phaseGroupOf(key);
 				if (g === null) continue;
-				const idx = GROUP_INDEX$1.get(g) ?? -1;
+				const idx = GROUP_INDEX.get(g) ?? -1;
 				if (idx > bestIndex) {
 					bestIndex = idx;
 					best = g;
@@ -112,12 +133,12 @@ window.__ModuleLoader__.load({
 		function cardFacts(card) {
 			const groups = /* @__PURE__ */ new Set();
 			for (const key of Object.keys(card.phases)) {
-				const g = phaseGroupOf$1(key);
+				const g = phaseGroupOf(key);
 				if (g !== null) groups.add(g);
 			}
 			const lockedGroups = /* @__PURE__ */ new Set();
 			for (const key of Object.keys(card.phases)) {
-				const g = phaseGroupOf$1(key);
+				const g = phaseGroupOf(key);
 				if (g !== null && card.phases[key].status === "LOCKED") lockedGroups.add(g);
 			}
 			const lockedCount = lockedGroups.size;
@@ -131,9 +152,9 @@ window.__ModuleLoader__.load({
 			let currentPhase = null;
 			let currentIdx = -1;
 			for (const key of Object.keys(card.phases)) {
-				const g = phaseGroupOf$1(key);
+				const g = phaseGroupOf(key);
 				if (g === null) continue;
-				const idx = GROUP_INDEX$1.get(g) ?? -1;
+				const idx = GROUP_INDEX.get(g) ?? -1;
 				if (idx > currentIdx) {
 					currentIdx = idx;
 					currentPhase = key;
@@ -141,7 +162,7 @@ window.__ModuleLoader__.load({
 			}
 			const tampered = Object.keys(card.tampers).length > 0;
 			const allMandatoryLocked = MANDATORY_GROUPS.every((g) => {
-				const row = Object.entries(card.phases).find(([key]) => phaseGroupOf$1(key) === g);
+				const row = Object.entries(card.phases).find(([key]) => phaseGroupOf(key) === g);
 				return row !== void 0 && row[1].status === "LOCKED";
 			});
 			const lockValidity = tampered ? "tampered" : allMandatoryLocked ? "locked" : "in-progress";
@@ -173,7 +194,7 @@ window.__ModuleLoader__.load({
 		function expandPhaseRows(card) {
 			const byGroup = /* @__PURE__ */ new Map();
 			for (const [fileName, row] of Object.entries(card.phases)) {
-				const g = phaseGroupOf$1(fileName);
+				const g = phaseGroupOf(fileName);
 				if (g !== null) byGroup.set(g, row);
 			}
 			const rows = [];
@@ -203,10 +224,13 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/board.tsx
 		/**
-		* Board overlay (Phase D R5, §11.8): the kanban view over the 'recursive'
-		* projection. Pure read-only renderer — no filesystem, no run-file scraping.
-		* Cards are grouped by worktree root (the projection's outer key) and mapped
-		* to their current-phase lane via derive.columnForRun.
+		* Board overlay (SP2 R1): the kanban view over the live host-route projection.
+		* Pure read-only renderer — no filesystem, no run-file scraping. Cards are
+		* grouped by worktree root (the projection's outer key) and mapped to their
+		* current-phase lane via derive.columnForRun. Renders NOTHING when the snapshot
+		* is null (no recursive root / not loaded) or the current session is not on the
+		* recursive preset (the gate lives in slots.ts — here an empty projection with
+		* a null root is a no-op, not an "empty board").
 		*/
 		/** Flatten the worktree-grouped projection into a stable run list. */
 		function listRuns(projection) {
@@ -215,8 +239,9 @@ window.__ModuleLoader__.load({
 			for (const worktreeRoot of Object.keys(projection)) for (const runId of Object.keys(projection[worktreeRoot])) runs.push(projection[worktreeRoot][runId]);
 			return runs;
 		}
-		function Board({ useProjection }) {
-			const runs = listRuns(useProjection("recursive"));
+		function Board({ snapshot }) {
+			if (snapshot === null || snapshot.root === null) return null;
+			const runs = listRuns(snapshot.projection);
 			if (runs.length === 0) return (0, react.createElement)("div", {
 				className: "rec-board",
 				"data-empty": true
@@ -244,12 +269,13 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region src/client/strip.tsx
 		/**
-		* Status strip (Phase D R7, §11.6): a thin glance at the active run's phase,
-		* gate state, and tamper badge, docked at conversation.input.dock. Renders
-		* nothing when no run is current.
+		* Status strip (SP2 R1): a thin glance at the active run's phase, gate state,
+		* and tamper badge, docked at conversation.input.dock. Renders NOTHING when no
+		* run is current or the snapshot is null (the preset gate lives in slots.ts).
 		*/
-		function StatusStrip({ useProjection }) {
-			const runs = listRuns(useProjection("recursive"));
+		function StatusStrip({ snapshot }) {
+			if (snapshot === null || snapshot.root === null) return null;
+			const runs = listRuns(snapshot.projection);
 			if (runs.length === 0) return null;
 			const active = runs[runs.length - 1];
 			const facts = cardFacts(active);
@@ -266,17 +292,138 @@ window.__ModuleLoader__.load({
 			return (0, react.createElement)("div", { className: "rec-settings" }, (0, react.createElement)("h2", {}, "Recursive"), (0, react.createElement)("p", {}, "Enforcement policy, scratch format, provider defaults, and preset install path are configured on the host. The client is read-only (§11.9)."), (0, react.createElement)("button", { onClick: close }, "Close"));
 		}
 		//#endregion
+		//#region src/client/host-api.ts
+		/**
+		* Live recursive board/strip feed (SP2 R1): the browser half of the host
+		* HTTP/SSE route. Replaces useProjection('recursive') — the board reads the
+		* FILESYSTEM FOLD served by the host, keyed per-WORKSPACE. The client passes
+		* its sessionId (PRIMARY — the host resolves the cwd from the attached
+		* session header) plus cwd as a fallback hint while hydrating; the host
+		* resolves the recursive root server-side, never trusting a client path.
+		*
+		* READ-ONLY (R9): GET state + GET events only; this module never mutates the
+		* host and never touches the filesystem.
+		*
+		* Mirrors the dsh-web-ui task-board + DSH-better-sidebar host-api pattern:
+		* fetch /state with no-store, EventSource /events with a visibilitychange
+		* re-listener, and an AbortController timeout on the initial fetch.
+		*/
+		const FETCH_TIMEOUT_MS = 15e3;
+		/** Query-string encoder for the two params. */
+		function scopeQuery(scope) {
+			const parts = [];
+			if (scope.sessionId) parts.push("sessionId=" + encodeURIComponent(scope.sessionId));
+			if (scope.cwd) parts.push("cwd=" + encodeURIComponent(scope.cwd));
+			return parts.length === 0 ? "" : "?" + parts.join("&");
+		}
+		/** Fetch the current state for one session scope (host resolves the workspace root). */
+		async function fetchLiveState(scope, signal) {
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+			try {
+				const res = await fetch("/.recursive/api/state" + scopeQuery(scope), {
+					signal: controller.signal,
+					cache: "no-store"
+				});
+				if (!res.ok) throw new Error("recursive live state: HTTP " + res.status);
+				return await res.json();
+			} finally {
+				clearTimeout(timer);
+			}
+		}
+		/**
+		* Subscribe to the SSE events feed. Returns a disposer. The host pushes a full
+		* {revision, root, projection} frame on every fs change + a 15s heartbeat.
+		*
+		* @param scope - sessionId primary + cwd fallback (host resolves the root).
+		* @param onFrame - called per data frame.
+		* @param onError - called when the stream fails/ends (the caller re-subscribes).
+		*/
+		function subscribeLiveEvents(scope, onFrame, onError) {
+			const url = "/.recursive/api/events" + scopeQuery(scope);
+			const es = new EventSource(url);
+			const onMessage = (event) => {
+				try {
+					onFrame(JSON.parse(event.data));
+				} catch {}
+			};
+			es.addEventListener("message", onMessage);
+			es.onerror = () => {
+				es.close();
+				onError?.();
+			};
+			const onVisible = () => {
+				if (document.visibilityState === "visible") {
+					es.close();
+					onError?.();
+				}
+			};
+			document.addEventListener("visibilitychange", onVisible);
+			return () => {
+				document.removeEventListener("visibilitychange", onVisible);
+				es.close();
+			};
+		}
+		//#endregion
+		//#region src/client/use-live.ts
+		/**
+		* useLiveProjection(scope): the client bridge to the live host route (SP2 R1).
+		*
+		* Reads the per-workspace filesystem fold served by the host HTTP/SSE route
+		* instead of the (removed) 'recursive' session projection. The scope carries
+		* sessionId PRIMARY (the host resolves cwd from the attached session header)
+		* plus cwd as a fallback hint. Returns { root, projection, revision } or null
+		* while the first state fetch is in flight. The hook never mutates the host
+		* (R9 read-only).
+		*
+		* If the scope has neither sessionId nor cwd the hook renders nothing — the
+		* caller gates on the recursive preset BEFORE this so a non-recursive session
+		* shows NOTHING (acceptance #3).
+		*/
+		/** Empty scope — nothing to key on. */
+		function isEmpty(scope) {
+			return !scope.sessionId && !scope.cwd;
+		}
+		/**
+		* Subscribe to the live route for one scope. Returns the current state. The SSE
+		* feed pushes full frames on every fs change; a dropped stream (sleep/error)
+		* triggers one refetch so the board never serves a stale fold.
+		*/
+		function useLiveProjection(scope) {
+			const [state, setState] = (0, react.useState)(null);
+			(0, react.useEffect)(() => {
+				if (isEmpty(scope)) return;
+				let disposed = false;
+				const apply = (frame) => {
+					if (!disposed) setState(frame);
+				};
+				fetchLiveState(scope).then(apply).catch(() => {});
+				const disposeEvents = subscribeLiveEvents(scope, apply, () => {
+					if (!disposed) fetchLiveState(scope).then(apply).catch(() => {});
+				});
+				return () => {
+					disposed = true;
+					disposeEvents();
+				};
+			}, [scope.sessionId, scope.cwd]);
+			return state;
+		}
+		//#endregion
 		//#region src/client/slots.ts
 		/**
-		* Slot registrations (Phase D R5/R6/R7/R8, §11.8): the sidebar launcher, the
-		* shell.overlay board, the conversation.input.dock status strip, and the
-		* settings.section page. The details-seat inspector is a swap driven by the
-		* board cards' click (R6); the strip + board + settings are additive seats.
+		* Slot registrations (SP2 R1): the sidebar launcher, the shell.overlay board,
+		* the conversation.input.dock status strip, and the settings.section page.
+		*
+		* The board (root scope) and strip (session scope) render ONLY for the
+		* recursive preset — the gate reads the CURRENT session's agentPreset from the
+		* sessions list snapshot (acceptance #3: a non-recursive session shows NOTHING).
 		*
-		* Self-contained structural seam: the real slot registry + runtime standard
-		* kit arrive from @deepseek-ai/dsh-client-ui-slots + @deepseek-ai/dsh-client-runtime
-		* at compose time; this module consumes the minimal ClientContext shape
-		* (contract.ts). The client is READ-ONLY (R9) — no filesystem, no mutation.
+		* The board reads cwd from the ROOT-scope standard prop useSessions (the
+		* scoped-slots root branch provides ONLY useSessions/useWorkspaces — useProjection
+		* is session-scope-only, which is why the board never reads it). The strip reads
+		* its sessionId from the session-scope standard prop.
+		*
+		* READ-ONLY (R9): the client only GETs the live host route; no mutation.
 		*/
 		function registerSlots(ctx) {
 			const disposers = [];
@@ -294,16 +441,21 @@ window.__ModuleLoader__.load({
 				id: "recursive-board",
 				order: 10
 			}, (props) => {
-				if (props?.useProjection === void 0) return null;
-				return (0, react.createElement)(Board, { useProjection: props.useProjection });
+				const useSessions = props?.useSessions;
+				if (useSessions === void 0) return null;
+				return (0, react.createElement)(RecursiveBoardGate, { useSessions });
 			})));
 			disposers.push(ctx.slots.inject("conversation.input.dock", () => ctx.slots.register({
 				name: "conversation.input.dock",
 				id: "recursive-strip",
 				order: 20
 			}, (props) => {
-				if (props?.useProjection === void 0) return null;
-				return (0, react.createElement)(StatusStrip, { useProjection: props.useProjection });
+				const useSessions = props?.useSessions;
+				if (useSessions === void 0) return null;
+				return (0, react.createElement)(RecursiveStripGate, {
+					useSessions,
+					sessionId: props?.sessionId
+				});
 			})));
 			disposers.push(ctx.slots.inject("settings.section", () => ctx.slots.register({
 				name: "settings.section",
@@ -315,148 +467,63 @@ window.__ModuleLoader__.load({
 				for (const d of disposers) d();
 			};
 		}
-		//#endregion
-		//#region src/client/node.ts
-		const RECURSIVE_NODE_KIND = "recursive/run";
-		const GROUP_INDEX = new Map([
-			"00",
-			"01",
-			"01.5",
-			"02",
-			"03",
-			"03.5",
-			"04",
-			"05",
-			"06",
-			"07",
-			"08"
-		].map((g, i) => [g, i]));
-		function phaseGroupOf(phase) {
-			const m = /^(\d{2}(?:\.\d)?)(?:-|$)/.exec(phase);
-			return m ? m[1] : null;
-		}
-		function currentPhaseOf(phases) {
-			let best = null;
-			let bestIdx = -1;
-			for (const key of Object.keys(phases)) {
-				const g = phaseGroupOf(key);
-				if (g === null) continue;
-				const idx = GROUP_INDEX.get(g) ?? -1;
-				if (idx > bestIdx) {
-					bestIdx = idx;
-					best = key;
-				}
-			}
-			return best;
+		/**
+		* Board gate: renders the board ONLY when the current session is on the
+		* recursive preset. The gate itself reads the live sessions snapshot via the
+		* standard useSessions hook and re-renders on change.
+		*/
+		function RecursiveBoardGate({ useSessions }) {
+			const list = useSessions();
+			const sessions = { list: {
+				getSnapshot: () => list,
+				subscribe: () => () => {}
+			} };
+			if (!isRecursivePreset(sessions)) return null;
+			const cwd = currentSessionCwd(sessions);
+			const snapshot = useLiveProjection({
+				sessionId: list.current,
+				cwd
+			});
+			return (0, react.createElement)(Board, { snapshot });
 		}
-		function nodeDataOf(s) {
-			const lockedCount = Object.values(s.phases).filter((p) => p.status === "LOCKED").length;
-			return {
-				runId: s.runId,
-				worktreeRoot: s.worktreeRoot,
-				state: s.state,
-				currentPhase: currentPhaseOf(s.phases),
-				lockedCount,
-				totalPhases: Object.keys(s.phases).length,
-				tampered: s.tampered,
-				gateBlocked: s.gateBlocked,
-				...s.mergedToRepoRoot === void 0 ? {} : { mergedToRepoRoot: s.mergedToRepoRoot }
-			};
+		/**
+		* Strip gate: same preset gate, session-scoped sessionId; the strip renders
+		* nothing for a non-recursive session.
+		*/
+		function RecursiveStripGate({ useSessions, sessionId }) {
+			const list = useSessions();
+			const sessions = { list: {
+				getSnapshot: () => list,
+				subscribe: () => () => {}
+			} };
+			if (!isRecursivePreset(sessions)) return null;
+			const snapshot = useLiveProjection({
+				sessionId,
+				cwd: currentSessionCwd(sessions)
+			});
+			return (0, react.createElement)(StatusStrip, { snapshot });
 		}
-		/** Extract a stable (runId, worktreeRoot) business id + lifecycle role from one event. */
-		function matchRecursiveNode(event) {
-			if (typeof event.type !== "string" || !event.type.startsWith("recursive/")) return null;
-			const data = event.data ?? {};
-			const runId = typeof data.runId === "string" ? data.runId : "";
-			const worktreeRoot = typeof data.worktreeRoot === "string" ? data.worktreeRoot : "";
-			if (runId === "" || worktreeRoot === "") return null;
-			return {
-				id: worktreeRoot + "\0" + runId,
-				role: event.type === "recursive/run-created" ? "start" : "update"
-			};
+		//#endregion
+		//#region src/client/apply-guard.ts
+		/** Claims the client apply slot. Returns true when this call won the slot. */
+		function claimClientApply() {
+			if (globalThis.__dshRecursiveModeClientApplied === true) return false;
+			globalThis.__dshRecursiveModeClientApplied = true;
+			return true;
 		}
-		/** Fold one recursive/* event into the node state. */
-		function foldRecursiveNode(s, event) {
-			const data = event.data ?? {};
-			const runId = typeof data.runId === "string" ? data.runId : "";
-			const worktreeRoot = typeof data.worktreeRoot === "string" ? data.worktreeRoot : "";
-			const base = s ?? {
-				runId,
-				worktreeRoot,
-				state: "active",
-				phases: {},
-				tampered: false,
-				gateBlocked: false
-			};
-			switch (event.type) {
-				case "recursive/run-created":
-					base.runId = runId;
-					base.worktreeRoot = worktreeRoot;
-					return base;
-				case "recursive/phase": {
-					const phase = String(data.phase ?? "");
-					if (phase !== "") base.phases[phase] = {
-						phase,
-						status: String(data.status ?? "")
-					};
-					return base;
-				}
-				case "recursive/phase-locked": {
-					const phase = String(data.phase ?? "");
-					if (phase !== "") base.phases[phase] = {
-						phase,
-						status: "LOCKED"
-					};
-					return base;
-				}
-				case "recursive/gate-blocked":
-					base.gateBlocked = true;
-					return base;
-				case "recursive/tamper":
-					base.tampered = true;
-					return base;
-				case "recursive/run-state":
-					base.state = typeof data.state === "string" ? data.state : base.state;
-					return base;
-				case "recursive/run-merged": {
-					const repoRoot = typeof data.repoRoot === "string" ? data.repoRoot : "";
-					if (repoRoot !== "") {
-						base.mergedToRepoRoot = repoRoot;
-						base.worktreeRoot = repoRoot;
-					}
-					return base;
-				}
-				default: return base;
-			}
+		/** Releases the claim (called from the client fiber cleanup on unload/hot-reload). */
+		function releaseClientApply() {
+			globalThis.__dshRecursiveModeClientApplied = void 0;
 		}
-		/** The structural ConversationNodeDefinition (host links to the real contract). */
-		const recursiveNodeDefinition = {
-			kind: RECURSIVE_NODE_KIND,
-			target: "chat",
-			match: matchRecursiveNode,
-			start: (_ctx, match) => foldRecursiveNode(void 0, match.event),
-			update: (ctx, match) => foldRecursiveNode(ctx.state, match.event),
-			buildViewNode: (ctx) => {
-				const state = ctx.state;
-				if (state === void 0) return null;
-				return {
-					key: ctx.key,
-					kind: RECURSIVE_NODE_KIND,
-					id: ctx.id,
-					target: "chat",
-					data: nodeDataOf(state)
-				};
-			}
-		};
 		//#endregion
 		//#region src/client/inspector.tsx
 		/**
-		* Drill-down inspector (Phase D R6, §11.5): the details-seat swap rendering
-		* one run's phase chain (with the always-shown 3.5 row + full 6/7/8 rows),
-		* lock badges, and tamper/gate facts — all from the projection, never disk.
+		* Drill-down inspector (SP2 R1): the details-seat swap rendering one run's
+		* phase chain (with the always-shown 3.5 row + full 6/7/8 rows), lock badges,
+		* and tamper/gate facts — all from the live host-route snapshot, never disk.
 		*/
-		function Inspector({ runId, worktreeRoot, useProjection, onBackToToolDetails }) {
-			const card = useProjection("recursive")?.[worktreeRoot]?.[runId];
+		function Inspector({ runId, worktreeRoot, snapshot, onBackToToolDetails }) {
+			const card = snapshot?.projection?.[worktreeRoot]?.[runId];
 			if (card === void 0) return (0, react.createElement)("div", { className: "rec-inspector" }, (0, react.createElement)("p", {}, "Run not found: " + runId));
 			const facts = cardFacts(card);
 			const rows = expandPhaseRows(card);
@@ -470,21 +537,32 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/client/index.ts
-		/** Browser-half plugin entry (R4). */
+		/** Required services (fiber inject waiting — the runtime must be up first). */
+		const inject = [
+			"slots",
+			"sessions",
+			"workspaces",
+			"connection"
+		];
+		/** Browser-half plugin entry (R4 + SP2 R1). */
 		function apply(ctx) {
+			if (!claimClientApply()) return;
+			ctx.effect(() => releaseClientApply, "recursive: client apply claim");
 			registerSlots(ctx);
 		}
 		//#endregion
 		exports.Board = Board;
 		exports.Inspector = Inspector;
-		exports.RECURSIVE_NODE_KIND = RECURSIVE_NODE_KIND;
 		exports.RecursiveSettings = RecursiveSettings;
 		exports.StatusStrip = StatusStrip;
 		exports.apply = apply;
-		exports.foldRecursiveNode = foldRecursiveNode;
+		exports.currentSessionCwd = currentSessionCwd;
+		exports.fetchLiveState = fetchLiveState;
+		exports.inject = inject;
+		exports.isRecursivePreset = isRecursivePreset;
 		exports.listRuns = listRuns;
-		exports.matchRecursiveNode = matchRecursiveNode;
-		exports.recursiveNodeDefinition = recursiveNodeDefinition;
+		exports.subscribeLiveEvents = subscribeLiveEvents;
+		exports.useLiveProjection = useLiveProjection;
 		return module.exports;
 	}
 });

package/lib/index.d.ts

@@ -18,8 +18,8 @@ export * from './delegation.ts';
 export * from './lifecycle.ts';
 export * from './enforcement.ts';
 export * from './policy.ts';
-export * from './events.ts';
-export * from './projection.ts';
+export * from './snapshot.ts';
+export * from './live-route.ts';
 /**
  * Bundle plugin entry. The Loader activates this row once `tools` is available
  * (`inject` below); the RecursiveRuntime service is constructed directly so it
@@ -28,13 +28,13 @@ export * from './projection.ts';
  */
 export declare const inject: string[];
 /**
- * Two-stage init (PROPOSAL §5.10):
- *  - Stage A (mount-time, this apply): register the isolated ctx.recursive
- *    service + the recursive_* tools + the /recursive command + the
- *    recursive:policy prompt section. No repo/run work here.
- *  - Stage B (agent/session-start): resolve the session's workspace root (R1),
- *    bootstrap the scaffold if missing, enumerate runs as dir names only, and
- *    inject a workspace-scoped notice. See stageBWorkflowInit + the
- *    agent/session-start listener below.
+ * Plugin entry (SP2 R1). Stage A (mount-time, this apply): register the
+ * isolated ctx.recursive service + the recursive_* tools + the /recursive
+ * command + the recursive:policy prompt section + the LIVE board/strip route
+ * (HTTP state + SSE), served per-workspace from the filesystem fold. No
+ * repo/run work and NO session-event emission here: zero recursive/* events
+ * are ever appended (resume-crash fix), and the board reads the live fs route.
  */
-export declare function apply(ctx: Context): void;
+export declare function apply(ctx: Context, config?: {
+    shellOnly?: boolean;
+}): void;