@try-works/dsh-recursive-mode 0.2.0 → 0.2.2

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.d.ts

@@ -8,6 +8,7 @@ export { createRecursiveLintTool } from './recursive_lint.tool.ts';
 export { createRecursiveCloseoutTool } from './recursive_closeout.tool.ts';
 export { createRecursiveScratchTool } from './recursive_scratch.tool.ts';
 export { createRecursiveWorktreeTool } from './recursive_worktree.tool.ts';
+export { createRecursivePhaseTool } from './recursive_phase.tool.ts';
 export * from './status.ts';
 export { PHASE_SEQUENCE, OPTIONAL_PHASES, normalizeForLockHash, lockHashFromContent, phaseIndex, isCoreArtifact, getPrerequisites, getLockStatus, getPrerequisiteBlockers, receiptPath, readReceipt, writeReceipt, invalidateReceipt, getStaleDownstreamPhases, getNextLegalPhase, getAllStaleReceipts, validateChain, } from './lock.ts';
 export type { LockReceipt, LockStatus, PrerequisiteBlocker, StaleDownstream, ChainPhaseResult, LockChainResult, } from './lock.ts';

package/lib/index.js

@@ -393,17 +393,43 @@ function getArtifactRequiredSections(fileName, workflowProfile = CURRENT_WORKFLO
 	return headings;
 }
 /**
+* LIVE BUG 6 (0.2.1): dedup gate for the agent/pre-step lint-rules reminder.
+* Keyed by (root, runId, phase) so each new run or phase transition gets its own
+* single injection, while re-arming steps in the SAME phase stay silent. Scoped
+* to the apply() effect/fiber lifetime (one instance per mount), matching the
+* repairedRoots dedup used by the scaffold repair above the injection point.
+*/
+var ReminderOnceGate = class {
+	seen = /* @__PURE__ */ new Set();
+	shouldInject(root, runId, phase) {
+		const key = root + "\0" + runId + "\0" + phase;
+		if (this.seen.has(key)) return false;
+		this.seen.add(key);
+		return true;
+	}
+};
+function phaseRulesFor(fileName, workflowProfile = CURRENT_WORKFLOW_PROFILE$1) {
+	return {
+		fileName,
+		label: fileName.replace(/\.md$/, ""),
+		requiredSections: getArtifactRequiredSections(fileName, workflowProfile),
+		audited: AUDITED_PHASE_FILES$2.has(fileName),
+		tdd: fileName === "03-implementation-summary.md",
+		qa: fileName === "05-manual-qa.md"
+	};
+}
+/**
 * Compact lint-rules message for the pre-step injection (R5): this phase's
-* required sections + phase-specific gate notes, derived from the canonical
-* artifact-template sections. Kept short enough to prepend as a system-style
-* reminder without bloating the step context.
+* required sections + phase-specific gate notes, built from phaseRulesFor
+* (single source of truth with the recursive_phase tool). Output is unchanged
+* from the prior inline build so r5-parity.spec.ts stays green.
 */
 function phaseLintRulesMessage(fileName, workflowProfile = CURRENT_WORKFLOW_PROFILE$1) {
-	const sections = getArtifactRequiredSections(fileName, workflowProfile);
+	const rules = phaseRulesFor(fileName, workflowProfile);
 	return [
 		"<system-reminder>",
 		"Recursive-mode phase lint rules for THIS phase (" + fileName + "):",
-		"Required sections: " + sections.join(" | "),
+		"Required sections: " + rules.requiredSections.join(" | "),
 		"Gates: Coverage: FAIL until all checkboxes pass; Approval: FAIL until user sign-off; lock only via recursive_lock (monotonic).",
 		"Audited phases: end with Audit: PASS before setting Coverage/Approval PASS; record Audit Context and Audit Verdict.",
 		"TDD (phase 3): declare TDD Mode: strict|pragmatic; strict requires RED + GREEN evidence paths.",
@@ -4470,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 = [
@@ -4502,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.
 */
@@ -4615,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.
 */
@@ -4643,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) {
@@ -4668,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",
@@ -4841,7 +4772,8 @@ function renderRecursivePolicy(context) {
 		"- Phase 3 lock requires TDD evidence (strict) or rationale (pragmatic); Phase 5 requires QA sign-off for human/hybrid modes.",
 		"- The control-plane root is resolved STRICTLY from this session workspace (never scan other workspaces).",
 		"- Scratch is disposable, git-ignored, and never citable as an Input.",
-		"- The workflow spec lives at /.recursive/RECURSIVE.md; bootstrap it when missing."
+		"- The workflow spec lives at /.recursive/RECURSIVE.md; bootstrap it when missing.",
+		"- Call recursive_phase when entering a new phase; the same rules are auto-injected once per phase transition."
 	];
 	if (currentFile) {
 		const sections = getArtifactRequiredSections(currentFile, CURRENT_WORKFLOW_PROFILE$1);
@@ -5383,6 +5315,26 @@ var RecursiveRuntime = class extends Service {
 		return foldRun(resolved.runDir, resolved.runId);
 	}
 	/**
+	* LIVE BUG 6 refined: structured phase rules for the CURRENT phase. Resolves
+	* the workspace root (same as status/lock), finds the latest run (or the
+	* given runId), advances via getNextLegalPhase, and returns the phase's lint
+	* rules + instructions. Returns null when no active phase exists. This is the
+	* canonical data source for the recursive_phase tool.
+	*/
+	async phaseRules(runId, agent) {
+		const root = await this.resolveRootFor(agent);
+		if (!root) return null;
+		const resolved = resolveRunDir(root, runId);
+		if (!resolved) return null;
+		const phase = getNextLegalPhase(resolved.runDir);
+		if (!phase) return null;
+		return {
+			runId: resolved.runId,
+			phase,
+			...phaseRulesFor(phase)
+		};
+	}
+	/**
 	* Scaffold a run directory with FULL per-phase templates (no-op if exists).
 	* 00-requirements.md + 00-worktree.md are byte-identical to canonical
 	* recursive-init.py (incl. git-context prefill); later phases carry every
@@ -5606,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;
@@ -5974,6 +5911,37 @@ function createRecursiveWorktreeTool(recursive) {
 	});
 }
 //#endregion
+//#region src/recursive_phase.tool.ts
+/**
+* recursive_phase (refined LIVE BUG 6): the canonical on-demand home of the
+* current phase's lint rules + instructions. Reads the same structured source
+* (runtime.phaseRules -> phaseRulesFor) as the once-per-phase pre-step
+* reminder, so the agent can re-ask for the rules without re-injecting them on
+* every step. Returns { error } when no active phase is found.
+*/
+function createRecursivePhaseTool(recursive) {
+	return defineTool({
+		name: "recursive_phase",
+		description: "Return the lint rules + instructions for the current recursive-mode phase (required sections, gates, TDD/QA notes). Call once when entering a new phase; the same rules are also auto-injected once per phase transition.",
+		parameters: { runId: {
+			type: "string",
+			description: "Optional run id (defaults to the latest run by mtime)"
+		} },
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => [{
+				type: "text",
+				text: JSON.stringify(value, null, 2)
+			}]
+		},
+		async execute(args, exec) {
+			const result = await recursive.phaseRules(args.runId, exec.agent);
+			if (!result) return { error: "no recursive phase found" };
+			return result;
+		}
+	});
+}
+//#endregion
 //#region src/bootstrap.ts
 /**
 * Idempotent scaffold installer (R3). TS port of install-recursive-mode.py's
@@ -6570,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
@@ -6845,6 +6813,7 @@ function apply(ctx, config) {
 			workspaceRegistry
 		});
 		const repairedRoots = /* @__PURE__ */ new Set();
+		const reminderGate = new ReminderOnceGate();
 		const disposers = [
 			ctx.tools.register(createRecursiveStatusTool(recursive)),
 			ctx.tools.register(createRecursiveInitTool(recursive)),
@@ -6852,7 +6821,8 @@ function apply(ctx, config) {
 			ctx.tools.register(createRecursiveLintTool(recursive)),
 			ctx.tools.register(createRecursiveCloseoutTool(recursive)),
 			ctx.tools.register(createRecursiveScratchTool(recursive)),
-			ctx.tools.register(createRecursiveWorktreeTool(recursive))
+			ctx.tools.register(createRecursiveWorktreeTool(recursive)),
+			ctx.tools.register(createRecursivePhaseTool(recursive))
 		];
 		const commands = ctx.get("commands");
 		if (commands) disposers.push(registerRecursiveCommand({ commands }, recursive));
@@ -6923,6 +6893,10 @@ function apply(ctx, config) {
 				kind: "enter",
 				messages
 			};
+			if (!reminderGate.shouldInject(root, runId, phase)) return {
+				kind: "enter",
+				messages
+			};
 			const reminder = phaseLintRulesMessage(phase);
 			return {
 				kind: "enter",
@@ -6954,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, 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/phase-rules.d.ts

@@ -25,10 +25,35 @@ export declare const DIFF_BASIS_FIELDS: string[];
  * prior-evidence file set).
  */
 export declare function getArtifactRequiredSections(fileName: string, workflowProfile?: string): string[];
+/**
+ * LIVE BUG 6 (0.2.1): dedup gate for the agent/pre-step lint-rules reminder.
+ * Keyed by (root, runId, phase) so each new run or phase transition gets its own
+ * single injection, while re-arming steps in the SAME phase stay silent. Scoped
+ * to the apply() effect/fiber lifetime (one instance per mount), matching the
+ * repairedRoots dedup used by the scaffold repair above the injection point.
+ */
+export declare class ReminderOnceGate {
+    private seen;
+    shouldInject(root: string, runId: string, phase: string): boolean;
+}
+/**
+ * Structured, single-source-of-truth rules for one phase (refined LIVE BUG 6
+ * design): consumed by BOTH the recursive_phase tool and the once-per-phase
+ * pre-step reminder. Derived from the canonical artifact-template sections.
+ */
+export interface PhaseRules {
+    fileName: string;
+    label: string;
+    requiredSections: string[];
+    audited: boolean;
+    tdd: boolean;
+    qa: boolean;
+}
+export declare function phaseRulesFor(fileName: string, workflowProfile?: string): PhaseRules;
 /**
  * Compact lint-rules message for the pre-step injection (R5): this phase's
- * required sections + phase-specific gate notes, derived from the canonical
- * artifact-template sections. Kept short enough to prepend as a system-style
- * reminder without bloating the step context.
+ * required sections + phase-specific gate notes, built from phaseRulesFor
+ * (single source of truth with the recursive_phase tool). Output is unchanged
+ * from the prior inline build so r5-parity.spec.ts stays green.
  */
 export declare function phaseLintRulesMessage(fileName: string, workflowProfile?: string): string;

package/lib/recursive_phase.tool.d.ts

@@ -0,0 +1,9 @@
+import type { RecursiveRuntime } from './runtime.ts';
+/**
+ * recursive_phase (refined LIVE BUG 6): the canonical on-demand home of the
+ * current phase's lint rules + instructions. Reads the same structured source
+ * (runtime.phaseRules -> phaseRulesFor) as the once-per-phase pre-step
+ * reminder, so the agent can re-ask for the rules without re-injecting them on
+ * every step. Returns { error } when no active phase is found.
+ */
+export declare function createRecursivePhaseTool(recursive: RecursiveRuntime): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/runtime.d.ts

@@ -1,12 +1,13 @@
 import { Service, type Context } from '@deepseek-ai/cordis';
 import type { RecursiveStatusResult } from './types.ts';
 import { type WorkspaceRegistryLike } from './workspace.ts';
+import { type PhaseRules } from './phase-rules.ts';
 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 {
@@ -174,6 +175,23 @@ export declare class RecursiveRuntime extends Service {
             };
         };
     } | null): Promise<RecursiveStatusResult | null>;
+    /**
+     * LIVE BUG 6 refined: structured phase rules for the CURRENT phase. Resolves
+     * the workspace root (same as status/lock), finds the latest run (or the
+     * given runId), advances via getNextLegalPhase, and returns the phase's lint
+     * rules + instructions. Returns null when no active phase exists. This is the
+     * canonical data source for the recursive_phase tool.
+     */
+    phaseRules(runId?: string, agent?: {
+        session?: {
+            header?: {
+                cwd?: string;
+            };
+        };
+    } | null): Promise<(PhaseRules & {
+        runId: string;
+        phase: string;
+    }) | null>;
     /**
      * Scaffold a run directory with FULL per-phase templates (no-op if exists).
      * 00-requirements.md + 00-worktree.md are byte-identical to canonical
@@ -255,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.0",
+  "version": "0.2.2",
   "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/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

@@ -9,7 +9,8 @@ import { createRecursiveLockTool } from './recursive_lock.tool.ts'
 import { createRecursiveLintTool } from './recursive_lint.tool.ts'
 import { createRecursiveCloseoutTool } from './recursive_closeout.tool.ts'
 import { createRecursiveScratchTool } from './recursive_scratch.tool.ts'
-import { createRecursiveWorktreeTool } from './recursive_worktree.tool.ts'
+import { createRecursiveWorktreeTool } from './recursive_worktree.tool.ts'
+import { createRecursivePhaseTool } from './recursive_phase.tool.ts'
 import { registerRecursiveCommand } from './commands.ts'
 import { evaluateToolGuard } from './enforcement.ts'
 import { renderRecursivePolicy } from './policy.ts'
@@ -18,7 +19,7 @@ import { snapshotWorkspace } from './snapshot.ts'
 import { mountRecursiveRoutesOnce, makeRecursiveRoutes, type RecursiveRouteHost } from './live-route.ts'
 import { enumerateRuns, stageBWorkflowInit } from './bootstrap.ts'
 import { getNextLegalPhase, getLockStatus } from './lock.ts'
-import { phaseLintRulesMessage } from './phase-rules.ts'
+import { phaseLintRulesMessage, ReminderOnceGate } from './phase-rules.ts'
 
 export const name = '@try-works/dsh-recursive-mode'
 
@@ -29,7 +30,8 @@ export { createRecursiveLockTool } from './recursive_lock.tool.ts'
 export { createRecursiveLintTool } from './recursive_lint.tool.ts'
 export { createRecursiveCloseoutTool } from './recursive_closeout.tool.ts'
 export { createRecursiveScratchTool } from './recursive_scratch.tool.ts'
-export { createRecursiveWorktreeTool } from './recursive_worktree.tool.ts'
+export { createRecursiveWorktreeTool } from './recursive_worktree.tool.ts'
+export { createRecursivePhaseTool } from './recursive_phase.tool.ts'
 export * from './status.ts'
 export {
   PHASE_SEQUENCE,
@@ -101,7 +103,8 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean; repoRoot?: s
     const workspaceRegistry = ctx.get('workspaceRegistry') as never
     const recursive = new RecursiveRuntime(ctx, { repoRoot: config?.repoRoot ?? process.cwd(), workspaceRegistry })
 
-    const repairedRoots = new Set<string>()
+    const repairedRoots = new Set<string>()
+    const reminderGate = new ReminderOnceGate()
     const disposers = [
       ctx.tools.register(createRecursiveStatusTool(recursive)),
       ctx.tools.register(createRecursiveInitTool(recursive)),
@@ -109,7 +112,8 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean; repoRoot?: s
       ctx.tools.register(createRecursiveLintTool(recursive)),
       ctx.tools.register(createRecursiveCloseoutTool(recursive)),
       ctx.tools.register(createRecursiveScratchTool(recursive)),
-      ctx.tools.register(createRecursiveWorktreeTool(recursive)),
+      ctx.tools.register(createRecursiveWorktreeTool(recursive)),
+      ctx.tools.register(createRecursivePhaseTool(recursive)),
     ]
 
     // /recursive command (R4): preset-scoped registration, workspace-scoped dispatch.
@@ -130,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 ''
@@ -207,7 +212,11 @@ export function apply(ctx: Context, config?: { shellOnly?: boolean; repoRoot?: s
         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)
+        if (!reminderGate.shouldInject(root, runId, phase)) return { kind: 'enter', messages } as const
+                // LIVE BUG 6 (0.2.1): inject the lint-rules reminder AT MOST ONCE PER PHASE.
+                // The scaffold repair above is deduped via repairedRoots; the reminder itself was
+                // not, so every pre-step while DRAFT re-injected it.
+                const reminder = phaseLintRulesMessage(phase)
         return {
           kind: 'enter',
           messages: [...messages, createUserMessage({ content: [{ type: 'text', text: reminder }], source: { kind: 'plugin', plugin: '@try-works/dsh-recursive-mode' } })],

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/phase-rules.ts

@@ -240,18 +240,61 @@ export function getArtifactRequiredSections(fileName: string, workflowProfile: s
   return headings
 }
 
+/**
+ * LIVE BUG 6 (0.2.1): dedup gate for the agent/pre-step lint-rules reminder.
+ * Keyed by (root, runId, phase) so each new run or phase transition gets its own
+ * single injection, while re-arming steps in the SAME phase stay silent. Scoped
+ * to the apply() effect/fiber lifetime (one instance per mount), matching the
+ * repairedRoots dedup used by the scaffold repair above the injection point.
+ */
+export class ReminderOnceGate {
+  private seen = new Set<string>()
+
+  shouldInject(root: string, runId: string, phase: string): boolean {
+    const key = root + '\u0000' + runId + '\u0000' + phase
+    if (this.seen.has(key)) return false
+    this.seen.add(key)
+    return true
+  }
+}
+
+/**
+ * Structured, single-source-of-truth rules for one phase (refined LIVE BUG 6
+ * design): consumed by BOTH the recursive_phase tool and the once-per-phase
+ * pre-step reminder. Derived from the canonical artifact-template sections.
+ */
+export interface PhaseRules {
+  fileName: string
+  label: string
+  requiredSections: string[]
+  audited: boolean
+  tdd: boolean
+  qa: boolean
+}
+
+export function phaseRulesFor(fileName: string, workflowProfile: string = CURRENT_WORKFLOW_PROFILE): PhaseRules {
+  return {
+    fileName,
+    label: fileName.replace(/\.md$/, ''),
+    requiredSections: getArtifactRequiredSections(fileName, workflowProfile),
+    audited: AUDITED_PHASE_FILES.has(fileName),
+    tdd: fileName === '03-implementation-summary.md',
+    qa: fileName === '05-manual-qa.md',
+  }
+}
+
 /**
  * Compact lint-rules message for the pre-step injection (R5): this phase's
- * required sections + phase-specific gate notes, derived from the canonical
- * artifact-template sections. Kept short enough to prepend as a system-style
- * reminder without bloating the step context.
+ * required sections + phase-specific gate notes, built from phaseRulesFor
+ * (single source of truth with the recursive_phase tool). Output is unchanged
+ * from the prior inline build so r5-parity.spec.ts stays green.
  */
 export function phaseLintRulesMessage(fileName: string, workflowProfile: string = CURRENT_WORKFLOW_PROFILE): string {
-  const sections = getArtifactRequiredSections(fileName, workflowProfile)
+  const rules = phaseRulesFor(fileName, workflowProfile)
   const lines = [
     '<system-reminder>',
     'Recursive-mode phase lint rules for THIS phase (' + fileName + '):',
-    'Required sections: ' + sections.join(' | '),
+    'Required sections: ' + rules.requiredSections.join(' | '),
     'Gates: Coverage: FAIL until all checkboxes pass; Approval: FAIL until user sign-off; lock only via recursive_lock (monotonic).',
     'Audited phases: end with Audit: PASS before setting Coverage/Approval PASS; record Audit Context and Audit Verdict.',
     'TDD (phase 3): declare TDD Mode: strict|pragmatic; strict requires RED + GREEN evidence paths.',
@@ -259,4 +302,4 @@ export function phaseLintRulesMessage(fileName: string, workflowProfile: string
     '</system-reminder>',
   ]
   return lines.join('\n')
-}
+}

package/src/policy.ts

@@ -55,6 +55,7 @@ export function renderRecursivePolicy(context: PolicyContext | null): string {
     '- The control-plane root is resolved STRICTLY from this session workspace (never scan other workspaces).',
     '- Scratch is disposable, git-ignored, and never citable as an Input.',
     '- The workflow spec lives at /.recursive/RECURSIVE.md; bootstrap it when missing.',
+    '- Call recursive_phase when entering a new phase; the same rules are auto-injected once per phase transition.',
   ];
 
   // R5: surface the current phase's required sections + gate checklist.

package/src/recursive_phase.tool.ts

@@ -0,0 +1,29 @@
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import type { JsonValue } from '@deepseek-ai/dsh-tools'
+import type { RecursiveRuntime } from './runtime.ts'
+
+/**
+ * recursive_phase (refined LIVE BUG 6): the canonical on-demand home of the
+ * current phase's lint rules + instructions. Reads the same structured source
+ * (runtime.phaseRules -> phaseRulesFor) as the once-per-phase pre-step
+ * reminder, so the agent can re-ask for the rules without re-injecting them on
+ * every step. Returns { error } when no active phase is found.
+ */
+export function createRecursivePhaseTool(recursive: RecursiveRuntime) {
+  return defineTool({
+    name: 'recursive_phase',
+    description: 'Return the lint rules + instructions for the current recursive-mode phase (required sections, gates, TDD/QA notes). Call once when entering a new phase; the same rules are also auto-injected once per phase transition.',
+    parameters: {
+      runId: { type: 'string', description: 'Optional run id (defaults to the latest run by mtime)' },
+    },
+    output: {
+      schema: { type: 'json' },
+      render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+    },
+    async execute(args: { runId?: string }, exec) {
+      const result = await recursive.phaseRules(args.runId, exec.agent as { session?: { header?: { cwd?: string } } } | null)
+      if (!result) return { error: 'no recursive phase found' } as const
+      return result as unknown as JsonValue
+    },
+  })
+}

package/src/runtime.ts

@@ -15,14 +15,15 @@ import {
 } from './lock.ts'
 import type { RecursiveStatusResult } from './types.ts'
 import { resolveControlPlaneRoot, type WorkspaceRegistryLike } from './workspace.ts'
+import { phaseRulesFor, type PhaseRules } from './phase-rules.ts'
 import { closeoutPhase } from './closeout.ts'
 import { readScratch, writeScratch, appendScratch, type ScratchTarget } from './scratch.ts'
 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'
@@ -338,6 +339,23 @@ export class RecursiveRuntime extends Service {
     return foldRun(resolved.runDir, resolved.runId)
   }
 
+  /**
+   * LIVE BUG 6 refined: structured phase rules for the CURRENT phase. Resolves
+   * the workspace root (same as status/lock), finds the latest run (or the
+   * given runId), advances via getNextLegalPhase, and returns the phase's lint
+   * rules + instructions. Returns null when no active phase exists. This is the
+   * canonical data source for the recursive_phase tool.
+   */
+  async phaseRules(runId?: string, agent?: { session?: { header?: { cwd?: string } } } | null): Promise<(PhaseRules & { runId: string; phase: string }) | null> {
+    const root = await this.resolveRootFor(agent)
+    if (!root) return null
+    const resolved = resolveRunDir(root, runId)
+    if (!resolved) return null
+    const phase = getNextLegalPhase(resolved.runDir)
+    if (!phase) return null
+    return { runId: resolved.runId, phase, ...phaseRulesFor(phase) }
+  }
+
   /**
    * Scaffold a run directory with FULL per-phase templates (no-op if exists).
    * 00-requirements.md + 00-worktree.md are byte-identical to canonical
@@ -559,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