erdos-problems 0.1.13 → 0.2.1

package/src/commands/sunflower.js

@@ -1,6 +1,13 @@
 import { getProblem } from '../atlas/catalog.js';
 import { getWorkspaceRoot } from '../runtime/paths.js';
-import { buildSunflowerStatusSnapshot, writeSunflowerStatusRecord } from '../runtime/sunflower.js';
+import {
+  buildSunflowerStatusSnapshot,
+  getSunflowerAtomSnapshot,
+  getSunflowerRouteSnapshot,
+  getSunflowerTicketSnapshot,
+  runSunflowerLocalScout,
+  writeSunflowerStatusRecord,
+} from '../runtime/sunflower.js';
 import { readCurrentProblem } from '../runtime/workspace.js';
 
 function parseStatusArgs(args) {
@@ -45,6 +52,53 @@ function parseTicketsArgs(args) {
   return parseStatusArgs(args);
 }
 
+function parseFrontierArgs(args) {
+  return parseStatusArgs(args);
+}
+
+function parseEntityArgs(args, entityLabel) {
+  const parsed = {
+    problemId: null,
+    entityId: null,
+    asJson: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === '--json') {
+      parsed.asJson = true;
+      continue;
+    }
+    if (!parsed.problemId) {
+      parsed.problemId = token;
+      continue;
+    }
+    if (!parsed.entityId) {
+      parsed.entityId = token;
+      continue;
+    }
+    return { error: `Unknown sunflower ${entityLabel} option: ${token}` };
+  }
+
+  return parsed;
+}
+
+function parseComputeArgs(args) {
+  const [computeCommand, ...rest] = args;
+  if (!computeCommand || computeCommand === 'help' || computeCommand === '--help') {
+    return { help: true };
+  }
+  if (computeCommand !== 'run') {
+    return { error: `Unknown sunflower compute subcommand: ${computeCommand}` };
+  }
+
+  const parsed = parseStatusArgs(rest);
+  return {
+    ...parsed,
+    computeCommand,
+  };
+}
+
 function getBoard(snapshot) {
   return snapshot.atomicBoardSummary;
 }
@@ -91,6 +145,24 @@ function ticketProgressLabel(ticket, snapshot) {
   return 'open';
 }
 
+function resolveSunflowerProblem(problemId) {
+  const resolvedProblemId = problemId ?? readCurrentProblem();
+  if (!resolvedProblemId) {
+    return { error: 'Missing problem id and no active problem is selected.' };
+  }
+
+  const problem = getProblem(resolvedProblemId);
+  if (!problem) {
+    return { error: `Unknown problem: ${resolvedProblemId}` };
+  }
+
+  if (problem.cluster !== 'sunflower') {
+    return { error: `Problem ${problem.problemId} is not in the sunflower harness.` };
+  }
+
+  return { problem };
+}
+
 function printSunflowerStatus(snapshot, registryPaths) {
   console.log(`${snapshot.displayName} sunflower harness`);
   console.log(`Title: ${snapshot.title}`);
@@ -140,6 +212,10 @@ function printSunflowerStatus(snapshot, registryPaths) {
   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(`Frontier note: ${snapshot.frontierNotePresent ? snapshot.frontierNotePath : '(missing)'}`);
+  console.log(`Route history: ${snapshot.routeHistoryPresent ? snapshot.routeHistoryPath : '(missing)'}`);
+  console.log(`Checkpoint template: ${snapshot.checkpointTemplatePresent ? snapshot.checkpointTemplatePath : '(missing)'}`);
+  console.log(`Report template: ${snapshot.reportTemplatePresent ? snapshot.reportTemplatePath : '(missing)'}`);
   console.log(`Compute lane present: ${snapshot.computeLanePresent ? 'yes' : 'no'}`);
   console.log(`Compute lane count: ${snapshot.computeLaneCount}`);
   console.log(`Compute summary: ${snapshot.computeSummary}`);
@@ -368,6 +444,124 @@ function printSunflowerTickets(snapshot) {
   }
 }
 
+function printSunflowerFrontier(snapshot) {
+  console.log(`${snapshot.displayName} sunflower frontier`);
+  console.log(`Active route: ${snapshot.activeRoute ?? '(none)'}`);
+  console.log(`Active ticket: ${snapshot.activeTicket?.ticketId ?? '(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(`Ready atoms: ${snapshot.readyAtomCount}`);
+  console.log(`Mirage frontiers: ${snapshot.mirageFrontierCount}`);
+  if (snapshot.firstReadyAtom) {
+    console.log(`First ready atom: ${snapshot.firstReadyAtom.atomId} — ${snapshot.firstReadyAtom.title}`);
+  }
+  if (snapshot.activeRouteDetail) {
+    console.log(`Route focus: ${snapshot.activeRouteDetail.title ?? snapshot.activeRouteDetail.routeId}`);
+    console.log(`Route why now: ${snapshot.activeRouteDetail.whyNow ?? '(none)'}`);
+  }
+  if (snapshot.activeTicketDetail) {
+    console.log(`Ticket focus: ${snapshot.activeTicketDetail.title ?? snapshot.activeTicketDetail.ticketId}`);
+    console.log(`Ticket blocker: ${snapshot.activeTicketDetail.currentBlocker ?? '(none)'}`);
+  }
+  if (snapshot.activeAtomDetail) {
+    console.log(`Atom focus: ${snapshot.activeAtomDetail.title ?? snapshot.activeAtomDetail.atomId}`);
+    console.log(`Atom why now: ${snapshot.activeAtomDetail.whyNow ?? '(none)'}`);
+  }
+  console.log(`Frontier note: ${snapshot.frontierNotePresent ? snapshot.frontierNotePath : '(missing)'}`);
+  console.log(`Route history: ${snapshot.routeHistoryPresent ? snapshot.routeHistoryPath : '(missing)'}`);
+}
+
+function printSunflowerRouteDetail(routeSnapshot) {
+  const detail = routeSnapshot.routeDetail;
+  const boardRoute = routeSnapshot.boardRoute;
+
+  console.log(`${routeSnapshot.displayName} sunflower route ${routeSnapshot.routeId}`);
+  console.log(`Active route: ${routeSnapshot.activeRoute ?? '(none)'}`);
+  if (detail) {
+    console.log(`Title: ${detail.title ?? '(none)'}`);
+    console.log(`Status: ${detail.status ?? '(none)'}`);
+    console.log(`Summary: ${detail.summary ?? '(none)'}`);
+    console.log(`Why now: ${detail.whyNow ?? '(none)'}`);
+    console.log(`Next move: ${detail.nextMove ?? '(none)'}`);
+    console.log(`Theorem module: ${detail.theoremModule ?? '(none)'}`);
+    console.log(`Ticket ids: ${detail.ticketIds.join(', ') || '(none)'}`);
+  }
+  if (boardRoute) {
+    console.log(`Loose progress: ${boardRoute.looseDone}/${boardRoute.looseTotal}`);
+    console.log(`Strict progress: ${boardRoute.strictDone}/${boardRoute.strictTotal}`);
+  }
+  if (routeSnapshot.firstReadyAtom) {
+    console.log(`First ready atom: ${routeSnapshot.firstReadyAtom.atomId} — ${routeSnapshot.firstReadyAtom.title}`);
+  }
+}
+
+function printSunflowerTicketDetail(ticketSnapshot) {
+  const detail = ticketSnapshot.ticketDetail;
+  const boardTicket = ticketSnapshot.boardTicket;
+
+  console.log(`${ticketSnapshot.displayName} sunflower ticket ${ticketSnapshot.ticketId}`);
+  console.log(`Active ticket: ${ticketSnapshot.activeTicketId ?? '(none)'}`);
+  if (detail) {
+    console.log(`Title: ${detail.title ?? '(none)'}`);
+    console.log(`Route: ${detail.routeId ?? '(none)'}`);
+    console.log(`Status: ${detail.status ?? '(none)'}`);
+    console.log(`Summary: ${detail.summary ?? '(none)'}`);
+    console.log(`Gate story: ${detail.gateStory ?? '(none)'}`);
+    console.log(`Current blocker: ${detail.currentBlocker ?? '(none)'}`);
+    console.log(`Next move: ${detail.nextMove ?? '(none)'}`);
+    console.log(`Atom ids: ${detail.atomIds.join(', ') || '(none)'}`);
+  }
+  if (boardTicket) {
+    console.log(`Leaf theorem: ${boardTicket.routeLeaf ?? '(none)'}`);
+    console.log(`Leaf status: ${boardTicket.leafStatus ?? '(none)'}`);
+    console.log(`Gate progress: ${boardTicket.gatesDone}/${boardTicket.gatesTotal}`);
+    console.log(`Atom progress: ${boardTicket.atomsDone}/${boardTicket.atomsTotal}`);
+  }
+  if (ticketSnapshot.firstReadyAtom?.ticketId === ticketSnapshot.ticketId) {
+    console.log(`First ready atom: ${ticketSnapshot.firstReadyAtom.atomId} — ${ticketSnapshot.firstReadyAtom.title}`);
+  }
+}
+
+function printSunflowerAtomDetail(atomSnapshot) {
+  const detail = atomSnapshot.atomDetail;
+  const boardAtom = atomSnapshot.boardAtom;
+
+  console.log(`${atomSnapshot.displayName} sunflower atom ${atomSnapshot.atomId}`);
+  if (detail) {
+    console.log(`Title: ${detail.title ?? '(none)'}`);
+    console.log(`Route: ${detail.routeId ?? '(none)'}`);
+    console.log(`Ticket: ${detail.ticketId ?? '(none)'}`);
+    console.log(`Gate: ${detail.gateId ?? '(none)'}`);
+    console.log(`Tier: ${detail.tier ?? '(none)'}`);
+    console.log(`Kind: ${detail.kind ?? '(none)'}`);
+    console.log(`Status: ${detail.status ?? '(none)'}`);
+    console.log(`Summary: ${detail.summary ?? '(none)'}`);
+    console.log(`Why now: ${detail.whyNow ?? '(none)'}`);
+    console.log(`Next move: ${detail.nextMove ?? '(none)'}`);
+    console.log(`Dependencies: ${detail.dependencies.join(', ') || '(none)'}`);
+    console.log(`Verification hook: ${detail.verificationHook.join(' | ') || '(none)'}`);
+  }
+  if (boardAtom) {
+    console.log(`Board queue status: ${boardAtom.status ?? '(none)'}`);
+  }
+  if (atomSnapshot.firstReadyAtom?.atomId === atomSnapshot.atomId) {
+    console.log('Current frontier atom: yes');
+  }
+}
+
+function printSunflowerComputeRun(result) {
+  console.log(`Sunflower local scout run created for problem ${result.snapshot.problemId}`);
+  console.log(`Run id: ${result.runId}`);
+  console.log(`Run dir: ${result.runDir}`);
+  console.log(`Lane: ${result.snapshot.activePacket?.laneId ?? '(none)'}`);
+  console.log(`Dispatch action: ${result.snapshot.computeGovernance?.dispatchResult.action ?? '(none)'}`);
+  console.log(`Selected rung: ${result.snapshot.computeGovernance?.selectedRung?.label ?? '(none)'}`);
+  console.log(`Current frontier: ${result.runRecord.currentFrontier}`);
+  console.log(`Run summary: ${result.runRecord.artifacts.runSummaryPath}`);
+}
+
 export function runSunflowerCommand(args) {
   const [subcommand, ...rest] = args;
 
@@ -379,10 +573,15 @@ export function runSunflowerCommand(args) {
     console.log('  erdos sunflower ladder [<id>] [--json]');
     console.log('  erdos sunflower routes [<id>] [--json]');
     console.log('  erdos sunflower tickets [<id>] [--json]');
+    console.log('  erdos sunflower frontier [<id>] [--json]');
+    console.log('  erdos sunflower route <problem-id> <route-id> [--json]');
+    console.log('  erdos sunflower ticket <problem-id> <ticket-id> [--json]');
+    console.log('  erdos sunflower atom <problem-id> <atom-id> [--json]');
+    console.log('  erdos sunflower compute run [<id>] [--json]');
     return 0;
   }
 
-  if (!['status', 'board', 'ready', 'ladder', 'routes', 'tickets'].includes(subcommand)) {
+  if (!['status', 'board', 'ready', 'ladder', 'routes', 'tickets', 'frontier', 'route', 'ticket', 'atom', 'compute'].includes(subcommand)) {
     console.error(`Unknown sunflower subcommand: ${subcommand}`);
     return 1;
   }
@@ -398,29 +597,103 @@ export function runSunflowerCommand(args) {
     parsed = parseRoutesArgs(rest);
   } else if (subcommand === 'tickets') {
     parsed = parseTicketsArgs(rest);
+  } else if (subcommand === 'frontier') {
+    parsed = parseFrontierArgs(rest);
+  } else if (subcommand === 'route') {
+    parsed = parseEntityArgs(rest, 'route');
+  } else if (subcommand === 'ticket') {
+    parsed = parseEntityArgs(rest, 'ticket');
+  } else if (subcommand === 'atom') {
+    parsed = parseEntityArgs(rest, 'atom');
+  } else if (subcommand === 'compute') {
+    parsed = parseComputeArgs(rest);
   } else {
     parsed = parseStatusArgs(rest);
   }
+
+  if (parsed?.help) {
+    console.log('Usage:');
+    console.log('  erdos sunflower compute run [<id>] [--json]');
+    return 0;
+  }
   if (parsed.error) {
     console.error(parsed.error);
     return 1;
   }
 
-  const problemId = parsed.problemId ?? readCurrentProblem();
-  if (!problemId) {
-    console.error('Missing problem id and no active problem is selected.');
+  const { problem, error } = resolveSunflowerProblem(parsed.problemId);
+  if (error) {
+    console.error(error);
     return 1;
   }
 
-  const problem = getProblem(problemId);
-  if (!problem) {
-    console.error(`Unknown problem: ${problemId}`);
-    return 1;
+  if (subcommand === 'route') {
+    if (!parsed.entityId) {
+      console.error('Missing route id.');
+      return 1;
+    }
+    const routeSnapshot = getSunflowerRouteSnapshot(problem, parsed.entityId);
+    if (!routeSnapshot) {
+      console.error(`Unknown sunflower route: ${parsed.entityId}`);
+      return 1;
+    }
+    if (parsed.asJson) {
+      console.log(JSON.stringify(routeSnapshot, null, 2));
+      return 0;
+    }
+    printSunflowerRouteDetail(routeSnapshot);
+    return 0;
   }
 
-  if (problem.cluster !== 'sunflower') {
-    console.error(`Problem ${problem.problemId} is not in the sunflower harness.`);
-    return 1;
+  if (subcommand === 'ticket') {
+    if (!parsed.entityId) {
+      console.error('Missing ticket id.');
+      return 1;
+    }
+    const ticketSnapshot = getSunflowerTicketSnapshot(problem, parsed.entityId);
+    if (!ticketSnapshot) {
+      console.error(`Unknown sunflower ticket: ${parsed.entityId}`);
+      return 1;
+    }
+    if (parsed.asJson) {
+      console.log(JSON.stringify(ticketSnapshot, null, 2));
+      return 0;
+    }
+    printSunflowerTicketDetail(ticketSnapshot);
+    return 0;
+  }
+
+  if (subcommand === 'atom') {
+    if (!parsed.entityId) {
+      console.error('Missing atom id.');
+      return 1;
+    }
+    const atomSnapshot = getSunflowerAtomSnapshot(problem, parsed.entityId);
+    if (!atomSnapshot) {
+      console.error(`Unknown sunflower atom: ${parsed.entityId}`);
+      return 1;
+    }
+    if (parsed.asJson) {
+      console.log(JSON.stringify(atomSnapshot, null, 2));
+      return 0;
+    }
+    printSunflowerAtomDetail(atomSnapshot);
+    return 0;
+  }
+
+  if (subcommand === 'compute') {
+    try {
+      const result = runSunflowerLocalScout(problem, getWorkspaceRoot());
+      if (parsed.asJson) {
+        console.log(JSON.stringify(result, null, 2));
+        return 0;
+      }
+      printSunflowerComputeRun(result);
+      return 0;
+    } catch (runError) {
+      console.error(String(runError.message ?? runError));
+      return 1;
+    }
   }
 
   const snapshot = buildSunflowerStatusSnapshot(problem);
@@ -456,6 +729,11 @@ export function runSunflowerCommand(args) {
     return 0;
   }
 
+  if (subcommand === 'frontier') {
+    printSunflowerFrontier(snapshot);
+    return 0;
+  }
+
   printSunflowerStatus(snapshot, registryPaths);
   return 0;
 }

package/src/commands/upstream.js

@@ -1,5 +1,34 @@
+import { getProblem } from '../atlas/catalog.js';
+import { fetchProblemSiteSnapshot } from '../upstream/site.js';
 import { buildUpstreamDiff, loadActiveUpstreamSnapshot, syncUpstream, writeDiffArtifacts } from '../upstream/sync.js';
 
+function parseDriftArgs(args) {
+  const parsed = {
+    problemId: null,
+    includeSite: false,
+    asJson: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === '--include-site') {
+      parsed.includeSite = true;
+      continue;
+    }
+    if (token === '--json') {
+      parsed.asJson = true;
+      continue;
+    }
+    if (!parsed.problemId) {
+      parsed.problemId = token;
+      continue;
+    }
+    return { error: `Unknown upstream drift option: ${token}` };
+  }
+
+  return parsed;
+}
+
 export async function runUpstreamCommand(args) {
   const [subcommand, ...rest] = args;
 
@@ -8,6 +37,7 @@ export async function runUpstreamCommand(args) {
     console.log('  erdos upstream show');
     console.log('  erdos upstream sync [--write-package-snapshot]');
     console.log('  erdos upstream diff [--write-package-report]');
+    console.log('  erdos upstream drift [<id>] [--include-site] [--json]');
     return 0;
   }
 
@@ -55,6 +85,105 @@ export async function runUpstreamCommand(args) {
     return 0;
   }
 
+  if (subcommand === 'drift') {
+    const parsed = parseDriftArgs(rest);
+    if (parsed.error) {
+      console.error(parsed.error);
+      return 1;
+    }
+
+    const diff = buildUpstreamDiff();
+    if (!parsed.problemId) {
+      const statusDrifts = diff.overlaps.filter((row) => !row.statusMatches);
+      const formalizationDrifts = diff.overlaps.filter((row) => !row.formalizedMatches);
+      const tagDrifts = diff.overlaps.filter((row) => row.localOnlyTags.length > 0 || row.upstreamOnlyTags.length > 0);
+      const payload = {
+        localProblemCount: diff.localProblemCount,
+        upstreamProblemCount: diff.upstreamProblemCount,
+        statusDriftCount: statusDrifts.length,
+        formalizationDriftCount: formalizationDrifts.length,
+        tagDriftCount: tagDrifts.length,
+        statusDrifts: statusDrifts.slice(0, 10),
+        formalizationDrifts: formalizationDrifts.slice(0, 10),
+        tagDrifts: tagDrifts.slice(0, 10),
+      };
+
+      if (parsed.asJson) {
+        console.log(JSON.stringify(payload, null, 2));
+        return 0;
+      }
+
+      console.log('Upstream drift dashboard');
+      console.log(`Local seeded problems: ${payload.localProblemCount}`);
+      console.log(`Upstream total problems: ${payload.upstreamProblemCount}`);
+      console.log(`Site-status drifts: ${payload.statusDriftCount}`);
+      console.log(`Formalization drifts: ${payload.formalizationDriftCount}`);
+      console.log(`Tag drifts: ${payload.tagDriftCount}`);
+      return 0;
+    }
+
+    const problem = getProblem(parsed.problemId);
+    const snapshot = loadActiveUpstreamSnapshot();
+    const upstreamRecord = snapshot?.index?.by_number?.[String(parsed.problemId)] ?? null;
+    if (!problem && !upstreamRecord) {
+      console.error(`Unknown problem: ${parsed.problemId}`);
+      return 1;
+    }
+
+    let siteSnapshot = null;
+    let siteError = null;
+    if (parsed.includeSite) {
+      try {
+        siteSnapshot = await fetchProblemSiteSnapshot(parsed.problemId);
+      } catch (error) {
+        siteError = String(error.message ?? error);
+      }
+    }
+
+    const payload = {
+      problemId: String(parsed.problemId),
+      local: problem
+        ? {
+            siteStatus: problem.siteStatus,
+            repoStatus: problem.repoStatus,
+            title: problem.title,
+          }
+        : null,
+      upstream: upstreamRecord
+        ? {
+            siteStatus: upstreamRecord.status?.state ?? null,
+            formalizedState: upstreamRecord.formalized?.state ?? null,
+            tags: upstreamRecord.tags ?? [],
+          }
+        : null,
+      site: siteSnapshot
+        ? {
+            siteStatus: siteSnapshot.siteStatus,
+            statusLine: siteSnapshot.siteStatusRaw,
+            title: siteSnapshot.title,
+          }
+        : null,
+      siteError,
+    };
+
+    if (parsed.asJson) {
+      console.log(JSON.stringify(payload, null, 2));
+      return 0;
+    }
+
+    console.log(`Upstream drift for problem ${parsed.problemId}`);
+    console.log(`Local site status: ${payload.local?.siteStatus ?? '(none)'}`);
+    console.log(`Upstream site status: ${payload.upstream?.siteStatus ?? '(none)'}`);
+    console.log(`Site snapshot status: ${payload.site?.siteStatus ?? '(not fetched)'}`);
+    console.log(`Local repo status: ${payload.local?.repoStatus ?? '(none)'}`);
+    console.log(`Upstream formalized state: ${payload.upstream?.formalizedState ?? '(none)'}`);
+    console.log(`Upstream tags: ${payload.upstream?.tags?.join(', ') || '(none)'}`);
+    if (siteError) {
+      console.log(`Site fetch note: ${siteError}`);
+    }
+    return 0;
+  }
+
   console.error(`Unknown upstream subcommand: ${subcommand}`);
   return 1;
 }

package/src/commands/workspace.js

@@ -1,5 +1,6 @@
 import { getProblem } from '../atlas/catalog.js';
 import { loadConfig } from '../runtime/config.js';
+import { buildNumberTheoryStatusSnapshot } from '../runtime/number-theory.js';
 import { buildSunflowerStatusSnapshot } from '../runtime/sunflower.js';
 import { getWorkspaceSummary } from '../runtime/workspace.js';
 
@@ -38,6 +39,8 @@ export function runWorkspaceCommand(args) {
   console.log(`Workspace pull dir: ${summary.pullDir}`);
   console.log(`Workspace artifact dir: ${summary.artifactDir}`);
   console.log(`Workspace literature dir: ${summary.literatureDir}`);
+  console.log(`Workspace runs dir: ${summary.runsDir}`);
+  console.log(`Workspace archives dir: ${summary.archivesDir}`);
   console.log(`Active seeded dossier dir: ${summary.seededProblemDir}`);
   console.log(`Preferred agent: ${config.preferredAgent}`);
   console.log(`Continuation mode: ${summary.continuationMode ?? config.continuation}`);
@@ -58,6 +61,8 @@ export function runWorkspaceCommand(args) {
       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 frontier note: ${sunflower.frontierNotePath ?? '(none)'}`);
+      console.log(`Sunflower route history: ${sunflower.routeHistoryPath ?? '(none)'}`);
       console.log(`Sunflower board: ${sunflower.atomicBoardPresent ? 'yes' : 'no'}`);
       if (sunflower.atomicBoardSummary) {
         console.log(`Sunflower board title: ${sunflower.atomicBoardSummary.boardTitle ?? '(none)'}`);
@@ -72,6 +77,21 @@ export function runWorkspaceCommand(args) {
       }
       console.log(`Sunflower compute next: ${sunflower.computeNextAction}`);
     }
+    if (problem?.cluster === 'number-theory') {
+      const numberTheory = buildNumberTheoryStatusSnapshot(problem);
+      console.log(`Number-theory family role: ${numberTheory.familyRole ?? '(none)'}`);
+      console.log(`Number-theory harness profile: ${numberTheory.harnessProfile ?? '(none)'}`);
+      console.log(`Number-theory route: ${numberTheory.activeRoute ?? '(none)'}`);
+      console.log(`Number-theory frontier: ${numberTheory.frontierDetail ?? '(none)'}`);
+      console.log(`Number-theory frontier note: ${numberTheory.frontierNotePath ?? '(none)'}`);
+      console.log(`Number-theory route history: ${numberTheory.routeHistoryPath ?? '(none)'}`);
+      console.log(`Number-theory archive mode: ${numberTheory.archiveMode ?? '(none)'}`);
+      console.log(`Number-theory active ticket: ${numberTheory.activeTicketDetail?.ticket_id ?? '(none)'}`);
+      console.log(`Number-theory ready atoms: ${numberTheory.readyAtomCount}`);
+      if (numberTheory.firstReadyAtom) {
+        console.log(`Number-theory first ready atom: ${numberTheory.firstReadyAtom.atom_id} — ${numberTheory.firstReadyAtom.title}`);
+      }
+    }
   }
   return 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,
+  };
+}