erdos-problems 0.1.4 → 0.1.6

package/problems/536/problem.yaml

@@ -12,7 +12,7 @@ upstream:
 status:
   site_status: open
   site_badge: OPEN
-  repo_status: cataloged
+  repo_status: active
   upstream_status: open
   upstream_last_update: 2025-08-31
 cluster: sunflower
@@ -20,14 +20,15 @@ prize:
   display: no
 related_problems:
   - "857"
+  - "856"
+  - "20"
 family_tags:
   - sunflower-analogue
   - number-theory
 harness:
   depth: dossier
 statement:
-  short: Number-theoretic analogue of the sunflower problem framed through least
-    common multiples.
+  short: Number-theoretic analogue of the sunflower problem framed through least common multiples and natural-density structure.
   normalized_md_path: STATEMENT.md
 references_path: REFERENCES.md
 evidence_path: EVIDENCE.md
@@ -36,3 +37,8 @@ formalization:
   status: planned
   upstream_state: yes
   upstream_last_update: 2025-11-12
+research_state:
+  open_problem: true
+  active_route: natural_density_lcm_bridge
+  route_breakthrough: false
+  problem_solved: false

package/problems/856/problem.yaml

@@ -12,7 +12,7 @@ upstream:
 status:
   site_status: open
   site_badge: OPEN
-  repo_status: cataloged
+  repo_status: active
   upstream_status: open
   upstream_last_update: 2025-08-31
 cluster: sunflower
@@ -20,14 +20,15 @@ prize:
   display: no
 related_problems:
   - "857"
+  - "536"
+  - "20"
 family_tags:
   - sunflower-analogue
   - number-theory
 harness:
   depth: dossier
 statement:
-  short: A harmonic or density-shaped LCM analogue whose exponents are explicitly
-    linked to progress on the weak sunflower problem.
+  short: A harmonic or density-shaped LCM analogue whose exponent behavior is explicitly linked to progress on the weak sunflower problem.
   normalized_md_path: STATEMENT.md
 references_path: REFERENCES.md
 evidence_path: EVIDENCE.md
@@ -36,3 +37,8 @@ formalization:
   status: planned
   upstream_state: no
   upstream_last_update: 2025-08-31
+research_state:
+  open_problem: true
+  active_route: harmonic_density_lcm_bridge
+  route_breakthrough: false
+  problem_solved: false

package/src/cli/index.js

@@ -1,9 +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';
@@ -20,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');
@@ -28,6 +39,9 @@ function printUsage() {
   console.log('  erdos scaffold problem <id> [--dest <path>]');
   console.log('  erdos bootstrap problem <id> [--dest <path>] [--sync-upstream]');
   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]');
+  console.log('  erdos maintainer seed problem <id> [--from-pull <path>] [--dest-root <path>] [--cluster <name>]');
 }
 
 const args = process.argv.slice(2);
@@ -43,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') {
@@ -55,6 +77,8 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = await runBootstrapCommand(rest);
 } else if (command === 'pull') {
   exitCode = await runPullCommand(rest);
+} else if (command === 'maintainer') {
+  exitCode = runMaintainerCommand(rest);
 } else {
   console.error(`Unknown command: ${command}`);
   printUsage();

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/maintainer.js

@@ -0,0 +1,182 @@
+import path from 'node:path';
+import { seedProblemFromPullBundle } from '../runtime/maintainer-seed.js';
+
+function parseMaintainerSeedArgs(args) {
+  const [kind, problemToken, ...rest] = args;
+  if (kind !== 'problem') {
+    return { error: 'Only `erdos maintainer seed problem <id>` is supported right now.' };
+  }
+
+  const parsed = {
+    problemId: problemToken,
+    fromPullDir: null,
+    destRoot: null,
+    cluster: null,
+    repoStatus: null,
+    harnessDepth: null,
+    title: null,
+    familyTags: [],
+    relatedProblems: [],
+    formalizationStatus: null,
+    activeRoute: null,
+    routeBreakthrough: false,
+    problemSolved: false,
+    force: false,
+  };
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (token === '--from-pull') {
+      parsed.fromPullDir = rest[index + 1];
+      if (!parsed.fromPullDir) {
+        return { error: 'Missing path after --from-pull.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--dest-root') {
+      parsed.destRoot = rest[index + 1];
+      if (!parsed.destRoot) {
+        return { error: 'Missing path after --dest-root.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--cluster') {
+      parsed.cluster = rest[index + 1];
+      if (!parsed.cluster) {
+        return { error: 'Missing cluster value after --cluster.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--repo-status') {
+      parsed.repoStatus = rest[index + 1];
+      if (!parsed.repoStatus) {
+        return { error: 'Missing repo status after --repo-status.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--harness-depth') {
+      parsed.harnessDepth = rest[index + 1];
+      if (!parsed.harnessDepth) {
+        return { error: 'Missing harness depth after --harness-depth.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--title') {
+      parsed.title = rest[index + 1];
+      if (!parsed.title) {
+        return { error: 'Missing title after --title.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--family-tag') {
+      const tag = rest[index + 1];
+      if (!tag) {
+        return { error: 'Missing tag after --family-tag.' };
+      }
+      parsed.familyTags.push(tag);
+      index += 1;
+      continue;
+    }
+    if (token === '--related') {
+      const related = rest[index + 1];
+      if (!related) {
+        return { error: 'Missing problem id after --related.' };
+      }
+      parsed.relatedProblems.push(related);
+      index += 1;
+      continue;
+    }
+    if (token === '--formalization-status') {
+      parsed.formalizationStatus = rest[index + 1];
+      if (!parsed.formalizationStatus) {
+        return { error: 'Missing value after --formalization-status.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--active-route') {
+      parsed.activeRoute = rest[index + 1];
+      if (!parsed.activeRoute) {
+        return { error: 'Missing value after --active-route.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--route-breakthrough') {
+      parsed.routeBreakthrough = true;
+      continue;
+    }
+    if (token === '--problem-solved') {
+      parsed.problemSolved = true;
+      continue;
+    }
+    if (token === '--force') {
+      parsed.force = true;
+      continue;
+    }
+    return { error: `Unknown maintainer seed option: ${token}` };
+  }
+
+  return parsed;
+}
+
+export function runMaintainerCommand(args) {
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos maintainer seed problem <id> [--from-pull <path>] [--dest-root <path>] [--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] [--force]');
+    return 0;
+  }
+
+  if (subcommand !== 'seed') {
+    console.error(`Unknown maintainer subcommand: ${subcommand}`);
+    return 1;
+  }
+
+  const parsed = parseMaintainerSeedArgs(rest);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+  if (!parsed.problemId) {
+    console.error('Missing problem id.');
+    return 1;
+  }
+
+  try {
+    const result = seedProblemFromPullBundle(parsed.problemId, {
+      fromPullDir: parsed.fromPullDir ? path.resolve(parsed.fromPullDir) : null,
+      destRoot: parsed.destRoot ? path.resolve(parsed.destRoot) : null,
+      cluster: parsed.cluster,
+      repoStatus: parsed.repoStatus,
+      harnessDepth: parsed.harnessDepth,
+      title: parsed.title,
+      familyTags: parsed.familyTags,
+      relatedProblems: parsed.relatedProblems,
+      formalizationStatus: parsed.formalizationStatus,
+      activeRoute: parsed.activeRoute,
+      routeBreakthrough: parsed.routeBreakthrough,
+      problemSolved: parsed.problemSolved,
+      force: parsed.force,
+    });
+
+    console.log(`Seeded dossier for problem ${parsed.problemId}`);
+    console.log(`Destination: ${result.destinationDir}`);
+    console.log(`Title: ${result.record.title}`);
+    console.log(`Cluster: ${result.record.cluster}`);
+    console.log(`Harness depth: ${result.record.harness.depth}`);
+    console.log(`Upstream record used: ${result.usedUpstreamRecord ? 'yes' : 'no'}`);
+    console.log(`Site snapshot used: ${result.usedSiteSnapshot ? 'yes' : 'no'}`);
+    return 0;
+  } catch (error) {
+    console.error(String(error.message ?? error));
+    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) {
@@ -129,6 +130,12 @@ function printArtifactInventory(problem, inventory, asJson) {
   if (inventory.packContext) {
     console.log(`- ${inventory.packContext.label}: ${inventory.packContext.exists ? 'present' : 'missing'} (${inventory.packContext.path})`);
   }
+  if (inventory.packProblemArtifacts.length > 0) {
+    console.log('Pack problem artifacts:');
+    for (const artifact of inventory.packProblemArtifacts) {
+      console.log(`- ${artifact.label}: ${artifact.exists ? 'present' : 'missing'} (${artifact.path})`);
+    }
+  }
   if (inventory.computePackets.length > 0) {
     console.log('Compute packets:');
     for (const packet of inventory.computePackets) {
@@ -194,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;
   }