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

package/src/client/inspector.tsx

@@ -1,23 +1,21 @@
 /**
- * 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.
  */
 import { createElement } from 'react'
-import type { RecursiveProjection } from '../types.ts'
+import type { LiveProjectionValue } from './contract.ts'
 import { cardFacts, expandPhaseRows } from './derive.ts'
-import type { RecursiveProjectionReader } from './contract.ts'
 
 export interface InspectorProps {
   runId: string
   worktreeRoot: string
-  useProjection: RecursiveProjectionReader
+  snapshot: LiveProjectionValue | null
   onBackToToolDetails: () => void
 }
 
-export function Inspector({ runId, worktreeRoot, useProjection, onBackToToolDetails }: InspectorProps) {
-  const projection = useProjection('recursive') as RecursiveProjection | undefined
-  const card = projection?.[worktreeRoot]?.[runId]
+export function Inspector({ runId, worktreeRoot, snapshot, onBackToToolDetails }: InspectorProps) {
+  const card = snapshot?.projection?.[worktreeRoot]?.[runId]
   if (card === undefined) {
     return createElement('div', { className: 'rec-inspector' },
       createElement('p', {}, 'Run not found: ' + runId),

package/src/client/slots.ts

@@ -1,30 +1,43 @@
 /**
- * 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.
  *
- * 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 (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).
+ *
+ * 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.
  */
-import { createElement } from 'react'
-import type { ClientContext, RecursiveProjectionReader } from './contract.ts'
-import type { RecursiveProjection } from '../types.ts'
+import { createElement, type ReactNode } from 'react'
+import type { ClientContext, ISessionsLike, SnapshotStoreLike, SessionListStateLike } from './contract.ts'
+import { isRecursivePreset, currentSessionCwd } from './contract.ts'
 import { Board } from './board.tsx'
 import { StatusStrip } from './strip.tsx'
 import { RecursiveSettings } from './settings.tsx'
+import { useLiveProjection } from './use-live.ts'
+
+/** Structural standard-prop face for the root scope (useSessions only). */
+interface RootSlotProps {
+  useSessions?: () => SessionListStateLike
+  useWorkspaces?: () => unknown
+}
 
-/** Narrow the projection whole value to the worktree-grouped run map. */
-function projectionOf(reader: RecursiveProjectionReader): RecursiveProjection | undefined {
-  return reader('recursive') as RecursiveProjection | undefined
+/** Structural standard-prop face for the session scope (sessionId + useSessions). */
+interface SessionSlotProps {
+  sessionId?: string
+  useSessions?: () => SessionListStateLike
+  useProjection?: unknown
 }
 
 export function registerSlots(ctx: ClientContext): () => void {
   const disposers: (() => void)[] = []
 
-  // Board launcher in the sidebar footer action list (always visible).
+  // Board launcher in the sidebar footer action list (always visible; opens the board).
   disposers.push(ctx.slots.inject('sidebar.footer.action', () => ctx.slots.register({
     name: 'sidebar.footer.action',
     id: 'recursive',
@@ -32,27 +45,29 @@ export function registerSlots(ctx: ClientContext): () => void {
     label: 'Recursive runs',
   }, () => createElement('button', { className: 'rec-launcher', title: 'Recursive runs' }, '⧉'))))
 
-  // Board panel overlay (root scope, cross-session read).
+  // Board panel overlay (root scope, cross-session read) — gated on the recursive preset.
   disposers.push(ctx.slots.inject('shell.overlay', () => ctx.slots.register({
     name: 'shell.overlay',
     id: 'recursive-board',
     order: 10,
-  }, (props: { useProjection?: RecursiveProjectionReader }) => {
-    if (props?.useProjection === undefined) return null
-    return createElement(Board, { useProjection: props.useProjection })
+  }, (props: RootSlotProps) => {
+    const useSessions = props?.useSessions
+    if (useSessions === undefined) return null
+    return createElement(RecursiveBoardGate, { useSessions })
   })))
 
-  // Status strip in the composer input dock (session scope).
+  // Status strip in the composer input dock (session scope) — gated the same way.
   disposers.push(ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({
     name: 'conversation.input.dock',
     id: 'recursive-strip',
     order: 20,
-  }, (props: { useProjection?: RecursiveProjectionReader }) => {
-    if (props?.useProjection === undefined) return null
-    return createElement(StatusStrip, { useProjection: props.useProjection })
+  }, (props: SessionSlotProps) => {
+    const useSessions = props?.useSessions
+    if (useSessions === undefined) return null
+    return createElement(RecursiveStripGate, { useSessions, sessionId: props?.sessionId })
   })))
 
-  // Settings section (root scope, always present).
+  // Settings section (root scope, always present; no gate — configuration is always available).
   disposers.push(ctx.slots.inject('settings.section', () => ctx.slots.register({
     name: 'settings.section',
     id: 'recursive',
@@ -63,5 +78,34 @@ export function registerSlots(ctx: ClientContext): () => void {
   return () => { for (const d of disposers) d() }
 }
 
-/** Export the projection reader narrow for the board/inspector/strip. */
-export { projectionOf }
+/**
+ * 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 }: { useSessions: () => SessionListStateLike }): ReactNode {
+  const list = useSessions()
+  const sessions: ISessionsLike = { list: { getSnapshot: () => list, subscribe: () => () => {} } as SnapshotStoreLike<SessionListStateLike> }
+  if (!isRecursivePreset(sessions)) return null
+  const cwd = currentSessionCwd(sessions)
+  const scope = { sessionId: list.current, cwd }
+  const snapshot = useLiveProjection(scope)
+  return createElement(Board, { snapshot })
+}
+
+/**
+ * Strip gate: same preset gate, session-scoped sessionId; the strip renders
+ * nothing for a non-recursive session.
+ */
+function RecursiveStripGate({ useSessions, sessionId }: { useSessions: () => SessionListStateLike; sessionId?: string }): ReactNode {
+  const list = useSessions()
+  const sessions: ISessionsLike = { list: { getSnapshot: () => list, subscribe: () => () => {} } as SnapshotStoreLike<SessionListStateLike> }
+  if (!isRecursivePreset(sessions)) return null
+  const cwd = currentSessionCwd(sessions)
+  const scope = { sessionId, cwd }
+  const snapshot = useLiveProjection(scope)
+  return createElement(StatusStrip, { snapshot })
+}
+
+/** Export the gate helpers for tests. */
+export { isRecursivePreset, currentSessionCwd }

package/src/client/strip.tsx

@@ -1,21 +1,21 @@
 /**
- * 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).
  */
 import { createElement } from 'react'
 import { cardFacts } from './derive.ts'
 import { listRuns } from './board.tsx'
-import type { RecursiveProjection } from '../types.ts'
-import type { RecursiveProjectionReader } from './contract.ts'
+import type { LiveProjectionValue } from './contract.ts'
 
 export interface StripProps {
-  useProjection: RecursiveProjectionReader
+  /** The live host-route snapshot (null = not loaded / no recursive root). */
+  snapshot: LiveProjectionValue | null
 }
 
-export function StatusStrip({ useProjection }: StripProps) {
-  const projection = useProjection('recursive') as RecursiveProjection | undefined
-  const runs = listRuns(projection)
+export function StatusStrip({ snapshot }: StripProps) {
+  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)

package/src/client/use-live.ts

@@ -0,0 +1,52 @@
+/**
+ * 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).
+ */
+import { useEffect, useState } from 'react'
+import { fetchLiveState, subscribeLiveEvents, type LiveRecursiveFrame, type LiveRecursiveState, type LiveScope } from './host-api.ts'
+
+/** Snapshot shape the board/strip consume (null = not loaded / no recursive root). */
+export type LiveProjectionSnapshot = LiveRecursiveState | null
+
+/** Empty scope — nothing to key on. */
+function isEmpty(scope: LiveScope): boolean {
+  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.
+ */
+export function useLiveProjection(scope: LiveScope): LiveProjectionSnapshot {
+  const [state, setState] = useState<LiveRecursiveState | null>(null)
+
+  useEffect(() => {
+    // Empty scope = no resolvable session row yet — render nothing, never fetch.
+    if (isEmpty(scope)) return
+    let disposed = false
+    const apply = (frame: LiveRecursiveFrame) => { if (!disposed) setState(frame) }
+
+    // Initial state + every refresh: a no-store fetch (cold resume = fresh fs read).
+    void fetchLiveState(scope).then(apply).catch(() => { /* no recursive root yet — stay empty */ })
+
+    // Live deltas over SSE.
+    const disposeEvents = subscribeLiveEvents(scope, apply, () => {
+      if (!disposed) void fetchLiveState(scope).then(apply).catch(() => {})
+    })
+
+    return () => { disposed = true; disposeEvents() }
+  }, [scope.sessionId, scope.cwd])
+
+  return state
+}

package/src/index.ts

@@ -1,5 +1,7 @@
 import { type Context } from '@deepseek-ai/cordis'
-import type { Session } from '@deepseek-ai/dsh-session'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
 import { RecursiveRuntime } from './runtime.ts'
 import { createRecursiveStatusTool } from './recursive_status.tool.ts'
 import { createRecursiveInitTool } from './recursive_init.tool.ts'
@@ -8,23 +10,14 @@ import { createRecursiveLintTool } from './recursive_lint.tool.ts'
 import { createRecursiveCloseoutTool } from './recursive_closeout.tool.ts'
 import { createRecursiveScratchTool } from './recursive_scratch.tool.ts'
 import { registerRecursiveCommand } from './commands.ts'
-import { stageBWorkflowInit } from './bootstrap.ts'
-import { evaluatePreStepGate, evaluateToolGuard, detectTamper, resolveEnforcementConfig, DEFAULT_ENFORCEMENT, type EnforcementConfig } from './enforcement.ts'
+import { evaluateToolGuard } from './enforcement.ts'
 import { detectTransitionIntent } from './lifecycle.ts'
 import { renderRecursivePolicy } from './policy.ts'
-import {
-  gateBlocked as gateBlockedEvent,
-  tamper as tamperEvent,
-  phaseIntent as phaseIntentEvent,
-  runCreated as runCreatedEvent,
-  phase as phaseEvent,
-  phaseLocked as phaseLockedEvent,
-  runState as runStateEvent,
-  runMerged as runMergedEvent,
-  subagentStart as subagentStartEvent,
-  subagentEnd as subagentEndEvent,
-} from './events.ts'
-import { recursiveProjectionUnit } from './projection.ts'
+import { snapshotWorkspace } from './snapshot.ts'
+import { mountRecursiveRoutesOnce, makeRecursiveRoutes, type RecursiveRouteHost } from './live-route.ts'
+import { enumerateRuns } from './bootstrap.ts'
+import { getNextLegalPhase, getLockStatus } from './lock.ts'
+import { phaseLintRulesMessage } from './phase-rules.ts'
 
 export const name = '@try-works/dsh-recursive-mode'
 
@@ -71,8 +64,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
@@ -83,16 +76,22 @@ export * from './projection.ts'
 export const inject = ['tools']
 
 /**
- * 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 function apply(ctx: Context) {
+export function apply(ctx: Context, config?: { shellOnly?: boolean }) {
+  // R4 shell split (02-to-be-plan.addendum-r4-r2-mount-resolution.md): the
+  // global bare-name row in cordis.patch.yml mounts with config.shellOnly=true
+  // to expose ONLY the client bundle for client discovery. It must register
+  // NOTHING on the server root — no tools, no /recursive command, no
+  // recursive:policy, no projection (BUG 4 always-on leak). The full server
+  // surface is mounted ONLY by the recursive preset's isolated recursive-realm,
+  // whose rows carry no config (shellOnly undefined).
+  if (config?.shellOnly) return
   ctx.effect(function* () {
     // Workspace registry: optional host service (durable). Access via ctx.get —
     // property access requires inject and would fail boot when undeclared.
@@ -100,27 +99,6 @@ export function apply(ctx: Context) {
     const workspaceRegistry = ctx.get('workspaceRegistry') as never
     const recursive = new RecursiveRuntime(ctx, { repoRoot: process.cwd(), workspaceRegistry })
 
-    /** Typed agent payload shape (session is a full Session). */
-    type AgentLike = { session?: Session | null }
-
-    /** Extract the session from a listener payload. */
-    const sessionOf = (p: unknown): Session | null => {
-      const a = (p as { agent?: AgentLike | null } | null)?.agent
-      return a?.session ?? null
-    }
-
-    /** Resolve the session's control-plane root (registry first, cwd fallback). */
-    const rootOf = async (p: unknown): Promise<string> => {
-      const a = (p as { agent?: AgentLike | null } | null)?.agent
-      const root = await recursive.resolveRootFor(a as { session?: { header?: { cwd?: string } } } | null)
-      return root ?? a?.session?.header.cwd ?? process.cwd()
-    }
-
-    /** Emit one recursive/* event into the session log (log-only). */
-    const emit = (session: Session | null, type: string, data: unknown) => {
-      if (!session) return
-      try { (session.append as unknown as (t: string, d: unknown) => void)(type, data) } catch { /* log-only; never fail the gate on an emit error */ }
-    }
     const disposers = [
       ctx.tools.register(createRecursiveStatusTool(recursive)),
       ctx.tools.register(createRecursiveInitTool(recursive)),
@@ -156,30 +134,14 @@ export function apply(ctx: Context) {
       }))
     }
 
-    // Phase C R3: agent/pre-step phase-transition gate (Layer 1, caller of the
-    // lifecycle transition set). Reads on transition intent only; rejects (strict)
-    // or warns (advisory) when the target gates fail.
-    const agentEvents = ctx as unknown as { on?: (event: string, listener: (payload: unknown, next?: unknown) => unknown) => () => void }
-    if (agentEvents.on) {
-      disposers.push(agentEvents.on('agent/pre-step', (payload, next) => {
-        const p = payload as { agent?: { session?: { events?: { type: string; data?: Record<string, unknown> }[] } } } | null
-        const events = p?.agent?.session?.events ?? []
-        const session = sessionOf(p)
-        const intent = recursive.detectTransitionIntent(events as never)
-        const decision = evaluatePreStepGate(events as never, recursive.enforcementConfig.preStep)
-        void (async () => {
-          // Emit a committed run-state (blocked) when a gate rejects the intent —
-          // the board then shows the run blocked, not merely a log message.
-          if (decision.gateBlocked && intent?.runId) {
-            const worktreeRoot = intent?.worktreeRoot ?? (await rootOf(p))
-            emit(session, 'recursive/gate-blocked', gateBlockedEvent({ runId: intent.runId, worktreeRoot, phase: intent?.targetArtifact ?? '', failures: decision.failures, kind: 'pre-step' }))
-            emit(session, 'recursive/run-state', runStateEvent({ runId: intent.runId, worktreeRoot, state: 'blocked', reason: 'gate-blocked: ' + decision.failures.join('; ') }))
-          }
-        })()
-        if (decision.kind === 'reject') return { kind: 'reject' }
-        return typeof next === 'function' ? next() : { kind: 'enter', messages: [] }
-      }))
-    }
+    // Phase C R3 (Layer 1, agent/pre-step proactive intent gate) is RETIRED
+    // under zero-emission (SP2 R1): its only signal was the recursive/phase-intent
+    // session event, whose emitter is now deleted, and it was ADVISORY by default
+    // (it never rejected; its sole side effect was the now-removed emission).
+    // Enforcement is preserved where it actually bites: Layer 2 (tools/pre-execute
+    // inspects the REAL tool call args below) plus the recursive_lock tool's own
+    // prerequisite validation in lockArtifact — strictly more reliable than the
+    // heuristic intent scan. See 03-implementation-summary.addendum-r1-*.md.
 
     // Phase C R4: tools/pre-execute surgical guards (Layer 2, caller of the
     // transition set). Scope-filtered to the active run's worktree.
@@ -195,87 +157,68 @@ export function apply(ctx: Context) {
         if (decision.kind === 'allow') return typeof next === 'function' ? next() : { kind: 'allow' }
         if (decision.kind === 'deny') return decision
         // ask -> in advisory we let it through with a warn (the approval seam is Phase D)
-        return typeof next === 'function' ? next() : { kind: 'allow' }
       }))
     }
 
-    // Phase C R8 + Phase D R1: fs/observed lock-tamper warnings -> recursive/tamper event.
-    const fsRuntime = ctx as unknown as { on?: (event: string, listener: (payload: unknown) => void) => () => void }
-    if (fsRuntime.on) {
-      disposers.push(fsRuntime.on('fs/observed', (payload) => {
-        const p = payload as { target?: { displayPath?: string }; agent?: AgentLike | null } | null
-        const path = p?.target?.displayPath ?? ''
-        if (!path) return
-        // B3: tamper detection is scoped to the SESSION's control-plane root,
-        // not the host checkout.
-        const sessionCwd = p?.agent?.session?.header.cwd ?? ''
-        const tamper = detectTamper(path, sessionCwd, '')
-        if (!tamper) return
-        // Resolve the worktree root from the tampered path (strip /.recursive/run/<id>/).
-        const normalized = path.replace(/\\/g, '/')
-        const marker = '/.recursive/run/'
-        const idx = normalized.indexOf(marker)
-        const worktreeRoot = idx >= 0 ? normalized.slice(0, idx) : sessionCwd
-        // Prefer the observing session's own log (additive); fall back to the
-        // session store list only when the payload carries no session.
-        const session = sessionOf(p) ?? null
-        if (session) {
-          emit(session, 'recursive/tamper', tamperEvent({ runId: tamper.runId, worktreeRoot, path: tamper.path, reason: tamper.reason }))
-          return
-        }
-        const sessions = ctx.get('sessions') as { list?: () => Session[] } | undefined
-        const match = sessions?.list?.().find((s) => {
-          const cwd = (s.header?.cwd ?? '').replace(/\\/g, '/')
-          return cwd === '' || cwd === worktreeRoot || cwd.startsWith(worktreeRoot + '/')
-        })
-        if (match) emit(match, 'recursive/tamper', tamperEvent({ runId: tamper.runId, worktreeRoot, path: tamper.path, reason: tamper.reason }))
+    // SP3 R5: agent/pre-step lint-rules injection (pre-step contract verified: the
+    // listener returns { kind: 'enter', messages: [...messages, injected] } and the
+    // returned array REPLACES the default [...claimed, context]). When the session's
+    // control-plane root has an active recursive run whose current phase doc is
+    // DRAFT, prepend a compact system-reminder with THAT phase's required sections +
+    // gates. Pure fs read (zero-emission): never appends recursive/* events.
+    const agentRuntime = ctx as unknown as { on?: (event: string, listener: (payload: unknown, next?: unknown) => unknown) => () => void }
+    if (agentRuntime.on) {
+      disposers.push(agentRuntime.on('agent/pre-step', async (payload, next) => {
+        const p = payload as {
+          messages?: Array<{ content: Array<{ type: string; text?: string }> }>,
+          agent?: { session?: { header?: { cwd?: string } } } | null,
+        } | null
+        const messages = p?.messages ?? []
+        const agent = p?.agent ?? null
+        const cwd = agent?.session?.header?.cwd ?? ''
+        // delegate first so later listeners keep veto power, then fold ours on
+        if (typeof next === 'function') await next()
+        if (!cwd) return { kind: 'enter', messages } as const
+        const root = await recursive.resolveRootForRoute(undefined, cwd, undefined)
+        if (!root) return { kind: 'enter', messages } as const
+        const runs = enumerateRuns(root)
+        if (runs.length === 0) return { kind: 'enter', messages } as const
+        const runId = runs[runs.length - 1]
+        const runDir = join(root, '.recursive', 'run', runId)
+        if (!existsSync(runDir)) return { kind: 'enter', messages } as const
+        const phase = getNextLegalPhase(runDir)
+        if (!phase) return { kind: 'enter', messages } as const
+        // only inject when the phase doc is DRAFT (not locked/missing).
+        const phasePath = join(runDir, phase)
+        const status = existsSync(phasePath) ? getLockStatus(phasePath) : null
+        if (status !== 'DRAFT') return { kind: 'enter', messages } as const
+        const reminder = phaseLintRulesMessage(phase)
+        return {
+          kind: 'enter',
+          messages: [...messages, createUserMessage({ content: [{ type: 'text', text: reminder }], source: { kind: 'plugin', plugin: '@try-works/dsh-recursive-mode' } })],
+        } as const
       }))
     }
 
-    // Phase D R2: register the recursive projection unit (activates only when a
-    // projection registry is composed — headless assemblies stay unaffected).
-    // The unit's cell is per-session: a session's own log is its workspace, so
-    // an accept-all init is scoped by the session boundary (see projection.ts
-    // emptyRecursiveFoldState). The registry (if present) is cached here so the
-    // session-start boundary can re-read run state after the projection drove.
-    let sessionProjections: { snapshot?: (session: Session) => { values: Partial<Record<string, unknown>> } } | null = null
-    ctx.inject(['sessionProjections'], (projectionCtx) => {
-      const registry = (projectionCtx as { sessionProjections?: { register: (def: unknown) => () => void; snapshot?: (session: Session) => unknown } }).sessionProjections
-      if (registry?.register) {
-        disposers.push(registry.register(recursiveProjectionUnit))
-        sessionProjections = registry as { snapshot?: (session: Session) => { values: Partial<Record<string, unknown>> } }
+    // Phase C R8: fs/observed lock-tamper WARNINGS are served to the board via the
+    // mountOnce-global: apply() runs per-session, but the route must register
+    // exactly once (WebServer.register throws on duplicate kind+path) and serve
+    // PER-WORKSPACE state. No-op when the host composes no webServer (headless).
+    const webServer = ctx.get('webServer') as
+      | { register: (route: { kind: string; path: string; handler: unknown }) => () => void }
+      | undefined
+    const sessionsStore = ctx.get('sessions') as
+      | { get?: (id: string) => { header?: { cwd?: string } } | undefined }
+      | undefined
+    if (webServer) {
+      const host: RecursiveRouteHost = {
+        // sessionId PRIMARY: the host resolves cwd from the attached session header;
+        // the client-passed cwd is a fallback hint (hydration / headless).
+        resolveRoot: async (sessionId: string | undefined, cwd: string) => recursive.resolveRootForRoute(sessionId, cwd, sessionsStore),
+        snapshot: async (root: string) => snapshotWorkspace(root),
+        revision: () => 1,
       }
-    })
-
-    // Stage B (R6): agent/session-start workflow init, workspace-scoped.
-    // NEW sessions emit recursive/run-state('active') after init; resumed
-    // sessions replay the projection (already folded from the persisted log) —
-    // no duplicate run-created. run-created is emitted by the lifecycle at the
-    // init/lock boundary (the only place a run's files first exist).
-    const events = ctx as unknown as { on?: (event: string, listener: (payload: unknown) => void) => () => void }
-    if (events.on) {
-      disposers.push(events.on('agent/session-start', (payload) => {
-        const p = payload as { agent?: AgentLike | null; source?: 'new' | 'resume' }
-        const session = sessionOf(p)
-        const cwd = p?.agent?.session?.header?.cwd
-        if (!cwd) return
-        void (async () => {
-          const root = await recursive.resolveRootFor(p?.agent as { session?: { header?: { cwd?: string } } } | null)
-          if (!root) return
-          const result = stageBWorkflowInit({ root, source: p.source === 'resume' ? 'resume' : 'new' })
-          // Emit run-state for the active run (from the projected wire value, the
-          // one same-source view) when the projection registry is present.
-          if (session) {
-            const runId = result.activeRunId ?? result.runs[result.runs.length - 1] ?? ''
-            if (runId) {
-              const snap = sessionProjections?.snapshot?.(session)
-              const proj = (snap?.values as { recursive?: Record<string, Record<string, { state?: string }>> } | undefined)?.recursive
-              const state = proj?.[root]?.[runId]?.state ?? 'active'
-              emit(session, 'recursive/run-state', runStateEvent({ runId, worktreeRoot: root, state: state as 'new' | 'active' | 'paused' | 'blocked' | 'complete' }))
-            }
-          }
-        })()
-      }))
+      disposers.push(mountRecursiveRoutesOnce('@try-works/dsh-recursive-mode', () => makeRecursiveRoutes(host), webServer))
     }
 
     yield () => { for (const d of disposers) d() }