@try-works/dsh-recursive-mode 0.1.3 → 0.1.5

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/fs-intent.ts

@@ -0,0 +1,84 @@
+/**
+ * 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
+ * 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
+ * emission — consistent with the per-workspace design + pre-step listener.
+ */
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { enumerateRuns } from './bootstrap.ts'
+import { foldRun } from './status.ts'
+import type { WorkspaceRegistryLike } from './workspace.ts'
+import { resolveControlPlaneRoot } from './workspace.ts'
+
+export interface FsPolicyIntent {
+  worktreeRoot: string
+  runId: string
+  /** The current phase doc file name (e.g. 03-implementation-summary.md), when determinable. */
+  currentPhaseFile: string | null
+}
+
+/**
+ * Resolve the recursive policy intent for one agent from the FILESYSTEM.
+ * Returns null when no control-plane root or run is present (callers defer,
+ * never fail hard). The registry path is async-only in the harness, so when a
+ * registry is present this resolves the session cwd directly (B4: the session
+ * cwd IS the workspace root when unregistered; a registered workspace resolves
+ * to the same cwd via resolveControlPlaneRoot's sync fallback).
+ */
+export function fsPolicyIntent(
+  agent: { session?: { header?: { cwd?: string } } } | null | undefined,
+  registry?: WorkspaceRegistryLike | null,
+  cwdFallback?: string,
+): FsPolicyIntent | null {
+  const cwd = agent?.session?.header?.cwd ?? cwdFallback ?? null
+  if (!cwd) return null
+  // B4 sync path: when the registry is absent the session cwd IS the root;
+  // when present, resolveControlPlaneRoot canonicalizes through the registry
+  // (async). For the sync prompt-section callback we take the B4 shortcut: the
+  // session cwd is authoritative per the workspace-scoping invariant. This is
+  // exactly what the pre-step listener's resolveRootForRoute falls back to.
+  const root = registry ? cwd : cwd
+  const runs = enumerateRuns(root)
+  if (runs.length === 0) return null
+  const runId = runs[runs.length - 1]
+  const runDir = join(root, '.recursive', 'run', runId)
+  if (!existsSync(runDir)) return null
+  const folded = foldRun(runDir, runId)
+  return {
+    worktreeRoot: root,
+    runId,
+    currentPhaseFile: folded.currentPhase ? folded.currentPhase.phaseName : null,
+  }
+}
+
+/**
+ * Async variant for callers that CAN await (pre-step listener, routes): uses
+ * resolveControlPlaneRoot for registry canonicalization when a registry is
+ * present, falling back to the session cwd (B4).
+ */
+export async function fsPolicyIntentAsync(
+  agent: { session?: { header?: { cwd?: string } } } | null | undefined,
+  registry?: WorkspaceRegistryLike | null,
+  cwdFallback?: string,
+): Promise<FsPolicyIntent | null> {
+  const cwd = agent?.session?.header?.cwd ?? cwdFallback ?? null
+  if (!cwd) return null
+  const root = await resolveControlPlaneRoot(agent, registry, cwdFallback)
+  if (!root) return null
+  const runs = enumerateRuns(root)
+  if (runs.length === 0) return null
+  const runId = runs[runs.length - 1]
+  const runDir = join(root, '.recursive', 'run', runId)
+  if (!existsSync(runDir)) return null
+  const folded = foldRun(runDir, runId)
+  return {
+    worktreeRoot: root,
+    runId,
+    currentPhaseFile: folded.currentPhase ? folded.currentPhase.phaseName : null,
+  }
+}