@try-works/dsh-recursive-mode 0.2.1 → 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.js

@@ -4496,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 = [
@@ -4528,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.
 */
@@ -4641,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.
 */
@@ -4669,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) {
@@ -4694,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",
@@ -5653,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;
@@ -6648,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
@@ -7038,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, createRecursivePhaseTool, 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/runtime.d.ts

@@ -6,8 +6,8 @@ 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 {
@@ -273,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.1",
+  "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

@@ -134,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 ''

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/runtime.ts

@@ -22,8 +22,8 @@ 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'
@@ -577,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