erdos-problems 0.1.5 → 0.1.7

package/README.md

@@ -38,6 +38,14 @@ erdos sunflower status 857
 erdos dossier show 857
 ```
 
+For an unseeded problem, the one-step self-seeding flow is now:
+
+```bash
+erdos seed problem 1 --include-site --cluster number-theory
+erdos problem show 1
+erdos workspace show
+```
+
 What `bootstrap` does:
 - sets the active workspace problem
 - scaffolds the canonical dossier files into `.erdos/scaffolds/<id>/`
@@ -45,6 +53,13 @@ What `bootstrap` does:
 - copies pack-specific context and compute packets when the problem has them
 - gives an agent a ready-to-read local artifact bundle immediately after install
 
+What `seed` does:
+- creates a pull bundle for any problem in the upstream snapshot
+- promotes that bundle into `.erdos/seeded-problems/<id>/`
+- auto-selects the problem in the workspace
+- syncs the staged research loop state and checkpoint shelf
+- makes the new dossier visible to the atlas commands immediately inside that workspace
+
 ## Pull lanes
 
 For any problem number in the upstream snapshot, you can create a workspace bundle even if the problem is not yet seeded locally:
@@ -138,6 +153,7 @@ erdos upstream diff
 erdos scaffold problem 857
 erdos bootstrap problem 857
 erdos bootstrap problem 857 --sync-upstream
+erdos seed problem 1 --include-site --cluster number-theory
 erdos pull problem 857
 erdos pull artifacts 857
 erdos pull literature 857
@@ -166,6 +182,7 @@ The CLI can surface these directly:
 - `erdos problem artifacts <id> --json` emits machine-readable inventory
 - `erdos scaffold problem <id>` copies the seeded dossier into the active workspace
 - `erdos bootstrap problem <id>` selects the problem and creates the scaffold in one step
+- `erdos seed problem <id>` self-seeds an unseeded problem into `.erdos/seeded-problems/` and syncs the loop
 - `erdos pull problem <id>` creates a workspace bundle for any problem in the upstream snapshot
 - `erdos maintainer seed problem <id>` promotes a pull bundle into a canonical local dossier
 
@@ -184,3 +201,38 @@ For sunflower problems, the CLI also surfaces pack-specific artifacts:
 - `docs/ERDOS_PROBLEMS_REPO_SPEC.md`
 - `docs/ERDOS_PROBLEMS_PROBLEM_SCHEMA.md`
 - `docs/ERDOS_SUNFLOWER_CLUSTER_SEED_PLAN.md`
+
+## Research loop
+
+`erdos-problems` now carries the staged loop we defined in the sunflower lab and the `.gpd`-style harness work:
+
+```bash
+erdos problem use 857
+erdos state sync
+erdos preflight
+erdos continuation use route
+erdos checkpoints sync
+erdos workspace show
+```
+
+This runtime writes:
+- `.erdos/config.json`
+- `.erdos/state.json`
+- `.erdos/STATE.md`
+- `.erdos/QUESTION-LEDGER.md`
+- `.erdos/checkpoints/CHECKPOINTS.md`
+- `.erdos/checkpoints/CHECKPOINTS.json`
+- `.erdos/registry/preflight/`
+
+The public package uses the same status ladder we settled on in the lab:
+- open problem
+- active route
+- route breakthrough
+- problem solved
+
+That means a fresh install now supports two clean research starts:
+- `erdos bootstrap problem <seeded-id>` for native packaged dossiers
+- `erdos seed problem <unseeded-id>` for workspace-local self-seeding with the same loop
+
+See also:
+- `docs/RESEARCH_LOOP.md`

package/docs/RESEARCH_LOOP.md

@@ -0,0 +1,58 @@
+# Research Loop
+
+`erdos-problems` now carries the staged research loop that was proven out in the sunflower lab and refined by the `.gpd` flow in `longevity-research`.
+
+## Runtime layout
+
+Workspace runtime files live under `.erdos/`:
+- `config.json`
+- `state.json`
+- `STATE.md`
+- `QUESTION-LEDGER.md`
+- `checkpoints/CHECKPOINTS.md`
+- `checkpoints/CHECKPOINTS.json`
+- `registry/preflight/`
+- `registry/compute/`
+
+## Core loop
+
+1. Select or bootstrap a problem.
+2. Sync state.
+3. Run preflight.
+4. Set continuation mode.
+5. Sync checkpoints.
+6. Pull or scaffold artifacts.
+7. Work the active route.
+8. Sync checkpoints again at honest boundaries.
+
+## Commands
+
+```bash
+erdos problem use 857
+erdos state sync
+erdos preflight
+erdos continuation use route
+erdos checkpoints sync
+erdos workspace show
+```
+
+For problems that are not yet packaged as native dossiers, the loop can start with one-step self-seeding:
+
+```bash
+erdos seed problem 1 --include-site --cluster number-theory
+erdos preflight
+erdos continuation use route
+erdos checkpoints sync
+```
+
+That flow writes the local dossier into `.erdos/seeded-problems/<id>/`, makes it visible to the atlas inside the current workspace, and immediately syncs the same state/checkpoint machinery used by packaged dossiers.
+
+## Status ladder
+
+The public package uses the same ladder we converged on in the lab:
+- open problem
+- active route
+- route breakthrough
+- problem solved
+
+The key rule is that route breakthroughs are never silently inflated into solved-problem claims.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erdos-problems",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "CLI atlas and staged research harness for Paul Erdos problems.",
   "type": "module",
   "bin": {

package/packs/sunflower/compute/20/u3_uniform_transfer_window_v0.yaml

@@ -0,0 +1,16 @@
+lane_id: u3_uniform_transfer_window_v0
+problem_id: "20"
+cluster: sunflower
+question: Can the uniform k=3 lane be frozen into a transfer-ready reduction packet that talks cleanly to the weak 857 export route?
+claim_level_goal: Verified
+status: ready_for_local_scout
+price_checked_local_date: 2026-03-25
+recommendation: local_scout_first
+approval_required: false
+summary: Problem 20 now has a frozen local-scout packet for the uniform k=3 transfer window. The job is to verify a small explicit reduction bundle before any paid compute rung is considered.
+source_repo: /Volumes/Code_2TB/code/sunflower-coda/repo
+public_feature: uniform_k3_frontier
+rungs:
+  - label: local_scout
+    mode: local
+    goal: verify the reduction packet, pull artifacts, and checkpoint the first honest route result

package/packs/sunflower/problems/20/CONTEXT.md

@@ -7,3 +7,8 @@ Role in family:
 Bootstrap focus:
 - start from the uniform k=3 lane
 - keep explicit bridges back to 857 whenever a route or method transfers cleanly
+
+Frontier framing:
+- the live goal is not “solve strong sunflower in one jump”
+- the live goal is to package the uniform k=3 lane into a recurrence-ready and transfer-ready route
+- checkpoint every route breakthrough before widening the public claim surface

package/packs/sunflower/problems/20/context.yaml

@@ -3,6 +3,11 @@ family_role: strong_sunflower_core
 harness_profile: deep
 default_active_route: uniform_k3_frontier
 bootstrap_focus: Frame the strong or uniform k=3 sunflower lane as the direct sibling frontier to the weak 857 route.
+route_story: Keep the uniform k=3 lane explicit, preserve every clean bridge to problem 857, and do not let local route work masquerade as full strong-sunflower closure.
+frontier_label: uniform_k3_frontier
+frontier_detail: Tighten the uniform k=3 route into a recurrence-ready and transfer-ready reduction packet that can talk honestly to the weak 857 export program.
+checkpoint_focus: Record honest uniform-family route claims, bridge notes to 857, and any reusable reductions without overstating global closure.
+next_honest_move: Pull the uniform k=3 dossier, sync checkpoints, and pressure the smallest recurrence-facing or reduction-facing obligation.
 related_core_problems:
   - "857"
   - "536"
@@ -16,3 +21,11 @@ artifact_focus:
   - uniform-family reductions
   - k=3 active route notes
   - bridge notes to 857
+question_ledger:
+  open_questions:
+    - Which uniform k=3 reduction is the next smallest honest route step?
+    - What bridge result would cleanly transfer from problem 20 back into the weak 857 program?
+  active_route_notes:
+    - Keep the active route stated in uniform-family language, not generic sunflower shorthand.
+  route_breakthroughs:
+    - If a route breakthrough lands, checkpoint it before widening to strong-sunflower victory language.

package/packs/sunflower/problems/857/CONTEXT.md

@@ -7,3 +7,8 @@ Role in family:
 Bootstrap focus:
 - preserve the live route framing in the scaffold
 - keep literature, artifact, and compute packets aligned with the active frontier rather than generic sunflower chatter
+
+Frontier framing:
+- preserve the active export/compression route as the live frontier
+- keep the recurrence-facing remainder terms explicit in every checkpoint
+- do not blur route breakthroughs into claims that the open problem is solved

package/packs/sunflower/problems/857/context.yaml

@@ -3,6 +3,11 @@ family_role: weak_sunflower_core
 harness_profile: deep
 default_active_route: anchored_selector_linearization
 bootstrap_focus: Start from the weak sunflower asymptotic route and preserve the active export/compression frontier in the scaffold.
+route_story: Keep the weak sunflower route pointed at recurrence-facing export and compression work, and preserve the distinction between route breakthroughs and full problem closure.
+frontier_label: anchored_selector_linearization
+frontier_detail: Preserve the live export/compression frontier and keep the recurrence-facing remainder terms explicit rather than flattening them into generic sunflower notes.
+checkpoint_focus: Record route breakthroughs, keep the open-problem versus active-route distinction sharp, and preserve the live remainder/compression obligations in every checkpoint.
+next_honest_move: Sync checkpoints, then keep compressing the explicit O1a export into a true recurrence-facing step.
 related_core_problems:
   - "20"
   - "536"
@@ -16,3 +21,12 @@ artifact_focus:
   - active route notes
   - formal frontier checkpoints
   - compute lane packets when frozen
+question_ledger:
+  open_questions:
+    - Which explicit compression step is the next honest reduction on the active weak-sunflower route?
+    - Which exported remainder term is still dominating the recurrence-facing frontier?
+  active_route_notes:
+    - Keep active-route notes tied to the explicit export/compression frontier, not generic sunflower chatter.
+    - Preserve the distinction between route breakthrough and full-problem solution in every artifact.
+  route_breakthroughs:
+    - When a route breakthrough lands, checkpoint it before selecting the next active route.

package/src/atlas/catalog.js

@@ -1,18 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parse } from 'yaml';
-import { getProblemDir, repoRoot } from '../runtime/paths.js';
+import { getProblemDir, getWorkspaceRoot, getWorkspaceSeededProblemsDir, repoRoot } from '../runtime/paths.js';
 
-let cachedProblems = null;
-
-function readProblemRecord(problemId) {
-  const problemDir = getProblemDir(problemId);
+function readProblemRecordFromDir(problemDir) {
   const yamlPath = path.join(problemDir, 'problem.yaml');
   const record = parse(fs.readFileSync(yamlPath, 'utf8'));
   return { problemDir, record };
 }
 
-function toCatalogProblem(problemDir, record) {
+function toCatalogProblem(problemDir, record, sourceKind) {
   const statementRelative = record.statement?.normalized_md_path ?? 'STATEMENT.md';
   const referencesRelative = record.references_path ?? 'REFERENCES.md';
   const evidenceRelative = record.evidence_path ?? 'EVIDENCE.md';
@@ -47,47 +44,58 @@ function toCatalogProblem(problemDir, record) {
     problemDir,
     problemYamlPath: path.join(problemDir, 'problem.yaml'),
     record,
+    sourceKind,
   };
 }
 
-export function loadLocalProblems() {
-  if (cachedProblems) {
-    return cachedProblems;
+function listProblemDirectories(rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    return [];
   }
-  const problemsRoot = path.join(repoRoot, 'problems');
-  const directories = fs
-    .readdirSync(problemsRoot, { withFileTypes: true })
+  return fs
+    .readdirSync(rootDir, { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name)
-    .sort((a, b) => Number(a) - Number(b));
+    .map((entry) => path.join(rootDir, entry.name));
+}
+
+export function loadLocalProblems(workspaceRoot = getWorkspaceRoot()) {
+  const packageRoot = path.join(repoRoot, 'problems');
+  const workspaceRootDir = getWorkspaceSeededProblemsDir(workspaceRoot);
+  const merged = new Map();
+
+  for (const problemDir of listProblemDirectories(packageRoot)) {
+    const { record } = readProblemRecordFromDir(problemDir);
+    merged.set(String(record.problem_id), toCatalogProblem(problemDir, record, 'package'));
+  }
+
+  for (const problemDir of listProblemDirectories(workspaceRootDir)) {
+    const { record } = readProblemRecordFromDir(problemDir);
+    merged.set(String(record.problem_id), toCatalogProblem(problemDir, record, 'workspace'));
+  }
 
-  cachedProblems = directories.map((problemId) => {
-    const { problemDir, record } = readProblemRecord(problemId);
-    return toCatalogProblem(problemDir, record);
-  });
-  return cachedProblems;
+  return [...merged.values()].sort((left, right) => Number(left.problemId) - Number(right.problemId));
 }
 
-export function listProblems(filters = {}) {
+export function listProblems(filters = {}, workspaceRoot = getWorkspaceRoot()) {
   const cluster = filters.cluster ? String(filters.cluster).toLowerCase() : null;
   const repoStatus = filters.repoStatus ? String(filters.repoStatus).toLowerCase() : null;
   const harnessDepth = filters.harnessDepth ? String(filters.harnessDepth).toLowerCase() : null;
   const siteStatus = filters.siteStatus ? String(filters.siteStatus).toLowerCase() : null;
 
-  return loadLocalProblems()
+  return loadLocalProblems(workspaceRoot)
     .filter((entry) => (cluster ? entry.cluster === cluster : true))
     .filter((entry) => (repoStatus ? entry.repoStatus === repoStatus : true))
     .filter((entry) => (harnessDepth ? entry.harnessDepth === harnessDepth : true))
     .filter((entry) => (siteStatus ? entry.siteStatus === siteStatus : true));
 }
 
-export function getProblem(problemId) {
-  return loadLocalProblems().find((entry) => entry.problemId === String(problemId));
+export function getProblem(problemId, workspaceRoot = getWorkspaceRoot()) {
+  return loadLocalProblems(workspaceRoot).find((entry) => entry.problemId === String(problemId));
 }
 
-export function getCluster(clusterName) {
+export function getCluster(clusterName, workspaceRoot = getWorkspaceRoot()) {
   const name = String(clusterName).toLowerCase();
-  const problems = listProblems({ cluster: name });
+  const problems = listProblems({ cluster: name }, workspaceRoot);
   if (problems.length === 0) {
     return null;
   }
@@ -99,11 +107,11 @@ export function getCluster(clusterName) {
   };
 }
 
-export function listClusters() {
-  const names = [...new Set(loadLocalProblems().map((entry) => entry.cluster))].sort();
-  return names.map((name) => getCluster(name));
+export function listClusters(workspaceRoot = getWorkspaceRoot()) {
+  const names = [...new Set(loadLocalProblems(workspaceRoot).map((entry) => entry.cluster))].sort();
+  return names.map((name) => getCluster(name, workspaceRoot));
 }
 
 export function clearCatalogCache() {
-  cachedProblems = null;
+  return null;
 }

package/src/cli/index.js

@@ -1,10 +1,15 @@
 import { runBootstrapCommand } from '../commands/bootstrap.js';
+import { runCheckpointsCommand } from '../commands/checkpoints.js';
 import { runClusterCommand } from '../commands/cluster.js';
+import { runContinuationCommand } from '../commands/continuation.js';
 import { runDossierCommand } from '../commands/dossier.js';
 import { runMaintainerCommand } from '../commands/maintainer.js';
+import { runPreflightCommand } from '../commands/preflight.js';
 import { runProblemCommand } from '../commands/problem.js';
 import { runPullCommand } from '../commands/pull.js';
 import { runScaffoldCommand } from '../commands/scaffold.js';
+import { runSeedCommand } from '../commands/seed.js';
+import { runStateCommand } from '../commands/state.js';
 import { runSunflowerCommand } from '../commands/sunflower.js';
 import { runUpstreamCommand } from '../commands/upstream.js';
 import { runWorkspaceCommand } from '../commands/workspace.js';
@@ -21,6 +26,12 @@ function printUsage() {
   console.log('  erdos cluster list');
   console.log('  erdos cluster show <name>');
   console.log('  erdos workspace show');
+  console.log('  erdos state sync [--json]');
+  console.log('  erdos state show [--json]');
+  console.log('  erdos continuation show [--json]');
+  console.log('  erdos continuation use <atom|route|phase|milestone> [--json]');
+  console.log('  erdos preflight [--allow-dirty] [--json]');
+  console.log('  erdos checkpoints sync [--json]');
   console.log('  erdos sunflower status [<id>] [--json]');
   console.log('  erdos dossier show <id>');
   console.log('  erdos upstream show');
@@ -28,6 +39,7 @@ function printUsage() {
   console.log('  erdos upstream diff [--write-package-report]');
   console.log('  erdos scaffold problem <id> [--dest <path>]');
   console.log('  erdos bootstrap problem <id> [--dest <path>] [--sync-upstream]');
+  console.log('  erdos seed problem <id> [--include-site] [--refresh-upstream] [--cluster <name>] [--repo-status <status>] [--harness-depth <depth>] [--title <title>] [--family-tag <tag>] [--related <id>] [--formalization-status <status>] [--active-route <route>] [--route-breakthrough] [--problem-solved] [--dest-root <path>] [--no-activate] [--no-loop-sync] [--force] [--json]');
   console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--refresh-upstream]');
   console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream]');
   console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--refresh-upstream]');
@@ -47,6 +59,14 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = runClusterCommand(rest);
 } else if (command === 'workspace') {
   exitCode = runWorkspaceCommand(rest);
+} else if (command === 'state') {
+  exitCode = runStateCommand(rest);
+} else if (command === 'continuation') {
+  exitCode = runContinuationCommand(rest);
+} else if (command === 'preflight') {
+  exitCode = runPreflightCommand(rest);
+} else if (command === 'checkpoints') {
+  exitCode = runCheckpointsCommand(rest);
 } else if (command === 'sunflower') {
   exitCode = runSunflowerCommand(rest);
 } else if (command === 'dossier') {
@@ -57,6 +77,8 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = runScaffoldCommand(rest);
 } else if (command === 'bootstrap') {
   exitCode = await runBootstrapCommand(rest);
+} else if (command === 'seed') {
+  exitCode = await runSeedCommand(rest);
 } else if (command === 'pull') {
   exitCode = await runPullCommand(rest);
 } else if (command === 'maintainer') {

package/src/commands/bootstrap.js

@@ -1,7 +1,9 @@
 import path from 'node:path';
 import { getProblem } from '../atlas/catalog.js';
+import { syncCheckpoints } from '../runtime/checkpoints.js';
 import { scaffoldProblem } from '../runtime/problem-artifacts.js';
 import { getWorkspaceProblemScaffoldDir } from '../runtime/paths.js';
+import { syncState } from '../runtime/state.js';
 import { setCurrentProblem } from '../runtime/workspace.js';
 import { syncUpstream } from '../upstream/sync.js';
 
@@ -71,11 +73,16 @@ export async function runBootstrapCommand(args) {
     ? path.resolve(parsed.destination)
     : getWorkspaceProblemScaffoldDir(problem.problemId);
   const result = scaffoldProblem(problem, destination);
+  const state = syncState();
+  const checkpoints = syncCheckpoints();
 
   console.log(`Bootstrapped problem ${problem.problemId} (${problem.title})`);
   console.log(`Active problem: ${problem.problemId}`);
+  console.log(`Active route: ${state.activeRoute ?? '(none)'}`);
   console.log(`Scaffold dir: ${result.destination}`);
   console.log(`Artifacts copied: ${result.copiedArtifacts.length}`);
   console.log(`Upstream record included: ${result.inventory.upstreamRecordIncluded ? 'yes' : 'no'}`);
+  console.log(`Checkpoint shelf: ${checkpoints.indexPath}`);
+  console.log(`Next honest move: ${state.nextHonestMove}`);
   return 0;
 }

package/src/commands/checkpoints.js

@@ -0,0 +1,36 @@
+import { syncCheckpoints } from '../runtime/checkpoints.js';
+
+export function runCheckpointsCommand(args) {
+  const [subcommand, ...rest] = args;
+  const asJson = rest.includes('--json');
+  const unknown = rest.filter((arg) => arg !== '--json');
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos checkpoints sync [--json]');
+    return 0;
+  }
+
+  if (subcommand !== 'sync') {
+    console.error(`Unknown checkpoints subcommand: ${subcommand}`);
+    return 1;
+  }
+
+  if (unknown.length > 0) {
+    console.error(`Unknown checkpoints option: ${unknown[0]}`);
+    return 1;
+  }
+
+  const result = syncCheckpoints();
+  if (asJson) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+
+  console.log('Checkpoint shelf synced');
+  console.log(`Index path: ${result.indexPath}`);
+  console.log(`Checkpoint JSON: ${result.checkpointJsonPath}`);
+  console.log(`Checkpoint count: ${result.checkpoints.length}`);
+  console.log(`Last checkpoint sync: ${result.state.lastCheckpointSyncAt}`);
+  return 0;
+}

package/src/commands/continuation.js

@@ -0,0 +1,60 @@
+import { ensureConfig, loadConfig, saveConfig } from '../runtime/config.js';
+import { continuationDisplay, continuationModes, resolveContinuation } from '../runtime/continuation.js';
+import { syncState } from '../runtime/state.js';
+
+function printContinuation(payload) {
+  console.log('Continuation mode');
+  console.log(`Requested: ${payload.requestedMode}`);
+  console.log(`Resolved: ${continuationDisplay(payload)}`);
+  console.log(`Review cadence: ${payload.reviewCadence}`);
+  console.log(`Max unattended minutes: ${payload.maxUnattendedMinutes}`);
+  console.log(`Checkpoint after load-bearing result: ${payload.checkpointAfterLoadBearingResult ? 'yes' : 'no'}`);
+  console.log(`Stop rule: ${payload.stopRule}`);
+}
+
+export function runContinuationCommand(args) {
+  const [subcommand, value, ...rest] = args;
+  const asJson = rest.includes('--json');
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos continuation show [--json]');
+    console.log(`  erdos continuation use <${continuationModes().join('|')}> [--json]`);
+    return 0;
+  }
+
+  if (subcommand === 'show') {
+    const config = ensureConfig();
+    const continuation = resolveContinuation({ requestedMode: config.continuation });
+    if (asJson) {
+      console.log(JSON.stringify(continuation, null, 2));
+      return 0;
+    }
+    printContinuation(continuation);
+    return 0;
+  }
+
+  if (subcommand === 'use') {
+    if (!value) {
+      console.error('Missing continuation mode.');
+      return 1;
+    }
+    if (!continuationModes().includes(value)) {
+      console.error(`Unknown continuation mode: ${value}`);
+      return 1;
+    }
+    const config = loadConfig();
+    saveConfig({ ...config, continuation: value });
+    const state = syncState();
+    if (asJson) {
+      console.log(JSON.stringify(state.continuation, null, 2));
+      return 0;
+    }
+    console.log(`Continuation mode set to ${continuationDisplay(state.continuation)}`);
+    printContinuation(state.continuation);
+    return 0;
+  }
+
+  console.error(`Unknown continuation subcommand: ${subcommand}`);
+  return 1;
+}

package/src/commands/preflight.js

@@ -0,0 +1,44 @@
+import { buildPreflightReport } from '../runtime/preflight.js';
+
+function printChecks(checks) {
+  for (const [label, payload] of Object.entries(checks)) {
+    console.log(`- ${label}: ${payload.ok ? 'ok' : 'attention'} (${payload.detail})`);
+  }
+}
+
+export function runPreflightCommand(args) {
+  const asJson = args.includes('--json');
+  const allowDirty = args.includes('--allow-dirty');
+  const unknown = args.filter((arg) => arg !== '--json' && arg !== '--allow-dirty');
+
+  if (args.length > 0 && (args[0] === 'help' || args[0] === '--help')) {
+    console.log('Usage:');
+    console.log('  erdos preflight [--allow-dirty] [--json]');
+    return 0;
+  }
+
+  if (unknown.length > 0) {
+    console.error(`Unknown preflight option: ${unknown[0]}`);
+    return 1;
+  }
+
+  const report = buildPreflightReport({ allowDirty });
+  if (asJson) {
+    console.log(JSON.stringify(report, null, 2));
+    return report.verdict === 'blocked' ? 2 : 0;
+  }
+
+  console.log('Research preflight');
+  console.log(`- Workspace root: ${report.workspaceRoot}`);
+  console.log(`- Open problem: ${report.activeProblem ?? '(none)'}`);
+  console.log(`- Active route: ${report.activeRoute ?? '(none)'}`);
+  console.log(`- Route breakthrough: ${report.routeBreakthrough ? 'yes' : 'no'}`);
+  console.log(`- Problem solved: ${report.problemSolved ? 'yes' : 'no'}`);
+  console.log(`- Continuation policy: ${report.continuationDisplay}`);
+  console.log(`- Current frontier: ${report.currentFrontier.kind} / ${report.currentFrontier.detail}`);
+  console.log(`- Next honest move: ${report.nextHonestMove}`);
+  console.log('Checks:');
+  printChecks(report.checks);
+  console.log(`Verdict: ${report.verdict}`);
+  return report.verdict === 'blocked' ? 2 : 0;
+}

package/src/commands/problem.js

@@ -1,5 +1,6 @@
 import { getProblem, listProblems } from '../atlas/catalog.js';
 import { getProblemArtifactInventory } from '../runtime/problem-artifacts.js';
+import { syncState } from '../runtime/state.js';
 import { readCurrentProblem, setCurrentProblem } from '../runtime/workspace.js';
 
 function parseListFilters(args) {
@@ -200,7 +201,10 @@ export function runProblemCommand(args) {
       return 1;
     }
     setCurrentProblem(problem.problemId);
+    const state = syncState();
     console.log(`Active problem set to ${problem.problemId} (${problem.title})`);
+    console.log(`Active route: ${state.activeRoute ?? '(none)'}`);
+    console.log(`Next honest move: ${state.nextHonestMove}`);
     return 0;
   }