erdos-problems 0.1.7 → 0.1.8

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

package/src/runtime/problem-artifacts.js

@@ -13,11 +13,21 @@ const DOSSIER_FILES = [
   ['FORMALIZATION.md', 'formalizationPath', 'FORMALIZATION.md'],
 ];
 
+const STARTER_LOOP_FILES = [
+  ['AGENT_START.md', 'AGENT_START.md'],
+  ['ROUTES.md', 'ROUTES.md'],
+  ['CHECKPOINT_NOTES.md', 'CHECKPOINT_NOTES.md'],
+];
+
 function getPackContextPath(problem) {
   if (!problem.cluster) {
     return null;
   }
-  return path.join(getPackDir(problem.cluster), 'README.md');
+  const packDir = getPackDir(problem.cluster);
+  if (!fs.existsSync(packDir)) {
+    return null;
+  }
+  return path.join(packDir, 'README.md');
 }
 
 function collectFiles(rootDir, relativeDir = '') {
@@ -71,6 +81,15 @@ export function getProblemArtifactInventory(problem) {
       exists: fs.existsSync(filePath),
     };
   });
+  const starterArtifacts = STARTER_LOOP_FILES.map(([label, destinationName]) => {
+    const filePath = path.join(problem.problemDir, label);
+    return {
+      label,
+      path: filePath,
+      destinationName,
+      exists: fs.existsSync(filePath),
+    };
+  }).filter((artifact) => artifact.exists);
 
   const packContextPath = getPackContextPath(problem);
   const packContext = packContextPath
@@ -103,6 +122,7 @@ export function getProblemArtifactInventory(problem) {
     harnessDepth: problem.harnessDepth,
     problemDir: problem.problemDir,
     canonicalArtifacts,
+    starterArtifacts,
     packContext,
     packProblemArtifacts,
     computePackets,
@@ -137,6 +157,18 @@ export function scaffoldProblem(problem, destination) {
     }
   }
 
+  const copiedStarterArtifacts = [];
+  for (const artifact of inventory.starterArtifacts) {
+    const destinationPath = path.join(destination, artifact.destinationName);
+    if (copyFileIfPresent(artifact.path, destinationPath)) {
+      copiedStarterArtifacts.push({
+        label: artifact.label,
+        sourcePath: artifact.path,
+        destinationPath,
+      });
+    }
+  }
+
   if (inventory.packContext?.exists) {
     const destinationPath = path.join(destination, inventory.packContext.destinationName);
     if (copyFileIfPresent(inventory.packContext.path, destinationPath)) {
@@ -203,10 +235,12 @@ export function scaffoldProblem(problem, destination) {
     problemId: problem.problemId,
     bundledProblemDir: problem.problemDir,
     copiedArtifacts,
+    copiedStarterArtifacts,
     packProblemArtifacts,
     computeArtifacts,
     packContext: inventory.packContext,
     canonicalArtifacts: inventory.canonicalArtifacts,
+    starterArtifacts: inventory.starterArtifacts,
     packProblemArtifactsInventory: inventory.packProblemArtifacts,
     computePackets: inventory.computePackets,
     upstreamSnapshot: inventory.upstreamSnapshot,
@@ -228,6 +262,7 @@ export function scaffoldProblem(problem, destination) {
       `- Repo status: ${problem.repoStatus}`,
       `- Harness depth: ${problem.harnessDepth}`,
       `- Upstream record included: ${inventory.upstreamRecordIncluded ? 'yes' : 'no'}`,
+      `- Starter loop artifacts copied: ${copiedStarterArtifacts.length}`,
       `- Pack problem artifacts copied: ${packProblemArtifacts.length}`,
       `- Compute packets copied: ${computeArtifacts.length}`,
       '',

package/src/runtime/sunflower.js

@@ -38,6 +38,22 @@ function getSunflowerContextMarkdownPath(problemId) {
   return path.join(getSunflowerProblemDir(problemId), 'CONTEXT.md');
 }
 
+function getSunflowerRoutePacketPath(problemId) {
+  return path.join(getSunflowerProblemDir(problemId), 'ROUTE_PACKET.yaml');
+}
+
+function getSunflowerAgentStartPath(problemId) {
+  return path.join(getSunflowerProblemDir(problemId), 'AGENT_START.md');
+}
+
+function getSunflowerCheckpointPacketPath(problemId) {
+  return path.join(getSunflowerProblemDir(problemId), 'CHECKPOINT_PACKET.md');
+}
+
+function getSunflowerReportPacketPath(problemId) {
+  return path.join(getSunflowerProblemDir(problemId), 'REPORT_PACKET.md');
+}
+
 function parseStringList(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -133,6 +149,26 @@ export function readSunflowerContext(problemId) {
   };
 }
 
+function readSunflowerRoutePacket(problemId) {
+  const routePacketPath = getSunflowerRoutePacketPath(problemId);
+  if (!fs.existsSync(routePacketPath)) {
+    return null;
+  }
+
+  const parsed = parse(fs.readFileSync(routePacketPath, 'utf8')) ?? {};
+  return {
+    routePacketId: compactText(parsed.route_packet_id),
+    routeId: compactText(parsed.route_id),
+    frontierClaim: compactText(parsed.frontier_claim),
+    theoremModule: compactText(parsed.theorem_module),
+    checkpointPacket: compactText(parsed.checkpoint_packet),
+    reportPacket: compactText(parsed.report_packet),
+    readyPrompts: parseStringList(parsed.ready_prompts),
+    verificationHook: parseStringList(parsed.verification_hook),
+    routePacketPath,
+  };
+}
+
 function chooseActivePacket(packets) {
   if (packets.length === 0) {
     return null;
@@ -273,10 +309,14 @@ function defaultQuestionLedger(problemId, routeState) {
 
 export function buildSunflowerStatusSnapshot(problem) {
   const context = readSunflowerContext(problem.problemId);
+  const routePacket = readSunflowerRoutePacket(problem.problemId);
   const packets = listSunflowerComputePackets(problem.problemId);
   const activePacket = chooseActivePacket(packets);
   const summary = deriveSummary(activePacket);
   const routeState = deriveRouteState(problem, context);
+  const agentStartPath = getSunflowerAgentStartPath(problem.problemId);
+  const checkpointPacketPath = getSunflowerCheckpointPacketPath(problem.problemId);
+  const reportPacketPath = getSunflowerReportPacketPath(problem.problemId);
 
   return {
     generatedAt: new Date().toISOString(),
@@ -303,6 +343,14 @@ export function buildSunflowerStatusSnapshot(problem) {
     contextPresent: Boolean(context),
     contextPath: context?.contextPath ?? null,
     contextMarkdownPath: context?.contextMarkdownExists ? context.contextMarkdownPath : null,
+    routePacketPresent: Boolean(routePacket),
+    routePacket,
+    agentStartPresent: fs.existsSync(agentStartPath),
+    agentStartPath: fs.existsSync(agentStartPath) ? agentStartPath : null,
+    checkpointPacketPresent: fs.existsSync(checkpointPacketPath),
+    checkpointPacketPath: fs.existsSync(checkpointPacketPath) ? checkpointPacketPath : null,
+    reportPacketPresent: fs.existsSync(reportPacketPath),
+    reportPacketPath: fs.existsSync(reportPacketPath) ? reportPacketPath : null,
     computeLanePresent: Boolean(activePacket),
     computeLaneCount: packets.length,
     computeSummary: summary.computeSummary,