erdos-problems 0.1.5 → 0.1.6

package/src/runtime/checkpoints.js

@@ -0,0 +1,208 @@
+import path from 'node:path';
+import { loadLocalProblems, getProblem } from '../atlas/catalog.js';
+import { loadConfig } from './config.js';
+import { ensureDir, writeJson, writeText } from './files.js';
+import {
+  getWorkspaceCheckpointIndexPath,
+  getWorkspaceCheckpointJsonPath,
+  getWorkspaceCheckpointsDir,
+  getWorkspaceProblemCheckpointsDir,
+  getWorkspaceRoot,
+  getWorkspaceRouteCheckpointsDir,
+} from './paths.js';
+import { getProblemArtifactInventory } from './problem-artifacts.js';
+import { buildSunflowerStatusSnapshot } from './sunflower.js';
+import { loadState, saveState, syncState } from './state.js';
+
+function safeName(value) {
+  return String(value).replace(/[^a-zA-Z0-9_-]+/g, '-');
+}
+
+function renderCanonicalArtifacts(inventory) {
+  return inventory.canonicalArtifacts
+    .map((artifact) => `- ${artifact.label}: ${artifact.exists ? 'present' : 'missing'} (${artifact.path})`)
+    .join('\n');
+}
+
+function renderProblemCheckpoint(problem, state) {
+  const inventory = getProblemArtifactInventory(problem);
+  const sunflower = problem.cluster === 'sunflower' ? buildSunflowerStatusSnapshot(problem) : null;
+  const research = problem.researchState ?? {};
+  const activeRoute = sunflower?.activeRoute ?? research.active_route ?? '(none)';
+  const routeBreakthrough = sunflower?.routeBreakthrough ?? Boolean(research.route_breakthrough);
+  const problemSolved = sunflower?.problemSolved ?? Boolean(research.problem_solved);
+  const nextHonestMove = sunflower?.nextHonestMove
+    ?? (activeRoute !== '(none)' ? `Advance ${activeRoute} against the dossier and evidence bundle.` : 'Seed or choose an active route.');
+  const frontier = sunflower?.frontierDetail ?? problem.shortStatement;
+  const checkpointFocus = sunflower?.checkpointFocus ?? 'Keep local route claims and upstream public status cleanly separated.';
+
+  return `# Problem ${problem.problemId} Checkpoint
+
+## Status Ladder
+
+- Open Problem: ${problem.problemId}
+- Active Route: ${activeRoute}
+- Route Breakthrough: ${routeBreakthrough ? 'yes' : 'no'}
+- Problem Solved: ${problemSolved ? 'yes' : 'no'}
+
+## Problem Record
+
+- Title: ${problem.title}
+- Cluster: ${problem.cluster}
+- Source: ${problem.sourceUrl}
+- Site status: ${problem.siteStatus}
+- Repo status: ${problem.repoStatus}
+- Harness depth: ${problem.harnessDepth}
+
+## Current Frontier
+
+- ${frontier}
+
+## Checkpoint Focus
+
+- ${checkpointFocus}
+
+## Next Honest Move
+
+- ${nextHonestMove}
+
+## Canonical Artifacts
+
+${renderCanonicalArtifacts(inventory)}
+
+## Continuation Frame
+
+- Active agent: ${state.activeAgent || '(none)'}
+- Continuation mode: ${state.continuation.mode}
+- Stop rule: ${state.continuation.stopRule}
+`;
+}
+
+function renderRouteCheckpoint(problem, state) {
+  const sunflower = problem.cluster === 'sunflower' ? buildSunflowerStatusSnapshot(problem) : null;
+  const frontier = sunflower?.frontierDetail ?? state.currentFrontier.detail;
+  const routeStory = sunflower?.routeStory ?? state.routeStory ?? '(none yet)';
+  const checkpointFocus = sunflower?.checkpointFocus ?? state.checkpointFocus ?? '(none yet)';
+
+  return `# Problem ${problem.problemId} Active Route Checkpoint
+
+## Status Ladder
+
+- Open Problem: ${problem.problemId}
+- Active Route: ${state.activeRoute || '(none)'}
+- Route Breakthrough: ${state.routeBreakthrough ? 'yes' : 'no'}
+- Problem Solved: ${state.problemSolved ? 'yes' : 'no'}
+
+## Current Frontier
+
+- ${frontier}
+
+## Route Story
+
+- ${routeStory}
+
+## Checkpoint Focus
+
+- ${checkpointFocus}
+
+## Continuation Frame
+
+- Continuation mode: ${state.continuation.mode}
+- Stop rule: ${state.continuation.stopRule}
+- Next honest move: ${state.nextHonestMove}
+`;
+}
+
+function renderIndex(state, checkpoints) {
+  const problemRows = checkpoints.filter((entry) => entry.kind === 'problem');
+  const routeRows = checkpoints.filter((entry) => entry.kind === 'route');
+
+  return [
+    '# Erdos Checkpoints',
+    '',
+    'This is the human-facing checkpoint shelf for the local research-loop runtime.',
+    'Canonical truth still lives in dossiers, pack artifacts, upstream snapshots, and generated workspace bundles.',
+    '',
+    '## Current Status Ladder',
+    '',
+    `- Open Problem: ${state.activeProblem || '(none)'}`,
+    `- Active Route: ${state.activeRoute || '(none)'}`,
+    `- Route Breakthrough: ${state.routeBreakthrough ? 'yes' : 'no'}`,
+    `- Problem Solved: ${state.problemSolved ? 'yes' : 'no'}`,
+    '',
+    '## Working Context',
+    '',
+    `- Continuation Mode: ${state.continuation.mode}`,
+    `- Next Honest Move: ${state.nextHonestMove}`,
+    '',
+    '## Problem Checkpoints',
+    '',
+    ...(problemRows.length > 0 ? problemRows.map((row) => `- [${row.label}](${row.relativePath})`) : ['- *(none)*']),
+    '',
+    '## Route Checkpoints',
+    '',
+    ...(routeRows.length > 0 ? routeRows.map((row) => `- [${row.label}](${row.relativePath})`) : ['- *(none)*']),
+    '',
+  ].join('\n');
+}
+
+export function syncCheckpoints(workspaceRoot = getWorkspaceRoot()) {
+  const config = loadConfig(workspaceRoot);
+  const state = syncState(workspaceRoot);
+  const problems = loadLocalProblems();
+
+  ensureDir(getWorkspaceCheckpointsDir(workspaceRoot));
+  ensureDir(getWorkspaceProblemCheckpointsDir(workspaceRoot));
+  ensureDir(getWorkspaceRouteCheckpointsDir(workspaceRoot));
+
+  const checkpoints = [];
+
+  for (const problem of problems) {
+    const filename = `problem-${problem.problemId}.md`;
+    const fullPath = path.join(getWorkspaceProblemCheckpointsDir(workspaceRoot), filename);
+    writeText(fullPath, renderProblemCheckpoint(problem, state));
+    checkpoints.push({
+      kind: 'problem',
+      label: `Problem ${problem.problemId}`,
+      path: fullPath,
+      relativePath: path.relative(getWorkspaceCheckpointsDir(workspaceRoot), fullPath),
+    });
+  }
+
+  if (state.activeProblem && state.activeRoute) {
+    const problem = getProblem(state.activeProblem);
+    if (problem) {
+      const filename = `problem-${state.activeProblem}--${safeName(state.activeRoute)}.md`;
+      const fullPath = path.join(getWorkspaceRouteCheckpointsDir(workspaceRoot), filename);
+      writeText(fullPath, renderRouteCheckpoint(problem, state));
+      checkpoints.push({
+        kind: 'route',
+        label: `Problem ${state.activeProblem} / ${state.activeRoute}`,
+        path: fullPath,
+        relativePath: path.relative(getWorkspaceCheckpointsDir(workspaceRoot), fullPath),
+      });
+    }
+  }
+
+  writeText(getWorkspaceCheckpointIndexPath(workspaceRoot), renderIndex(state, checkpoints));
+  writeJson(getWorkspaceCheckpointJsonPath(workspaceRoot), {
+    syncedAt: new Date().toISOString(),
+    activeProblem: state.activeProblem,
+    activeRoute: state.activeRoute,
+    continuationMode: state.continuation.mode,
+    activeAgent: config.preferredAgent,
+    checkpoints,
+  });
+
+  const nextState = saveState({
+    ...loadState(workspaceRoot),
+    lastCheckpointSyncAt: new Date().toISOString(),
+  }, workspaceRoot);
+
+  return {
+    indexPath: getWorkspaceCheckpointIndexPath(workspaceRoot),
+    checkpointJsonPath: getWorkspaceCheckpointJsonPath(workspaceRoot),
+    checkpoints,
+    state: nextState,
+  };
+}

package/src/runtime/config.js

@@ -0,0 +1,37 @@
+import { fileExists, readJson, writeJson } from './files.js';
+import { getWorkspaceConfigPath, getWorkspaceRoot } from './paths.js';
+
+const DEFAULT_CONFIG = {
+  preferredAgent: 'erdos',
+  continuation: 'route',
+};
+
+export function defaultConfig() {
+  return { ...DEFAULT_CONFIG };
+}
+
+export function loadConfig(workspaceRoot = getWorkspaceRoot()) {
+  const configPath = getWorkspaceConfigPath(workspaceRoot);
+  if (!fileExists(configPath)) {
+    return defaultConfig();
+  }
+  return {
+    ...DEFAULT_CONFIG,
+    ...readJson(configPath),
+  };
+}
+
+export function saveConfig(config, workspaceRoot = getWorkspaceRoot()) {
+  const payload = {
+    ...DEFAULT_CONFIG,
+    ...config,
+  };
+  writeJson(getWorkspaceConfigPath(workspaceRoot), payload);
+  return payload;
+}
+
+export function ensureConfig(workspaceRoot = getWorkspaceRoot()) {
+  const payload = loadConfig(workspaceRoot);
+  saveConfig(payload, workspaceRoot);
+  return payload;
+}

package/src/runtime/continuation.js

@@ -0,0 +1,65 @@
+const PRESETS = {
+  atom: {
+    mode: 'atom',
+    reviewCadence: 'tight',
+    maxUnattendedMinutes: 25,
+    checkpointAfterLoadBearingResult: true,
+    stopRule: 'Stop after one load-bearing atomic step or blocker.',
+  },
+  route: {
+    mode: 'route',
+    reviewCadence: 'balanced',
+    maxUnattendedMinutes: 90,
+    checkpointAfterLoadBearingResult: true,
+    stopRule: 'Continue until the active route reaches a real boundary or blocker.',
+  },
+  milestone: {
+    mode: 'milestone',
+    reviewCadence: 'sparse',
+    maxUnattendedMinutes: 180,
+    checkpointAfterLoadBearingResult: false,
+    stopRule: 'Continue until the problem milestone boundary or blocker.',
+  },
+};
+
+const ALIASES = {
+  phase: 'route',
+};
+
+export function continuationModes() {
+  return ['atom', 'route', 'phase', 'milestone'];
+}
+
+export function normalizeContinuationMode(mode = 'route') {
+  const raw = String(mode || 'route');
+  if (PRESETS[raw]) {
+    return raw;
+  }
+  if (ALIASES[raw]) {
+    return ALIASES[raw];
+  }
+  return 'route';
+}
+
+export function continuationDisplay(continuation = {}) {
+  const requested = continuation.requestedMode || continuation.mode || 'route';
+  const normalized = normalizeContinuationMode(requested);
+  if (requested === 'phase' && normalized === 'route') {
+    return 'route (phase-style)';
+  }
+  return normalized;
+}
+
+export function resolveContinuation(raw = {}) {
+  const requested = raw.requestedMode || raw.mode || 'route';
+  const mode = normalizeContinuationMode(requested);
+  const rest = { ...raw };
+  delete rest.mode;
+  delete rest.requestedMode;
+  return {
+    ...PRESETS[mode],
+    ...rest,
+    mode,
+    requestedMode: requested,
+  };
+}

package/src/runtime/git.js

@@ -0,0 +1,52 @@
+import { execFileSync } from 'node:child_process';
+
+function runGit(workspaceRoot, args) {
+  try {
+    return execFileSync('git', ['-C', workspaceRoot, ...args], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function gitSummary(workspaceRoot) {
+  if (!workspaceRoot) {
+    return {
+      exists: false,
+      isGitRepo: false,
+      clean: null,
+      branch: null,
+      detail: 'missing',
+    };
+  }
+
+  const inside = runGit(workspaceRoot, ['rev-parse', '--is-inside-work-tree']);
+  if (inside !== 'true') {
+    return {
+      exists: true,
+      isGitRepo: false,
+      clean: null,
+      branch: null,
+      detail: 'not a git repository',
+    };
+  }
+
+  const branch = runGit(workspaceRoot, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  const porcelain = runGit(workspaceRoot, ['status', '--porcelain']) ?? '';
+  const clean = porcelain.trim().length === 0;
+  const changedPaths = porcelain
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  return {
+    exists: true,
+    isGitRepo: true,
+    clean,
+    branch,
+    detail: clean ? 'clean' : `${changedPaths.length} changed path(s)`,
+    changedPaths,
+  };
+}

package/src/runtime/paths.js

@@ -8,72 +8,108 @@ export function getWorkspaceRoot() {
   return process.cwd();
 }
 
-export function getWorkspaceDir() {
-  return path.join(getWorkspaceRoot(), '.erdos');
+export function getWorkspaceDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(workspaceRoot, '.erdos');
+}
+
+export function getWorkspaceConfigPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'config.json');
 }
 
 export function getWorkspaceRegistryDir(workspaceRoot = getWorkspaceRoot()) {
-  return path.join(workspaceRoot, '.erdos', 'registry');
+  return path.join(getWorkspaceDir(workspaceRoot), 'registry');
+}
+
+export function getWorkspaceRegistryBucketDir(bucket, workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceRegistryDir(workspaceRoot), String(bucket));
 }
 
 export function getWorkspaceComputeRegistryDir(workspaceRoot = getWorkspaceRoot()) {
   return path.join(getWorkspaceRegistryDir(workspaceRoot), 'compute');
 }
 
-export function getWorkspaceStatePath() {
-  return path.join(getWorkspaceDir(), 'state.json');
+export function getWorkspaceStatePath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'state.json');
+}
+
+export function getWorkspaceStateMarkdownPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'STATE.md');
+}
+
+export function getWorkspaceQuestionLedgerPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'QUESTION-LEDGER.md');
+}
+
+export function getCurrentProblemPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'current-problem.json');
+}
+
+export function getWorkspaceReportsDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'reports');
+}
+
+export function getWorkspaceDiffPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceReportsDir(workspaceRoot), 'UPSTREAM_DIFF.md');
+}
+
+export function getWorkspaceUpstreamDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'upstream', 'erdosproblems');
+}
+
+export function getWorkspaceUpstreamYamlPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceUpstreamDir(workspaceRoot), 'problems.yaml');
 }
 
-export function getCurrentProblemPath() {
-  return path.join(getWorkspaceDir(), 'current-problem.json');
+export function getWorkspaceUpstreamIndexPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceUpstreamDir(workspaceRoot), 'PROBLEMS_INDEX.json');
 }
 
-export function getWorkspaceReportsDir() {
-  return path.join(getWorkspaceDir(), 'reports');
+export function getWorkspaceUpstreamManifestPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceUpstreamDir(workspaceRoot), 'SYNC_MANIFEST.json');
 }
 
-export function getWorkspaceDiffPath() {
-  return path.join(getWorkspaceReportsDir(), 'UPSTREAM_DIFF.md');
+export function getWorkspaceScaffoldsDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'scaffolds');
 }
 
-export function getWorkspaceUpstreamDir() {
-  return path.join(getWorkspaceDir(), 'upstream', 'erdosproblems');
+export function getWorkspaceProblemScaffoldDir(problemId, workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceScaffoldsDir(workspaceRoot), String(problemId));
 }
 
-export function getWorkspaceUpstreamYamlPath() {
-  return path.join(getWorkspaceUpstreamDir(), 'problems.yaml');
+export function getWorkspacePullsDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'pulls');
 }
 
-export function getWorkspaceUpstreamIndexPath() {
-  return path.join(getWorkspaceUpstreamDir(), 'PROBLEMS_INDEX.json');
+export function getWorkspaceProblemPullDir(problemId, workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspacePullsDir(workspaceRoot), String(problemId));
 }
 
-export function getWorkspaceUpstreamManifestPath() {
-  return path.join(getWorkspaceUpstreamDir(), 'SYNC_MANIFEST.json');
+export function getWorkspaceProblemArtifactDir(problemId, workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceProblemPullDir(problemId, workspaceRoot), 'artifacts');
 }
 
-export function getWorkspaceScaffoldsDir() {
-  return path.join(getWorkspaceDir(), 'scaffolds');
+export function getWorkspaceProblemLiteratureDir(problemId, workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceProblemPullDir(problemId, workspaceRoot), 'literature');
 }
 
-export function getWorkspaceProblemScaffoldDir(problemId) {
-  return path.join(getWorkspaceScaffoldsDir(), String(problemId));
+export function getWorkspaceCheckpointsDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'checkpoints');
 }
 
-export function getWorkspacePullsDir() {
-  return path.join(getWorkspaceDir(), 'pulls');
+export function getWorkspaceProblemCheckpointsDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceCheckpointsDir(workspaceRoot), 'problem-checkpoints');
 }
 
-export function getWorkspaceProblemPullDir(problemId) {
-  return path.join(getWorkspacePullsDir(), String(problemId));
+export function getWorkspaceRouteCheckpointsDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceCheckpointsDir(workspaceRoot), 'route-checkpoints');
 }
 
-export function getWorkspaceProblemArtifactDir(problemId) {
-  return path.join(getWorkspaceProblemPullDir(problemId), 'artifacts');
+export function getWorkspaceCheckpointIndexPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceCheckpointsDir(workspaceRoot), 'CHECKPOINTS.md');
 }
 
-export function getWorkspaceProblemLiteratureDir(problemId) {
-  return path.join(getWorkspaceProblemPullDir(problemId), 'literature');
+export function getWorkspaceCheckpointJsonPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceCheckpointsDir(workspaceRoot), 'CHECKPOINTS.json');
 }
 
 export function getProblemDir(problemId) {

package/src/runtime/preflight.js

@@ -0,0 +1,106 @@
+import {
+  getProblem,
+} from '../atlas/catalog.js';
+import { ensureConfig, loadConfig } from './config.js';
+import { fileExists, writeJson } from './files.js';
+import { gitSummary } from './git.js';
+import {
+  getWorkspaceCheckpointIndexPath,
+  getWorkspaceConfigPath,
+  getWorkspaceDir,
+  getWorkspaceQuestionLedgerPath,
+  getWorkspaceRegistryBucketDir,
+  getWorkspaceRoot,
+  getWorkspaceStateMarkdownPath,
+  getWorkspaceStatePath,
+} from './paths.js';
+import { getProblemArtifactInventory } from './problem-artifacts.js';
+import { syncState } from './state.js';
+
+function checkpointPath(workspaceRoot) {
+  return getWorkspaceCheckpointIndexPath(workspaceRoot);
+}
+
+export function buildPreflightReport(options = {}, workspaceRoot = getWorkspaceRoot()) {
+  ensureConfig(workspaceRoot);
+  const config = loadConfig(workspaceRoot);
+  const state = syncState(workspaceRoot);
+  const problem = state.activeProblem ? getProblem(state.activeProblem) : null;
+  const inventory = problem ? getProblemArtifactInventory(problem) : null;
+  const git = gitSummary(workspaceRoot);
+
+  const checks = {
+    erdosRuntime: {
+      ok: fileExists(getWorkspaceDir(workspaceRoot)),
+      detail: getWorkspaceDir(workspaceRoot),
+    },
+    configFile: {
+      ok: fileExists(getWorkspaceConfigPath(workspaceRoot)),
+      detail: getWorkspaceConfigPath(workspaceRoot),
+    },
+    stateFile: {
+      ok: fileExists(getWorkspaceStatePath(workspaceRoot)),
+      detail: getWorkspaceStatePath(workspaceRoot),
+    },
+    stateMarkdown: {
+      ok: fileExists(getWorkspaceStateMarkdownPath(workspaceRoot)),
+      detail: getWorkspaceStateMarkdownPath(workspaceRoot),
+    },
+    questionLedger: {
+      ok: fileExists(getWorkspaceQuestionLedgerPath(workspaceRoot)),
+      detail: getWorkspaceQuestionLedgerPath(workspaceRoot),
+    },
+    checkpointShelf: {
+      ok: fileExists(checkpointPath(workspaceRoot)),
+      detail: checkpointPath(workspaceRoot),
+    },
+    activeProblem: {
+      ok: Boolean(problem),
+      detail: problem ? `${problem.problemId} (${problem.title})` : '(none)',
+    },
+    activeRoute: {
+      ok: !problem || problem.harnessDepth !== 'deep' ? true : Boolean(state.activeRoute),
+      detail: state.activeRoute || '(none)',
+    },
+    canonicalDossier: {
+      ok: !inventory ? false : inventory.canonicalArtifacts.every((artifact) => artifact.exists),
+      detail: inventory ? `${inventory.canonicalArtifacts.filter((artifact) => artifact.exists).length}/${inventory.canonicalArtifacts.length} canonical file(s)` : '(no active problem)',
+    },
+    upstreamSnapshot: {
+      ok: Boolean(inventory?.upstreamSnapshot),
+      detail: inventory?.upstreamSnapshot?.kind ?? '(missing)',
+    },
+    workspaceGit: {
+      ok: options.allowDirty ? true : git.clean !== false,
+      detail: git.isGitRepo ? `${git.branch || '(unknown branch)'} / ${git.detail}` : git.detail,
+    },
+  };
+
+  let verdict = 'ok';
+  if (!checks.erdosRuntime.ok || !checks.configFile.ok || !checks.stateFile.ok || !checks.activeProblem.ok || !checks.canonicalDossier.ok || !checks.upstreamSnapshot.ok) {
+    verdict = 'blocked';
+  } else if (!checks.questionLedger.ok || !checks.checkpointShelf.ok || !checks.activeRoute.ok || !checks.workspaceGit.ok) {
+    verdict = 'needs_attention';
+  }
+
+  const record = {
+    checkedAt: new Date().toISOString(),
+    workspaceRoot,
+    verdict,
+    activeProblem: state.activeProblem,
+    problemTitle: state.problemTitle,
+    activeRoute: state.activeRoute,
+    routeBreakthrough: state.routeBreakthrough,
+    problemSolved: state.problemSolved,
+    continuationMode: state.continuation.mode,
+    continuationDisplay: state.continuation.requestedMode === 'phase' ? 'route (phase-style)' : state.continuation.mode,
+    activeAgent: config.preferredAgent,
+    currentFrontier: state.currentFrontier,
+    nextHonestMove: state.nextHonestMove,
+    checks,
+  };
+
+  const registryPath = `${Date.now()}.json`;
+  writeJson(`${getWorkspaceRegistryBucketDir('preflight', workspaceRoot)}/${registryPath}`, record);
+  return record;
+}