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

package/src/client/open-state.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared board open-state (run 08 R1): module-level store behind the launcher,
+ * the shell.overlay entry, and the board<->inspector swap. Zero session events,
+ * zero host mutation — the client remains a read-only projection (R5/R9).
+ */
+import { useSyncExternalStore } from 'react'
+
+export interface BoardSelection {
+  worktreeRoot: string;
+  runId: string;
+}
+
+export interface BoardState {
+  open: boolean;
+  selection: BoardSelection | null;
+}
+
+export interface BoardOpenState {
+  get(): BoardState;
+  openBoard(): void;
+  close(): void;
+  openInspector(selection: BoardSelection): void;
+  backToBoard(): void;
+  subscribe(fn: () => void): () => void;
+}
+
+export function createBoardState(initial: BoardState = { open: false, selection: null }): BoardOpenState {
+  let state: BoardState = initial;
+  const listeners = new Set<() => void>();
+  const emit = (): void => { for (const fn of listeners) fn() };
+  return {
+    get: () => state,
+    openBoard: () => { state = { ...state, open: true }; emit(); },
+    close: () => { state = { ...state, open: false, selection: null }; emit(); },
+    openInspector: (selection) => { state = { ...state, open: true, selection }; emit(); },
+    backToBoard: () => { state = { ...state, selection: null }; emit(); },
+    subscribe: (fn) => { listeners.add(fn); return () => { listeners.delete(fn) }; },
+  };
+}
+
+/** App-wide singleton shared by the launcher, overlay, board, and inspector. */
+export const boardState = createBoardState();
+
+export function useBoardState(store: BoardOpenState = boardState): BoardState {
+  return useSyncExternalStore(store.subscribe, store.get, store.get);
+}

package/src/client/slots.ts

@@ -1,15 +1,15 @@
 /**
- * Slot registrations (SP2 R1): the sidebar launcher, the shell.overlay board,
- * the conversation.input.dock status strip, and the settings.section page.
+ * Slot registrations (SP2 R1 + run 08 R1/R3/R4): the sidebar launcher, the
+ * shell.overlay board, the conversation.input.dock status strip, and the
+ * settings.section page.
  *
- * The board (root scope) and strip (session scope) render ONLY for the
- * recursive preset — the gate reads the CURRENT session's agentPreset from the
- * sessions list snapshot (acceptance #3: a non-recursive session shows NOTHING).
- *
- * 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.
+ * Run 08: the launcher now OPENS the shared board store (onClick), and the
+ * shell.overlay entry renders the board gated on that store + the recursive
+ * preset, swapping to the drill-down inspector when a run is selected. 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). The strip reads its sessionId from the session-scope
+ * standard prop.
  *
  * READ-ONLY (R9): the client only GETs the live host route; no mutation.
  */
@@ -17,9 +17,11 @@ 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 { Inspector } from './inspector.tsx'
 import { StatusStrip } from './strip.tsx'
 import { RecursiveSettings } from './settings.tsx'
 import { useLiveProjection } from './use-live.ts'
+import { boardState, useBoardState } from './open-state.ts'
 
 /** Structural standard-prop face for the root scope (useSessions only). */
 interface RootSlotProps {
@@ -34,18 +36,28 @@ interface SessionSlotProps {
   useProjection?: unknown
 }
 
+export type OverlayContent = 'hidden' | 'board' | 'inspector'
+
+/** Gate: hidden unless open AND recursive preset; inspector when a run is selected. */
+export function overlayContent(state: { open: boolean; selection: unknown }, sessions: ISessionsLike): OverlayContent {
+  if (!state.open) return 'hidden'
+  if (!isRecursivePreset(sessions)) return 'hidden'
+  if (state.selection !== null) return 'inspector'
+  return 'board'
+}
+
 export function registerSlots(ctx: ClientContext): () => void {
   const disposers: (() => void)[] = []
 
-  // Board launcher in the sidebar footer action list (always visible; opens the board).
+  // Board launcher in the sidebar footer action list — OPENS the shared board store (run 08 R1).
   disposers.push(ctx.slots.inject('sidebar.footer.action', () => ctx.slots.register({
     name: 'sidebar.footer.action',
     id: 'recursive',
     order: 50,
     label: 'Recursive runs',
-  }, () => createElement('button', { className: 'rec-launcher', title: 'Recursive runs' }, '⧉'))))
+  }, () => createElement('button', { className: 'rec-launcher', title: 'Recursive runs', onClick: () => boardState.openBoard() }, '⧉'))))
 
-  // Board panel overlay (root scope, cross-session read) — gated on the recursive preset.
+  // Board panel overlay (root scope, cross-session read) — gated on the recursive preset + shared store.
   disposers.push(ctx.slots.inject('shell.overlay', () => ctx.slots.register({
     name: 'shell.overlay',
     id: 'recursive-board',
@@ -53,7 +65,7 @@ export function registerSlots(ctx: ClientContext): () => void {
   }, (props: RootSlotProps) => {
     const useSessions = props?.useSessions
     if (useSessions === undefined) return null
-    return createElement(RecursiveBoardGate, { useSessions })
+    return createElement(RecursiveBoardOverlay, { useSessions })
   })))
 
   // Status strip in the composer input dock (session scope) — gated the same way.
@@ -79,18 +91,27 @@ export function registerSlots(ctx: ClientContext): () => void {
 }
 
 /**
- * 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.
+ * Board overlay: subscribes to the shared board store, gates on open + recursive
+ * preset, and swaps board <-> inspector (run 08 R1/R3).
  */
-function RecursiveBoardGate({ useSessions }: { useSessions: () => SessionListStateLike }): ReactNode {
+function RecursiveBoardOverlay({ useSessions }: { useSessions: () => SessionListStateLike }): ReactNode {
+  const board = useBoardState()
   const list = useSessions()
   const sessions: ISessionsLike = { list: { getSnapshot: () => list, subscribe: () => () => {} } as SnapshotStoreLike<SessionListStateLike> }
-  if (!isRecursivePreset(sessions)) return null
+  const content = overlayContent(board, sessions)
+  if (content === 'hidden') return null
   const cwd = currentSessionCwd(sessions)
   const scope = { sessionId: list.current, cwd }
   const snapshot = useLiveProjection(scope)
-  return createElement(Board, { snapshot })
+  if (content === 'inspector' && board.selection !== null) {
+    return createElement(Inspector, {
+      runId: board.selection.runId,
+      worktreeRoot: board.selection.worktreeRoot,
+      snapshot,
+      onBackToToolDetails: () => boardState.backToBoard(),
+    })
+  }
+  return createElement(Board, { snapshot, onOpenInspector: (sel) => boardState.openInspector(sel) })
 }
 
 /**

package/src/commands.ts

@@ -13,6 +13,7 @@ import { existsSync, readdirSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import type { RecursiveRuntime } from './runtime.ts'
 import { resolveControlPlaneRoot } from './workspace.ts'
+import { bootstrapScaffold } from './bootstrap.ts'
 
 export type RecursiveVerb = 'status' | 'spec' | 'worktree' | 'init' | 'lock' | 'qa' | 'closeout' | 'addendum' | 'review' | 'scratch' | 'bootstrap' | 'list' | 'help'
 
@@ -65,6 +66,16 @@ export function executeRecursiveCommand(root: string, rawInput: string): Recursi
     case 'help': {
       return { kind: 'success', text: HELP_TEXT + ' — see /.recursive/RECURSIVE.md' }
     }
+    case 'bootstrap': {
+      // R6 (run 09): manual repair path — idempotent upsert scaffold repair.
+      // Adds missing control-plane files/dirs + re-upserts marked blocks;
+      // never overwrites user content or touches run/ artifacts.
+      const result = bootstrapScaffold(root)
+      const summary = result.created.length === 0
+        ? 'scaffold already complete (no changes)'
+        : 'created ' + result.created.length + ' item(s), ' + result.existing.length + ' existing'
+      return { kind: 'success', text: 'recursive-mode scaffold repair: ' + summary + ' — root ' + root }
+    }
     case 'closeout': {
       const phaseMatch = arg.match(/--phase\s+(\d{2})/)
       const phase = phaseMatch?.[1] ?? ''

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,
+  }
+}