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

package/src/phase-rules.ts

@@ -0,0 +1,262 @@
+/**
+ * Phase rules (R5): canonical parity port of lint-recursive-run.py's
+ * get_artifact_required_sections + workflow/audit constants. Single source of
+ * truth for per-phase required section headings and audit extras; consumed by
+ * initRun templates, renderRecursivePolicy, and the pre-step lint-rules
+ * injection. Values are byte-identical to the canonical linter (recursive-
+ * mode-audit-v2).
+ */
+
+export const CURRENT_WORKFLOW_PROFILE = 'recursive-mode-audit-v2'
+export const STRICT_WORKFLOW_PROFILE = 'recursive-mode-audit-v1'
+export const COMPAT_WORKFLOW_PROFILE = 'memory-phase8'
+export const STRICT_WORKFLOW_PROFILES = new Set([CURRENT_WORKFLOW_PROFILE, STRICT_WORKFLOW_PROFILE])
+
+export const LATE_PHASE_ARTIFACTS = ['06-decisions-update.md', '07-state-update.md', '08-memory-impact.md']
+
+export 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',
+])
+
+export const PRIOR_RECURSIVE_EVIDENCE_FILES = new Set([
+  '01-as-is.md',
+  '02-to-be-plan.md',
+  '04-test-summary.md',
+  '07-state-update.md',
+  '08-memory-impact.md',
+])
+
+export const DIFF_AUDITED_FILES = new Set([
+  '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',
+])
+
+export const TRACEABILITY_REQUIRED_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',
+  '05-manual-qa.md',
+  '06-decisions-update.md',
+  '07-state-update.md',
+  '08-memory-impact.md',
+])
+
+export const AUDIT_REQUIRED_HEADINGS = [
+  'Audit Context',
+  'Effective Inputs Re-read',
+  'Earlier Phase Reconciliation',
+  'Subagent Contribution Verification',
+  'Worktree Diff Audit',
+  'Gaps Found',
+  'Repair Work Performed',
+  'Requirement Completion Status',
+  'Audit Verdict',
+]
+
+export const DIFF_BASIS_FIELDS = [
+  'Baseline type',
+  'Baseline reference',
+  'Comparison reference',
+  'Normalized baseline',
+  'Normalized comparison',
+  'Normalized diff command',
+]
+
+const SECTION_MAP: Record<string, string[]> = {
+  '00-worktree.md': [
+    'TODO',
+    'Directory Selection',
+    'Safety Verification',
+    'Worktree Creation',
+    'Main Branch Protection',
+    'Project Setup',
+    'Test Baseline Verification',
+    'Worktree Context',
+    'Diff Basis For Later Audits',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '00-requirements.md': [
+    'TODO',
+    'Requirements',
+    'Out of Scope',
+    'Constraints',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '01-as-is.md': [
+    'TODO',
+    'Reproduction Steps (Novice-Runnable)',
+    'Current Behavior by Requirement',
+    'Source Requirement Inventory',
+    'Relevant Code Pointers',
+    'Known Unknowns',
+    'Evidence',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '01.5-root-cause.md': [
+    'TODO',
+    'Error Analysis',
+    'Reproduction Verification',
+    'Recent Changes Analysis',
+    'Evidence Gathering (Multi-Layer if applicable)',
+    'Data Flow Trace',
+    'Pattern Analysis',
+    'Hypothesis Testing',
+    'Root Cause Summary',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '02-to-be-plan.md': [
+    'TODO',
+    'Planned Changes by File',
+    'Requirement Mapping',
+    'Implementation Steps',
+    'Testing Strategy',
+    'Playwright Plan (if applicable)',
+    'Manual QA Scenarios',
+    'Idempotence and Recovery',
+    'Implementation Sub-phases',
+    'Plan Drift Check',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '03-implementation-summary.md': [
+    'TODO',
+    'Changes Applied',
+    'TDD Compliance Log',
+    'Plan Deviations',
+    'Implementation Evidence',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '03.5-code-review.md': [
+    'TODO',
+    'Review Scope',
+    'Plan Alignment Assessment',
+    'Code Quality Assessment',
+    'Issues Found',
+    'Verdict',
+    'Review Metadata',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '04-test-summary.md': [
+    'TODO',
+    'Pre-Test Implementation Audit',
+    'Environment',
+    'Execution Mode',
+    'Commands Executed (Exact)',
+    'Results Summary',
+    'Evidence and Artifacts',
+    'Failures and Diagnostics (if any)',
+    'Flake/Rerun Notes',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '05-manual-qa.md': [
+    'TODO',
+    'QA Execution Record',
+    'QA Scenarios and Results',
+    'Evidence and Artifacts',
+    'User Sign-Off',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '06-decisions-update.md': [
+    'TODO',
+    'Decisions Changes Applied',
+    'Rationale',
+    'Resulting Decision Entry',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '07-state-update.md': [
+    'TODO',
+    'State Changes Applied',
+    'Rationale',
+    'Resulting State Summary',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+  '08-memory-impact.md': [
+    'TODO',
+    'Diff Basis',
+    'Changed Paths Review',
+    'Affected Memory Docs',
+    'Run-Local Skill Usage Capture',
+    'Skill Memory Promotion Review',
+    'Uncovered Paths',
+    'Router and Parent Refresh',
+    'Final Status Summary',
+    'Traceability',
+    'Coverage Gate',
+    'Approval Gate',
+  ],
+}
+
+/**
+ * get_artifact_required_sections(file_name, workflow_profile): canonical-parity
+ * required section headings for a phase artifact. Defaults to TODO + Coverage
+ * Gate + Approval Gate for unknown files. Audited phases in strict profiles get
+ * the audit headings appended (plus Prior Recursive Evidence Reviewed for the
+ * prior-evidence file set).
+ */
+export function getArtifactRequiredSections(fileName: string, workflowProfile: string = CURRENT_WORKFLOW_PROFILE): string[] {
+  const headings = [...(SECTION_MAP[fileName] ?? ['TODO', 'Coverage Gate', 'Approval Gate'])]
+  if (STRICT_WORKFLOW_PROFILES.has(workflowProfile) && AUDITED_PHASE_FILES.has(fileName)) {
+    headings.push(...AUDIT_REQUIRED_HEADINGS)
+    if (PRIOR_RECURSIVE_EVIDENCE_FILES.has(fileName)) {
+      headings.push('Prior Recursive Evidence Reviewed')
+    }
+  }
+  return headings
+}
+
+/**
+ * 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.
+ */
+export function phaseLintRulesMessage(fileName: string, workflowProfile: string = CURRENT_WORKFLOW_PROFILE): string {
+  const sections = getArtifactRequiredSections(fileName, workflowProfile)
+  const lines = [
+    '<system-reminder>',
+    'Recursive-mode phase lint rules for THIS phase (' + fileName + '):',
+    'Required sections: ' + sections.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.',
+    'QA (phase 5): declare QA Execution Mode: human|agent-operated|hybrid; human/hybrid need user sign-off.',
+    '</system-reminder>',
+  ]
+  return lines.join('\n')
+}

package/src/policy.ts

@@ -2,8 +2,9 @@
  * recursive:policy prompt-section renderer (Phase C R5, PROPOSAL 8.4 Layer 3).
  * Renders the CURRENT phase's contract from folded state + enforcement config:
  * what must exist before advancing, which tools are denied/asked this phase,
- * the strict/pragmatic TDD mode, the QA mode, and the lock chain - the same
- * rules the machine gates enforce (no prompt/gate contradiction).
+ * the strict/pragmatic TDD mode, the QA mode, the lock chain, and (R5) the
+ * current phase's required sections + gate checklist — the same rules the
+ * machine gates enforce (no prompt/gate contradiction).
  */
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
@@ -12,6 +13,7 @@ import { foldRun } from './status.ts'
 import type { RecursivePhaseState } from './lifecycle.ts'
 import type { EnforcementConfig } from './enforcement.ts'
 import { DEFAULT_ENFORCEMENT } from './enforcement.ts'
+import { getArtifactRequiredSections, AUDITED_PHASE_FILES, CURRENT_WORKFLOW_PROFILE } from './phase-rules.ts'
 
 export interface PolicyContext {
   worktreeRoot: string
@@ -32,10 +34,12 @@ export function renderRecursivePolicy(context: PolicyContext | null): string {
   // Derive the current phase from files (never trust an unchecked fold).
   let currentPhase = folded?.phase ?? ''
   let nextRequired = ''
+  let currentFile = ''
   const status = existsSync(runDir) ? foldRun(runDir, context.runId) : null
   if (status?.currentPhase) {
     currentPhase = status.currentPhase.label + ' (' + status.currentPhase.status + ')'
     nextRequired = status.currentPhase.phaseName + ' (' + status.currentPhase.key + ')'
+    currentFile = status.currentPhase.phaseName
   }
 
   const strictness = (gate: EnforcementConfig[keyof EnforcementConfig]) => gate
@@ -51,6 +55,26 @@ 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.',
-  ]
+  ];
+
+  // R5: surface the current phase's required sections + gate checklist.
+  if (currentFile) {
+    const sections = getArtifactRequiredSections(currentFile, CURRENT_WORKFLOW_PROFILE)
+    lines.push('');
+    lines.push('## This phase (' + currentFile + ') required sections (canonical lint):');
+    lines.push('- ' + sections.join(' | '));
+    lines.push('## This phase gate checklist:');
+    lines.push('- Coverage: FAIL until every checklist item is done; Approval: FAIL until sign-off; lock only via recursive_lock (monotonic).');
+    if (AUDITED_PHASE_FILES.has(currentFile)) {
+      lines.push('- Audited phase: end with Audit: PASS before setting Coverage/Approval PASS; record Audit Context + Audit Verdict.');
+    }
+    if (currentFile === '03-implementation-summary.md') {
+      lines.push('- TDD Mode: strict|pragmatic; strict requires RED + GREEN evidence paths.');
+    }
+    if (currentFile === '05-manual-qa.md') {
+      lines.push('- QA Execution Mode: human|agent-operated|hybrid; human/hybrid require user sign-off.');
+    }
+  }
+
   return lines.join('\n')
-}
+}

package/src/runtime.ts

@@ -1,6 +1,9 @@
 import { Service, type Context } from '@deepseek-ai/cordis'
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
 import { join } from 'node:path'
+import { referencesRoot } from './bootstrap.ts'
+import { requirementsContent, worktreeContent, laterPhaseContent, detectGitContext, RUN_SCAFFOLD_DIRS, type GitContext } from './init-templates.ts'
 import { foldRun, resolveRunDir } from './status.ts'
 import {
   getLockStatus,
@@ -22,9 +25,8 @@ import { delegate, validateReferences, writeActionRecord, evaluateDelegationResu
 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 type { Session } from '@deepseek-ai/dsh-session'
-import { runCreated as runCreatedEvent, phase as phaseEvent, phaseLocked as phaseLockedEvent, runState as runStateEvent } from './events.ts'
 import { renderRecursivePolicy, type PolicyContext } from './policy.ts'
-import { foldRecursiveProjection as foldProjectionEvent, emptyRecursiveFoldState, recursiveProjectionUnit, isInsideWorkspace, type RecursiveEventLike, type RecursiveFoldState } from './projection.ts'
+import { snapshotWorkspace } from './snapshot.ts'
 
 declare module '@deepseek-ai/cordis' {
   interface Context {
@@ -303,23 +305,28 @@ export class RecursiveRuntime extends Service {
   }
 
   /**
-   * Emit a recursive/* event into the session whose control-plane root matches
-   * `root` (additive log-only; the projection drives from these). Falls back to
-   * the agent's session when passed, else the session store list.
+   * SP2 R1 route adapter: resolve the control-plane root for the live route.
+   * sessionId PRIMARY — the host looks up the attached session header cwd and
+   * resolves the root from THAT; the client-passed cwd is a fallback hint only
+   * (hydration / headless callers). Two sessions in one workspace collapse to
+   * one root; a subdir cwd resolves up to the workspace root.
    */
-  private emitToSession(root: string, type: string, data: unknown, agent?: { session?: { header?: { cwd?: string } } | null } | null) {
-    const sessions = this.ctx.get('sessions') as { list?: () => Session[] } | undefined
-    const candidates: Session[] = []
-    if (agent?.session) candidates.push(agent.session as unknown as Session)
-    const listed = sessions?.list?.() ?? []
-    for (const s of listed) candidates.push(s)
-    const norm = (x: string) => x.split(String.fromCharCode(92)).join("/")
-    const target = candidates.find((s) => {
-      const cwd = norm(s.header?.cwd ?? "")
-      return cwd === "" || cwd === norm(root) || cwd.startsWith(norm(root) + "/")
-    })
-    if (!target) return
-    try { (target.append as unknown as (t: string, d: unknown) => void)(type, data) } catch { /* log-only */ }
+  async resolveRootForRoute(sessionId: string | undefined, cwd: string, sessionsStore?: { get?: (id: string) => { header?: { cwd?: string } } | undefined } | null): Promise<string | null> {
+    // 1) Attached session header (authoritative when present).
+    if (sessionId && sessionsStore?.get) {
+      const attached = sessionsStore.get(sessionId)
+      const headerCwd = attached?.header?.cwd
+      if (headerCwd) {
+        const root = await resolveControlPlaneRoot({ session: { header: { cwd: headerCwd } } }, this.workspaceRegistry, this.repoRoot)
+        if (root) return root
+      }
+    }
+    // 2) Client cwd fallback (hydration / headless) — still registry-canonicalized.
+    if (cwd) {
+      const root = await resolveControlPlaneRoot({ session: { header: { cwd } } }, this.workspaceRegistry, this.repoRoot)
+      if (root) return root
+    }
+    return null
   }
 
   async status(runId?: string, agent?: { session?: { header?: { cwd?: string } } } | null): Promise<RecursiveStatusResult | null> {
@@ -331,8 +338,12 @@ export class RecursiveRuntime extends Service {
   }
 
   /**
-   * Scaffold a run directory with stub artifact headers (no-op if exists).
-   * Returns the run dir + created artifacts.
+   * 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
+   * required section (get_artifact_required_sections) + TODO + FAIL gates.
+   * Also scaffolds addenda/subagents/router-prompts/evidence dirs. Returns the
+   * run dir + created artifacts.
    */
   async initRun(runId: string, agent?: { session?: { header?: { cwd?: string } } } | null): Promise<{ runDir: string; runId: string; created: string[]; existing: string[] }> {
     const root = await this.resolveRootFor(agent)
@@ -341,23 +352,50 @@ export class RecursiveRuntime extends Service {
     mkdirSync(runDir, { recursive: true })
     const created: string[] = []
     const existing: string[] = []
-    for (const [file, fields] of Object.entries(ARTIFACT_STUB)) {
+
+    // Scaffold dirs (canonical recursive-init sequence).
+    for (const dir of RUN_SCAFFOLD_DIRS) {
+      const p = join(runDir, dir)
+      if (existsSync(p)) { existing.push(dir + '/'); continue }
+      mkdirSync(p, { recursive: true })
+      created.push(dir + '/')
+    }
+
+    // Git context for the Phase 0 diff-basis prefill (canonical parity).
+    const { context: gitContext, error: prefillError } = detectGitContext(root)
+
+    // Phase 0 templates: byte-identical to canonical recursive-init.py.
+    const phase0: Array<[string, string]> = [
+      ['00-requirements.md', requirementsContent(runId, 'feature', '')],
+      ['00-worktree.md', worktreeContent(runId, root, gitContext, prefillError)],
+    ]
+    for (const [file, content] of phase0) {
       const path = join(runDir, file)
-      if (existsSync(path)) {
-        existing.push(file)
-        continue
-      }
-      const header = fields.map((f, i) => (i === 0 ? f + runId : f)).join('\n')
-      writeFileSync(path, '# ' + file.replace(/\.md$/, '') + ' — ' + file + '\n\n' + header + '\n', 'utf8')
+      if (existsSync(path)) { existing.push(file); continue }
+      writeFileSync(path, content, 'utf8')
       created.push(file)
     }
-    // B2: a run's files first exist here — the run-created event feeds the
-    // projection's worktree-grouped card. Emit only when the scaffold is fresh
-    // (created.length > 0) so resume/ensure does not double-log.
-    if (created.length > 0) {
-      this.emitToSession(root, 'recursive/run-created', runCreatedEvent({ runId, worktreeRoot: root }), agent)
-      this.emitToSession(root, 'recursive/run-state', runStateEvent({ runId, worktreeRoot: root, state: 'new' }), agent)
+
+    // Later phases: full required-sections scaffold.
+    const laterPhases = [
+      '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',
+      '05-manual-qa.md',
+      '06-decisions-update.md',
+      '07-state-update.md',
+      '08-memory-impact.md',
+    ]
+    for (const file of laterPhases) {
+      const path = join(runDir, file)
+      if (existsSync(path)) { existing.push(file); continue }
+      writeFileSync(path, laterPhaseContent(runId, file), 'utf8')
+      created.push(file)
     }
+
     return { runDir, runId, created, existing }
   }
 
@@ -376,9 +414,8 @@ export class RecursiveRuntime extends Service {
     if (!existsSync(artifactPath)) throw new Error('Artifact not found: ' + artifact)
     const status = getLockStatus(artifactPath)
     if (status === 'LOCKED') throw new Error('Artifact already LOCKED: ' + artifact)
-    // B2: log the phase-intent BEFORE validation so the pre-step gate reads it
-    // (the caller of the transition set). Never a projection event.
-    this.emitToSession(root, 'recursive/phase-intent', { runId, worktreeRoot: root, targetArtifact: artifact, kind: 'lock' }, agent)
+    // B2: the pre-step gate reads transition intent from the session log; the
+    // durable commit below is what the live fs route folds. No phase-intent event.
     const blockers = getPrerequisiteBlockers(runDir, artifact)
     if (blockers.length > 0) {
       throw new Error('Prerequisite blockers: ' + blockers.map(b => b.artifact + ' (' + b.status + ')').join(', '))
@@ -392,11 +429,7 @@ export class RecursiveRuntime extends Service {
     content = setOrInsertField(content, 'LockHash', lockHash, ['LockedAt', 'Status'])
     writeFileSync(artifactPath, content, 'utf8')
     const receipt = writeReceipt(runDir, artifact, artifactPath)
-    // B2: the commit is durable — emit phase + phase-locked (the projection's
-    // last-wins phase chain + lock badge + truncated hash).
-    this.emitToSession(root, 'recursive/phase', phaseEvent({ runId, worktreeRoot: root, phase: artifact, status: 'LOCKED' }), agent)
-    this.emitToSession(root, 'recursive/phase-locked', phaseLockedEvent({ runId, worktreeRoot: root, phase: artifact, lockedAt, lockHash }), agent)
-    this.emitToSession(root, 'recursive/run-state', runStateEvent({ runId, worktreeRoot: root, state: 'active' }), agent)
+    // B2: the commit is durable — the live fs route folds it on the next GET.
     return {
       artifact,
       runId,
@@ -419,11 +452,7 @@ export class RecursiveRuntime extends Service {
     const hadReceipt = invalidateReceipt(runDir, artifact)
     const stale = getStaleDownstreamPhases(runDir, artifact)
     for (const entry of stale) invalidateReceipt(runDir, entry.artifact)
-    // B2: reopen reverts to DRAFT — log phase-intent + emit the transition so
-    // the pre-step gate and projection both see the reverted state.
-    this.emitToSession(root, 'recursive/phase-intent', { runId, worktreeRoot: root, targetArtifact: artifact, kind: 'reopen' }, agent)
-    this.emitToSession(root, 'recursive/phase', phaseEvent({ runId, worktreeRoot: root, phase: artifact, status: 'DRAFT' }), agent)
-    this.emitToSession(root, 'recursive/run-state', runStateEvent({ runId, worktreeRoot: root, state: 'active', reason: 'reopened ' + artifact }), agent)
+    // B2: reopen reverts to DRAFT — the live fs route folds the reverted state.
     return {
       artifact,
       runId,
@@ -435,8 +464,12 @@ export class RecursiveRuntime extends Service {
   }
 
   /**
-   * Lint an artifact for phase-specific issues. Minimal structural checks:
-   * gates present, TODO section, Status field, LockHash consistency.
+   * Lint an artifact with FULL canonical parity: shells out to the vendored
+   * lint-recursive-run.py (byte-identical to canonical) and parses its
+   * [FAIL]/[WARN] lines + Summary counts. `errors` = FAIL lines, `warnings` =
+   * WARN lines, `passed` = no FAIL (WARN-only passes, matching the canonical
+   * non-strict verdict). Falls back to the structural check only if the vendored
+   * script is unavailable (e.g. bundled lib without references/).
    */
   async lintArtifact(runId: string, artifact?: string, agent?: { session?: { header?: { cwd?: string } } } | null): Promise<LintArtifactResult> {
     const root = await this.resolveRootFor(agent)
@@ -447,6 +480,24 @@ export class RecursiveRuntime extends Service {
     if (!existsSync(artifactPath)) {
       return { artifact: target, runId, errors: ['Artifact not found'], warnings: [], passed: false }
     }
+    const lintScript = join(referencesRoot(), 'scripts', 'lint-recursive-run.py')
+    if (existsSync(lintScript)) {
+      try {
+        const stdout = execFileSync('python', [lintScript, '--repo-root', root, '--run-id', runId], {
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'ignore'],
+          timeout: 60000,
+        })
+        return parseLintOutput(stdout, target, runId)
+      } catch (err) {
+        const stdout = (err as { stdout?: string })?.stdout ?? ''
+        if (stdout.includes('Summary')) {
+          return parseLintOutput(stdout, target, runId)
+        }
+        // script failed to run entirely — fall through to structural check
+      }
+    }
+    // Structural fallback (no vendored script available).
     const content = readFileSync(artifactPath, 'utf8')
     const errors: string[] = []
     const warnings: string[] = []
@@ -456,10 +507,7 @@ export class RecursiveRuntime extends Service {
     else if (status === 'STALE_LOCK') errors.push('LockHash mismatch or missing lock fields')
     if (!/^[ \t]*## TODO[ \t]*$/m.test(content)) errors.push('Missing ## TODO section')
     for (const gate of ['Coverage', 'Approval']) {
-      if (!new RegExp('^[ \\t]*' + gate + ':\\s*(PASS|FAIL)\\s*$', 'm').test(content)) warnings.push('Missing ' + gate + ' gate')
-    }
-    if (target === '03-implementation-summary.md' && !new RegExp('^[ \\t]*TDD Compliance:\\s*(PASS|FAIL)\\s*$', 'm').test(content)) {
-      warnings.push('Missing TDD Compliance gate')
+      if (!new RegExp('^[ \t]*' + gate + ':\s*(PASS|FAIL)\s*$', 'm').test(content)) warnings.push('Missing ' + gate + ' gate')
     }
     return { artifact: target, runId, errors, warnings, passed: errors.length === 0 }
   }
@@ -504,31 +552,6 @@ export class RecursiveRuntime extends Service {
     return coupleGateBlockToGoal(goalService as never, agent, ref, reason)
   }
 
-  /** Phase D R1: append a recursive/* event through the host session adapter (worktree-keyed). */
-  emitRecursiveEvent(session: unknown, type: string, data: Record<string, unknown>): void {
-    const s = session as { append?: (type: string, data: unknown) => void } | null | undefined
-    if (s && typeof s.append === 'function') {
-      s.append(type, data)
-    }
-  }
-
-  /** Phase D R2/R9: fold a session log into the worktree-grouped projection. */
-  foldRecursiveProjection(events: readonly RecursiveEventLike[], workspaceRoot = ''): RecursiveFoldState {
-    let state = emptyRecursiveFoldState(workspaceRoot)
-    for (const event of events) state = foldProjectionEvent(state, event)
-    return state
-  }
-
-  /** Phase D R2: the registered projection unit (key 'recursive'). */
-  get projectionUnit() {
-    return recursiveProjectionUnit
-  }
-
-  /** Phase D R9: whether a worktreeRoot is inside the workspace control-plane root. */
-  isInsideWorkspace(worktreeRoot: string, workspaceRoot: string): boolean {
-    return isInsideWorkspace(worktreeRoot, workspaceRoot)
-  }
-
   /** Phase C R7: resolve the enforcement config (strict|advisory, default advisory). */
   get enforcementConfig(): EnforcementConfig {
     return this._enforcementConfig ?? DEFAULT_ENFORCEMENT
@@ -562,3 +585,32 @@ function setOrInsertField(content: string, fieldName: string, value: string, aft
 function escapeRegExp(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
+
+/**
+ * Parse the vendored lint-recursive-run.py stdout into a LintArtifactResult.
+ * [FAIL] lines -> errors, [WARN] lines -> warnings. When the run directory has
+ * multiple artifacts, FAIL/WARN lines carry the artifact path; we keep only the
+ * lines for the requested artifact (or all when the path is ambiguous).
+ */
+function parseLintOutput(stdout: string, target: string, runId: string): LintArtifactResult {
+  const errors: string[] = []
+  const warnings: string[] = []
+  const failRe = /^\[FAIL\]\s+(.*)$/gm
+  const warnRe = /^\[WARN\]\s+(.*)$/gm
+  const targetSuffix = target.replace(/^.*[\\/]/, '')
+  const isForTarget = (line: string) => {
+    const pathMatch = line.match(/[A-Za-z0-9_.-]+\.md/)
+    return !pathMatch || pathMatch[0] === targetSuffix
+  }
+  let m: RegExpExecArray | null
+  while ((m = failRe.exec(stdout)) !== null) {
+    if (isForTarget(m[1])) errors.push(m[1].trim())
+  }
+  while ((m = warnRe.exec(stdout)) !== null) {
+    if (isForTarget(m[1])) warnings.push(m[1].trim())
+  }
+  // If the target artifact appears nowhere in the output but the run was linted,
+  // keep the parsed errors/warnings (canonical script lints the whole run).
+  return { artifact: target, runId, errors, warnings, passed: errors.length === 0 }
+}
+