erdos-problems 0.1.5 → 0.1.6

package/README.md

@@ -184,3 +184,34 @@ 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
+
+See also:
+- `docs/RESEARCH_LOOP.md`

package/docs/RESEARCH_LOOP.md

@@ -0,0 +1,47 @@
+# 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
+```
+
+## 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.6",
   "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/cli/index.js

@@ -1,10 +1,14 @@
 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 { 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 +25,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');
@@ -47,6 +57,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') {

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;
   }
 

package/src/commands/state.js

@@ -0,0 +1,57 @@
+import { getWorkspaceQuestionLedgerPath, getWorkspaceStateMarkdownPath } from '../runtime/paths.js';
+import { loadState, syncState } from '../runtime/state.js';
+
+function printState(state) {
+  console.log('Erdos research state');
+  console.log(`Workspace root: ${state.workspaceRoot}`);
+  console.log(`Open problem: ${state.activeProblem || '(none)'}`);
+  console.log(`Problem title: ${state.problemTitle || '(none)'}`);
+  console.log(`Cluster: ${state.cluster || '(none)'}`);
+  console.log(`Family role: ${state.familyRole || '(none)'}`);
+  console.log(`Harness profile: ${state.harnessProfile || '(none)'}`);
+  console.log(`Active route: ${state.activeRoute || '(none)'}`);
+  console.log(`Route breakthrough: ${state.routeBreakthrough ? 'yes' : 'no'}`);
+  console.log(`Problem solved: ${state.problemSolved ? 'yes' : 'no'}`);
+  console.log(`Continuation mode: ${state.continuation.mode}`);
+  console.log(`Current frontier: ${state.currentFrontier.kind} / ${state.currentFrontier.detail}`);
+  console.log(`Route story: ${state.routeStory || '(none)'}`);
+  console.log(`Checkpoint focus: ${state.checkpointFocus || '(none)'}`);
+  console.log(`Next honest move: ${state.nextHonestMove}`);
+  console.log(`State markdown: ${getWorkspaceStateMarkdownPath()}`);
+  console.log(`Question ledger: ${getWorkspaceQuestionLedgerPath()}`);
+}
+
+export function runStateCommand(args) {
+  const [subcommand, ...rest] = args;
+  const asJson = rest.includes('--json');
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos state sync [--json]');
+    console.log('  erdos state show [--json]');
+    return 0;
+  }
+
+  if (subcommand === 'sync') {
+    const state = syncState();
+    if (asJson) {
+      console.log(JSON.stringify(state, null, 2));
+      return 0;
+    }
+    printState(state);
+    return 0;
+  }
+
+  if (subcommand === 'show') {
+    const state = loadState();
+    if (asJson) {
+      console.log(JSON.stringify(state, null, 2));
+      return 0;
+    }
+    printState(state);
+    return 0;
+  }
+
+  console.error(`Unknown state subcommand: ${subcommand}`);
+  return 1;
+}

package/src/commands/sunflower.js

@@ -35,6 +35,11 @@ function printSunflowerStatus(snapshot, registryPaths) {
   console.log(`Open problem: ${snapshot.openProblem ? 'yes' : 'no'}`);
   console.log(`Problem solved: ${snapshot.problemSolved ? 'yes' : 'no'}`);
   console.log(`Bootstrap focus: ${snapshot.bootstrapFocus ?? '(none)'}`);
+  console.log(`Route story: ${snapshot.routeStory ?? '(none)'}`);
+  console.log(`Frontier label: ${snapshot.frontierLabel ?? '(none)'}`);
+  console.log(`Frontier detail: ${snapshot.frontierDetail ?? '(none)'}`);
+  console.log(`Checkpoint focus: ${snapshot.checkpointFocus ?? '(none)'}`);
+  console.log(`Next honest move: ${snapshot.nextHonestMove}`);
   console.log(`Related core problems: ${snapshot.relatedCoreProblems.join(', ') || '(none)'}`);
   console.log(`Literature focus: ${snapshot.literatureFocus.join(', ') || '(none)'}`);
   console.log(`Artifact focus: ${snapshot.artifactFocus.join(', ') || '(none)'}`);

package/src/commands/workspace.js

@@ -1,4 +1,5 @@
 import { getProblem } from '../atlas/catalog.js';
+import { loadConfig } from '../runtime/config.js';
 import { buildSunflowerStatusSnapshot } from '../runtime/sunflower.js';
 import { getWorkspaceSummary } from '../runtime/workspace.js';
 
@@ -17,15 +18,31 @@ export function runWorkspaceCommand(args) {
   }
 
   const summary = getWorkspaceSummary();
+  const config = loadConfig();
   console.log(`Workspace root: ${summary.workspaceRoot}`);
   console.log(`State dir: ${summary.stateDir}`);
   console.log(`Initialized: ${summary.hasState ? 'yes' : 'no'}`);
   console.log(`Active problem: ${summary.activeProblem ?? '(none)'}`);
+  console.log(`Config path: ${summary.configPath}`);
+  console.log(`State file: ${summary.statePath}`);
+  console.log(`State markdown: ${summary.stateMarkdownPath}`);
+  console.log(`Question ledger: ${summary.questionLedgerPath}`);
+  console.log(`Checkpoint shelf: ${summary.checkpointIndexPath}`);
   console.log(`Workspace upstream dir: ${summary.upstreamDir}`);
   console.log(`Workspace scaffold dir: ${summary.scaffoldDir}`);
   console.log(`Workspace pull dir: ${summary.pullDir}`);
   console.log(`Workspace artifact dir: ${summary.artifactDir}`);
   console.log(`Workspace literature dir: ${summary.literatureDir}`);
+  console.log(`Preferred agent: ${config.preferredAgent}`);
+  console.log(`Continuation mode: ${summary.continuationMode ?? config.continuation}`);
+  console.log(`Active route: ${summary.activeRoute ?? '(none)'}`);
+  console.log(`Route breakthrough: ${summary.routeBreakthrough ? 'yes' : 'no'}`);
+  console.log(`Problem solved: ${summary.problemSolved ? 'yes' : 'no'}`);
+  console.log(`Checkpoint synced at: ${summary.lastCheckpointSyncAt ?? '(never)'}`);
+  console.log(`Next honest move: ${summary.nextHonestMove ?? '(none)'}`);
+  if (summary.currentFrontier) {
+    console.log(`Current frontier: ${summary.currentFrontier.kind} / ${summary.currentFrontier.detail}`);
+  }
   console.log(`Updated at: ${summary.updatedAt ?? '(none)'}`);
   if (summary.activeProblem) {
     const problem = getProblem(summary.activeProblem);
@@ -34,6 +51,7 @@ export function runWorkspaceCommand(args) {
       console.log(`Sunflower family role: ${sunflower.familyRole ?? '(none)'}`);
       console.log(`Sunflower harness profile: ${sunflower.harnessProfile ?? '(none)'}`);
       console.log(`Sunflower route: ${sunflower.activeRoute ?? '(none)'}`);
+      console.log(`Sunflower frontier: ${sunflower.frontierDetail ?? '(none)'}`);
       console.log(`Sunflower compute: ${sunflower.computeLanePresent ? 'yes' : 'no'}`);
       if (sunflower.activePacket) {
         console.log(`Sunflower compute lane: ${sunflower.activePacket.laneId} [${sunflower.activePacket.status}]`);