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

package/lib/fs-intent.d.ts

@@ -0,0 +1,34 @@
+import type { WorkspaceRegistryLike } 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 declare function fsPolicyIntent(agent: {
+    session?: {
+        header?: {
+            cwd?: string;
+        };
+    };
+} | null | undefined, registry?: WorkspaceRegistryLike | null, cwdFallback?: string): FsPolicyIntent | 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 declare function fsPolicyIntentAsync(agent: {
+    session?: {
+        header?: {
+            cwd?: string;
+        };
+    };
+} | null | undefined, registry?: WorkspaceRegistryLike | null, cwdFallback?: string): Promise<FsPolicyIntent | null>;

package/lib/index.d.ts

@@ -37,4 +37,5 @@ export declare const inject: string[];
  */
 export declare function apply(ctx: Context, config?: {
     shellOnly?: boolean;
+    repoRoot?: string;
 }): void;

package/lib/index.js

@@ -3444,6 +3444,42 @@ function registerRecursiveCommand(ctx, recursive) {
 	});
 }
 //#endregion
+//#region src/fs-intent.ts
+/**
+* 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.
+*/
+/**
+* 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).
+*/
+function fsPolicyIntent(agent, registry, cwdFallback) {
+	const cwd = agent?.session?.header?.cwd ?? cwdFallback ?? null;
+	if (!cwd) return null;
+	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
+	};
+}
+//#endregion
 //#region src/snapshot.ts
 /** Resolve a run's lock facts for one artifact file (receipt first, status fallback). */
 function lockFactsOf(runDir, artifact) {
@@ -3682,7 +3718,7 @@ function apply(ctx, config) {
 	ctx.effect(function* () {
 		const workspaceRegistry = ctx.get("workspaceRegistry");
 		const recursive = new RecursiveRuntime(ctx, {
-			repoRoot: process.cwd(),
+			repoRoot: config?.repoRoot ?? process.cwd(),
 			workspaceRegistry
 		});
 		const disposers = [
@@ -3702,14 +3738,11 @@ function apply(ctx, config) {
 			text: (context) => {
 				const agent = context?.agent;
 				if (!agent) return "";
-				if (!(agent.session?.header?.cwd ?? "")) return "";
-				const events = agent.session?.events ?? [];
-				const intent = detectTransitionIntent(events);
-				if (!intent || intent.worktreeRoot === "") return "";
+				const intent = fsPolicyIntent(agent, workspaceRegistry);
+				if (!intent) return "";
 				return renderRecursivePolicy({
 					worktreeRoot: intent.worktreeRoot,
 					runId: intent.runId,
-					folded: recursive.foldPhase(events),
 					config: recursive.enforcementConfig
 				});
 			}

package/lib/policy.d.ts

@@ -3,7 +3,7 @@ import type { EnforcementConfig } from './enforcement.ts';
 export interface PolicyContext {
     worktreeRoot: string;
     runId: string;
-    folded: RecursivePhaseState | null;
+    folded?: RecursivePhaseState | null;
     config?: EnforcementConfig;
 }
 /**

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.1.4",
+  "version": "0.1.5",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

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

package/src/index.ts

@@ -11,8 +11,8 @@ import { createRecursiveCloseoutTool } from './recursive_closeout.tool.ts'
 import { createRecursiveScratchTool } from './recursive_scratch.tool.ts'
 import { registerRecursiveCommand } from './commands.ts'
 import { evaluateToolGuard } from './enforcement.ts'
-import { detectTransitionIntent } from './lifecycle.ts'
 import { renderRecursivePolicy } from './policy.ts'
+import { fsPolicyIntent } from './fs-intent.ts'
 import { snapshotWorkspace } from './snapshot.ts'
 import { mountRecursiveRoutesOnce, makeRecursiveRoutes, type RecursiveRouteHost } from './live-route.ts'
 import { enumerateRuns } from './bootstrap.ts'
@@ -83,7 +83,7 @@ export const inject = ['tools']
  * 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, config?: { shellOnly?: boolean }) {
+export function apply(ctx: Context, config?: { shellOnly?: boolean; repoRoot?: string }) {
   // 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
@@ -97,7 +97,7 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean }) {
     // property access requires inject and would fail boot when undeclared.
     // Resolve the control-plane root strictly from the session agent's cwd.
     const workspaceRegistry = ctx.get('workspaceRegistry') as never
-    const recursive = new RecursiveRuntime(ctx, { repoRoot: process.cwd(), workspaceRegistry })
+    const recursive = new RecursiveRuntime(ctx, { repoRoot: config?.repoRoot ?? process.cwd(), workspaceRegistry })
 
     const disposers = [
       ctx.tools.register(createRecursiveStatusTool(recursive)),
@@ -122,14 +122,16 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean }) {
         name: 'recursive:policy',
         order: 55,
         text: (context: unknown) => {
-          const agent = (context as { agent?: { session?: { header?: { cwd?: string }; events?: { type: string; data?: Record<string, unknown> }[] } } } | undefined)?.agent
+          const agent = (context as { agent?: { session?: { header?: { cwd?: string } } } } | undefined)?.agent
           if (!agent) return ''
-          const cwd = agent.session?.header?.cwd ?? ''
-          if (!cwd) return ''
-          const events = agent.session?.events ?? []
-          const intent = detectTransitionIntent(events as never)
-          if (!intent || intent.worktreeRoot === '') return ''
-          return renderRecursivePolicy({ worktreeRoot: intent.worktreeRoot, runId: intent.runId, folded: recursive.foldPhase(events as never), config: recursive.enforcementConfig })
+          // 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/*
+          // events are appended.
+          const intent = fsPolicyIntent(agent, workspaceRegistry as never)
+          if (!intent) return ''
+          return renderRecursivePolicy({ worktreeRoot: intent.worktreeRoot, runId: intent.runId, config: recursive.enforcementConfig })
         },
       }))
     }

package/src/policy.ts

@@ -18,7 +18,7 @@ import { getArtifactRequiredSections, AUDITED_PHASE_FILES, CURRENT_WORKFLOW_PROF
 export interface PolicyContext {
   worktreeRoot: string
   runId: string
-  folded: RecursivePhaseState | null
+  folded?: RecursivePhaseState | null
   config?: EnforcementConfig
 }