erdos-problems 0.1.12 → 0.2.0

package/src/runtime/archive.js

@@ -0,0 +1,87 @@
+import path from 'node:path';
+import { getProblem } from '../atlas/catalog.js';
+import { ensureDir, writeJson, writeText } from './files.js';
+import { getWorkspaceArchiveDir, getWorkspaceRoot } from './paths.js';
+
+function isSolved(problem) {
+  return String(problem?.siteStatus ?? '').toLowerCase() === 'solved'
+    || Boolean(problem?.researchState?.problem_solved);
+}
+
+export function getArchiveView(problemId) {
+  const problem = getProblem(problemId);
+  if (!problem) {
+    return null;
+  }
+
+  return {
+    problemId: problem.problemId,
+    displayName: problem.displayName,
+    title: problem.title,
+    siteStatus: problem.siteStatus,
+    repoStatus: problem.repoStatus,
+    solved: isSolved(problem),
+    archiveMode: isSolved(problem) ? 'method_exemplar' : 'inactive',
+    nextMove: isSolved(problem)
+      ? 'Extract reusable methods, references, and formalization hooks without treating this as an open-problem cockpit.'
+      : 'This problem is not currently in solved archival mode.',
+  };
+}
+
+export function scaffoldArchive(problemId, workspaceRoot = getWorkspaceRoot()) {
+  const problem = getProblem(problemId);
+  if (!problem) {
+    throw new Error(`Unknown problem: ${problemId}`);
+  }
+  if (!isSolved(problem)) {
+    throw new Error(`Problem ${problemId} is not solved, so archival mode is not active.`);
+  }
+
+  const archiveDir = getWorkspaceArchiveDir(problemId, workspaceRoot);
+  ensureDir(archiveDir);
+
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    problemId: problem.problemId,
+    displayName: problem.displayName,
+    title: problem.title,
+    siteStatus: problem.siteStatus,
+    repoStatus: problem.repoStatus,
+    archiveMode: 'method_exemplar',
+  };
+
+  writeJson(path.join(archiveDir, 'ARCHIVE.json'), payload);
+  writeText(
+    path.join(archiveDir, 'ARCHIVE_SUMMARY.md'),
+    [
+      `# ${problem.displayName} Archive Summary`,
+      '',
+      `- Title: ${problem.title}`,
+      `- Site status: ${problem.siteStatus}`,
+      `- Repo status: ${problem.repoStatus}`,
+      '',
+      'Archive posture:',
+      '- treat this solved problem as a method exemplar',
+      '- extract reusable arguments, formalization hooks, and references',
+      '- do not run the open-problem frontier loop here',
+      '',
+    ].join('\n'),
+  );
+  writeText(
+    path.join(archiveDir, 'METHOD_PACKET.md'),
+    [
+      `# ${problem.displayName} Method Packet`,
+      '',
+      'Prompts:',
+      '- What method or reduction pattern is reusable?',
+      '- What verification surface is already clean here?',
+      '- What should be ported into open-problem packs as technique, not as status inflation?',
+      '',
+    ].join('\n'),
+  );
+
+  return {
+    archiveDir,
+    payload,
+  };
+}

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/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

@@ -35,6 +35,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 +104,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 +156,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 +183,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,7 +200,20 @@ 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,
     };
   }
@@ -273,6 +299,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,
   };