erdos-problems 0.1.4 → 0.1.6

package/src/commands/pull.js

@@ -1,15 +1,19 @@
 import path from 'node:path';
 import { getProblem } from '../atlas/catalog.js';
-import { ensureDir, writeJson, writeText } from '../runtime/files.js';
-import { getWorkspaceProblemPullDir } from '../runtime/paths.js';
-import { scaffoldProblem } from '../runtime/problem-artifacts.js';
+import { copyFileIfPresent, ensureDir, writeJson, writeText } from '../runtime/files.js';
+import {
+  getWorkspaceProblemArtifactDir,
+  getWorkspaceProblemLiteratureDir,
+  getWorkspaceProblemPullDir,
+} from '../runtime/paths.js';
+import { getProblemArtifactInventory, scaffoldProblem } from '../runtime/problem-artifacts.js';
 import { loadActiveUpstreamSnapshot, syncUpstream } from '../upstream/sync.js';
 import { fetchProblemSiteSnapshot } from '../upstream/site.js';
 
 function parsePullArgs(args) {
   const [kind, value, ...rest] = args;
-  if (kind !== 'problem') {
-    return { error: 'Only `erdos pull problem <id>` is supported right now.' };
+  if (!['problem', 'artifacts', 'literature'].includes(kind)) {
+    return { error: 'Usage: erdos pull problem|artifacts|literature <id> [--dest <path>] [--include-site] [--refresh-upstream]' };
   }
 
   let destination = null;
@@ -38,6 +42,7 @@ function parsePullArgs(args) {
   }
 
   return {
+    kind,
     problemId: value,
     destination,
     includeSite,
@@ -45,31 +50,36 @@ function parsePullArgs(args) {
   };
 }
 
-function writeUpstreamOnlyBundle(problemId, destination, upstreamRecord, snapshot) {
+function buildProblemRecord(problemId, localProblem, upstreamRecord) {
+  return {
+    generatedAt: new Date().toISOString(),
+    problemId: String(problemId),
+    title: localProblem?.title ?? `Erdos Problem #${problemId}`,
+    cluster: localProblem?.cluster ?? null,
+    siteStatus: localProblem?.siteStatus ?? upstreamRecord?.status?.state ?? 'unknown',
+    repoStatus: localProblem?.repoStatus ?? 'upstream-only',
+    harnessDepth: localProblem?.harnessDepth ?? 'unseeded',
+    sourceUrl: localProblem?.sourceUrl ?? `https://www.erdosproblems.com/${problemId}`,
+    activeRoute: localProblem?.researchState?.active_route ?? null,
+  };
+}
+
+function writeUpstreamOnlyBundle(problemId, destination, upstreamRecord, snapshot, readmeTitle) {
   ensureDir(destination);
 
   if (upstreamRecord) {
     writeJson(path.join(destination, 'UPSTREAM_RECORD.json'), upstreamRecord);
   }
 
-  const generatedAt = new Date().toISOString();
-  writeJson(path.join(destination, 'PROBLEM.json'), {
-    generatedAt,
-    problemId,
-    title: `Erdos Problem #${problemId}`,
-    cluster: null,
-    siteStatus: upstreamRecord?.status?.state ?? 'unknown',
-    repoStatus: 'upstream-only',
-    harnessDepth: 'unseeded',
-    sourceUrl: `https://www.erdosproblems.com/${problemId}`,
-    activeRoute: null,
-  });
-
+  const problemRecord = buildProblemRecord(problemId, null, upstreamRecord);
+  writeJson(path.join(destination, 'PROBLEM.json'), problemRecord);
   writeJson(path.join(destination, 'ARTIFACT_INDEX.json'), {
-    generatedAt,
-    problemId,
+    generatedAt: problemRecord.generatedAt,
+    problemId: String(problemId),
     copiedArtifacts: [],
     canonicalArtifacts: [],
+    packProblemArtifactsInventory: [],
+    computePackets: [],
     upstreamSnapshot: snapshot
       ? {
           kind: snapshot.kind,
@@ -82,11 +92,10 @@ function writeUpstreamOnlyBundle(problemId, destination, upstreamRecord, snapsho
       : null,
     includedUpstreamRecord: Boolean(upstreamRecord),
   });
-
   writeText(
     path.join(destination, 'README.md'),
     [
-      `# Erdos Problem ${problemId} Pull Bundle`,
+      `# ${readmeTitle}`,
       '',
       'This bundle was generated from upstream public metadata.',
       '',
@@ -97,6 +106,20 @@ function writeUpstreamOnlyBundle(problemId, destination, upstreamRecord, snapsho
       '',
     ].join('\n'),
   );
+
+  return {
+    problemRecord,
+    artifactsCopied: 0,
+    inventory: null,
+  };
+}
+
+function writeArtifactsLane(problemId, destination, localProblem, upstreamRecord, snapshot) {
+  if (localProblem) {
+    return scaffoldProblem(localProblem, destination);
+  }
+
+  return writeUpstreamOnlyBundle(problemId, destination, upstreamRecord, snapshot, `Erdos Problem ${problemId} Artifact Bundle`);
 }
 
 async function maybeWriteSiteBundle(problemId, destination, includeSite) {
@@ -136,10 +159,110 @@ async function maybeWriteSiteBundle(problemId, destination, includeSite) {
   }
 }
 
+async function writeLiteratureLane(problemId, destination, localProblem, upstreamRecord, includeSite) {
+  ensureDir(destination);
+
+  const includedFiles = [];
+  const copied = (sourcePath, destinationName, label) => {
+    const destinationPath = path.join(destination, destinationName);
+    if (copyFileIfPresent(sourcePath, destinationPath)) {
+      includedFiles.push({ label, sourcePath, destinationPath });
+      return true;
+    }
+    return false;
+  };
+
+  if (upstreamRecord) {
+    writeJson(path.join(destination, 'UPSTREAM_RECORD.json'), upstreamRecord);
+  }
+
+  let inventory = null;
+  if (localProblem) {
+    inventory = getProblemArtifactInventory(localProblem);
+    copied(localProblem.referencesPath, 'REFERENCES.md', 'REFERENCES.md');
+    copied(localProblem.statementPath, 'STATEMENT.md', 'STATEMENT.md');
+    if (inventory.packContext?.exists) {
+      copied(inventory.packContext.path, 'PACK_CONTEXT.md', inventory.packContext.label);
+    }
+    for (const artifact of inventory.packProblemArtifacts) {
+      copied(artifact.path, path.join('PACK_PROBLEM', artifact.destinationName), artifact.label);
+    }
+  }
+
+  const siteStatus = await maybeWriteSiteBundle(problemId, destination, includeSite);
+  const problemRecord = buildProblemRecord(problemId, localProblem, upstreamRecord);
+  writeJson(path.join(destination, 'PROBLEM.json'), problemRecord);
+  writeJson(path.join(destination, 'LITERATURE_INDEX.json'), {
+    generatedAt: new Date().toISOString(),
+    problemId: String(problemId),
+    includedFiles,
+    includedUpstreamRecord: Boolean(upstreamRecord),
+    includedSiteSnapshot: siteStatus.included,
+    siteSnapshotError: siteStatus.error,
+  });
+  writeText(
+    path.join(destination, 'README.md'),
+    [
+      `# Erdos Problem ${problemId} Literature Bundle`,
+      '',
+      'This literature lane was generated by the erdos CLI.',
+      '',
+      `- Local dossier included: ${localProblem ? 'yes' : 'no'}`,
+      `- Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`,
+      `- Live site snapshot included: ${siteStatus.included ? 'yes' : 'no'}`,
+      '',
+    ].join('\n'),
+  );
+
+  return {
+    destination,
+    includedFiles,
+    siteStatus,
+  };
+}
+
+function writeRootProblemBundle(rootDir, problemId, localProblem, upstreamRecord, snapshot, artifactsDir, literatureDir) {
+  ensureDir(rootDir);
+  const problemRecord = buildProblemRecord(problemId, localProblem, upstreamRecord);
+
+  if (upstreamRecord) {
+    writeJson(path.join(rootDir, 'UPSTREAM_RECORD.json'), upstreamRecord);
+  }
+
+  writeJson(path.join(rootDir, 'PROBLEM.json'), problemRecord);
+  writeJson(path.join(rootDir, 'PULL_INDEX.json'), {
+    generatedAt: new Date().toISOString(),
+    problemId: String(problemId),
+    rootDir,
+    artifactsDir,
+    literatureDir,
+    snapshotKind: snapshot?.kind ?? null,
+    upstreamCommit: snapshot?.manifest.upstream_commit ?? null,
+  });
+  writeText(
+    path.join(rootDir, 'README.md'),
+    [
+      `# Erdos Problem ${problemId} Pull Bundle`,
+      '',
+      'This pull bundle contains per-problem workspace lanes for artifacts and literature.',
+      '',
+      `- Artifacts lane: ${artifactsDir}`,
+      `- Literature lane: ${literatureDir}`,
+      `- Local canonical dossier available: ${localProblem ? 'yes' : 'no'}`,
+      `- Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`,
+      '',
+    ].join('\n'),
+  );
+
+  return problemRecord;
+}
+
 export async function runPullCommand(args) {
   if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
     console.log('Usage:');
     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]');
     return 0;
   }
 
@@ -166,38 +289,66 @@ export async function runPullCommand(args) {
     return 1;
   }
 
-  const destination = parsed.destination
-    ? path.resolve(parsed.destination)
-    : getWorkspaceProblemPullDir(parsed.problemId);
+  if (parsed.kind === 'artifacts') {
+    const destination = parsed.destination
+      ? path.resolve(parsed.destination)
+      : getWorkspaceProblemArtifactDir(parsed.problemId);
+    const result = writeArtifactsLane(String(parsed.problemId), destination, localProblem, upstreamRecord, snapshot);
+    console.log(`Artifact bundle created: ${destination}`);
+    console.log(`Local canonical dossier included: ${localProblem ? 'yes' : 'no'}`);
+    console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
+    console.log(`Artifacts copied: ${result.copiedArtifacts?.length ?? result.artifactsCopied ?? 0}`);
+    return 0;
+  }
 
-  let scaffoldResult = null;
-  if (localProblem) {
-    scaffoldResult = scaffoldProblem(localProblem, destination);
-  } else {
-    writeUpstreamOnlyBundle(String(parsed.problemId), destination, upstreamRecord, snapshot);
+  if (parsed.kind === 'literature') {
+    const destination = parsed.destination
+      ? path.resolve(parsed.destination)
+      : getWorkspaceProblemLiteratureDir(parsed.problemId);
+    const result = await writeLiteratureLane(String(parsed.problemId), destination, localProblem, upstreamRecord, parsed.includeSite);
+    console.log(`Literature bundle created: ${destination}`);
+    console.log(`Local dossier context included: ${localProblem ? 'yes' : 'no'}`);
+    console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
+    console.log(`Live site snapshot included: ${result.siteStatus.included ? 'yes' : 'no'}`);
+    if (result.siteStatus.error) {
+      console.log(`Live site snapshot note: ${result.siteStatus.error}`);
+    }
+    return 0;
   }
 
+  const rootDestination = parsed.destination
+    ? path.resolve(parsed.destination)
+    : getWorkspaceProblemPullDir(parsed.problemId);
+  const artifactDestination = path.join(rootDestination, 'artifacts');
+  const literatureDestination = path.join(rootDestination, 'literature');
 
-  const siteStatus = await maybeWriteSiteBundle(String(parsed.problemId), destination, parsed.includeSite);
+  writeRootProblemBundle(rootDestination, String(parsed.problemId), localProblem, upstreamRecord, snapshot, artifactDestination, literatureDestination);
+  const artifactResult = writeArtifactsLane(String(parsed.problemId), artifactDestination, localProblem, upstreamRecord, snapshot);
+  const literatureResult = await writeLiteratureLane(String(parsed.problemId), literatureDestination, localProblem, upstreamRecord, parsed.includeSite);
 
-  writeJson(path.join(destination, 'PULL_STATUS.json'), {
+  writeJson(path.join(rootDestination, 'PULL_STATUS.json'), {
     generatedAt: new Date().toISOString(),
     problemId: String(parsed.problemId),
     usedLocalDossier: Boolean(localProblem),
     includedUpstreamRecord: Boolean(upstreamRecord),
     upstreamSnapshotKind: snapshot?.kind ?? null,
-    siteSnapshotAttempted: siteStatus.attempted,
-    siteSnapshotIncluded: siteStatus.included,
-    siteSnapshotError: siteStatus.error,
-    scaffoldArtifactsCopied: scaffoldResult?.copiedArtifacts.length ?? 0,
+    artifactLanePath: artifactDestination,
+    literatureLanePath: literatureDestination,
+    artifactArtifactsCopied: artifactResult.copiedArtifacts?.length ?? artifactResult.artifactsCopied ?? 0,
+    literatureFilesCopied: literatureResult.includedFiles.length,
+    siteSnapshotAttempted: literatureResult.siteStatus.attempted,
+    siteSnapshotIncluded: literatureResult.siteStatus.included,
+    siteSnapshotError: literatureResult.siteStatus.error,
   });
 
-  console.log(`Pull bundle created: ${destination}`);
+  console.log(`Pull bundle created: ${rootDestination}`);
+  console.log(`Artifact lane: ${artifactDestination}`);
+  console.log(`Literature lane: ${literatureDestination}`);
   console.log(`Local canonical dossier included: ${localProblem ? 'yes' : 'no'}`);
   console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
-  console.log(`Live site snapshot included: ${siteStatus.included ? 'yes' : 'no'}`);
-  if (siteStatus.error) {
-    console.log(`Live site snapshot note: ${siteStatus.error}`);
+  console.log(`Live site snapshot included: ${literatureResult.siteStatus.included ? 'yes' : 'no'}`);
+  if (literatureResult.siteStatus.error) {
+    console.log(`Live site snapshot note: ${literatureResult.siteStatus.error}`);
   }
   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

@@ -28,10 +28,22 @@ function parseStatusArgs(args) {
 function printSunflowerStatus(snapshot, registryPaths) {
   console.log(`${snapshot.displayName} sunflower harness`);
   console.log(`Title: ${snapshot.title}`);
+  console.log(`Family role: ${snapshot.familyRole ?? '(none)'}`);
+  console.log(`Harness profile: ${snapshot.harnessProfile ?? '(none)'}`);
   console.log(`Active route: ${snapshot.activeRoute ?? '(none)'}`);
   console.log(`Route breakthrough: ${snapshot.routeBreakthrough ? 'yes' : 'no'}`);
   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)'}`);
+  console.log(`Context file: ${snapshot.contextPath ?? '(none)'}`);
   console.log(`Compute lane present: ${snapshot.computeLanePresent ? 'yes' : 'no'}`);
   console.log(`Compute lane count: ${snapshot.computeLaneCount}`);
   console.log(`Compute summary: ${snapshot.computeSummary}`);

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,19 +18,40 @@ 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);
     if (problem?.cluster === 'sunflower') {
       const sunflower = buildSunflowerStatusSnapshot(problem);
+      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}]`);

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