erdos-problems 0.1.13 → 0.2.1

package/src/runtime/checkpoints.js

@@ -62,6 +62,13 @@ function renderProblemCheckpoint(problem, state) {
 
 - ${checkpointFocus}
 
+## Pack Context
+
+- Frontier Note: ${sunflower?.frontierNotePath ?? '(none)'}
+- Route History: ${sunflower?.routeHistoryPath ?? '(none)'}
+- Checkpoint Template: ${sunflower?.checkpointTemplatePath ?? '(none)'}
+- Report Template: ${sunflower?.reportTemplatePath ?? '(none)'}
+
 ## Next Honest Move
 
 - ${nextHonestMove}
@@ -92,6 +99,20 @@ function renderRouteCheckpoint(problem, state) {
   const mirageLine = sunflower
     ? `- Mirage Frontiers: ${sunflower.mirageFrontierCount}`
     : null;
+  const routeDetailLine = sunflower?.activeRouteDetail?.summary
+    ? `- Route Detail: ${sunflower.activeRouteDetail.summary}`
+    : null;
+  const ticketDetailLine = sunflower?.activeTicketDetail?.currentBlocker
+    ? `- Ticket Blocker: ${sunflower.activeTicketDetail.currentBlocker}`
+    : null;
+  const packArtifactLines = sunflower
+    ? [
+        `- Frontier Note: ${sunflower.frontierNotePath ?? '(none)'}`,
+        `- Route History: ${sunflower.routeHistoryPath ?? '(none)'}`,
+        `- Checkpoint Template: ${sunflower.checkpointTemplatePath ?? '(none)'}`,
+        `- Report Template: ${sunflower.reportTemplatePath ?? '(none)'}`,
+      ].join('\n')
+    : null;
 
   return `# Problem ${problem.problemId} Active Route Checkpoint
 
@@ -107,6 +128,8 @@ function renderRouteCheckpoint(problem, state) {
 - ${frontier}
 ${activeTicketLine}
 ${readyAtomLine}
+${routeDetailLine ? `\n${routeDetailLine}` : ''}
+${ticketDetailLine ? `\n${ticketDetailLine}` : ''}
 ${mirageLine ? `\n${mirageLine}` : ''}
 
 ## Route Story
@@ -117,6 +140,10 @@ ${mirageLine ? `\n${mirageLine}` : ''}
 
 - ${checkpointFocus}
 
+## Pack Artifacts
+
+${packArtifactLines ?? '- Frontier Note: *(none)*'}
+
 ## Continuation Frame
 
 - Continuation mode: ${state.continuation.mode}

package/src/runtime/maintainer-seed.js

@@ -397,9 +397,18 @@ function renderAgentStartMarkdown(problemId, record) {
     `- Harness depth: ${record.harness.depth}`,
     `- Site status: ${record.status.site_status}`,
     '',
+    'Read in this order:',
+    '- `STATEMENT.md`',
+    '- `REFERENCES.md`',
+    '- `EVIDENCE.md`',
+    '- `FORMALIZATION.md`',
+    '- `PUBLIC_STATUS_REVIEW.md`',
+    '- `AGENT_WEBSEARCH_BRIEF.md`',
+    '',
     'First honest move:',
     `- tighten the local dossier for problem ${problemId} against its pull bundle, references, and upstream provenance before widening claims.`,
     '- read `PUBLIC_STATUS_REVIEW.md` and run the suggested queries in `AGENT_WEBSEARCH_BRIEF.md` before trusting a single public status surface.',
+    '- write down the smallest route hypothesis that would make the next session cleaner, even if it remains provisional.',
     '',
   ].join('\n');
 }
@@ -421,6 +430,10 @@ function renderRoutesMarkdown(problemId, record) {
     `- 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.',
+    '- Suggested route-writing prompts:',
+    '  - What is the smallest honest route name?',
+    '  - What theorem, evidence bundle, or survey note does it point at?',
+    '  - What would count as a route breakthrough versus only route clarification?',
     '',
   ].join('\n');
 }
@@ -439,6 +452,7 @@ function renderCheckpointNotesMarkdown(problemId, record) {
     '- Which upstream/public truth changed, if any?',
     '- What did the public-status review and agent websearch brief surface beyond erdosproblems.com?',
     '- Which artifact or literature bundle should the next agent read first?',
+    '- What route, evidence, and formalization notes should be promoted out of scratch space into canonical dossier files?',
     '',
   ].join('\n');
 }
@@ -508,3 +522,59 @@ export function seedProblemFromPullBundle(problemId, options = {}) {
     starterLoopArtifacts: STARTER_LOOP_ARTIFACTS,
   };
 }
+
+function renderReviewChecklist(problemId, bundle, destinationDir) {
+  return [
+    `# Problem ${problemId} Maintainer Review Checklist`,
+    '',
+    `- Pull bundle: ${bundle.pullDir}`,
+    `- Proposed destination: ${destinationDir}`,
+    '',
+    '## Provenance',
+    '',
+    `- Upstream record included: ${bundle.upstreamRecord ? 'yes' : 'no'}`,
+    `- Site snapshot included: ${bundle.siteExtract || bundle.siteSummary ? 'yes' : 'no'}`,
+    `- Public search review included: ${bundle.publicStatusReview || bundle.publicStatusReviewMarkdown ? 'yes' : 'no'}`,
+    '',
+    '## Review questions',
+    '',
+    '- Is the public site status clearly open right now?',
+    '- Does the seeded short statement capture the actual mathematical focus cleanly?',
+    '- Are the cluster and family tags honest?',
+    '- Does the dossier need a deeper route starter before publication?',
+    '- Should this problem remain dossier-depth or enter a family pack later?',
+    '',
+    '## Ready-to-promote checks',
+    '',
+    '- Statement reviewed',
+    '- References reviewed',
+    '- Evidence starter reviewed',
+    '- Formalization starter reviewed',
+    '- Public-status review read',
+    '- Agent websearch brief read',
+    '',
+  ].join('\n');
+}
+
+export function reviewPullBundleForSeeding(problemId, options = {}) {
+  const bundle = loadPullBundle(problemId, options.fromPullDir);
+  const destinationRoot = path.resolve(options.destRoot ?? path.join(repoRoot, 'problems'));
+  const destinationDir = path.join(destinationRoot, String(problemId));
+  const reviewPath = path.resolve(options.dest ?? path.join(bundle.pullDir, 'REVIEW_CHECKLIST.md'));
+  const title = deriveTitle(problemId, bundle, options.title);
+  const shortStatement = deriveShortStatement(problemId, bundle, title);
+
+  writeText(reviewPath, renderReviewChecklist(problemId, bundle, destinationDir));
+
+  return {
+    problemId: String(problemId),
+    reviewPath,
+    pullDir: bundle.pullDir,
+    destinationDir,
+    usedUpstreamRecord: Boolean(bundle.upstreamRecord),
+    usedSiteSnapshot: Boolean(bundle.siteExtract || bundle.siteSummary),
+    usedPublicStatusReview: Boolean(bundle.publicStatusReview || bundle.publicStatusReviewMarkdown),
+    title,
+    shortStatement,
+  };
+}

package/src/runtime/number-theory.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { getPackProblemDir } from './paths.js';
+
+function readYamlIfPresent(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  return parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function getPackFile(problemId, fileName) {
+  return path.join(getPackProblemDir('number-theory', problemId), fileName);
+}
+
+function normalizeQuestionLedger(rawLedger) {
+  return {
+    openQuestions: rawLedger?.open_questions ?? [],
+    activeRouteNotes: rawLedger?.active_route_notes ?? [],
+    routeBreakthroughs: rawLedger?.route_breakthroughs ?? [],
+    problemSolved: rawLedger?.problem_solved ?? [],
+  };
+}
+
+function parseOpsDetails(problemId) {
+  const opsDetailsPath = getPackFile(problemId, 'OPS_DETAILS.yaml');
+  const payload = readYamlIfPresent(opsDetailsPath);
+  if (!payload) {
+    return null;
+  }
+  return {
+    packetId: payload.packet_id ?? null,
+    summary: payload.summary ?? null,
+    path: opsDetailsPath,
+    routes: payload.routes ?? [],
+    tickets: payload.tickets ?? [],
+    atoms: payload.atoms ?? [],
+  };
+}
+
+function findActiveRouteDetail(opsDetails, activeRoute) {
+  if (!opsDetails || !Array.isArray(opsDetails.routes)) {
+    return null;
+  }
+  return opsDetails.routes.find((route) => route.route_id === activeRoute) ?? opsDetails.routes[0] ?? null;
+}
+
+function findActiveTicketDetail(opsDetails, activeRoute) {
+  if (!opsDetails || !Array.isArray(opsDetails.tickets)) {
+    return null;
+  }
+  return (
+    opsDetails.tickets.find((ticket) => ticket.status === 'active' && (!activeRoute || ticket.route_id === activeRoute))
+    ?? opsDetails.tickets.find((ticket) => !activeRoute || ticket.route_id === activeRoute)
+    ?? opsDetails.tickets[0]
+    ?? null
+  );
+}
+
+function findFirstReadyAtom(opsDetails, activeRoute) {
+  if (!opsDetails || !Array.isArray(opsDetails.atoms)) {
+    return null;
+  }
+  return (
+    opsDetails.atoms.find((atom) => atom.status === 'ready' && (!activeRoute || atom.route_id === activeRoute))
+    ?? opsDetails.atoms.find((atom) => atom.status === 'ready')
+    ?? null
+  );
+}
+
+function resolveArchiveMode(problem) {
+  const siteStatus = String(problem.siteStatus ?? '').toLowerCase();
+  if (siteStatus === 'solved') {
+    return 'method_exemplar';
+  }
+  if (siteStatus === 'disproved') {
+    return 'counterexample_archive';
+  }
+  return null;
+}
+
+export function buildNumberTheoryStatusSnapshot(problem) {
+  const contextPath = getPackFile(problem.problemId, 'context.yaml');
+  const contextMarkdownPath = getPackFile(problem.problemId, 'CONTEXT.md');
+  const routePacketPath = getPackFile(problem.problemId, 'ROUTE_PACKET.yaml');
+  const frontierNotePath = getPackFile(problem.problemId, 'FRONTIER_NOTE.md');
+  const routeHistoryPath = getPackFile(problem.problemId, 'ROUTE_HISTORY.md');
+  const checkpointTemplatePath = getPackFile(problem.problemId, 'CHECKPOINT_TEMPLATE.md');
+  const reportTemplatePath = getPackFile(problem.problemId, 'REPORT_TEMPLATE.md');
+
+  const context = readYamlIfPresent(contextPath) ?? {};
+  const routePacket = readYamlIfPresent(routePacketPath);
+  const opsDetails = parseOpsDetails(problem.problemId);
+
+  const activeRoute =
+    problem.researchState?.active_route
+    ?? context.default_active_route
+    ?? routePacket?.route_id
+    ?? null;
+  const routeBreakthrough = typeof problem.researchState?.route_breakthrough === 'boolean'
+    ? problem.researchState.route_breakthrough
+    : false;
+  const archiveMode = resolveArchiveMode(problem);
+  const problemSolved = typeof problem.researchState?.problem_solved === 'boolean'
+    ? problem.researchState.problem_solved
+    : String(problem.siteStatus ?? '').toLowerCase() === 'solved';
+  const openProblem = typeof problem.researchState?.open_problem === 'boolean'
+    ? problem.researchState.open_problem
+    : String(problem.siteStatus ?? '').toLowerCase() === 'open';
+
+  const activeRouteDetail = findActiveRouteDetail(opsDetails, activeRoute);
+  const activeTicketDetail = findActiveTicketDetail(opsDetails, activeRoute);
+  const firstReadyAtom = findFirstReadyAtom(opsDetails, activeRoute);
+  const readyAtoms = Array.isArray(opsDetails?.atoms)
+    ? opsDetails.atoms.filter((atom) => atom.status === 'ready')
+    : [];
+
+  return {
+    generatedAt: new Date().toISOString(),
+    problemId: problem.problemId,
+    displayName: problem.displayName,
+    title: problem.title,
+    cluster: problem.cluster,
+    familyRole: context.family_role ?? 'number_theory_pack',
+    harnessProfile: context.harness_profile ?? 'starter_cockpit',
+    activeRoute,
+    routeBreakthrough,
+    problemSolved,
+    openProblem,
+    siteStatus: problem.siteStatus,
+    archiveMode,
+    bootstrapFocus: context.bootstrap_focus ?? null,
+    routeStory: context.route_story ?? routePacket?.frontier_claim ?? problem.shortStatement,
+    frontierLabel: context.frontier_label ?? activeRoute ?? 'number_theory_frontier',
+    frontierDetail: firstReadyAtom?.summary ?? context.frontier_detail ?? activeRouteDetail?.summary ?? problem.shortStatement,
+    checkpointFocus: context.checkpoint_focus ?? activeRouteDetail?.why_now ?? null,
+    nextHonestMove:
+      firstReadyAtom?.next_move
+      ?? activeTicketDetail?.next_move
+      ?? context.next_honest_move
+      ?? 'Pull the dossier, freeze the route note, and preserve public-status honesty.',
+    relatedCoreProblems: context.related_core_problems ?? [],
+    literatureFocus: context.literature_focus ?? [],
+    artifactFocus: context.artifact_focus ?? [],
+    questionLedger: normalizeQuestionLedger(context.question_ledger),
+    contextPresent: fs.existsSync(contextPath),
+    contextPath,
+    contextMarkdownPath,
+    routePacketPresent: Boolean(routePacket),
+    routePacket,
+    routePacketPath,
+    frontierNotePresent: fs.existsSync(frontierNotePath),
+    frontierNotePath,
+    routeHistoryPresent: fs.existsSync(routeHistoryPath),
+    routeHistoryPath,
+    checkpointTemplatePresent: fs.existsSync(checkpointTemplatePath),
+    checkpointTemplatePath,
+    reportTemplatePresent: fs.existsSync(reportTemplatePath),
+    reportTemplatePath,
+    opsDetailsPresent: Boolean(opsDetails),
+    opsDetailsPath: opsDetails?.path ?? getPackFile(problem.problemId, 'OPS_DETAILS.yaml'),
+    opsDetails,
+    activeRouteDetail,
+    activeTicketDetail,
+    firstReadyAtom,
+    readyAtomCount: readyAtoms.length,
+  };
+}

package/src/runtime/paths.js

@@ -120,6 +120,22 @@ export function getWorkspaceCheckpointsDir(workspaceRoot = getWorkspaceRoot()) {
   return path.join(getWorkspaceDir(workspaceRoot), 'checkpoints');
 }
 
+export function getWorkspaceRunsDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'runs');
+}
+
+export function getWorkspaceRunDir(runId, workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceRunsDir(workspaceRoot), String(runId));
+}
+
+export function getWorkspaceArchivesDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'archives');
+}
+
+export function getWorkspaceArchiveDir(problemId, workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceArchivesDir(workspaceRoot), String(problemId));
+}
+
 export function getWorkspaceProblemCheckpointsDir(workspaceRoot = getWorkspaceRoot()) {
   return path.join(getWorkspaceCheckpointsDir(workspaceRoot), 'problem-checkpoints');
 }

package/src/runtime/state.js

@@ -7,6 +7,7 @@ import {
   getWorkspaceStateMarkdownPath,
   getWorkspaceStatePath,
 } from './paths.js';
+import { buildNumberTheoryStatusSnapshot } from './number-theory.js';
 import { buildSunflowerStatusSnapshot } from './sunflower.js';
 import { readCurrentProblem } from './workspace.js';
 import { continuationDisplay, resolveContinuation } from './continuation.js';
@@ -35,6 +36,9 @@ function defaultState(config, workspaceRoot) {
     routeStory: null,
     checkpointFocus: null,
     nextHonestMove: 'Select or bootstrap an Erdős problem to begin.',
+    packArtifacts: null,
+    activeTicketId: null,
+    activeAtomId: null,
     lastCheckpointSyncAt: null,
   };
 }
@@ -101,6 +105,13 @@ function renderStateMarkdown(state) {
 
 - ${state.checkpointFocus || '(none yet)'}
 
+## Pack Artifacts
+
+- Frontier Note: ${state.packArtifacts?.frontierNotePath || '(none)'}
+- Route History: ${state.packArtifacts?.routeHistoryPath || '(none)'}
+- Checkpoint Template: ${state.packArtifacts?.checkpointTemplatePath || '(none)'}
+- Report Template: ${state.packArtifacts?.reportTemplatePath || '(none)'}
+
 ## Next Honest Move
 
 - ${state.nextHonestMove}
@@ -146,6 +157,9 @@ function deriveGenericProblemSummary(problem) {
       : 'No active route is recorded for this dossier yet.',
     checkpointFocus: 'Keep dossier truth, upstream provenance, and local route state sharply separated.',
     nextHonestMove,
+    packArtifacts: null,
+    activeTicketId: null,
+    activeAtomId: null,
     questionLedger: {
       openQuestions: ['What is the next smallest honest route or evidence obligation for this problem?'],
       activeRouteNotes: activeRoute ? [`Current active route: ${activeRoute}`] : [],
@@ -170,10 +184,10 @@ function deriveProblemSummary(problem) {
       : sunflower.frontierDetail || sunflower.computeSummary || sunflower.bootstrapFocus || problem.shortStatement;
     const routeStory = sunflower.activeTicket
       ? `Work ${sunflower.activeTicket.ticketId} (${sunflower.activeTicket.ticketName}) without blurring ticket-local pressure into solved-problem claims.`
-      : (sunflower.routeStory || sunflower.bootstrapFocus || null);
+      : (sunflower.activeRouteDetail?.summary || sunflower.routeStory || sunflower.bootstrapFocus || null);
     const checkpointFocus = sunflower.activeTicket
       ? `Keep the board packet honest around ${sunflower.activeTicket.ticketId} while preserving the open-problem / active-route / route-breakthrough ladder.`
-      : (sunflower.checkpointFocus || null);
+      : (sunflower.activeRouteDetail?.whyNow || sunflower.checkpointFocus || null);
     return {
       familyRole: sunflower.familyRole,
       harnessProfile: sunflower.harnessProfile,
@@ -187,11 +201,54 @@ function deriveProblemSummary(problem) {
       },
       routeStory,
       checkpointFocus,
-      nextHonestMove: sunflower.nextHonestMove || sunflower.computeNextAction || 'Refresh the active route and package a new honest checkpoint.',
+      nextHonestMove:
+        sunflower.activeAtomDetail?.nextMove
+        || sunflower.activeTicketDetail?.nextMove
+        || sunflower.nextHonestMove
+        || sunflower.computeNextAction
+        || 'Refresh the active route and package a new honest checkpoint.',
+      packArtifacts: {
+        frontierNotePath: sunflower.frontierNotePath,
+        routeHistoryPath: sunflower.routeHistoryPath,
+        checkpointTemplatePath: sunflower.checkpointTemplatePath,
+        reportTemplatePath: sunflower.reportTemplatePath,
+      },
+      activeTicketId: sunflower.activeTicket?.ticketId ?? null,
+      activeAtomId: sunflower.firstReadyAtom?.atomId ?? null,
       questionLedger: sunflower.questionLedger,
     };
   }
 
+  if (problem.cluster === 'number-theory') {
+    const snapshot = buildNumberTheoryStatusSnapshot(problem);
+    return {
+      familyRole: snapshot.familyRole,
+      harnessProfile: snapshot.harnessProfile,
+      activeRoute: snapshot.activeRoute,
+      routeBreakthrough: snapshot.routeBreakthrough,
+      problemSolved: snapshot.problemSolved,
+      openProblem: snapshot.openProblem,
+      currentFrontier: {
+        kind: snapshot.firstReadyAtom ? 'ready_atom' : 'route_frontier',
+        detail: snapshot.firstReadyAtom
+          ? `${snapshot.firstReadyAtom.atom_id} — ${snapshot.firstReadyAtom.title}`
+          : snapshot.frontierDetail,
+      },
+      routeStory: snapshot.activeRouteDetail?.summary || snapshot.routeStory,
+      checkpointFocus: snapshot.checkpointFocus,
+      nextHonestMove: snapshot.nextHonestMove,
+      packArtifacts: {
+        frontierNotePath: snapshot.frontierNotePath,
+        routeHistoryPath: snapshot.routeHistoryPath,
+        checkpointTemplatePath: snapshot.checkpointTemplatePath,
+        reportTemplatePath: snapshot.reportTemplatePath,
+      },
+      activeTicketId: snapshot.activeTicketDetail?.ticket_id ?? null,
+      activeAtomId: snapshot.firstReadyAtom?.atom_id ?? null,
+      questionLedger: snapshot.questionLedger,
+    };
+  }
+
   return deriveGenericProblemSummary(problem);
 }
 
@@ -273,6 +330,9 @@ export function syncState(workspaceRoot = getWorkspaceRoot()) {
     routeStory: summary.routeStory,
     checkpointFocus: summary.checkpointFocus,
     nextHonestMove: summary.nextHonestMove,
+    packArtifacts: summary.packArtifacts,
+    activeTicketId: summary.activeTicketId,
+    activeAtomId: summary.activeAtomId,
     lastCheckpointSyncAt: existing.lastCheckpointSyncAt ?? null,
   };