@try-works/dsh-recursive-mode 0.2.1 → 0.2.3

package/lib/client/board.d.ts

@@ -9,8 +9,14 @@ export interface BoardProps {
     workspacePath?: string;
     onOpenInspector?: (selection: BoardSelection) => void;
     onClose?: () => void;
+    /**
+     * 'overlay' (default) renders the board as a full-viewport fixed overlay
+     * (shell.overlay / launcher). 'view' renders it inline, filling its parent
+     * (a conversation.view tab), with no close button and no fixed positioning.
+     */
+    variant?: 'overlay' | 'view';
 }
-export declare function Board({ snapshot, workspacePath, onOpenInspector, onClose }: BoardProps): import("react").DetailedReactHTMLElement<{
+export declare function Board({ snapshot, workspacePath, onOpenInspector, onClose, variant }: BoardProps): import("react").DetailedReactHTMLElement<{
     className: string;
     'data-theme': import("./theme.ts").BoardTheme;
 }, HTMLElement> | null;

package/lib/client/index.d.ts

@@ -14,6 +14,7 @@
 import type { ClientContext } from './contract.ts';
 export { Board, listRuns } from './board.tsx';
 export { Inspector } from './inspector.tsx';
+export { RecursiveView } from './slots.ts';
 export { RecursiveSettings } from './settings.tsx';
 export { useLiveProjection } from './use-live.ts';
 export type { LiveProjectionSnapshot } from './use-live.ts';

package/lib/client/slots.d.ts

@@ -41,6 +41,16 @@ export declare function useRecursiveSessions(useSessions: SnapshotSelectorHook<S
 export declare function RecursiveLauncherGate({ useSessions }: {
     useSessions: SnapshotSelectorHook<SessionListStateLike>;
 }): ReactNode;
+/**
+ * RecursiveView: the conversation.view tab body. Renders the run board INLINE
+ * (fills the view area) keyed on the CURRENT workspace, and swaps to the
+ * inspector modal when a run is opened. Read-only (R9): uses the live host
+ * route. No preset gate — the tab is discoverable in any session.
+ */
+export declare function RecursiveView({ useSessions, useWorkspaces }: {
+    useSessions: SnapshotSelectorHook<SessionListStateLike>;
+    useWorkspaces: SnapshotSelectorHook<WorkspaceListStateLike>;
+}): ReactNode;
 export declare function registerSlots(ctx: ClientContext): () => void;
 /**
  * Board overlay: subscribes to the shared board store, gates on open + recursive

package/lib/client.js

@@ -335,8 +335,8 @@ 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 closeButton$1(onClose) {
-			if (onClose === void 0) return null;
+		function closeButton$1(onClose, variant) {
+			if (onClose === void 0 || variant === "view") return null;
 			return (0, react.createElement)("button", {
 				type: "button",
 				className: "rec-close",
@@ -356,7 +356,7 @@ window.__ModuleLoader__.load({
 				"data-pill": kind
 			}, PILL_LABELS[kind]);
 		}
-		function Board({ snapshot, workspacePath, onOpenInspector, onClose }) {
+		function Board({ snapshot, workspacePath, onOpenInspector, onClose, variant = "overlay" }) {
 			const { theme, toggle } = useBoardTheme();
 			if (snapshot === null || snapshot.root === null) return null;
 			const runs = workspacePath !== void 0 && workspacePath !== "" && !sameWorkspacePath(workspacePath, snapshot.root) ? [] : listRuns(snapshot.projection);
@@ -365,21 +365,22 @@ window.__ModuleLoader__.load({
 				worktreeRoot: run.worktreeRoot,
 				runId: run.runId
 			});
+			const rootCls = variant === "view" ? "rec-board rec-board-view" : "rec-board";
 			if (runs.length === 0) return (0, react.createElement)("div", {
-				className: "rec-board",
+				className: rootCls,
 				"data-theme": theme,
 				"data-empty": true
 			}, (0, react.createElement)("header", { className: "rec-board-header" }, (0, react.createElement)("h2", { className: "rec-board-title" }, "Recursive runs"), (0, react.createElement)("span", { className: "rec-board-path" }, headerPath), (0, react.createElement)("span", { className: "rec-board-count" }, "0 runs"), (0, react.createElement)(ThemeToggle, {
 				theme,
 				toggle
-			}), closeButton$1(onClose)), (0, react.createElement)("p", { className: "rec-board-empty" }, "No recursive runs in this workspace yet."));
+			}), closeButton$1(onClose, variant)), (0, react.createElement)("p", { className: "rec-board-empty" }, "No recursive runs in this workspace yet."));
 			return (0, react.createElement)("div", {
-				className: "rec-board",
+				className: rootCls,
 				"data-theme": theme
 			}, (0, react.createElement)("header", { className: "rec-board-header" }, (0, react.createElement)("h2", { className: "rec-board-title" }, "Recursive runs"), (0, react.createElement)("span", { className: "rec-board-path" }, headerPath), (0, react.createElement)("span", { className: "rec-board-count" }, runs.length + " runs"), (0, react.createElement)(ThemeToggle, {
 				theme,
 				toggle
-			}), closeButton$1(onClose)), (0, react.createElement)("div", { className: "rec-columns" }, KANBAN_LANES.map((lane) => {
+			}), closeButton$1(onClose, variant)), (0, react.createElement)("div", { className: "rec-columns" }, KANBAN_LANES.map((lane) => {
 				const laneRuns = runs.filter((r) => columnForRun(r) === lane.id);
 				return (0, react.createElement)("section", {
 					key: lane.id,
@@ -781,6 +782,17 @@ window.__ModuleLoader__.load({
   overflow: hidden;
 }
 
+/* Inline board (conversation.view tab): fills its parent view area, not fixed. */
+.rec-board-view {
+  position: relative;
+  inset: auto;
+  z-index: auto;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  flex: 1;
+}
+
 .rec-board-header {
   display: flex;
   align-items: center;
@@ -1257,9 +1269,51 @@ window.__ModuleLoader__.load({
 				onClick: () => boardState.openBoard()
 			}, "⧉");
 		}
+		/**
+		* RecursiveView: the conversation.view tab body. Renders the run board INLINE
+		* (fills the view area) keyed on the CURRENT workspace, and swaps to the
+		* inspector modal when a run is opened. Read-only (R9): uses the live host
+		* route. No preset gate — the tab is discoverable in any session.
+		*/
+		function RecursiveView({ useSessions, useWorkspaces }) {
+			const board = useBoardState();
+			const sessions = useRecursiveSessions(useSessions);
+			const wsPath = currentWorkspacePath(useWorkspaces((s) => s) ?? {
+				items: [],
+				recentWorkspaceId: void 0
+			}, sessions);
+			const snapshot = useLiveProjection({ cwd: wsPath });
+			if (board.selection !== null) return (0, react.createElement)(Inspector, {
+				runId: board.selection.runId,
+				worktreeRoot: board.selection.worktreeRoot,
+				snapshot,
+				onBackToToolDetails: () => boardState.backToBoard(),
+				onClose: () => boardState.close()
+			});
+			return (0, react.createElement)(Board, {
+				snapshot,
+				workspacePath: wsPath,
+				variant: "view",
+				onOpenInspector: (sel) => boardState.openInspector(sel)
+			});
+		}
 		function registerSlots(ctx) {
 			const disposers = [];
 			disposers.push(injectBoardStyles());
+			disposers.push(ctx.slots.inject("conversation.view", () => ctx.slots.register({
+				name: "conversation.view",
+				id: "recursive",
+				order: 20,
+				label: "Recursive"
+			}, (props) => {
+				const useSessions = props?.useSessions;
+				const useWorkspaces = props?.useWorkspaces;
+				if (useSessions === void 0 || useWorkspaces === void 0) return null;
+				return (0, react.createElement)(RecursiveView, {
+					useSessions,
+					useWorkspaces
+				});
+			})));
 			disposers.push(ctx.slots.inject("sidebar.footer.action", () => ctx.slots.register({
 				name: "sidebar.footer.action",
 				id: "recursive",
@@ -1355,6 +1409,7 @@ window.__ModuleLoader__.load({
 		exports.Board = Board;
 		exports.Inspector = Inspector;
 		exports.RecursiveSettings = RecursiveSettings;
+		exports.RecursiveView = RecursiveView;
 		exports.apply = apply;
 		exports.currentSessionCwd = currentSessionCwd;
 		exports.currentWorkspacePath = currentWorkspacePath;

package/lib/enforcement.d.ts

@@ -1,4 +1,3 @@
-import { type SessionEventLike } from './lifecycle.ts';
 export type EnforcementMode = 'strict' | 'advisory';
 export interface EnforcementConfig {
     preStep: EnforcementMode;
@@ -8,19 +7,6 @@ export interface EnforcementConfig {
 /** Validate the enforcement config shape (unknown keys fail at plugin load). */
 export declare function resolveEnforcementConfig(config: unknown): EnforcementConfig;
 export declare const DEFAULT_ENFORCEMENT: EnforcementConfig;
-/**
- * Layer 1 - agent/pre-step phase-transition gate decision.
- * Reads on TRANSITION INTENT ONLY (13.5): no transition intent means the step
- * passes through untouched. On a transition intent whose gates fail:
- *  - strict  -> reject (turn ends blocked, no model call spent)
- *  - advisory -> enter (warn only; a recursive/gate-blocked event is emitted)
- */
-export interface PreStepGateDecision {
-    kind: 'reject' | 'enter';
-    gateBlocked: boolean;
-    failures: string[];
-}
-export declare function evaluatePreStepGate(events: readonly SessionEventLike[], mode?: EnforcementMode): PreStepGateDecision;
 /**
  * Layer 2 - tools/pre-execute guard decision.
  * Pure predicate: inspects the pending tool execution (name + args) against

package/lib/index.js

@@ -4496,16 +4496,15 @@ function evaluateDelegationResult(result) {
 //#endregion
 //#region src/lifecycle.ts
 /**
-* Run state machine + serialized transition driver + recursive/* events
-* (Phase C R1/R2/R6, PROPOSAL 8.8).
+* Transition gate validation + goal coupling (Phase C R1/R2/R6, PROPOSAL 8.4).
 *
-* Authority is TRANSITIONS AND EVENTS ONLY - this module never stores run
-* state in a second place. It reconciles the file tree via the existing
-* read path (run.ts/status.ts/lock.ts), validates the target phase's gates
-* (PROPOSAL 8.4), delegates the artifact write to lock.ts (canonical
-* lock-hash + monotonic chain preserved), and emits the recursive/* events.
-* State is DERIVED on every transition; resume/fork/session-restart
-* reconstruct identical state by re-reading files + folding the session log.
+* Live BUG dsh-v0.1.1-rc.2 compatibility (0.2.2): the legacy session-event fold
+* surface (foldRecursivePhase / detectTransitionIntent / hasOpenTurn /
+* LifecycleDriver / the recursive/* event payload interfaces) was REMOVED.
+* The plugin is zero-emission: no recursive/* session event is ever appended
+* or emitted, so nothing folds them. What remains is the pure transition gate
+* check (validateTransition — reads the file tree + lock chain, writes nothing)
+* plus the shared intent/result types and the goal-coupling no-op helper.
 */
 /** Run-level durable states (PROPOSAL 8.8). */
 const RUN_STATES = [
@@ -4528,66 +4527,6 @@ const AUDITED_PHASE_FILES = /* @__PURE__ */ new Set([
 	"08-memory-impact.md"
 ]);
 /**
-* Pure last-wins fold over the recursive/* events (the foldPlanMode pattern).
-* A log with no recursive/phase folds to null; the last recursive/run-state
-* wins for the run-level flag.
-*/
-function foldRecursivePhase(events, end = events.length) {
-	let runId = "";
-	let phaseName = "";
-	let status = "";
-	let runState = "active";
-	let seen = false;
-	let index = 0;
-	for (const event of events) {
-		if (index >= end) break;
-		index++;
-		if (event.type === "recursive/phase") {
-			const d = event.data ?? {};
-			runId = String(d.runId ?? runId);
-			phaseName = String(d.phase ?? phaseName);
-			status = String(d.status ?? status);
-			seen = true;
-		} else if (event.type === "recursive/run-state") {
-			const d = event.data ?? {};
-			runId = String(d.runId ?? runId);
-			runState = asRunState(d.state);
-			seen = true;
-		}
-	}
-	return seen ? {
-		runId,
-		phase: phaseName,
-		status,
-		runState
-	} : null;
-}
-function asRunState(value) {
-	return RUN_STATES.includes(value) ? value : "active";
-}
-/** Whether the session log holds an opened turn without its closing turn/end. */
-function hasOpenTurn(events) {
-	let open = false;
-	for (const event of events) if (event.type === "turn/start") open = true;
-	else if (event.type === "turn/end") open = false;
-	return open;
-}
-/** Detect a pending transition intent from the session log (the lock tool logs it). */
-function detectTransitionIntent(events) {
-	let intent = null;
-	for (const event of events) if (event.type === "recursive/phase-intent") {
-		const d = event.data ?? {};
-		intent = {
-			runId: String(d.runId ?? ""),
-			worktreeRoot: String(d.worktreeRoot ?? ""),
-			targetArtifact: String(d.targetArtifact ?? ""),
-			kind: d.kind === "reopen" || d.kind === "advance" ? d.kind : "lock",
-			evidence: d.evidence
-		};
-	}
-	return intent;
-}
-/**
 * Validate a proposed transition against the target phase's gates (PROPOSAL 8.4).
 * Pure: reads the current file tree + lock.ts chain; writes nothing.
 */
@@ -4641,20 +4580,6 @@ function validateTransition(intent) {
 	};
 }
 /**
-* A serialized per-run transition driver (coalesced - the single-reservation
-* pattern). Two concurrent 'lock Phase 3' intents queue; the second observes
-* the first's committed state instead of racing the write.
-*/
-var LifecycleDriver = class {
-	drivers = /* @__PURE__ */ new Map();
-	/** Run one transition serially per runId. */
-	serialize(runId, run) {
-		const next = (this.drivers.get(runId) ?? Promise.resolve()).then(run, run);
-		this.drivers.set(runId, next.then(() => void 0, () => void 0));
-		return next;
-	}
-};
-/**
 * Couple a gate-block to the goal service (PROPOSAL 8.4 goal integration).
 * Graceful no-op when the goal service or agent is unavailable.
 */
@@ -4669,9 +4594,8 @@ function coupleGateBlockToGoal(goalService, agent, ref, reason) {
 * Enforcement config + pre-step gate + tool guards + tamper detection
 * (Phase C R3/R4/R7/R8, PROPOSAL 8.4/8.6/13.5).
 *
-* Layers 1 and 2 are CALLERS of the lifecycle transition set - they never
-* reimplement the predicates. Configurable strict|advisory per gate
-* (default advisory).
+* Layer 2 (tool guards) and Layer 8 (tamper) are the remaining enforcement
+* layers. Configurable strict|advisory per gate (default advisory).
 */
 /** Validate the enforcement config shape (unknown keys fail at plugin load). */
 function resolveEnforcementConfig(config) {
@@ -4694,25 +4618,6 @@ const DEFAULT_ENFORCEMENT = {
 	toolGuards: "advisory",
 	tamper: "advisory"
 };
-function evaluatePreStepGate(events, mode = "advisory") {
-	const intent = detectTransitionIntent(events);
-	if (!intent || intent.worktreeRoot === "" || intent.runId === "") return {
-		kind: "enter",
-		gateBlocked: false,
-		failures: []
-	};
-	const check = validateTransition(intent);
-	if (check.passed) return {
-		kind: "enter",
-		gateBlocked: false,
-		failures: []
-	};
-	return {
-		kind: mode === "strict" ? "reject" : "enter",
-		gateBlocked: true,
-		failures: check.failures
-	};
-}
 /** Tool names the locked-artifact write guard treats as write operations. */
 const WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
 	"write",
@@ -5653,21 +5558,6 @@ var RecursiveRuntime = class extends Service {
 			passed: errors.length === 0
 		};
 	}
-	/** Phase C R1/R2: fold the log into phase state; validate a transition intent. */
-	foldPhase(events) {
-		return foldRecursivePhase(events);
-	}
-	validateTransition(intent) {
-		return validateTransition(intent);
-	}
-	detectTransitionIntent(events) {
-		return detectTransitionIntent(events);
-	}
-	/** Phase C R3: Layer 1 pre-step gate decision (caller of the transition set). */
-	gatePreStep(events, config) {
-		const mode = (config ?? this.enforcementConfig).preStep;
-		return evaluatePreStepGate(events, mode);
-	}
 	/** Phase C R4: Layer 2 tool guard decision (caller of the transition set). */
 	guardTool(exec, root, runId, config) {
 		const mode = (config ?? this.enforcementConfig).toolGuards;
@@ -6648,8 +6538,8 @@ function registerRecursiveCommand(ctx, recursive) {
 /**
 * fs-intent.ts — filesystem-derived recursive intent (R5 policy-render fix).
 *
-* SP2 zero-emission retired the recursive/phase-intent SESSION EVENT emitter,
-* so detectTransitionIntent(events) is ALWAYS null and the recursive:policy
+* SP2 zero-emission retired the recursive/phase-intent SESSION EVENT emitter
+* (and 0.2.2 removed the event-fold helper that read it), so the recursive:policy
 * prompt section rendered ''. This module derives the SAME intent from the
 * filesystem instead: session cwd -> control-plane root -> enumerate runs ->
 * latest run -> current phase (foldRun). Pure read-only fs folding, zero
@@ -7038,4 +6928,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { DEFAULT_ENFORCEMENT, LifecycleDriver, OPTIONAL_PHASES, PHASES, PHASE_SEQUENCE, RECURSIVE_API_PREFIX, RUN_ARTIFACT_SEQUENCE, RUN_STATES, RecursiveRuntime, apply, buildDelegationPrompt, buildReviewBundle, capabilityProbe, childScratchPath, contentSha256, coupleGateBlockToGoal, createChildBrief, createHandoff, createRecursiveCloseoutTool, createRecursiveInitTool, createRecursiveLintTool, createRecursiveLockTool, createRecursivePhaseTool, createRecursiveScratchTool, createRecursiveStatusTool, createRecursiveWorktreeTool, defaultReviewToolFilter, delegate, delegationDecisionBasis, delegationError, detectTamper, detectTransitionIntent, discoverRuns, escapeRegExp, evaluateDelegationResult, evaluatePreStepGate, evaluateToolGuard, foldRecursivePhase, foldRun, foldRunCard, getAllStaleReceipts, getArtifactState, getGateStatus, getLatestRunDirectory, getLockStatus, getMdFieldValue, getNextLegalPhase, getPrerequisiteBlockers, getPrerequisites, getStaleDownstreamPhases, getTodoStats, getWorkflowProfile, hasOpenTurn, inject, invalidateReceipt, isCoreArtifact, loadRouterPolicy, lockHashFromContent, makeRecursiveRoutes, mountRecursiveRoutesOnce, name, normalizeForLockHash, phaseIndex, probeCapabilities, readReceipt, receiptPath, renderRecursivePolicy, replyPath, resolveEnforcementConfig, resolveRole, resolveRunDir, reviewBundleDir, reviewOutputSchema, routerPolicyPath, snapshotWorkspace, trimMdValue, validateChain, validateReferences, validateTransition, writeActionRecord, writeReceipt };
+export { DEFAULT_ENFORCEMENT, OPTIONAL_PHASES, PHASES, PHASE_SEQUENCE, RECURSIVE_API_PREFIX, RUN_ARTIFACT_SEQUENCE, RUN_STATES, RecursiveRuntime, apply, buildDelegationPrompt, buildReviewBundle, capabilityProbe, childScratchPath, contentSha256, coupleGateBlockToGoal, createChildBrief, createHandoff, createRecursiveCloseoutTool, createRecursiveInitTool, createRecursiveLintTool, createRecursiveLockTool, createRecursivePhaseTool, createRecursiveScratchTool, createRecursiveStatusTool, createRecursiveWorktreeTool, defaultReviewToolFilter, delegate, delegationDecisionBasis, delegationError, detectTamper, discoverRuns, escapeRegExp, evaluateDelegationResult, evaluateToolGuard, foldRun, foldRunCard, getAllStaleReceipts, getArtifactState, getGateStatus, getLatestRunDirectory, getLockStatus, getMdFieldValue, getNextLegalPhase, getPrerequisiteBlockers, getPrerequisites, getStaleDownstreamPhases, getTodoStats, getWorkflowProfile, inject, invalidateReceipt, isCoreArtifact, loadRouterPolicy, lockHashFromContent, makeRecursiveRoutes, mountRecursiveRoutesOnce, name, normalizeForLockHash, phaseIndex, probeCapabilities, readReceipt, receiptPath, renderRecursivePolicy, replyPath, resolveEnforcementConfig, resolveRole, resolveRunDir, reviewBundleDir, reviewOutputSchema, routerPolicyPath, snapshotWorkspace, trimMdValue, validateChain, validateReferences, validateTransition, writeActionRecord, writeReceipt };

package/lib/lifecycle.d.ts

@@ -15,86 +15,23 @@ export interface PhaseTransitionIntent {
         qaSignOff?: boolean;
     };
 }
-/** Folded phase state (last-wins over recursive/phase + recursive/run-state). */
+/** Folded phase state (run key + current phase + current run-level state). */
 export interface RecursivePhaseState {
     runId: string;
     phase: string;
     status: string;
     runState: RunState;
 }
-/** A session-event-like carrier (the pure fold reads events by shape). */
-export interface SessionEventLike {
-    type: string;
-    data?: Record<string, unknown>;
-}
 /** Gate check result - the transition set's single output. */
 export interface GateCheckResult {
     passed: boolean;
     failures: string[];
 }
-/**
- * Payload shapes for the recursive/* events. These are LEGACY structural
- * views kept for internal consumers; the single source of truth for the
- * emitted payloads is events.ts (every event carries { runId, worktreeRoot }).
- * Aligned here so no local interface drifts out of the worktree-keyed
- * invariant (B7).
- */
-export interface RecursivePhaseEvent {
-    runId: string;
-    worktreeRoot: string;
-    phase: string;
-    status: string;
-}
-export interface RecursiveRunStateEvent {
-    runId: string;
-    worktreeRoot: string;
-    state: RunState;
-    reason?: string;
-}
-export interface RecursiveGateBlockedEvent {
-    runId: string;
-    worktreeRoot: string;
-    phase: string;
-    failures: string[];
-    kind: string;
-}
-export interface RecursiveTamperEvent {
-    runId: string;
-    worktreeRoot: string;
-    path: string;
-    reason: string;
-}
-export interface RecursiveTransitionFailedEvent {
-    runId: string;
-    worktreeRoot: string;
-    phase: string;
-    error: string;
-}
-/**
- * Pure last-wins fold over the recursive/* events (the foldPlanMode pattern).
- * A log with no recursive/phase folds to null; the last recursive/run-state
- * wins for the run-level flag.
- */
-export declare function foldRecursivePhase(events: readonly SessionEventLike[], end?: number): RecursivePhaseState | null;
-/** Whether the session log holds an opened turn without its closing turn/end. */
-export declare function hasOpenTurn(events: readonly SessionEventLike[]): boolean;
-/** Detect a pending transition intent from the session log (the lock tool logs it). */
-export declare function detectTransitionIntent(events: readonly SessionEventLike[]): PhaseTransitionIntent | null;
 /**
  * Validate a proposed transition against the target phase's gates (PROPOSAL 8.4).
  * Pure: reads the current file tree + lock.ts chain; writes nothing.
  */
 export declare function validateTransition(intent: PhaseTransitionIntent): GateCheckResult;
-/**
- * A serialized per-run transition driver (coalesced - the single-reservation
- * pattern). Two concurrent 'lock Phase 3' intents queue; the second observes
- * the first's committed state instead of racing the write.
- */
-export declare class LifecycleDriver {
-    private readonly drivers;
-    /** Run one transition serially per runId. */
-    serialize(runId: string, run: () => Promise<void>): Promise<void>;
-}
 /**
  * Couple a gate-block to the goal service (PROPOSAL 8.4 goal integration).
  * Graceful no-op when the goal service or agent is unavailable.

package/lib/runtime.d.ts

@@ -6,8 +6,8 @@ import { type ScratchTarget } from './scratch.ts';
 import { type ReviewBundleInput } from './review.ts';
 import { type SubagentProviderLike, type RouteDecision, type CapabilityProbe } from './router.ts';
 import { type SubagentsRuntimeLike, type SubagentStartRequestLike, type SubagentResultLike, type Reference } from './delegation.ts';
-import { type PhaseTransitionIntent, type SessionEventLike, type RecursivePhaseState, type GateCheckResult } from './lifecycle.ts';
-import { type EnforcementConfig, type PreStepGateDecision, type ToolGuardDecision, type ToolExecLike } from './enforcement.ts';
+import { type RecursivePhaseState } from './lifecycle.ts';
+import { type EnforcementConfig, type ToolGuardDecision, type ToolExecLike } from './enforcement.ts';
 import { type CreateWorktreeResult, type PromoteBranchResult } from './worktree.ts';
 declare module '@deepseek-ai/cordis' {
     interface Context {
@@ -273,12 +273,6 @@ export declare class RecursiveRuntime extends Service {
             };
         };
     } | null): Promise<LintArtifactResult>;
-    /** Phase C R1/R2: fold the log into phase state; validate a transition intent. */
-    foldPhase(events: readonly SessionEventLike[]): RecursivePhaseState | null;
-    validateTransition(intent: PhaseTransitionIntent): GateCheckResult;
-    detectTransitionIntent(events: readonly SessionEventLike[]): PhaseTransitionIntent | null;
-    /** Phase C R3: Layer 1 pre-step gate decision (caller of the transition set). */
-    gatePreStep(events: readonly SessionEventLike[], config?: EnforcementConfig): PreStepGateDecision;
     /** Phase C R4: Layer 2 tool guard decision (caller of the transition set). */
     guardTool(exec: ToolExecLike, root: string, runId: string, config?: EnforcementConfig): ToolGuardDecision;
     /** Phase C R8: fs/observed tamper detection. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@try-works/dsh-recursive-mode",
   "description": "recursive-mode workflow as a DeepSeek Harness bundle: RecursiveRuntime service + recursive_status tool",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -45,10 +45,10 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-session": "0.1.0-rc.5",
-    "@deepseek-ai/dsh-session-projection": "0.1.0-rc.5",
-    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.5",
-    "@deepseek-ai/dsh-tools": "0.1.0-rc.5",
+    "@deepseek-ai/dsh-session": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.1-rc.2",
     "react": "^18.2.0"
   },
   "devDependencies": {
@@ -84,7 +84,8 @@
     "build": "node -e \"require('node:fs').rmSync('lib',{recursive:true,force:true})\" && tsc -p tsconfig.build.json && tsdown",
     "bundle": "tsdown",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepare": "node -e \"require('node:fs').rmSync('lib',{recursive:true,force:true})\" && tsc -p tsconfig.build.json && tsdown"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-session-projection": {

package/src/client/board.tsx

@@ -32,10 +32,16 @@ export interface BoardProps {
   workspacePath?: string
   onOpenInspector?: (selection: BoardSelection) => void
   onClose?: () => void
+  /**
+   * 'overlay' (default) renders the board as a full-viewport fixed overlay
+   * (shell.overlay / launcher). 'view' renders it inline, filling its parent
+   * (a conversation.view tab), with no close button and no fixed positioning.
+   */
+  variant?: 'overlay' | 'view'
 }
 
-function closeButton(onClose: (() => void) | undefined) {
-  if (onClose === undefined) return null
+function closeButton(onClose: (() => void) | undefined, variant: 'overlay' | 'view') {
+  if (onClose === undefined || variant === 'view') return null
   return createElement('button', { type: 'button', className: 'rec-close', onClick: onClose, title: 'Close', 'aria-label': 'Close' }, '×')
 }
 
@@ -49,7 +55,7 @@ function solidPill(kind: ReturnType<typeof cardPill>) {
   return createElement('span', { className: 'rec-pill', 'data-pill': kind }, PILL_LABELS[kind])
 }
 
-export function Board({ snapshot, workspacePath, onOpenInspector, onClose }: BoardProps) {
+export function Board({ snapshot, workspacePath, onOpenInspector, onClose, variant = 'overlay' }: BoardProps) {
   const { theme, toggle } = useBoardTheme()
   if (snapshot === null || snapshot.root === null) return null
   // Run 16: when the synchronous workspace path differs from the async snapshot
@@ -59,25 +65,26 @@ export function Board({ snapshot, workspacePath, onOpenInspector, onClose }: Boa
   const runs = stale ? [] : listRuns(snapshot.projection)
   const headerPath = workspacePath ?? snapshot.root
   const open = (run: RecursiveRunCard) => () => onOpenInspector?.({ worktreeRoot: run.worktreeRoot, runId: run.runId })
+  const rootCls = variant === 'view' ? 'rec-board rec-board-view' : 'rec-board'
   if (runs.length === 0) {
-    return createElement('div', { className: 'rec-board', 'data-theme': theme, 'data-empty': true },
+    return createElement('div', { className: rootCls, 'data-theme': theme, 'data-empty': true },
       createElement('header', { className: 'rec-board-header' },
         createElement('h2', { className: 'rec-board-title' }, 'Recursive runs'),
         createElement('span', { className: 'rec-board-path' }, headerPath),
         createElement('span', { className: 'rec-board-count' }, '0 runs'),
         createElement(ThemeToggle, { theme, toggle }),
-        closeButton(onClose),
+        closeButton(onClose, variant),
       ),
       createElement('p', { className: 'rec-board-empty' }, 'No recursive runs in this workspace yet.'),
     )
   }
-  return createElement('div', { className: 'rec-board', 'data-theme': theme },
+  return createElement('div', { className: rootCls, 'data-theme': theme },
     createElement('header', { className: 'rec-board-header' },
       createElement('h2', { className: 'rec-board-title' }, 'Recursive runs'),
       createElement('span', { className: 'rec-board-path' }, headerPath),
       createElement('span', { className: 'rec-board-count' }, runs.length + ' runs'),
       createElement(ThemeToggle, { theme, toggle }),
-      closeButton(onClose),
+      closeButton(onClose, variant),
     ),
     createElement('div', { className: 'rec-columns' },
       KANBAN_LANES.map((lane) => {

package/src/client/index.ts

@@ -17,6 +17,7 @@ import { claimClientApply, releaseClientApply } from './apply-guard.ts'
 
 export { Board, listRuns } from './board.tsx'
 export { Inspector } from './inspector.tsx'
+export { RecursiveView } from './slots.ts'
 export { RecursiveSettings } from './settings.tsx'
 export { useLiveProjection } from './use-live.ts'
 export type { LiveProjectionSnapshot } from './use-live.ts'

package/src/client/slots.ts

@@ -64,11 +64,54 @@ export function RecursiveLauncherGate({ useSessions }: { useSessions: SnapshotSe
   return createElement('button', { className: 'rec-launcher', title: 'Recursive runs', onClick: () => boardState.openBoard() }, '⧉')
 }
 
+/**
+ * RecursiveView: the conversation.view tab body. Renders the run board INLINE
+ * (fills the view area) keyed on the CURRENT workspace, and swaps to the
+ * inspector modal when a run is opened. Read-only (R9): uses the live host
+ * route. No preset gate — the tab is discoverable in any session.
+ */
+export function RecursiveView({ useSessions, useWorkspaces }: { useSessions: SnapshotSelectorHook<SessionListStateLike>; useWorkspaces: SnapshotSelectorHook<WorkspaceListStateLike> }): ReactNode {
+  const board = useBoardState()
+  const sessions = useRecursiveSessions(useSessions)
+  const workspaces: WorkspaceListStateLike = useWorkspaces((s) => s) ?? { items: [], recentWorkspaceId: undefined }
+  const wsPath = currentWorkspacePath(workspaces, sessions)
+  const scope = { cwd: wsPath }
+  const snapshot = useLiveProjection(scope)
+  // Inspector drill-down (modal over the inline board) when a run is selected.
+  if (board.selection !== null) {
+    return createElement(Inspector, {
+      runId: board.selection.runId,
+      worktreeRoot: board.selection.worktreeRoot,
+      snapshot,
+      onBackToToolDetails: () => boardState.backToBoard(),
+      onClose: () => boardState.close(),
+    })
+  }
+  return createElement(Board, { snapshot, workspacePath: wsPath, variant: 'view', onOpenInspector: (sel) => boardState.openInspector(sel) })
+}
+
 export function registerSlots(ctx: ClientContext): () => void {
   const disposers: (() => void)[] = []
   // Run 15: inject the one-shot theme-token stylesheet once per document (idempotent).
   disposers.push(injectBoardStyles())
 
+  // Conversation view tab (Chat | Trajectory | Recursive): the recursive run
+  // board as a first-class tab in the conversation header, rendered INLINE in
+  // the view area (not a fixed overlay). Order 20 places it to the RIGHT of
+  // Trajectory (order 10). Always present — no recursive-preset gate, so the
+  // entry point is discoverable in any session.
+  disposers.push(ctx.slots.inject('conversation.view', () => ctx.slots.register({
+    name: 'conversation.view',
+    id: 'recursive',
+    order: 20,
+    label: 'Recursive',
+  }, (props: RootSlotProps) => {
+    const useSessions = props?.useSessions
+    const useWorkspaces = props?.useWorkspaces
+    if (useSessions === undefined || useWorkspaces === undefined) return null
+    return createElement(RecursiveView, { useSessions, useWorkspaces })
+  })))
+
   // Board launcher in the sidebar footer action list — OPENS the shared board store (run 08 R1).
   // Run 11 (UX gate): the seat is root-scoped (visible in every session), but the board it
   // opens is recursive-preset-gated. In a code/other session the icon was a dead click — a

package/src/client/styles.ts

@@ -136,6 +136,17 @@ const BOARD_CSS = `
   overflow: hidden;
 }
 
+/* Inline board (conversation.view tab): fills its parent view area, not fixed. */
+.rec-board-view {
+  position: relative;
+  inset: auto;
+  z-index: auto;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  flex: 1;
+}
+
 .rec-board-header {
   display: flex;
   align-items: center;

package/src/enforcement.ts

@@ -2,15 +2,13 @@
  * Enforcement config + pre-step gate + tool guards + tamper detection
  * (Phase C R3/R4/R7/R8, PROPOSAL 8.4/8.6/13.5).
  *
- * Layers 1 and 2 are CALLERS of the lifecycle transition set - they never
- * reimplement the predicates. Configurable strict|advisory per gate
- * (default advisory).
+ * Layer 2 (tool guards) and Layer 8 (tamper) are the remaining enforcement
+ * layers. Configurable strict|advisory per gate (default advisory).
  */
 import { existsSync, readFileSync } from 'node:fs'
 import { join, isAbsolute, resolve, sep } from 'node:path'
 import { getLockStatus, getPrerequisiteBlockers } from './lock.ts'
 import { getMdFieldValue } from './status.ts'
-import { validateTransition, type PhaseTransitionIntent, type SessionEventLike, detectTransitionIntent } from './lifecycle.ts'
 
 export type EnforcementMode = 'strict' | 'advisory'
 
@@ -37,32 +35,6 @@ export function resolveEnforcementConfig(config: unknown): EnforcementConfig {
 
 export const DEFAULT_ENFORCEMENT: EnforcementConfig = { preStep: 'advisory', toolGuards: 'advisory', tamper: 'advisory' }
 
-/**
- * Layer 1 - agent/pre-step phase-transition gate decision.
- * Reads on TRANSITION INTENT ONLY (13.5): no transition intent means the step
- * passes through untouched. On a transition intent whose gates fail:
- *  - strict  -> reject (turn ends blocked, no model call spent)
- *  - advisory -> enter (warn only; a recursive/gate-blocked event is emitted)
- */
-export interface PreStepGateDecision {
-  kind: 'reject' | 'enter'
-  gateBlocked: boolean
-  failures: string[]
-}
-
-export function evaluatePreStepGate(
-  events: readonly SessionEventLike[],
-  mode: EnforcementMode = 'advisory',
-): PreStepGateDecision {
-  const intent = detectTransitionIntent(events)
-  if (!intent || intent.worktreeRoot === '' || intent.runId === '') {
-    return { kind: 'enter', gateBlocked: false, failures: [] }
-  }
-  const check = validateTransition(intent)
-  if (check.passed) return { kind: 'enter', gateBlocked: false, failures: [] }
-  return { kind: mode === 'strict' ? 'reject' : 'enter', gateBlocked: true, failures: check.failures }
-}
-
 /** Tool names the locked-artifact write guard treats as write operations. */
 const WRITE_TOOL_NAMES = new Set(['write', 'edit', 'fs_write', 'fs-write', 'pwsh', 'shell', 'bash', 'run_code'])
 

package/src/fs-intent.ts

@@ -1,8 +1,8 @@
 /**
  * fs-intent.ts — filesystem-derived recursive intent (R5 policy-render fix).
  *
- * SP2 zero-emission retired the recursive/phase-intent SESSION EVENT emitter,
- * so detectTransitionIntent(events) is ALWAYS null and the recursive:policy
+ * SP2 zero-emission retired the recursive/phase-intent SESSION EVENT emitter
+ * (and 0.2.2 removed the event-fold helper that read it), so the recursive:policy
  * prompt section rendered ''. This module derives the SAME intent from the
  * filesystem instead: session cwd -> control-plane root -> enumerate runs ->
  * latest run -> current phase (foldRun). Pure read-only fs folding, zero

package/src/index.ts

@@ -134,8 +134,9 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean; repoRoot?: s
           if (!agent) return ''
           // SP3 R5 policy-render fix: derive intent from the FILESYSTEM, not the
           // retired recursive/phase-intent session event (zero-emission removed
-          // the emitter, so detectTransitionIntent was ALWAYS null and this
-          // section rendered ''). Pure read-only fs folding; no recursive/*
+          // the emitter; 0.2.2 deleted the event-fold helper that read it, so this
+          // signal was ALWAYS null and this section rendered ''). Pure read-only fs
+          // folding; no recursive/*
           // events are appended.
           const intent = fsPolicyIntent(agent, workspaceRegistry as never)
           if (!intent) return ''

package/src/lifecycle.ts

@@ -1,14 +1,13 @@
 /**
- * Run state machine + serialized transition driver + recursive/* events
- * (Phase C R1/R2/R6, PROPOSAL 8.8).
+ * Transition gate validation + goal coupling (Phase C R1/R2/R6, PROPOSAL 8.4).
  *
- * Authority is TRANSITIONS AND EVENTS ONLY - this module never stores run
- * state in a second place. It reconciles the file tree via the existing
- * read path (run.ts/status.ts/lock.ts), validates the target phase's gates
- * (PROPOSAL 8.4), delegates the artifact write to lock.ts (canonical
- * lock-hash + monotonic chain preserved), and emits the recursive/* events.
- * State is DERIVED on every transition; resume/fork/session-restart
- * reconstruct identical state by re-reading files + folding the session log.
+ * Live BUG dsh-v0.1.1-rc.2 compatibility (0.2.2): the legacy session-event fold
+ * surface (foldRecursivePhase / detectTransitionIntent / hasOpenTurn /
+ * LifecycleDriver / the recursive/* event payload interfaces) was REMOVED.
+ * The plugin is zero-emission: no recursive/* session event is ever appended
+ * or emitted, so nothing folds them. What remains is the pure transition gate
+ * check (validateTransition — reads the file tree + lock chain, writes nothing)
+ * plus the shared intent/result types and the goal-coupling no-op helper.
  */
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
@@ -34,7 +33,7 @@ export interface PhaseTransitionIntent {
   }
 }
 
-/** Folded phase state (last-wins over recursive/phase + recursive/run-state). */
+/** Folded phase state (run key + current phase + current run-level state). */
 export interface RecursivePhaseState {
   runId: string
   phase: string
@@ -42,100 +41,18 @@ export interface RecursivePhaseState {
   runState: RunState
 }
 
-/** A session-event-like carrier (the pure fold reads events by shape). */
-export interface SessionEventLike {
-  type: string
-  data?: Record<string, unknown>
-}
-
 /** Gate check result - the transition set's single output. */
 export interface GateCheckResult {
   passed: boolean
   failures: string[]
 }
 
-/**
- * Payload shapes for the recursive/* events. These are LEGACY structural
- * views kept for internal consumers; the single source of truth for the
- * emitted payloads is events.ts (every event carries { runId, worktreeRoot }).
- * Aligned here so no local interface drifts out of the worktree-keyed
- * invariant (B7).
- */
-export interface RecursivePhaseEvent { runId: string; worktreeRoot: string; phase: string; status: string }
-export interface RecursiveRunStateEvent { runId: string; worktreeRoot: string; state: RunState; reason?: string }
-export interface RecursiveGateBlockedEvent { runId: string; worktreeRoot: string; phase: string; failures: string[]; kind: string }
-export interface RecursiveTamperEvent { runId: string; worktreeRoot: string; path: string; reason: string }
-export interface RecursiveTransitionFailedEvent { runId: string; worktreeRoot: string; phase: string; error: string }
-
 /** The audited phase files whose lock requires Audit: PASS (parity with status.ts). */
 const AUDITED_PHASE_FILES = new Set([
   '01-as-is.md', '01.5-root-cause.md', '02-to-be-plan.md', '03-implementation-summary.md',
   '03.5-code-review.md', '04-test-summary.md', '06-decisions-update.md', '07-state-update.md', '08-memory-impact.md',
 ])
 
-/**
- * Pure last-wins fold over the recursive/* events (the foldPlanMode pattern).
- * A log with no recursive/phase folds to null; the last recursive/run-state
- * wins for the run-level flag.
- */
-export function foldRecursivePhase(events: readonly SessionEventLike[], end = events.length): RecursivePhaseState | null {
-  let runId = ''
-  let phaseName = ''
-  let status = ''
-  let runState: RunState = 'active'
-  let seen = false
-  let index = 0
-  for (const event of events) {
-    if (index >= end) break
-    index++
-    if (event.type === 'recursive/phase') {
-      const d = event.data ?? {}
-      runId = String(d.runId ?? runId)
-      phaseName = String(d.phase ?? phaseName)
-      status = String(d.status ?? status)
-      seen = true
-    } else if (event.type === 'recursive/run-state') {
-      const d = event.data ?? {}
-      runId = String(d.runId ?? runId)
-      runState = asRunState(d.state)
-      seen = true
-    }
-  }
-  return seen ? { runId, phase: phaseName, status, runState } : null
-}
-
-function asRunState(value: unknown): RunState {
-  return RUN_STATES.includes(value as RunState) ? (value as RunState) : 'active'
-}
-
-/** Whether the session log holds an opened turn without its closing turn/end. */
-export function hasOpenTurn(events: readonly SessionEventLike[]): boolean {
-  let open = false
-  for (const event of events) {
-    if (event.type === 'turn/start') open = true
-    else if (event.type === 'turn/end') open = false
-  }
-  return open
-}
-
-/** Detect a pending transition intent from the session log (the lock tool logs it). */
-export function detectTransitionIntent(events: readonly SessionEventLike[]): PhaseTransitionIntent | null {
-  let intent: PhaseTransitionIntent | null = null
-  for (const event of events) {
-    if (event.type === 'recursive/phase-intent') {
-      const d = event.data ?? {}
-      intent = {
-        runId: String(d.runId ?? ''),
-        worktreeRoot: String(d.worktreeRoot ?? ''),
-        targetArtifact: String(d.targetArtifact ?? ''),
-        kind: (d.kind === 'reopen' || d.kind === 'advance' ? d.kind : 'lock'),
-        evidence: d.evidence as PhaseTransitionIntent['evidence'],
-      }
-    }
-  }
-  return intent
-}
-
 /**
  * Validate a proposed transition against the target phase's gates (PROPOSAL 8.4).
  * Pure: reads the current file tree + lock.ts chain; writes nothing.
@@ -202,23 +119,6 @@ export function validateTransition(intent: PhaseTransitionIntent): GateCheckResu
   return { passed: failures.length === 0, failures }
 }
 
-/**
- * A serialized per-run transition driver (coalesced - the single-reservation
- * pattern). Two concurrent 'lock Phase 3' intents queue; the second observes
- * the first's committed state instead of racing the write.
- */
-export class LifecycleDriver {
-  private readonly drivers = new Map<string, Promise<void>>()
-
-  /** Run one transition serially per runId. */
-  serialize(runId: string, run: () => Promise<void>): Promise<void> {
-    const previous = this.drivers.get(runId) ?? Promise.resolve()
-    const next = previous.then(run, run)
-    this.drivers.set(runId, next.then(() => undefined, () => undefined))
-    return next
-  }
-}
-
 /**
  * Couple a gate-block to the goal service (PROPOSAL 8.4 goal integration).
  * Graceful no-op when the goal service or agent is unavailable.

package/src/runtime.ts

@@ -22,8 +22,8 @@ import { buildReviewBundle, type ReviewBundleInput } from './review.ts'
 import { createHandoff, createChildBrief, replyPath, childScratchPath, buildDelegationPrompt, type HandoffInput, type ChildBriefInput } from './handoff.ts'
 import { loadRouterPolicy, routerPolicyPath, resolveRole, capabilityProbe, delegationDecisionBasis, type RouterPolicy, type SubagentProviderLike, type RouteDecision, type CapabilityProbe } from './router.ts'
 import { delegate, validateReferences, writeActionRecord, evaluateDelegationResult, reviewOutputSchema, defaultReviewToolFilter, type SubagentsRuntimeLike, type SubagentStartRequestLike, type SubagentResultLike, type Reference, type ActionRecordInput } from './delegation.ts'
-import { foldRecursivePhase, validateTransition, detectTransitionIntent, LifecycleDriver, coupleGateBlockToGoal, type PhaseTransitionIntent, type SessionEventLike, type RecursivePhaseState, type GateCheckResult } from './lifecycle.ts'
-import { resolveEnforcementConfig, DEFAULT_ENFORCEMENT, evaluatePreStepGate, evaluateToolGuard, detectTamper, type EnforcementConfig, type PreStepGateDecision, type ToolGuardDecision, type ToolExecLike } from './enforcement.ts'
+import { validateTransition, coupleGateBlockToGoal, type PhaseTransitionIntent, type RecursivePhaseState, type GateCheckResult } from './lifecycle.ts'
+import { resolveEnforcementConfig, DEFAULT_ENFORCEMENT, evaluateToolGuard, detectTamper, type EnforcementConfig, type ToolGuardDecision, type ToolExecLike } from './enforcement.ts'
 import type { Session } from '@deepseek-ai/dsh-session'
 import { renderRecursivePolicy, type PolicyContext } from './policy.ts'
 import { snapshotWorkspace } from './snapshot.ts'
@@ -577,25 +577,6 @@ export class RecursiveRuntime extends Service {
     return { artifact: target, runId, errors, warnings, passed: errors.length === 0 }
   }
 
-  /** Phase C R1/R2: fold the log into phase state; validate a transition intent. */
-  foldPhase(events: readonly SessionEventLike[]): RecursivePhaseState | null {
-    return foldRecursivePhase(events)
-  }
-
-  validateTransition(intent: PhaseTransitionIntent): GateCheckResult {
-    return validateTransition(intent)
-  }
-
-  detectTransitionIntent(events: readonly SessionEventLike[]): PhaseTransitionIntent | null {
-    return detectTransitionIntent(events)
-  }
-
-  /** Phase C R3: Layer 1 pre-step gate decision (caller of the transition set). */
-  gatePreStep(events: readonly SessionEventLike[], config?: EnforcementConfig): PreStepGateDecision {
-    const mode = (config ?? this.enforcementConfig).preStep
-    return evaluatePreStepGate(events, mode)
-  }
-
   /** Phase C R4: Layer 2 tool guard decision (caller of the transition set). */
   guardTool(exec: ToolExecLike, root: string, runId: string, config?: EnforcementConfig): ToolGuardDecision {
     const mode = (config ?? this.enforcementConfig).toolGuards