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

package/references/scripts/verify-locks.ps1

@@ -0,0 +1,25 @@
+[CmdletBinding()]
+param(
+    [string]$RunId = "",
+    [string]$RepoRoot = (Get-Location).Path,
+    [switch]$Fix,
+    [switch]$ShowHashes
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+$python = if ($env:PYTHON) { $env:PYTHON } elseif (Get-Command python -ErrorAction SilentlyContinue) { "python" } else { $null }
+if (-not $python) {
+    Write-Host "[FAIL] Python executable not found in PATH."
+    exit 1
+}
+
+$scriptPath = Join-Path $PSScriptRoot "verify-locks.py"
+$argsList = @($scriptPath, "--repo-root", $RepoRoot)
+if ($RunId) { $argsList += @("--run-id", $RunId) }
+if ($Fix.IsPresent) { $argsList += "--fix" }
+if ($ShowHashes.IsPresent) { $argsList += "--show-hashes" }
+
+& $python @argsList
+exit $LASTEXITCODE

package/references/scripts/verify-locks.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+"""
+Verify recursive-mode artifact lock integrity.
+
+Python equivalent to scripts/verify-locks.ps1.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import re
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def load_phase_rules_module():
+    module_path = Path(__file__).with_name("recursive_phase_rules.py")
+    spec = importlib.util.spec_from_file_location("recursive_phase_rules", module_path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Unable to load phase rules module from {module_path}")
+    module = importlib.util.module_from_spec(spec)
+    try:
+        spec.loader.exec_module(module)
+    except FileNotFoundError:
+        raise RuntimeError(f"Phase rules module not found: {module_path}")
+    return module
+
+
+STATUS_RE = re.compile(r'(?m)^[ \t]*Status:\s*(?:`|")?(\w+)(?:`|")?\s*$')
+LOCK_HASH_RE = re.compile(r'(?m)^[ \t]*LockHash:\s*(?:`|")?([a-fA-F0-9]{64})(?:`|")?\s*$')
+LOCKED_AT_RE = re.compile(r'(?m)^[ \t]*LockedAt:\s*(?:`|")?([^`"\r\n]+)(?:`|")?\s*$')
+LOCK_HASH_LINE_RE = re.compile(r'(?m)^[ \t]*LockHash:.*(?:\n|$)')
+WORKFLOW_VERSION_RE = re.compile(r'(?m)^[ \t]*Workflow version:\s*(?:`|")?([^`"\r\n]+)(?:`|")?\s*$')
+CURRENT_WORKFLOW_PROFILE = "recursive-mode-audit-v2"
+STRICT_WORKFLOW_PROFILE = "recursive-mode-audit-v1"
+COMPAT_WORKFLOW_PROFILE = "memory-phase8"
+STRICT_WORKFLOW_PROFILES = {CURRENT_WORKFLOW_PROFILE, STRICT_WORKFLOW_PROFILE}
+AUDITED_PHASE_FILES = {
+    "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",
+}
+
+
+@dataclass
+class LockResult:
+    valid: bool
+    error: str | None = None
+    stored_hash: str | None = None
+    actual_hash: str | None = None
+    locked_at: str | None = None
+    fixed: bool = False
+    new_locked_at: str | None = None
+    new_hash: str | None = None
+
+
+def write_status(status: str, message: str) -> None:
+    print(f"[{status}] {message}")
+
+
+def normalize_for_lock_hash(content: str) -> str:
+    normalized = content.replace("\r\n", "\n").replace("\r", "\n")
+    normalized = LOCK_HASH_LINE_RE.sub("", normalized)
+    return normalized
+
+
+def lock_hash_from_content(content: str) -> str:
+    normalized = normalize_for_lock_hash(content)
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()
+
+
+def get_workflow_profile(run_dir: Path) -> str:
+    requirements_path = run_dir / "00-requirements.md"
+    if requirements_path.exists():
+        content = requirements_path.read_text(encoding="utf-8")
+        match = WORKFLOW_VERSION_RE.search(content)
+        if match:
+            workflow_version = match.group(1).strip()
+            if workflow_version == CURRENT_WORKFLOW_PROFILE:
+                return CURRENT_WORKFLOW_PROFILE
+            if workflow_version == STRICT_WORKFLOW_PROFILE:
+                return STRICT_WORKFLOW_PROFILE
+            if workflow_version == COMPAT_WORKFLOW_PROFILE:
+                return COMPAT_WORKFLOW_PROFILE
+
+    for artifact in ("06-decisions-update.md", "07-state-update.md", "08-memory-impact.md"):
+        if (run_dir / artifact).exists():
+            return COMPAT_WORKFLOW_PROFILE
+
+    return "legacy"
+
+
+def test_lock_valid(artifact_path: Path, fix: bool = False) -> LockResult:
+    if not artifact_path.exists():
+        return LockResult(valid=False, error="File not found")
+
+    content = artifact_path.read_text(encoding="utf-8")
+
+    status_match = STATUS_RE.search(content)
+    if not status_match:
+        return LockResult(valid=False, error="No Status field found")
+    status = status_match.group(1)
+    if status != "LOCKED":
+        return LockResult(valid=False, error=f"Status is '{status}', expected 'LOCKED'")
+
+    hash_match = LOCK_HASH_RE.search(content)
+    if not hash_match:
+        return LockResult(valid=False, error="No LockHash field found")
+    stored_hash = hash_match.group(1).lower()
+
+    locked_at_match = LOCKED_AT_RE.search(content)
+    if not locked_at_match:
+        return LockResult(valid=False, error="No LockedAt field found")
+    locked_at = locked_at_match.group(1)
+
+    actual_hash = lock_hash_from_content(content)
+    if stored_hash == actual_hash:
+        return LockResult(valid=True, locked_at=locked_at, stored_hash=stored_hash)
+
+    result = LockResult(
+        valid=False,
+        error="Hash mismatch",
+        stored_hash=stored_hash,
+        actual_hash=actual_hash,
+        locked_at=locked_at,
+    )
+
+    if fix:
+        new_locked_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        content_with_new_locked_at = re.sub(
+            r"(?m)^[ \t]*LockedAt:.*$",
+            f"LockedAt: `{new_locked_at}`",
+            content,
+        )
+        new_hash = lock_hash_from_content(content_with_new_locked_at)
+        new_content = re.sub(
+            r"(?m)^[ \t]*LockHash:.*$",
+            f"LockHash: `{new_hash}`",
+            content_with_new_locked_at,
+        )
+        artifact_path.write_text(new_content, encoding="utf-8", newline="")
+
+        result.fixed = True
+        result.new_locked_at = new_locked_at
+        result.new_hash = new_hash
+
+    return result
+
+
+def test_gate(content: str, name: str) -> tuple[bool, str | None]:
+    pass_re = re.compile(rf"{name}:\s*PASS")
+    fail_re = re.compile(rf"{name}:\s*FAIL")
+    if pass_re.search(content):
+        return True, None
+    if fail_re.search(content):
+        return False, f"{name} gate shows FAIL"
+    return False, f"No {name} gate result found"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Verify recursive-mode artifact lock integrity.")
+    parser.add_argument("--run-id", default="", help="Run ID to verify. If omitted, scans all runs.")
+    parser.add_argument("--repo-root", default=".", help="Repository root path.")
+    parser.add_argument("--fix", action="store_true", help="Fix incorrect lock hashes (updates LockedAt + LockHash).")
+    parser.add_argument("--show-hashes", action="store_true", help="Show valid lock hashes in output.")
+    args = parser.parse_args()
+
+    resolved_repo_root = Path(args.repo_root).resolve()
+    print("\nRecursive Lock Verification")
+    print("=====================\n")
+    print(f"Repository: {resolved_repo_root}")
+    print(f"Run ID: {args.run_id if args.run_id else '(scanning all runs)'}\n")
+
+    run_base_dir = resolved_repo_root / ".recursive" / "run"
+    if not run_base_dir.exists():
+        write_status("FAIL", f"recursive run directory not found: {run_base_dir}")
+        return 1
+
+    if args.run_id:
+        runs = [args.run_id]
+    else:
+        runs = sorted([d.name for d in run_base_dir.iterdir() if d.is_dir()])
+
+    artifacts = [
+        {"file": "00-requirements.md", "name": "Requirements", "optional": False},
+        {"file": "00-worktree.md", "name": "Worktree Setup", "optional": False},
+        {"file": "01-as-is.md", "name": "AS-IS Analysis", "optional": True},
+        {"file": "01.5-root-cause.md", "name": "Root Cause", "optional": True},
+        {"file": "02-to-be-plan.md", "name": "TO-BE Plan", "optional": True},
+        {"file": "03-implementation-summary.md", "name": "Implementation", "optional": True},
+        {"file": "03.5-code-review.md", "name": "Code Review", "optional": True},
+        {"file": "04-test-summary.md", "name": "Test Summary", "optional": True},
+        {"file": "05-manual-qa.md", "name": "Manual QA", "optional": True},
+        {"file": "06-decisions-update.md", "name": "Decisions Update", "optional": False},
+        {"file": "07-state-update.md", "name": "State Update", "optional": False},
+        {"file": "08-memory-impact.md", "name": "Memory Impact", "optional": False},
+    ]
+
+    total_runs = 0
+    valid_runs = 0
+    fixed_runs = 0
+    failed_runs = 0
+    stale_chain_runs = 0
+
+    phase_rules = load_phase_rules_module()
+
+    for run in runs:
+        total_runs += 1
+        run_dir = run_base_dir / run
+        workflow_profile = get_workflow_profile(run_dir)
+        print(f"Checking run: {run}")
+        print("-" * 50)
+        print(f"Workflow profile: {workflow_profile}")
+
+        run_valid = True
+        run_fixed = False
+
+        for artifact in artifacts:
+            artifact_path = run_dir / artifact["file"]
+            is_required = not artifact["optional"]
+            if workflow_profile == "legacy" and artifact["file"] in {"06-decisions-update.md", "07-state-update.md", "08-memory-impact.md"}:
+                is_required = False
+            if not artifact_path.exists():
+                if not is_required:
+                    write_status("INFO", f"{artifact['name']}: Not found (optional)")
+                else:
+                    write_status("FAIL", f"{artifact['name']}: Missing (required)")
+                    run_valid = False
+                continue
+
+            content = artifact_path.read_text(encoding="utf-8")
+            if not re.search(r'(?m)^[ \t]*Status:\s*(?:`|")?LOCKED(?:`|")?\s*$', content):
+                write_status("WARN", f"{artifact['name']}: Not locked (DRAFT)")
+                run_valid = False
+                continue
+
+            result = test_lock_valid(artifact_path, fix=args.fix)
+            if result.valid:
+                write_status("PASS", f"{artifact['name']}: Valid (locked at {result.locked_at})")
+                if args.show_hashes and result.stored_hash:
+                    print(f"         Hash: {result.stored_hash}")
+            else:
+                if result.fixed:
+                    write_status("WARN", f"{artifact['name']}: Fixed hash mismatch (was tampered)")
+                    if result.stored_hash:
+                        print(f"         Old hash: {result.stored_hash}")
+                    if result.new_hash:
+                        print(f"         New hash: {result.new_hash}")
+                    if result.new_locked_at:
+                        print(f"         Updated at: {result.new_locked_at}")
+                    run_fixed = True
+                else:
+                    write_status("FAIL", f"{artifact['name']}: {result.error}")
+                    if result.stored_hash and result.actual_hash:
+                        print(f"         Stored: {result.stored_hash}")
+                        print(f"         Actual: {result.actual_hash}")
+                    run_valid = False
+
+            # Gate checks
+            updated_content = artifact_path.read_text(encoding="utf-8")
+            coverage_ok, coverage_reason = test_gate(updated_content, "Coverage")
+            approval_ok, approval_reason = test_gate(updated_content, "Approval")
+            audit_required = workflow_profile in STRICT_WORKFLOW_PROFILES and artifact["file"] in AUDITED_PHASE_FILES
+            audit_ok = True
+            audit_reason = None
+            if audit_required:
+                audit_ok, audit_reason = test_gate(updated_content, "Audit")
+            if not coverage_ok:
+                write_status("FAIL", f"{artifact['name']}: Coverage gate - {coverage_reason}")
+                run_valid = False
+            if not approval_ok:
+                write_status("FAIL", f"{artifact['name']}: Approval gate - {approval_reason}")
+                run_valid = False
+            if not audit_ok:
+                write_status("FAIL", f"{artifact['name']}: Audit gate - {audit_reason}")
+                run_valid = False
+
+        addenda_dir = run_dir / "addenda"
+        if addenda_dir.exists():
+            addenda_files = sorted(addenda_dir.glob("*.md"))
+            if addenda_files:
+                print("\nAddenda:")
+                for addendum in addenda_files:
+                    result = test_lock_valid(addendum, fix=args.fix)
+                    if result.valid:
+                        write_status("PASS", f"  {addendum.name}: Valid")
+                    elif result.fixed:
+                        write_status("WARN", f"  {addendum.name}: Fixed")
+                        run_fixed = True
+                    else:
+                        write_status("FAIL", f"  {addendum.name}: {result.error}")
+                        run_valid = False
+
+        # Stale-chain detection: check whether any prerequisite hash in a receipt
+        # no longer matches the current artifact content.
+        stale_entries = phase_rules.get_all_stale_receipts(run_dir)
+        run_stale = False
+        if stale_entries:
+            print("\nStale lock-chain receipts:")
+            for entry in stale_entries:
+                write_status("WARN", f"  {entry['artifact']}: {entry['reason']}")
+                run_stale = True
+
+        print()
+        if run_stale:
+            stale_chain_runs += 1
+            run_valid = False
+            write_status("WARN", f"Run '{run}': Stale lock-chain receipts detected (re-lock in phase order)")
+        elif run_valid and not run_fixed:
+            valid_runs += 1
+            write_status("PASS", f"Run '{run}': All locks valid")
+        elif run_fixed:
+            fixed_runs += 1
+            write_status("WARN", f"Run '{run}': Locks fixed (tampering detected)")
+        else:
+            failed_runs += 1
+            write_status("FAIL", f"Run '{run}': Lock verification failed")
+        print()
+
+    print("=====================")
+    print("Summary")
+    print("=====================\n")
+    print(f"Total runs checked: {total_runs}")
+    write_status("PASS", f"Valid runs: {valid_runs}")
+    if stale_chain_runs > 0:
+        write_status("WARN", f"Stale-chain runs: {stale_chain_runs}")
+    if fixed_runs > 0:
+        write_status("WARN", f"Fixed runs (tampered): {fixed_runs}")
+    if failed_runs > 0:
+        write_status("FAIL", f"Failed runs: {failed_runs}")
+    print()
+
+    if failed_runs == 0 and stale_chain_runs == 0:
+        write_status("PASS", "All locks verified successfully")
+        return 0
+    if failed_runs == 0:
+        write_status("WARN", "Lock hashes valid but stale-chain receipts detected")
+        return 1
+    write_status("FAIL", "Some locks failed verification")
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/install-preset.cmd

@@ -0,0 +1,7 @@
+@echo off
+rem install-preset.cmd — thin launcher for scripts\install-preset.js
+rem Materializes the `recursive` agent preset into %DSH_HOME%\.agent-presets\recursive\
+rem with an absolute file-URL row into the profile-installed package.
+setlocal
+node "%~dp0install-preset.js" %*
+exit /b %ERRORLEVEL%

package/scripts/install-preset.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * install-preset.js — materialize the `recursive` agent preset into the user's
+ * DSH home so `agentPreset.list` returns `recursive` and selecting it mounts the
+ * full per-session recursive-mode surface.
+ *
+ * R2 resolution (02-to-be-plan.addendum-r4-r2-mount-resolution.md), option (B):
+ * the preset's server-surface row is written as an ABSOLUTE file URL into the
+ * PROFILE-installed package (lib/index.js), NOT a vendored copy. This keeps the
+ * nested @deepseek-ai/cordis + @deepseek-ai/dsh-tools imports resolving through
+ * the profile's flat-fallback junctions (same cordis symbols => Service identity
+ * preserved), and `ctx.recursive` resolves correctly inside the isolate realm.
+ *
+ * Idempotent + atomic: writes to a temp file in the same directory, then renames.
+ *
+ * Usage: node install-preset.js [--profile <name>] [--dsh-home <dir>] [--force]
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { homedir } from 'node:os'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const PACKAGE_ROOT = resolve(__dirname, '..')
+const PRESET_SOURCE_DIR = join(PACKAGE_ROOT, 'preset', 'recursive')
+const PRESET_SOURCE = join(PRESET_SOURCE_DIR, 'agent.cordis.yml')
+const PRESET_METADATA_SOURCE = join(PRESET_SOURCE_DIR, 'preset.yml')
+const PLACEHOLDER = '@@RECURSIVE_SERVER_ENTRY@@'
+const PKG_NAME = '@try-works/dsh-recursive-mode'
+
+function parseArgs(argv) {
+  const out = { profile: 'web', dshHome: '', force: false }
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === '--profile' && argv[i + 1]) { out.profile = argv[++i]; continue }
+    if (a === '--dsh-home' && argv[i + 1]) { out.dshHome = argv[++i]; continue }
+    if (a === '--force') { out.force = true; continue }
+  }
+  return out
+}
+
+function fail(msg) {
+  console.error('[install-preset] FAIL: ' + msg)
+  process.exitCode = 1
+}
+
+const args = parseArgs(process.argv.slice(2))
+const dshHome = args.dshHome || process.env.DSH_HOME || join(homedir(), '.dsh')
+
+// Locate the profile install dir and its lib/index.js.
+const profilePkgDir = join(dshHome, 'profiles', args.profile, 'node_modules', ...PKG_NAME.split('/'))
+const serverEntry = join(profilePkgDir, 'lib', 'index.js')
+
+if (!existsSync(serverEntry)) {
+  fail(
+    'Profile-installed package entry not found: ' + serverEntry + "\n" +
+    '  Install the package into the profile first: pnpm dsh plugin --profile ' + args.profile + ' add ' + PKG_NAME,
+  )
+  process.exit(1)
+}
+
+const serverUrl = pathToFileURL(serverEntry).href
+
+// Read the preset template and materialize the placeholder.
+const template = readFileSync(PRESET_SOURCE, 'utf8')
+if (!template.includes(PLACEHOLDER)) {
+  fail('Preset template missing placeholder ' + PLACEHOLDER + ' in ' + PRESET_SOURCE)
+  process.exit(1)
+}
+const materialized = template.replaceAll(PLACEHOLDER, serverUrl)
+
+// Destination: ~/.dsh/.agent-presets/recursive/agent.cordis.yml
+const presetDir = join(dshHome, '.agent-presets', 'recursive')
+const presetFile = join(presetDir, 'agent.cordis.yml')
+
+if (existsSync(presetFile) && !args.force) {
+  const existing = readFileSync(presetFile, 'utf8')
+  if (existing === materialized) {
+    console.log('[install-preset] OK (already up to date): ' + presetFile)
+    console.log('  server entry: ' + serverUrl)
+    process.exit(0)
+  }
+}
+
+mkdirSync(presetDir, { recursive: true })
+const tmp = join(presetDir, '.agent.cordis.yml.tmp')
+writeFileSync(tmp, materialized, 'utf8')
+renameSync(tmp, presetFile)
+
+// Copy the optional display metadata (preset.yml) beside the composition so the
+// picker shows the human-facing name instead of the id. Absent source is fine.
+const metadataFile = join(presetDir, 'preset.yml')
+if (existsSync(PRESET_METADATA_SOURCE)) {
+  const metadataTmp = join(presetDir, '.preset.yml.tmp')
+  writeFileSync(metadataTmp, readFileSync(PRESET_METADATA_SOURCE, 'utf8'), 'utf8')
+  renameSync(metadataTmp, metadataFile)
+}
+
+console.log('[install-preset] OK: ' + presetFile)
+console.log('  server entry: ' + serverUrl)
+console.log('  (re-run is idempotent; add --force to overwrite an existing file)')

package/scripts/lint-recursive-run.py

@@ -743,7 +743,7 @@ def get_git_changed_files(repo_root: Path, diff_basis: dict[str, str | None]) ->
 
     try:
         diff_result = subprocess.run(
-            ["git", "-C", str(repo_root), *normalized_basis["git_args"]],
+            ["git", "-C", str(repo_root), *normalized_basis["git_args"], "--relative"],
             check=False,
             capture_output=True,
             text=True,
@@ -774,7 +774,7 @@ def get_git_changed_files(repo_root: Path, diff_basis: dict[str, str | None]) ->
     return sorted(set(path.strip() for path in changed if path.strip())), None
 
 
-def get_phase_owned_actual_changed_files(file_name: str, actual_changed_files: list[str] | None) -> list[str] | None:
+def get_phase_owned_actual_changed_files(file_name: str, actual_changed_files: list[str] | None, repo_root: Path | None = None) -> list[str] | None:
     if actual_changed_files is None:
         return None
     if file_name == "02-to-be-plan.md":
@@ -797,7 +797,9 @@ def get_phase_owned_actual_changed_files(file_name: str, actual_changed_files: l
         owned_paths.append(path)
 
     if file_name in PRODUCT_DIFF_PHASE_FILES:
-        return owned_paths
+        if repo_root is None:
+            return owned_paths
+        return [p for p in owned_paths if (repo_root / p).exists()]
     if file_name in DECISIONS_DIFF_PHASE_FILES | STATE_DIFF_PHASE_FILES | MEMORY_DIFF_PHASE_FILES:
         return owned_paths
     return None
@@ -1432,7 +1434,7 @@ def lint_requirement_completion_status(
         )
 
     if file_path.name in REQUIREMENT_CHANGED_FILE_ACCOUNTING_FILES:
-        expected_scope = set(get_phase_owned_actual_changed_files(file_path.name, actual_changed_files) or [])
+        expected_scope = set(get_phase_owned_actual_changed_files(file_path.name, actual_changed_files, run_dir.parent.parent.parent) or [])
         if expected_scope:
             claimed_changed_files = set()
             for fields in entries.values():
@@ -2476,7 +2478,7 @@ def lint_audit_sections(
     if audit_status == "PASS" and gaps_body and not re.search(r"\bnone\b", gaps_body, re.IGNORECASE):
         issues.append("Audit: PASS is invalid while Gaps Found still lists unresolved in-scope gaps")
 
-    expected_changed_files = get_phase_owned_actual_changed_files(file_path.name, actual_changed_files)
+    expected_changed_files = get_phase_owned_actual_changed_files(file_path.name, actual_changed_files, run_dir.parent.parent.parent)
     if file_path.name in DIFF_AUDITED_FILES and expected_changed_files is not None:
         if diff_basis_error:
             issues.append(f"Cannot verify git diff basis: {diff_basis_error}")

package/scripts/test-recursive-mode-smoke.ts

@@ -25,8 +25,8 @@ import { resolveRole, capabilityProbe, loadRouterPolicy } from '../src/router.ts
 import { validateReferences, writeActionRecord, reviewOutputSchema } from '../src/delegation.ts'
 import { writeChildScratch, readParentScratch } from '../src/scratch.ts'
 import { foldRecursivePhase, validateTransition, LifecycleDriver, coupleGateBlockToGoal, type SessionEventLike, type PhaseTransitionIntent } from '../src/lifecycle.ts'
-import { runCreated, phase, phaseLocked, gateBlocked, tamper, runMerged, runState } from '../src/events.ts'
-import { foldRecursiveProjection, emptyRecursiveFoldState, recursiveProjectionUnit, isInsideWorkspace } from '../src/projection.ts'
+import { snapshotWorkspace } from '../src/snapshot.ts'
+import { RECURSIVE_API_PREFIX, makeRecursiveRoutes, mountRecursiveRoutesOnce } from '../src/live-route.ts'
 import { columnForRun, cardFacts, nodeKeyOf, expandPhaseRows } from '../src/client/derive.ts'
 import { evaluatePreStepGate, evaluateToolGuard, resolveEnforcementConfig, DEFAULT_ENFORCEMENT, detectTamper } from '../src/enforcement.ts'
 import { renderRecursivePolicy } from '../src/policy.ts'
@@ -165,34 +165,35 @@ async function main() {
     check('R6 goal coupling no-op', coupleGateBlockToGoal(null, {}, { id: 'g' }, { code: 'G', message: 'x' }) === false)
 
 
-    // ---- Phase D checks (run 06 R10) ----
-    const pEvents: { type: string; data: unknown }[] = [
-      { type: 'recursive/run-created', data: runCreated({ runId: '10-smoke', worktreeRoot: wsA, template: 't', repo: 'r' }) },
-      { type: 'recursive/phase', data: phase({ runId: '10-smoke', worktreeRoot: wsA, phase: '03-implementation-summary.md', status: 'DRAFT' }) },
-      { type: 'recursive/phase-locked', data: phaseLocked({ runId: '10-smoke', worktreeRoot: wsA, phase: '03-implementation-summary.md', lockedAt: '2026-08-16T00:00:00Z', lockHash: 'h' }) },
-      { type: 'recursive/gate-blocked', data: gateBlocked({ runId: '10-smoke', worktreeRoot: wsA, phase: '04', failures: ['f'], kind: 'pre-step' }) },
-      { type: 'recursive/tamper', data: tamper({ runId: '10-smoke', worktreeRoot: wsA, path: 'p.md', reason: 'hash' }) },
-      { type: 'recursive/run-state', data: runState({ runId: '10-smoke', worktreeRoot: wsA, state: 'blocked' }) },
-    ]
-    let fold = emptyRecursiveFoldState(wsA)
-    for (const e of pEvents) fold = foldRecursiveProjection(fold, e as never)
-    check('R2 projection fold groups by worktreeRoot', Object.keys(fold.byWorktree).length === 1 && fold.byWorktree[wsA] !== undefined)
-    const card = fold.byWorktree[wsA]['10-smoke']
-    check('R2/R9 projection card facts', card !== undefined && card.phases['03-implementation-summary.md'].status === 'LOCKED' && card.state === 'blocked' && card.tampers['p.md'].reason === 'hash')
-    // R9 worktree-scope reject: fold an event whose worktreeRoot is outside wsA
-    const before = fold
-    fold = foldRecursiveProjection(fold, { type: 'recursive/run-created', data: runCreated({ runId: 'x', worktreeRoot: 'C:' + String.fromCharCode(92) + 'elsewhere' }) } as never)
-    check('R9 out-of-workspace event rejected (same ref)', fold === before)
-    // R5/R6 derive
-    check('R5 columnForRun maps to implementation lane', columnForRun(card) === '3/3.5')
-    const facts = cardFacts(card)
-    check('R5 cardFacts progress + tampered + gateBlocked', facts.lockedCount === 1 && facts.tampered === true && facts.gateBlocked === true)
+    // ---- Phase D checks (SP2 R1 live route, replaces the session projection) ----
+    // The live route folds the FILESYSTEM (snapshotWorkspace), not session events.
+    const snapshot = snapshotWorkspace(wsA)
+    check('R2 snapshot groups by worktreeRoot', Object.keys(snapshot).length === 1 && snapshot[wsA] !== undefined)
+    const card = snapshot[wsA]?.['10-smoke']
+    // Wire contract parity: phases are keyed by FILENAME (the deleted projection.ts
+    // keyed recursive/phase events by filename), which derive.ts phaseGroupOf parses.
+    // 03 is DRAFT here (written for the tool-guard test); 06 exists from closeoutPhase.
+    check('R2/R9 snapshot card facts', card !== undefined && card.worktreeRoot === wsA && card.phases['03-implementation-summary.md']?.status === 'DRAFT')
+    // R9 worktree-scope: a run directory outside wsA is never folded.
+    check('R9 snapshot is workspace-scoped', Object.keys(snapshot).every(root => root === wsA))
+    // R5/R6 derive over the snapshot card (furthest present phase is 06 -> closeout lane).
+    check('R5 columnForRun maps to the furthest present phase', columnForRun(card as never) === '6-8')
+    const facts = cardFacts(card as never)
+    // 00-requirements.md is LOCKED (written above); 03 is DRAFT; no tamper;
+    // no gate-block (the fs carries none of the transient event facts).
+    check('R5 cardFacts progress + tampered + gateBlocked', facts.lockedCount === 1 && facts.tampered === false && facts.gateBlocked === false)
     // R7 node key
     check('R7 nodeKeyOf includes worktreeRoot', nodeKeyOf('10-smoke', wsA).includes(wsA))
-    check('R6 expandPhaseRows always shows 3.5', expandPhaseRows(card).some(r => r.phase === '03.5'))
-    // R2 unit validity
-    check('R2 projection unit key + stateVersion', recursiveProjectionUnit.key === 'recursive' && recursiveProjectionUnit.stateVersion === 1 && recursiveProjectionUnit.schema.safeParse(fold.byWorktree).success)
-    check('R9 isInsideWorkspace normalization', isInsideWorkspace('D:' + String.fromCharCode(92) + 'DEV' + String.fromCharCode(92) + 'x', 'D:/DEV/x') === true)
+    check('R6 expandPhaseRows always shows 3.5', expandPhaseRows(card as never).some(r => r.phase === '03.5'))
+    // R2 route: prefix + mountOnce-global (second mount no-ops)
+    check('R2 route prefix', RECURSIVE_API_PREFIX === '/.recursive/api')
+    const routes = makeRecursiveRoutes({ resolveRoot: async () => wsA, snapshot: async (root: string) => snapshotWorkspace(root), revision: () => 1 })
+    check('R2 route count', routes.length === 2 && routes[0].kind === 'exact' && routes[1].kind === 'exact')
+    let registerCount = 0
+    const fakeServer = { register: () => { registerCount++; return () => {} } }
+    const mk = () => mountRecursiveRoutesOnce('@try-works/dsh-recursive-mode', () => makeRecursiveRoutes({ resolveRoot: async () => wsA, snapshot: async (root: string) => snapshotWorkspace(root), revision: () => 1 }), fakeServer)
+    mk(); mk()
+    check('R2 mountOnce-global (second mount no-ops)', registerCount === 2)
 
     console.log(failures === 0 ? 'SMOKE PASS' : 'SMOKE FAIL (' + failures + ' failures)')
     process.exitCode = failures === 0 ? 0 : 1