@polymorphism-tech/morph-spec 4.21.0 → 5.0.1

package/framework/hooks/claude-code/pre-compact/save-morph-context.js

@@ -1,199 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * PreCompact Hook: Inject MORPH Context into Compact Summary
- *
- * Event: PreCompact
- *
- * Injects a rich morph-spec state snapshot as additionalContext so that
- * Claude's compacted summary includes feature state, task progress, outputs,
- * and next steps. Ensures the session resumes with full morph awareness
- * without having to re-read all the spec files.
- *
- * Also saves snapshot to .morph/memory/ for SessionStart to reference.
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import {
-  stateExists, loadState, getActiveFeature,
-  derivePhaseForFeature, getPendingGates, getOutputs,
-} from '../../shared/state-reader.js';
-import { injectContext, pass } from '../../shared/hook-response.js';
-import { logHookActivity } from '../../shared/activity-logger.js';
-import { buildRichContext, DECISIONS_MAX_CHARS, MAX_PENDING_TASKS } from '../../shared/compact-restore.js';
-
-const PHASE_POSITIONS = {
-  proposal: 1,
-  uiux: 2, design: 2,
-  plan: 3,
-  tasks: 4,
-  implement: 5, sync: 5,
-};
-const PIPELINE_TOTAL = 5;
-
-const NEXT_STEP_HINT = {
-  proposal:  (n) => `Continue spec pipeline: /morph-proposal ${n}`,
-  design:    (n) => `Approve design gate: morph-spec approve ${n} design`,
-  uiux:      (n) => `Approve UI gate: morph-spec approve ${n} uiux`,
-  tasks:     (n) => `Approve tasks gate: morph-spec approve ${n} tasks`,
-  implement: (n) => `Continue implementation: morph-spec task start ${n} <next-task-id>`,
-};
-
-try {
-  if (!stateExists()) pass();
-
-  const state = loadState();
-  if (!state) pass();
-
-  const active = getActiveFeature();
-  const cwd    = process.cwd();
-
-  // ── Disk snapshot (for SessionStart restore) ──────────────────────────────
-  const snapshot = {
-    timestamp:     new Date().toISOString(),
-    event:         'pre-compact',
-    activeFeature: active ? active.name : null,
-    features:      {},
-  };
-
-  for (const [name, feature] of Object.entries(state.features || {})) {
-    snapshot.features[name] = {
-      phase:    feature.phase || derivePhaseForFeature(name),
-      status:   feature.status,
-      workflow: feature.workflow,
-      tasks:    feature.tasks,
-      approvalGates: Object.fromEntries(
-        Object.entries(feature.approvalGates || {}).map(([gate, data]) => [gate, data.approved])
-      ),
-    };
-  }
-
-  // ── Enrich snapshot with richContext (decisions + taskList) ───────────────
-  if (active) {
-    try {
-      const { name: activeName, feature: activeFeature } = active;
-      const activePhase = derivePhaseForFeature(activeName);
-      let decisionsContent = '';
-      const decisionsPath = join(cwd, `.morph/features/${activeName}/2-design/decisions.md`);
-      if (existsSync(decisionsPath)) {
-        try { decisionsContent = readFileSync(decisionsPath, 'utf-8'); } catch { /* ignore */ }
-      }
-      let specContent = '';
-      const specPath2 = join(cwd, `.morph/features/${activeName}/2-design/spec.md`);
-      if (existsSync(specPath2)) {
-        try { specContent = readFileSync(specPath2, 'utf-8'); } catch { /* ignore */ }
-      }
-      snapshot.richContext = buildRichContext(activeFeature, activePhase, decisionsContent, specContent);
-    } catch { /* fail-open: richContext is optional */ }
-  }
-  // ─────────────────────────────────────────────────────────────────────────
-
-  const memoryDir = join(cwd, '.morph', 'memory');
-  if (!existsSync(memoryDir)) mkdirSync(memoryDir, { recursive: true });
-  const ts = new Date().toISOString().replace(/[:.]/g, '-');
-  writeFileSync(join(memoryDir, `pre-compact-${ts}.json`), JSON.stringify(snapshot, null, 2), 'utf-8');
-
-  // ── Nothing more to inject if no active feature ───────────────────────────
-  if (!active) pass();
-
-  const { name, feature } = active;
-  const phase = derivePhaseForFeature(name);
-  const pos   = PHASE_POSITIONS[phase];
-  const phaseLabel = pos ? `${phase} (${pos}/${PIPELINE_TOTAL})` : phase;
-
-  const lines = [
-    '=== MORPH-SPEC COMPACT CONTEXT ===',
-    `Preserve this section verbatim in the compact summary.`,
-    '',
-    `Feature : ${name}`,
-    `Phase   : ${phaseLabel}`,
-    `Status  : ${feature.status}  |  Workflow: ${feature.workflow || 'auto'}`,
-  ];
-
-  // Task progress
-  const tasks = feature.tasks || {};
-  const done  = tasks.completed || 0;
-  const total = tasks.total     || 0;
-  if (total > 0) {
-    const pct = Math.round(done / total * 100);
-    lines.push(`Tasks   : ${done}/${total} completed (${pct}%)`);
-  }
-
-  // In-progress + next pending tasks from taskList
-  const taskList  = Array.isArray(feature.taskList) ? feature.taskList : [];
-  const inProg    = taskList.filter(t => t.status === 'in_progress');
-  const pending   = taskList.filter(t => t.status === 'pending').slice(0, MAX_PENDING_TASKS);
-
-  if (inProg.length > 0) {
-    lines.push('');
-    lines.push('In progress:');
-    for (const t of inProg) lines.push(`  [${t.id}] ${t.title}`);
-  }
-  if (pending.length > 0) {
-    lines.push('');
-    lines.push('Next pending tasks:');
-    for (const t of pending) lines.push(`  [${t.id}] ${t.title}`);
-    if (taskList.filter(t => t.status === 'pending').length > MAX_PENDING_TASKS) {
-      lines.push(`  ... (see tasks.md for full list)`);
-    }
-  }
-
-  // Created outputs
-  const outputs  = getOutputs(name) || {};
-  const created  = Object.entries(outputs).filter(([, o]) => o.created);
-  const missing  = Object.entries(outputs).filter(([, o]) => !o.created);
-  if (created.length > 0) {
-    lines.push('');
-    lines.push('Created outputs:');
-    for (const [type, o] of created) lines.push(`  ✓ ${type}: ${o.path}`);
-  }
-  if (missing.length > 0) {
-    lines.push('Pending outputs:');
-    for (const [type, o] of missing) lines.push(`  ✗ ${type}: ${o.path}`);
-  }
-
-  // Active agents
-  const agents = feature.activeAgents || [];
-  if (agents.length > 0) {
-    lines.push('');
-    lines.push(`Active agents: ${agents.join(', ')}`);
-  }
-
-  // Pending approval gates
-  const pendingGates = getPendingGates(name);
-  if (pendingGates.length > 0) {
-    lines.push(`Pending approvals: ${pendingGates.join(', ')}`);
-  }
-
-  // Key decisions (truncated to stay within context budget)
-  const decisionsPath = join(cwd, `.morph/features/${name}/2-design/decisions.md`);
-  if (existsSync(decisionsPath)) {
-    try {
-      const raw = readFileSync(decisionsPath, 'utf-8');
-      const content = raw.length > DECISIONS_MAX_CHARS
-        ? raw.slice(0, DECISIONS_MAX_CHARS) + '\n[... truncated — full file at decisions.md]'
-        : raw;
-      lines.push('');
-      lines.push('Key decisions (decisions.md):');
-      lines.push(content);
-    } catch { /* non-blocking */ }
-  }
-
-  // Next step
-  const hintFn = NEXT_STEP_HINT[phase];
-  if (hintFn) {
-    lines.push('');
-    lines.push(`Next step: ${hintFn(name)}`);
-  }
-
-  lines.push('');
-  lines.push('=== END MORPH CONTEXT ===');
-
-  logHookActivity('save-morph-context', 'PreCompact', 'context_saved');
-  injectContext(lines.join('\n'));
-} catch {
-  process.exit(0);
-}

package/framework/hooks/claude-code/pre-tool-use/task-tracking-guard.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * PreToolUse Hook: Advisory Task Tracking Guard
- *
- * Event: PreToolUse | Matcher: Write|Edit
- *
- * During implement phase, injects a warning if no task is currently in_progress.
- * Advisory only (type: approve with context) — never blocks.
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { readStdin } from '../../shared/stdin-reader.js';
-import { stateExists, loadState, getActiveFeature, derivePhaseForFeature } from '../../shared/state-reader.js';
-import { approve, pass } from '../../shared/hook-response.js';
-import { getFilePath } from '../../shared/payload-utils.js';
-
-try {
-  if (!stateExists()) pass();
-
-  const payload = await readStdin();
-  if (!payload) pass();
-
-  const filePath = getFilePath(payload);
-  if (!filePath) pass();
-
-  // Skip files inside .morph/ — internal framework writes don't need task tracking
-  if (filePath.includes('.morph/') || filePath.includes('.morph\\')) pass();
-
-  // Only check during implement phase
-  const active = getActiveFeature();
-  if (!active) pass();
-
-  const { name, feature } = active;
-  const phase = feature.phase || derivePhaseForFeature(name);
-  if (phase !== 'implement') pass();
-
-  // Check if any task is in_progress (read directly from taskList)
-  if (feature.taskList?.some(t => t.status === 'in_progress')) pass();
-  // Fallback: legacy counter check
-  if (feature.tasks?.inProgress > 0) pass();
-
-  // No task in_progress — inject advisory warning
-  approve(
-    `[morph-spec] WARNING: No active task tracking detected during implement phase.\n` +
-    `Before writing code, start a task:\n` +
-    `  morph-spec task start ${name} <id>   # mark it in progress\n` +
-    `Task tracking ensures validators run, checkpoints fire, and progress is recorded.\n` +
-    `If a task is more complex than expected, use: morph-spec task expand ${name} <id> --into "T00Xa: Sub" "T00Xb: Sub"`
-  );
-} catch {
-  // Fail-open
-  process.exit(0);
-}

package/framework/hooks/claude-code/session-start/inject-morph-context.js

@@ -1,323 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * SessionStart Hook: Inject MORPH-SPEC Context
- *
- * Event: SessionStart | Matcher: startup|resume|compact
- *
- * Reads state.json and injects a summary as additionalContext so Claude
- * knows the current morph-spec state at session start.
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { loadState, getActiveFeature, getPendingGates, getMissingOutputs, derivePhaseForFeature, getTaskStats } from '../../shared/state-reader.js';
-import { loadSessionSnapshot, formatPreviousSession } from '../../shared/session-snapshot.js';
-import { stateExists } from '../../shared/state-reader.js';
-import { injectContext, pass } from '../../shared/hook-response.js';
-import { resetActivity, logHookActivity, archiveSession, logEvent } from '../../shared/activity-logger.js';
-import { readFileSync, existsSync, writeFileSync, renameSync, unlinkSync, statSync } from 'fs';
-import { join } from 'path';
-import { resetStaleTasks } from '../../shared/stale-task-reset.js';
-import { execSync as _execSync } from 'child_process';
-import { parseWorktreeResult, buildWorktreeContextLine, buildWorktreeResumeContext } from '../../shared/worktree-helpers.js';
-
-const DEFAULT_SPEC_MAX_CHARS = 6000;
-
-function getSpecMaxChars() {
-  try {
-    const configPath = join(process.cwd(), '.morph/config/config.json');
-    if (!existsSync(configPath)) return DEFAULT_SPEC_MAX_CHARS;
-    const cfg = JSON.parse(readFileSync(configPath, 'utf-8'));
-    return cfg?.hooks?.specInjectionLimit ?? DEFAULT_SPEC_MAX_CHARS;
-  } catch {
-    return DEFAULT_SPEC_MAX_CHARS;
-  }
-}
-
-function getProjectConfig() {
-  try {
-    const configPath = join(process.cwd(), '.morph/config/config.json');
-    if (!existsSync(configPath)) return null;
-    return JSON.parse(readFileSync(configPath, 'utf-8'));
-  } catch {
-    return null;
-  }
-}
-
-const SPEC_MAX_CHARS = getSpecMaxChars();
-
-/**
- * Atomic state save for hook context.
- * Same approach as state-manager.js saveState — write to tmp, then rename.
- * Fail-open: any error is silently ignored.
- * @param {Object} state - Full state object
- * @param {string} cwd - Project root path
- */
-function saveStateSync(state, cwd) {
-  const statePath = join(cwd, '.morph/state.json');
-  const tmpPath = `${statePath}.tmp.hook.${process.pid}`;
-  try {
-    state.metadata = state.metadata || {};
-    state.metadata.lastUpdated = new Date().toISOString();
-    writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf8');
-    renameSync(tmpPath, statePath);
-  } catch {
-    try { unlinkSync(tmpPath); } catch { /* ignore cleanup errors */ }
-  }
-}
-
-try {
-  if (!stateExists()) pass();
-
-  const state = loadState();
-  if (!state?.features || Object.keys(state.features).length === 0) pass();
-
-  const active = getActiveFeature();
-
-  // Archive previous session log before resetting
-  const activeFeatureName = active?.name || '';
-  const activePhase = active ? derivePhaseForFeature(active.name) : '';
-  archiveSession();
-
-  // Reset activity log for new session
-  resetActivity(new Date().toISOString(), activeFeatureName, activePhase);
-  logEvent('session_start', { feature: activeFeatureName, phase: activePhase });
-  logHookActivity('inject-morph-context', 'SessionStart', 'ok');
-
-  // ── Stale task cleanup ──────────────────────────────────────────────────────
-  // Reset any in_progress tasks older than 1 hour — they are orphans from an
-  // interrupted session and are no longer being actively implemented.
-  const staleResetLog = resetStaleTasks(state);
-  if (staleResetLog.length > 0) {
-    saveStateSync(state, process.cwd());
-  }
-  // ────────────────────────────────────────────────────────────────────────────
-
-  const lines = ['MORPH-SPEC Status:'];
-
-  // ── Context freshness check ─────────────────────────────────────────────
-  // If .morph/context/README.md is missing or older than 24h, suggest refresh.
-  try {
-    const contextReadmePath = join(process.cwd(), '.morph/context/README.md');
-    let contextStale = false;
-    if (!existsSync(contextReadmePath)) {
-      contextStale = true;
-    } else {
-      const stat = statSync(contextReadmePath);
-      const ageMs = Date.now() - stat.mtimeMs;
-      const TWENTY_FOUR_HOURS = 24 * 60 * 60 * 1000;
-      contextStale = ageMs > TWENTY_FOUR_HOURS;
-    }
-    if (contextStale) {
-      lines.push('');
-      lines.push('⚠ Architecture context is stale or missing. Run: morph-spec context refresh');
-    }
-  } catch {
-    // Fail-open — context freshness check must never block the session
-  }
-  // ────────────────────────────────────────────────────────────────────────
-
-  if (staleResetLog.length > 0) {
-    lines.push(`⚠️  ${staleResetLog.length} task(s) auto-reset in_progress → pending (orphaned from previous session): ${staleResetLog.join(', ')}`);
-  }
-
-  if (active) {
-    const { name, feature } = active;
-    const phase = derivePhaseForFeature(name);
-    lines.push(`- Active feature: ${name} (phase: ${phase}, workflow: ${feature.workflow || 'auto'})`);
-    lines.push(`- Status: ${feature.status}`);
-
-    // Task progress (read directly from taskList)
-    const stats = getTaskStats(feature);
-    if (stats.total > 0) {
-      lines.push(`- Tasks: ${stats.completed}/${stats.total} completed`);
-    }
-
-    // Pending approvals
-    const pending = getPendingGates(name);
-    if (pending.length > 0) {
-      lines.push(`- Pending approvals: ${pending.join(', ')}`);
-    }
-
-    // Next required output
-    const missing = getMissingOutputs(name);
-    if (missing.length > 0) {
-      const next = missing[0];
-      lines.push(`- Next required output: ${next.type} → ${next.path}`);
-    }
-
-    // Checkpoints
-    if (feature.checkpoints?.length > 0) {
-      const lastCp = feature.checkpoints[feature.checkpoints.length - 1];
-      lines.push(`- Last checkpoint: #${lastCp.checkpointNum} (${lastCp.passed ? 'passed' : 'failed'})`);
-    }
-
-    // Trust level visibility — warn when low trust may block approval gates
-    const APPROVAL_GATE_PHASES = new Set(['proposal', 'design', 'tasks']);
-    if (APPROVAL_GATE_PHASES.has(phase)) {
-      const config = getProjectConfig();
-      const trustLevel = config?.trust?.level || config?.trustLevel || 'low';
-      const workflow = feature.workflow || config?.workflow;
-      if (trustLevel !== 'high' && trustLevel !== 'maximum') {
-        lines.push('');
-        lines.push(`⚠ Trust level: ${trustLevel} — approval gates require manual approval`);
-        lines.push(`  To auto-approve: morph-spec trust set ${name} high`);
-      }
-      if (!workflow && config?.workflowDetection?.confidence === 0) {
-        lines.push('');
-        lines.push('ℹ Workflow not detected (confidence: 0). Set manually in .morph/config/config.json → workflow');
-      }
-    }
-
-    // Active feature spec (truncated for context budget)
-    const specPath = join(process.cwd(), `.morph/features/${name}/2-design/spec.md`);
-    if (existsSync(specPath)) {
-      try {
-        const specContent = readFileSync(specPath, 'utf-8');
-        const truncated = specContent.length > SPEC_MAX_CHARS
-          ? specContent.slice(0, SPEC_MAX_CHARS) + `\n\n[... spec truncated — full file at .morph/features/${name}/2-design/spec.md]`
-          : specContent;
-        lines.push('');
-        lines.push(`--- Active feature spec (${name}/2-design/spec.md) ---`);
-        lines.push(truncated);
-        lines.push('--- End spec ---');
-      } catch {
-        // Non-blocking: skip spec injection on read error
-      }
-    }
-
-    // ── Worktree context injection ─────────────────────────────────────────────
-    // For the active feature, detect existing worktree from state metadata and
-    // inject MANDATORY instructions to work inside it.
-    // The worktree is created by `morph-proposal` Step 0 or `morph-apply` Step 0.
-    // This hook only injects the context — it does NOT create worktrees.
-    // Fail-open: any error is silently ignored.
-    try {
-      const worktreeMeta = feature.worktree;
-      if (worktreeMeta?.path) {
-        const contextLine = buildWorktreeResumeContext(worktreeMeta, name);
-        if (contextLine) {
-          lines.push('');
-          lines.push(contextLine);
-        }
-      }
-    } catch {
-      // Fail-open — worktree context must never block the session
-    }
-    // ────────────────────────────────────────────────────────────────────────────
-
-    // ── Previous session context ──────────────────────────────────────────────
-    // Inject summary from previous session for "getting up to speed"
-    try {
-      const snapshot = loadSessionSnapshot(process.cwd());
-      const previousSessionText = formatPreviousSession(snapshot);
-      if (previousSessionText) {
-        lines.push('');
-        lines.push(previousSessionText);
-      }
-    } catch {
-      // Fail-open — previous session context must never block
-    }
-    // ────────────────────────────────────────────────────────────────────────
-  } else {
-    // Show summary of all features
-    const featureNames = Object.keys(state.features);
-    lines.push(`- Features: ${featureNames.length} (${featureNames.join(', ')})`);
-
-    for (const [fname, feat] of Object.entries(state.features)) {
-      const fPhase = derivePhaseForFeature(fname);
-      lines.push(`  - ${fname}: phase=${fPhase}, status=${feat.status}`);
-    }
-  }
-
-  // ── MCP status injection ────────────────────────────────────────────────────
-  // Cross-reference configured MCPs with phase recommendations from mcp-registry.json.
-  // Fail-open: all inside try/catch, no crash on missing files.
-  try {
-    const currentPhase = active ? derivePhaseForFeature(active.name) : '';
-    if (currentPhase) {
-      // Read configured MCPs from settings
-      const configuredMcps = new Set();
-      const settingsFiles = [
-        join(process.cwd(), '.claude', 'settings.local.json'),
-        join(process.cwd(), '.claude', 'settings.json'),
-      ];
-      for (const sf of settingsFiles) {
-        if (existsSync(sf)) {
-          try {
-            const s = JSON.parse(readFileSync(sf, 'utf8'));
-            for (const name of Object.keys(s.mcpServers || {})) {
-              configuredMcps.add(name.toLowerCase());
-            }
-          } catch { /* ignore */ }
-        }
-      }
-
-      // Read recommended MCPs from phases.json or mcp-registry.json
-      let recommended = [];
-      const registryPaths = [
-        join(process.cwd(), 'framework', 'skills', 'level-0-meta', 'mcp-registry.json'),
-        join(process.cwd(), '.morph', 'framework', 'skills', 'level-0-meta', 'mcp-registry.json'),
-      ];
-      for (const rp of registryPaths) {
-        if (existsSync(rp)) {
-          try {
-            const registry = JSON.parse(readFileSync(rp, 'utf8'));
-            recommended = registry.phaseMatrix?.[currentPhase] || [];
-            break;
-          } catch { /* ignore */ }
-        }
-      }
-
-      if (recommended.length > 0) {
-        const mcpStatus = recommended.map(name => {
-          const isConfigured = configuredMcps.has(name.toLowerCase());
-          return `${name} ${isConfigured ? '✓' : '✗ (recommended)'}`;
-        });
-        lines.push('');
-        lines.push(`MCPs: ${mcpStatus.join(', ')}`);
-      }
-    }
-  } catch {
-    // Fail-open — MCP status must never block the session
-  }
-  // ────────────────────────────────────────────────────────────────────────────
-
-  // ── CLI availability detection ─────────────────────────────────────────────
-  // Check which development CLIs are available for the current phase.
-  // Uses execSync with short timeout — fail-open on any error.
-  try {
-    const currentPhaseForCli = active ? derivePhaseForFeature(active.name) : '';
-    if (currentPhaseForCli) {
-      const cliChecks = [
-        { name: 'docker', cmd: 'docker --version', phases: ['design', 'implement'] },
-        { name: 'neonctl', cmd: 'neonctl --version', phases: ['design', 'implement'] },
-        { name: 'psql', cmd: 'psql --version', phases: ['design', 'implement'] },
-        { name: 'az', cmd: 'az version --output none', phases: ['implement'] },
-        { name: 'gh', cmd: 'gh --version', phases: ['design', 'tasks', 'implement'] },
-      ];
-
-      const relevant = cliChecks.filter(c => c.phases.includes(currentPhaseForCli));
-      if (relevant.length > 0) {
-        const cliStatus = relevant.map(c => {
-          try {
-            _execSync(c.cmd, { stdio: 'pipe', timeout: 5000 });
-            return `${c.name} ✓`;
-          } catch {
-            return `${c.name} ✗`;
-          }
-        });
-        lines.push(`CLIs: ${cliStatus.join(', ')}`);
-      }
-    }
-  } catch {
-    // Fail-open — CLI detection must never block the session
-  }
-  // ────────────────────────────────────────────────────────────────────────────
-
-  injectContext(lines.join('\n'));
-} catch {
-  // Fail-open
-  process.exit(0);
-}

package/framework/hooks/claude-code/session-start/post-compact-restore.js

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * SessionStart Hook: Post-Compact Context Restore
- *
- * Event: SessionStart | Matcher: compact
- *
- * Fires ONLY when a session starts after context compaction.
- * Reads the latest pre-compact memory file and injects the richContext
- * block (decisions.md snippet + task list) so Claude resumes with full
- * morph awareness even if the compact summary was truncated.
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { existsSync, readdirSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { injectContext, pass } from '../../shared/hook-response.js';
-import { stateExists } from '../../shared/state-reader.js';
-import { buildRestoreBlock, findLatestMemoryFile } from '../../shared/compact-restore.js';
-
-try {
-  if (!stateExists()) pass();
-
-  const memoryDir = join(process.cwd(), '.morph', 'memory');
-  if (!existsSync(memoryDir)) pass();
-
-  const files = readdirSync(memoryDir);
-  const latest = findLatestMemoryFile(files);
-  if (!latest) pass();
-
-  const raw = readFileSync(join(memoryDir, latest), 'utf-8');
-  const snapshot = JSON.parse(raw);
-
-  const block = buildRestoreBlock(snapshot);
-  if (!block) pass();
-
-  injectContext(block);
-} catch {
-  process.exit(0);
-}