erdos-problems 0.1.6 → 0.1.8

package/src/commands/pull.js

@@ -10,6 +10,36 @@ import { getProblemArtifactInventory, scaffoldProblem } from '../runtime/problem
 import { loadActiveUpstreamSnapshot, syncUpstream } from '../upstream/sync.js';
 import { fetchProblemSiteSnapshot } from '../upstream/site.js';
 
+function normalizeClusterLabel(rawTag) {
+  return String(rawTag ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function inferClusterFromUpstream(upstreamRecord) {
+  const normalized = Array.isArray(upstreamRecord?.tags)
+    ? upstreamRecord.tags.map(normalizeClusterLabel).filter(Boolean)
+    : [];
+  if (normalized.includes('number-theory')) {
+    return 'number-theory';
+  }
+  if (normalized.includes('graph-theory') || normalized.includes('chromatic-number')) {
+    return 'graph-theory';
+  }
+  if (normalized.includes('geometry')) {
+    return 'geometry';
+  }
+  if (normalized.includes('analysis')) {
+    return 'analysis';
+  }
+  if (normalized.includes('combinatorics') || normalized.includes('intersecting-family')) {
+    return 'combinatorics';
+  }
+  return null;
+}
+
 function parsePullArgs(args) {
   const [kind, value, ...rest] = args;
   if (!['problem', 'artifacts', 'literature'].includes(kind)) {
@@ -55,7 +85,7 @@ function buildProblemRecord(problemId, localProblem, upstreamRecord) {
     generatedAt: new Date().toISOString(),
     problemId: String(problemId),
     title: localProblem?.title ?? `Erdos Problem #${problemId}`,
-    cluster: localProblem?.cluster ?? null,
+    cluster: localProblem?.cluster ?? inferClusterFromUpstream(upstreamRecord),
     siteStatus: localProblem?.siteStatus ?? upstreamRecord?.status?.state ?? 'unknown',
     repoStatus: localProblem?.repoStatus ?? 'upstream-only',
     harnessDepth: localProblem?.harnessDepth ?? 'unseeded',
@@ -257,22 +287,29 @@ function writeRootProblemBundle(rootDir, problemId, localProblem, upstreamRecord
   return problemRecord;
 }
 
-export async function runPullCommand(args) {
+export async function runPullCommand(args, options = {}) {
+  const silent = options.silent === true;
   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]');
+    if (!silent) {
+      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;
   }
 
   const parsed = parsePullArgs(args);
   if (parsed.error) {
-    console.error(parsed.error);
+    if (!silent) {
+      console.error(parsed.error);
+    }
     return 1;
   }
   if (!parsed.problemId) {
-    console.error('Missing problem id.');
+    if (!silent) {
+      console.error('Missing problem id.');
+    }
     return 1;
   }
 
@@ -285,7 +322,9 @@ export async function runPullCommand(args) {
   const upstreamRecord = snapshot?.index?.by_number?.[String(parsed.problemId)] ?? null;
 
   if (!localProblem && !upstreamRecord) {
-    console.error(`Problem ${parsed.problemId} is not present in the local dossier set or upstream snapshot.`);
+    if (!silent) {
+      console.error(`Problem ${parsed.problemId} is not present in the local dossier set or upstream snapshot.`);
+    }
     return 1;
   }
 
@@ -294,10 +333,12 @@ export async function runPullCommand(args) {
       ? 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}`);
+    if (!silent) {
+      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;
   }
 
@@ -306,12 +347,14 @@ export async function runPullCommand(args) {
       ? 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}`);
+    if (!silent) {
+      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;
   }
@@ -341,14 +384,16 @@ export async function runPullCommand(args) {
     siteSnapshotError: literatureResult.siteStatus.error,
   });
 
-  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: ${literatureResult.siteStatus.included ? 'yes' : 'no'}`);
-  if (literatureResult.siteStatus.error) {
-    console.log(`Live site snapshot note: ${literatureResult.siteStatus.error}`);
+  if (!silent) {
+    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: ${literatureResult.siteStatus.included ? 'yes' : 'no'}`);
+    if (literatureResult.siteStatus.error) {
+      console.log(`Live site snapshot note: ${literatureResult.siteStatus.error}`);
+    }
   }
   return 0;
 }

package/src/commands/seed.js

@@ -0,0 +1,264 @@
+import path from 'node:path';
+import { getProblem } from '../atlas/catalog.js';
+import { syncCheckpoints } from '../runtime/checkpoints.js';
+import { seedProblemFromPullBundle } from '../runtime/maintainer-seed.js';
+import { getWorkspaceProblemPullDir, getWorkspaceRoot, getWorkspaceSeededProblemsDir } from '../runtime/paths.js';
+import { syncState } from '../runtime/state.js';
+import { readCurrentProblem, setCurrentProblem } from '../runtime/workspace.js';
+import { runPullCommand } from './pull.js';
+
+function parseSeedArgs(args) {
+  const [kind, value, ...rest] = args;
+  if (kind !== 'problem') {
+    return { error: 'Only `erdos seed problem <id>` is supported right now.' };
+  }
+
+  const parsed = {
+    problemId: value,
+    includeSite: false,
+    refreshUpstream: false,
+    cluster: null,
+    repoStatus: 'local_seeded',
+    harnessDepth: 'dossier',
+    title: null,
+    familyTags: [],
+    relatedProblems: [],
+    formalizationStatus: 'planned',
+    activeRoute: null,
+    routeBreakthrough: false,
+    problemSolved: false,
+    destRoot: null,
+    noActivate: false,
+    noLoopSync: false,
+    force: false,
+    asJson: false,
+  };
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (token === '--include-site') {
+      parsed.includeSite = true;
+      continue;
+    }
+    if (token === '--refresh-upstream') {
+      parsed.refreshUpstream = true;
+      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 === '--dest-root') {
+      parsed.destRoot = rest[index + 1];
+      if (!parsed.destRoot) {
+        return { error: 'Missing path after --dest-root.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--no-activate') {
+      parsed.noActivate = true;
+      continue;
+    }
+    if (token === '--no-loop-sync') {
+      parsed.noLoopSync = true;
+      continue;
+    }
+    if (token === '--force') {
+      parsed.force = true;
+      continue;
+    }
+    if (token === '--json') {
+      parsed.asJson = true;
+      continue;
+    }
+    return { error: `Unknown seed option: ${token}` };
+  }
+
+  return parsed;
+}
+
+export async function runSeedCommand(args) {
+  if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
+    console.log('Usage:');
+    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]');
+    return 0;
+  }
+
+  const parsed = parseSeedArgs(args);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+  if (!parsed.problemId) {
+    console.error('Missing problem id.');
+    return 1;
+  }
+
+  const workspaceRoot = getWorkspaceRoot();
+  const pullDir = getWorkspaceProblemPullDir(parsed.problemId, workspaceRoot);
+  const defaultSeedRoot = getWorkspaceSeededProblemsDir(workspaceRoot);
+  const destinationRoot = parsed.destRoot
+    ? path.resolve(parsed.destRoot)
+    : defaultSeedRoot;
+  const seedsIntoWorkspaceOverlay = destinationRoot === defaultSeedRoot;
+
+  const pullArgs = ['problem', String(parsed.problemId), '--dest', pullDir];
+  if (parsed.includeSite) {
+    pullArgs.push('--include-site');
+  }
+  if (parsed.refreshUpstream) {
+    pullArgs.push('--refresh-upstream');
+  }
+
+  const pullExit = await runPullCommand(pullArgs, { silent: parsed.asJson });
+  if (pullExit !== 0) {
+    return pullExit;
+  }
+
+  const packageProblem = getProblem(parsed.problemId, workspaceRoot);
+  const result = seedProblemFromPullBundle(parsed.problemId, {
+    fromPullDir: pullDir,
+    destRoot: destinationRoot,
+    cluster: parsed.cluster ?? packageProblem?.cluster ?? 'uncategorized',
+    repoStatus: parsed.repoStatus,
+    harnessDepth: parsed.harnessDepth,
+    title: parsed.title,
+    familyTags: parsed.familyTags,
+    relatedProblems: parsed.relatedProblems,
+    formalizationStatus: parsed.formalizationStatus,
+    activeRoute: parsed.activeRoute ?? (parsed.problemSolved ? null : 'seed_route_pending'),
+    routeBreakthrough: parsed.routeBreakthrough,
+    problemSolved: parsed.problemSolved,
+    force: parsed.force,
+  });
+
+  const activated = !parsed.noActivate && seedsIntoWorkspaceOverlay;
+  const loopSynced = !parsed.noLoopSync && activated;
+
+  let state = null;
+  let checkpoints = null;
+  if (activated) {
+    setCurrentProblem(parsed.problemId, workspaceRoot);
+  }
+  if (loopSynced) {
+    state = syncState(workspaceRoot);
+    checkpoints = syncCheckpoints(workspaceRoot);
+  }
+
+  const payload = {
+    problemId: String(parsed.problemId),
+    pullDir,
+    destinationDir: result.destinationDir,
+    cluster: result.record.cluster,
+    harnessDepth: result.record.harness.depth,
+    title: result.record.title,
+    activated,
+    loopSynced,
+    activeProblem: activated ? readCurrentProblem(workspaceRoot) : null,
+    activeRoute: state?.activeRoute ?? null,
+    nextHonestMove: state?.nextHonestMove ?? null,
+    checkpointShelf: checkpoints?.indexPath ?? null,
+    usedUpstreamRecord: result.usedUpstreamRecord,
+    usedSiteSnapshot: result.usedSiteSnapshot,
+    workspaceOverlayVisible: seedsIntoWorkspaceOverlay,
+  };
+
+  if (parsed.asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    return 0;
+  }
+
+  console.log(`Seeded local dossier for problem ${parsed.problemId}`);
+  console.log(`Pull bundle: ${pullDir}`);
+  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'}`);
+  console.log(`Workspace overlay visible: ${seedsIntoWorkspaceOverlay ? 'yes' : 'no'}`);
+  console.log(`Activated: ${activated ? 'yes' : 'no'}`);
+  console.log(`Loop synced: ${loopSynced ? 'yes' : 'no'}`);
+  if (!seedsIntoWorkspaceOverlay && (!parsed.noActivate || !parsed.noLoopSync)) {
+    console.log('Note: activation and loop sync were skipped because --dest-root points outside .erdos/seeded-problems.');
+  }
+  if (state) {
+    console.log(`Active route: ${state.activeRoute ?? '(none)'}`);
+    console.log(`Next honest move: ${state.nextHonestMove}`);
+  }
+  if (checkpoints) {
+    console.log(`Checkpoint shelf: ${checkpoints.indexPath}`);
+  }
+  return 0;
+}

package/src/commands/sunflower.js

@@ -44,6 +44,16 @@ function printSunflowerStatus(snapshot, registryPaths) {
   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(`Route packet present: ${snapshot.routePacketPresent ? 'yes' : 'no'}`);
+  if (snapshot.routePacket) {
+    console.log(`Route packet id: ${snapshot.routePacket.routePacketId ?? '(none)'}`);
+    console.log(`Route packet route: ${snapshot.routePacket.routeId ?? '(none)'}`);
+    console.log(`Route frontier claim: ${snapshot.routePacket.frontierClaim ?? '(none)'}`);
+    console.log(`Theorem module: ${snapshot.routePacket.theoremModule ?? '(none)'}`);
+  }
+  console.log(`Agent start packet: ${snapshot.agentStartPresent ? snapshot.agentStartPath : '(missing)'}`);
+  console.log(`Checkpoint packet: ${snapshot.checkpointPacketPresent ? snapshot.checkpointPacketPath : '(missing)'}`);
+  console.log(`Report packet: ${snapshot.reportPacketPresent ? snapshot.reportPacketPath : '(missing)'}`);
   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

@@ -29,10 +29,12 @@ export function runWorkspaceCommand(args) {
   console.log(`Question ledger: ${summary.questionLedgerPath}`);
   console.log(`Checkpoint shelf: ${summary.checkpointIndexPath}`);
   console.log(`Workspace upstream dir: ${summary.upstreamDir}`);
+  console.log(`Workspace seeded-problems dir: ${summary.seededProblemsDir}`);
   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(`Active seeded dossier dir: ${summary.seededProblemDir}`);
   console.log(`Preferred agent: ${config.preferredAgent}`);
   console.log(`Continuation mode: ${summary.continuationMode ?? config.continuation}`);
   console.log(`Active route: ${summary.activeRoute ?? '(none)'}`);

package/src/runtime/maintainer-seed.js

@@ -4,6 +4,39 @@ import { stringify } from 'yaml';
 import { ensureDir, fileExists, readJson, readText, writeText } from './files.js';
 import { getProblemDir, getWorkspaceProblemPullDir, repoRoot } from './paths.js';
 
+const STATEMENT_SKIP_PATTERNS = [
+  /^open$/i,
+  /^proved(?:\s*\(.*\))?$/i,
+  /^disproved(?:\s*\(.*\))?$/i,
+  /^decidable$/i,
+  /^verifiable$/i,
+  /^erd[őo]s problem #\d+/i,
+  /^this has been solved/i,
+  /^-\s*\$\d+/i,
+  /^-$/i,
+  /^#\d+\s*:/i,
+  /^forum$/i,
+  /^inbox$/i,
+  /^favourites$/i,
+  /^tags$/i,
+  /^more$/i,
+  /^faq$/i,
+  /^prizes$/i,
+  /^view the latex source$/i,
+  /^view history$/i,
+  /^external data from the database/i,
+  /^formalised statement\?$/i,
+  /\bdisclaimer\b/i,
+  /^this is (open|proved|disproved|verifiable|decidable)\b/i,
+  /^\s*[a-z][a-z ]+\|\s*$/i,
+];
+
+const STARTER_LOOP_ARTIFACTS = [
+  'AGENT_START.md',
+  'ROUTES.md',
+  'CHECKPOINT_NOTES.md',
+];
+
 function normalizeTitle(rawTitle, problemId) {
   const fallback = `Erdos Problem #${problemId}`;
   if (!rawTitle) {
@@ -29,6 +62,34 @@ function uppercaseBadge(status) {
   return String(status ?? 'unknown').trim().toUpperCase() || 'UNKNOWN';
 }
 
+function normalizeClusterLabel(rawTag) {
+  return String(rawTag ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function inferClusterFromTags(tags) {
+  const normalized = Array.isArray(tags) ? tags.map(normalizeClusterLabel).filter(Boolean) : [];
+  if (normalized.includes('number-theory')) {
+    return 'number-theory';
+  }
+  if (normalized.includes('graph-theory') || normalized.includes('chromatic-number')) {
+    return 'graph-theory';
+  }
+  if (normalized.includes('geometry')) {
+    return 'geometry';
+  }
+  if (normalized.includes('analysis')) {
+    return 'analysis';
+  }
+  if (normalized.includes('combinatorics') || normalized.includes('intersecting-family')) {
+    return 'combinatorics';
+  }
+  return 'uncategorized';
+}
+
 function getDefaultPullDir(problemId) {
   return getWorkspaceProblemPullDir(problemId);
 }
@@ -84,12 +145,22 @@ function deriveTitle(problemId, bundle, titleOverride) {
   return `Erdos Problem #${problemId}`;
 }
 
+function extractStatementCandidates(bundle) {
+  const previewLines = Array.isArray(bundle.siteExtract?.previewLines)
+    ? bundle.siteExtract.previewLines
+    : [];
+
+  return previewLines
+    .map((line) => String(line ?? '').replace(/\s+/g, ' ').trim())
+    .filter(Boolean)
+    .filter((line) => !STATEMENT_SKIP_PATTERNS.some((pattern) => pattern.test(line)))
+    .filter((line) => !/^\w[\w -]+$/.test(line) || line.length > 40);
+}
+
 function deriveShortStatement(problemId, bundle, title) {
-  const preview = Array.isArray(bundle.siteExtract?.previewLines)
-    ? bundle.siteExtract.previewLines.find((line) => String(line ?? '').trim())
-    : null;
-  if (preview) {
-    return String(preview).replace(/\s+/g, ' ').trim();
+  const statementCandidate = extractStatementCandidates(bundle)[0];
+  if (statementCandidate) {
+    return statementCandidate;
   }
   if (bundle.problemRecord?.title && bundle.problemRecord.title !== title) {
     return String(bundle.problemRecord.title).trim();
@@ -157,7 +228,7 @@ function buildProblemRecord(problemId, bundle, options) {
       upstream_status: upstreamRecord.status?.state ?? null,
       upstream_last_update: upstreamRecord.status?.last_update ?? null,
     },
-    cluster: options.cluster,
+    cluster: options.cluster ?? inferClusterFromTags(upstreamRecord.tags),
     prize: {
       display: upstreamRecord.prize ?? 'unknown',
     },
@@ -191,6 +262,7 @@ function renderStatementMarkdown(problemId, record, bundle) {
   const previewLines = Array.isArray(bundle.siteExtract?.previewLines)
     ? bundle.siteExtract.previewLines.filter((line) => String(line ?? '').trim())
     : [];
+  const statementCandidates = extractStatementCandidates(bundle);
 
   return [
     `# Problem ${problemId} Statement`,
@@ -199,8 +271,19 @@ function renderStatementMarkdown(problemId, record, bundle) {
     '',
     'Normalized focus:',
     `- ${record.statement.short}`,
-    previewLines.length > 0 ? '- Seeded with preview lines from the public site snapshot' : '- Seeded from upstream public metadata',
+    statementCandidates.length > 0
+      ? '- Seeded with filtered statement candidates from the public site snapshot'
+      : previewLines.length > 0
+        ? '- Seeded with preview lines from the public site snapshot'
+        : '- Seeded from upstream public metadata',
     '',
+    ...(statementCandidates.length > 0
+      ? [
+          'Statement candidates:',
+          ...statementCandidates.slice(0, 4).map((line) => `- ${line}`),
+          '',
+        ]
+      : []),
     ...(previewLines.length > 0
       ? [
           'Public-site preview:',
@@ -256,6 +339,69 @@ function renderFormalizationMarkdown(record) {
   ].join('\n');
 }
 
+function renderAgentStartMarkdown(problemId, record) {
+  const activeRoute = record.research_state?.active_route ?? 'seed_route_pending';
+  const routeMode = activeRoute ? 'route' : 'milestone';
+  return [
+    '# Agent Start',
+    '',
+    'Fast start:',
+    `- \`erdos problem show ${problemId}\``,
+    '- `erdos workspace show`',
+    '- `erdos preflight`',
+    `- \`erdos continuation use ${routeMode}\``,
+    '- `erdos checkpoints sync`',
+    '',
+    'Working assumptions:',
+    `- Open problem: ${record.research_state?.open_problem === false ? 'no' : 'yes'}`,
+    `- Active route: ${activeRoute}`,
+    `- Repo status: ${record.status.repo_status}`,
+    `- Harness depth: ${record.harness.depth}`,
+    '',
+    'First honest move:',
+    `- tighten the local dossier for problem ${problemId} against its pull bundle, references, and upstream provenance before widening claims.`,
+    '',
+  ].join('\n');
+}
+
+function renderRoutesMarkdown(problemId, record) {
+  const activeRoute = record.research_state?.active_route ?? 'seed_route_pending';
+  return [
+    '# Routes',
+    '',
+    '## Status Ladder',
+    '',
+    `- Open problem: ${record.research_state?.open_problem === false ? 'no' : 'yes'}`,
+    `- Active route: ${activeRoute}`,
+    `- Route breakthrough: ${record.research_state?.route_breakthrough ? 'yes' : 'no'}`,
+    `- Problem solved: ${record.research_state?.problem_solved ? 'yes' : 'no'}`,
+    '',
+    '## Starter route notes',
+    '',
+    `- Current seeded route placeholder for problem ${problemId}: \`${activeRoute}\``,
+    '- Treat this as a workspace-level route marker until a curated route tree is written.',
+    '- Keep route progress separate from global problem status.',
+    '',
+  ].join('\n');
+}
+
+function renderCheckpointNotesMarkdown(problemId, record) {
+  return [
+    '# Checkpoint Notes',
+    '',
+    `- Problem: ${problemId}`,
+    `- Repo status: ${record.status.repo_status}`,
+    `- Harness depth: ${record.harness.depth}`,
+    '',
+    'Checkpoint prompts:',
+    '- What changed in the active route since the last honest checkpoint?',
+    '- Which claim level is justified right now: Exact, Verified, Heuristic, or Conjecture?',
+    '- Which upstream/public truth changed, if any?',
+    '- Which artifact or literature bundle should the next agent read first?',
+    '',
+  ].join('\n');
+}
+
 export function seedProblemFromPullBundle(problemId, options = {}) {
   const bundle = loadPullBundle(problemId, options.fromPullDir);
   const destinationRoot = path.resolve(options.destRoot ?? path.join(repoRoot, 'problems'));
@@ -267,7 +413,7 @@ export function seedProblemFromPullBundle(problemId, options = {}) {
 
   ensureDir(destinationDir);
   const record = buildProblemRecord(problemId, bundle, {
-    cluster: options.cluster ?? 'uncategorized',
+    cluster: options.cluster ?? null,
     repoStatus: options.repoStatus ?? 'cataloged',
     harnessDepth: options.harnessDepth ?? 'dossier',
     title: options.title ?? null,
@@ -284,11 +430,15 @@ export function seedProblemFromPullBundle(problemId, options = {}) {
   writeText(path.join(destinationDir, 'REFERENCES.md'), renderReferencesMarkdown(record, bundle));
   writeText(path.join(destinationDir, 'EVIDENCE.md'), renderEvidenceMarkdown(problemId, record, bundle));
   writeText(path.join(destinationDir, 'FORMALIZATION.md'), renderFormalizationMarkdown(record));
+  writeText(path.join(destinationDir, 'AGENT_START.md'), renderAgentStartMarkdown(problemId, record));
+  writeText(path.join(destinationDir, 'ROUTES.md'), renderRoutesMarkdown(problemId, record));
+  writeText(path.join(destinationDir, 'CHECKPOINT_NOTES.md'), renderCheckpointNotesMarkdown(problemId, record));
 
   return {
     destinationDir,
     record,
     usedSiteSnapshot: Boolean(bundle.siteExtract || bundle.siteSummary),
     usedUpstreamRecord: Boolean(bundle.upstreamRecord),
+    starterLoopArtifacts: STARTER_LOOP_ARTIFACTS,
   };
 }