erdos-problems 0.2.1 → 0.2.3

package/src/commands/graph-theory.js

@@ -0,0 +1,180 @@
+import { getProblem } from '../atlas/catalog.js';
+import { buildGraphTheoryStatusSnapshot } from '../runtime/graph-theory.js';
+import { readCurrentProblem } from '../runtime/workspace.js';
+
+function resolveGraphTheoryProblem(problemId) {
+  const resolvedId = problemId ?? readCurrentProblem();
+  if (!resolvedId) {
+    return { error: 'Missing problem id and no active problem is selected.' };
+  }
+
+  const problem = getProblem(resolvedId);
+  if (!problem) {
+    return { error: `Unknown problem: ${resolvedId}` };
+  }
+  if (problem.cluster !== 'graph-theory') {
+    return { error: `Problem ${resolvedId} is not in the graph-theory pack.` };
+  }
+  return { problem };
+}
+
+function parseArgs(args) {
+  const parsed = { problemId: null, asJson: false };
+  for (const token of args) {
+    if (token === '--json') {
+      parsed.asJson = true;
+      continue;
+    }
+    if (!parsed.problemId) {
+      parsed.problemId = token;
+      continue;
+    }
+    return { error: `Unknown graph-theory option: ${token}` };
+  }
+  return parsed;
+}
+
+function printStatus(snapshot) {
+  console.log(`${snapshot.displayName} graph-theory harness`);
+  console.log(`Family role: ${snapshot.familyRole}`);
+  console.log(`Harness profile: ${snapshot.harnessProfile}`);
+  console.log(`Site status: ${snapshot.siteStatus}`);
+  console.log(`Archive mode: ${snapshot.archiveMode ?? '(none)'}`);
+  console.log(`Active route: ${snapshot.activeRoute ?? '(none)'}`);
+  console.log(`Route breakthrough: ${snapshot.routeBreakthrough ? 'yes' : 'no'}`);
+  console.log(`Open problem: ${snapshot.openProblem ? 'yes' : 'no'}`);
+  console.log(`Problem solved: ${snapshot.problemSolved ? 'yes' : 'no'}`);
+  console.log(`Frontier label: ${snapshot.frontierLabel}`);
+  console.log(`Frontier detail: ${snapshot.frontierDetail}`);
+  console.log(`Checkpoint focus: ${snapshot.checkpointFocus ?? '(none)'}`);
+  console.log(`Next honest move: ${snapshot.nextHonestMove}`);
+  console.log(`Route packet present: ${snapshot.routePacketPresent ? 'yes' : 'no'}`);
+  if (snapshot.routePacket?.route_packet_id) {
+    console.log(`Route packet id: ${snapshot.routePacket.route_packet_id}`);
+  }
+  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(`Active ticket: ${snapshot.activeTicketDetail?.ticket_id ?? '(none)'}`);
+  console.log(`Ready atoms: ${snapshot.readyAtomCount}`);
+  if (snapshot.firstReadyAtom) {
+    console.log(`First ready atom: ${snapshot.firstReadyAtom.atom_id} — ${snapshot.firstReadyAtom.title}`);
+  }
+}
+
+function printFrontier(snapshot) {
+  console.log(`${snapshot.displayName} graph-theory frontier`);
+  console.log(`Active route: ${snapshot.activeRoute ?? '(none)'}`);
+  console.log(`Frontier label: ${snapshot.frontierLabel}`);
+  console.log(`Frontier detail: ${snapshot.frontierDetail}`);
+  console.log(`Archive mode: ${snapshot.archiveMode ?? '(none)'}`);
+  console.log(`Next honest move: ${snapshot.nextHonestMove}`);
+}
+
+function printRoutes(snapshot) {
+  console.log(`${snapshot.displayName} graph-theory routes`);
+  console.log(`Active route: ${snapshot.activeRoute ?? '(none)'}`);
+  if (!snapshot.opsDetails?.routes?.length) {
+    console.log('Routes: none recorded.');
+    return;
+  }
+  for (const route of snapshot.opsDetails.routes) {
+    const flags = [];
+    if (route.route_id === snapshot.activeRoute) {
+      flags.push('active');
+    }
+    if (route.status && !flags.includes(route.status)) {
+      flags.push(route.status);
+    }
+    console.log(`- ${route.route_id}${flags.length ? ` [${flags.join(', ')}]` : ''}`);
+    if (route.title) {
+      console.log(`  title: ${route.title}`);
+    }
+    if (route.summary) {
+      console.log(`  summary: ${route.summary}`);
+    }
+    if (route.why_now) {
+      console.log(`  why now: ${route.why_now}`);
+    }
+    if (route.next_move) {
+      console.log(`  next move: ${route.next_move}`);
+    }
+  }
+}
+
+function printTickets(snapshot) {
+  console.log(`${snapshot.displayName} graph-theory tickets`);
+  console.log(`Active ticket: ${snapshot.activeTicketDetail?.ticket_id ?? '(none)'}`);
+  if (!snapshot.opsDetails?.tickets?.length) {
+    console.log('Tickets: none recorded.');
+    return;
+  }
+  for (const ticket of snapshot.opsDetails.tickets) {
+    const flags = [];
+    if (ticket.ticket_id === snapshot.activeTicketDetail?.ticket_id) {
+      flags.push('active');
+    }
+    if (ticket.status && !flags.includes(ticket.status)) {
+      flags.push(ticket.status);
+    }
+    console.log(`- ${ticket.ticket_id}${flags.length ? ` [${flags.join(', ')}]` : ''}`);
+    if (ticket.title) {
+      console.log(`  title: ${ticket.title}`);
+    }
+    if (ticket.summary) {
+      console.log(`  summary: ${ticket.summary}`);
+    }
+    if (ticket.current_blocker) {
+      console.log(`  blocker: ${ticket.current_blocker}`);
+    }
+    if (ticket.next_move) {
+      console.log(`  next move: ${ticket.next_move}`);
+    }
+  }
+}
+
+export function runGraphTheoryCommand(args) {
+  const [subcommand, ...rest] = args;
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos graph-theory status [<id>] [--json]');
+    console.log('  erdos graph-theory frontier [<id>] [--json]');
+    console.log('  erdos graph-theory routes [<id>] [--json]');
+    console.log('  erdos graph-theory tickets [<id>] [--json]');
+    return 0;
+  }
+  if (!['status', 'frontier', 'routes', 'tickets'].includes(subcommand)) {
+    console.error(`Unknown graph-theory subcommand: ${subcommand}`);
+    return 1;
+  }
+  const parsed = parseArgs(rest);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+  const { problem, error } = resolveGraphTheoryProblem(parsed.problemId);
+  if (error) {
+    console.error(error);
+    return 1;
+  }
+  const snapshot = buildGraphTheoryStatusSnapshot(problem);
+  if (parsed.asJson) {
+    console.log(JSON.stringify(snapshot, null, 2));
+    return 0;
+  }
+  if (subcommand === 'frontier') {
+    printFrontier(snapshot);
+    return 0;
+  }
+  if (subcommand === 'routes') {
+    printRoutes(snapshot);
+    return 0;
+  }
+  if (subcommand === 'tickets') {
+    printTickets(snapshot);
+    return 0;
+  }
+  printStatus(snapshot);
+  return 0;
+}

package/src/commands/number-theory.js

@@ -1,5 +1,10 @@
 import { getProblem } from '../atlas/catalog.js';
-import { buildNumberTheoryStatusSnapshot } from '../runtime/number-theory.js';
+import {
+  buildNumberTheoryStatusSnapshot,
+  getNumberTheoryAtomSnapshot,
+  getNumberTheoryRouteSnapshot,
+  getNumberTheoryTicketSnapshot,
+} from '../runtime/number-theory.js';
 import { readCurrentProblem } from '../runtime/workspace.js';
 
 function resolveNumberTheoryProblem(problemId) {
@@ -24,6 +29,7 @@ function parseArgs(args) {
   const parsed = {
     problemId: null,
     asJson: false,
+    entityId: null,
   };
 
   for (const token of args) {
@@ -35,6 +41,10 @@ function parseArgs(args) {
       parsed.problemId = token;
       continue;
     }
+    if (!parsed.entityId) {
+      parsed.entityId = token;
+      continue;
+    }
     return { error: `Unknown number-theory option: ${token}` };
   }
 
@@ -146,6 +156,44 @@ function printTickets(snapshot) {
   }
 }
 
+function printRouteDetail(snapshot) {
+  const route = snapshot.routeDetail;
+  console.log(`${snapshot.displayName} number-theory route ${snapshot.routeId}`);
+  console.log(`Title: ${route.title ?? snapshot.routeId}`);
+  console.log(`Status: ${route.status ?? '(unknown)'}`);
+  console.log(`Active route: ${route.route_id === snapshot.activeRoute ? 'yes' : 'no'}`);
+  console.log(`Summary: ${route.summary ?? '(none)'}`);
+  console.log(`Why now: ${route.why_now ?? '(none)'}`);
+  console.log(`Next move: ${route.next_move ?? '(none)'}`);
+  if (Array.isArray(route.ticket_ids) && route.ticket_ids.length > 0) {
+    console.log(`Tickets: ${route.ticket_ids.join(', ')}`);
+  }
+}
+
+function printTicketDetail(snapshot) {
+  const ticket = snapshot.ticketDetail;
+  console.log(`${snapshot.displayName} number-theory ticket ${snapshot.ticketId}`);
+  console.log(`Title: ${ticket.title ?? snapshot.ticketId}`);
+  console.log(`Status: ${ticket.status ?? '(unknown)'}`);
+  console.log(`Active ticket: ${ticket.ticket_id === snapshot.activeTicketDetail?.ticket_id ? 'yes' : 'no'}`);
+  console.log(`Summary: ${ticket.summary ?? '(none)'}`);
+  console.log(`Current blocker: ${ticket.current_blocker ?? '(none)'}`);
+  console.log(`Next move: ${ticket.next_move ?? '(none)'}`);
+  if (Array.isArray(ticket.atom_ids) && ticket.atom_ids.length > 0) {
+    console.log(`Atoms: ${ticket.atom_ids.join(', ')}`);
+  }
+}
+
+function printAtomDetail(snapshot) {
+  const atom = snapshot.atomDetail;
+  console.log(`${snapshot.displayName} number-theory atom ${snapshot.atomId}`);
+  console.log(`Title: ${atom.title ?? snapshot.atomId}`);
+  console.log(`Status: ${atom.status ?? '(unknown)'}`);
+  console.log(`Current frontier atom: ${atom.atom_id === snapshot.firstReadyAtom?.atom_id ? 'yes' : 'no'}`);
+  console.log(`Summary: ${atom.summary ?? '(none)'}`);
+  console.log(`Next move: ${atom.next_move ?? '(none)'}`);
+}
+
 export function runNumberTheoryCommand(args) {
   const [subcommand, ...rest] = args;
 
@@ -155,10 +203,13 @@ export function runNumberTheoryCommand(args) {
     console.log('  erdos number-theory frontier [<id>] [--json]');
     console.log('  erdos number-theory routes [<id>] [--json]');
     console.log('  erdos number-theory tickets [<id>] [--json]');
+    console.log('  erdos number-theory route <problem-id> <route-id> [--json]');
+    console.log('  erdos number-theory ticket <problem-id> <ticket-id> [--json]');
+    console.log('  erdos number-theory atom <problem-id> <atom-id> [--json]');
     return 0;
   }
 
-  if (!['status', 'frontier', 'routes', 'tickets'].includes(subcommand)) {
+  if (!['status', 'frontier', 'routes', 'tickets', 'route', 'ticket', 'atom'].includes(subcommand)) {
     console.error(`Unknown number-theory subcommand: ${subcommand}`);
     return 1;
   }
@@ -175,6 +226,60 @@ export function runNumberTheoryCommand(args) {
     return 1;
   }
 
+  if (subcommand === 'route') {
+    if (!parsed.entityId) {
+      console.error('Missing route id.');
+      return 1;
+    }
+    const snapshot = getNumberTheoryRouteSnapshot(problem, parsed.entityId);
+    if (!snapshot) {
+      console.error(`Unknown number-theory route: ${parsed.entityId}`);
+      return 1;
+    }
+    if (parsed.asJson) {
+      console.log(JSON.stringify(snapshot, null, 2));
+      return 0;
+    }
+    printRouteDetail(snapshot);
+    return 0;
+  }
+
+  if (subcommand === 'ticket') {
+    if (!parsed.entityId) {
+      console.error('Missing ticket id.');
+      return 1;
+    }
+    const snapshot = getNumberTheoryTicketSnapshot(problem, parsed.entityId);
+    if (!snapshot) {
+      console.error(`Unknown number-theory ticket: ${parsed.entityId}`);
+      return 1;
+    }
+    if (parsed.asJson) {
+      console.log(JSON.stringify(snapshot, null, 2));
+      return 0;
+    }
+    printTicketDetail(snapshot);
+    return 0;
+  }
+
+  if (subcommand === 'atom') {
+    if (!parsed.entityId) {
+      console.error('Missing atom id.');
+      return 1;
+    }
+    const snapshot = getNumberTheoryAtomSnapshot(problem, parsed.entityId);
+    if (!snapshot) {
+      console.error(`Unknown number-theory atom: ${parsed.entityId}`);
+      return 1;
+    }
+    if (parsed.asJson) {
+      console.log(JSON.stringify(snapshot, null, 2));
+      return 0;
+    }
+    printAtomDetail(snapshot);
+    return 0;
+  }
+
   const snapshot = buildNumberTheoryStatusSnapshot(problem);
   if (parsed.asJson) {
     console.log(JSON.stringify(snapshot, null, 2));

package/src/commands/workspace.js

@@ -1,11 +1,12 @@
 import { getProblem } from '../atlas/catalog.js';
 import { loadConfig } from '../runtime/config.js';
+import { buildGraphTheoryStatusSnapshot } from '../runtime/graph-theory.js';
 import { buildNumberTheoryStatusSnapshot } from '../runtime/number-theory.js';
 import { buildSunflowerStatusSnapshot } from '../runtime/sunflower.js';
 import { getWorkspaceSummary } from '../runtime/workspace.js';
 
 export function runWorkspaceCommand(args) {
-  const [subcommand] = args;
+  const [subcommand, ...rest] = args;
 
   if (!subcommand || subcommand === 'help' || subcommand === '--help') {
     console.log('Usage:');
@@ -18,8 +19,30 @@ export function runWorkspaceCommand(args) {
     return 1;
   }
 
+  const asJson = rest.includes('--json');
+
   const summary = getWorkspaceSummary();
   const config = loadConfig();
+  if (asJson) {
+    const payload = {
+      ...summary,
+      preferredAgent: config.preferredAgent,
+    };
+    if (summary.activeProblem) {
+      const problem = getProblem(summary.activeProblem);
+      if (problem?.cluster === 'sunflower') {
+        payload.sunflower = buildSunflowerStatusSnapshot(problem);
+      }
+      if (problem?.cluster === 'number-theory') {
+        payload.numberTheory = buildNumberTheoryStatusSnapshot(problem);
+      }
+      if (problem?.cluster === 'graph-theory') {
+        payload.graphTheory = buildGraphTheoryStatusSnapshot(problem);
+      }
+    }
+    console.log(JSON.stringify(payload, null, 2));
+    return 0;
+  }
   console.log(`Workspace root: ${summary.workspaceRoot}`);
   console.log(`State dir: ${summary.stateDir}`);
   console.log(`Initialized: ${summary.hasState ? 'yes' : 'no'}`);
@@ -92,6 +115,21 @@ export function runWorkspaceCommand(args) {
         console.log(`Number-theory first ready atom: ${numberTheory.firstReadyAtom.atom_id} — ${numberTheory.firstReadyAtom.title}`);
       }
     }
+    if (problem?.cluster === 'graph-theory') {
+      const graphTheory = buildGraphTheoryStatusSnapshot(problem);
+      console.log(`Graph-theory family role: ${graphTheory.familyRole ?? '(none)'}`);
+      console.log(`Graph-theory harness profile: ${graphTheory.harnessProfile ?? '(none)'}`);
+      console.log(`Graph-theory route: ${graphTheory.activeRoute ?? '(none)'}`);
+      console.log(`Graph-theory frontier: ${graphTheory.frontierDetail ?? '(none)'}`);
+      console.log(`Graph-theory frontier note: ${graphTheory.frontierNotePath ?? '(none)'}`);
+      console.log(`Graph-theory route history: ${graphTheory.routeHistoryPath ?? '(none)'}`);
+      console.log(`Graph-theory archive mode: ${graphTheory.archiveMode ?? '(none)'}`);
+      console.log(`Graph-theory active ticket: ${graphTheory.activeTicketDetail?.ticket_id ?? '(none)'}`);
+      console.log(`Graph-theory ready atoms: ${graphTheory.readyAtomCount}`);
+      if (graphTheory.firstReadyAtom) {
+        console.log(`Graph-theory first ready atom: ${graphTheory.firstReadyAtom.atom_id} — ${graphTheory.firstReadyAtom.title}`);
+      }
+    }
   }
   return 0;
 }

package/src/runtime/graph-theory.js

@@ -0,0 +1,167 @@
+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('graph-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 findRouteDetail(opsDetails, routeId) {
+  if (!opsDetails || !Array.isArray(opsDetails.routes)) {
+    return null;
+  }
+  return opsDetails.routes.find((route) => route.route_id === routeId) ?? null;
+}
+
+function firstMatching(items, predicate) {
+  if (!Array.isArray(items)) {
+    return null;
+  }
+  return items.find(predicate) ?? items[0] ?? null;
+}
+
+function resolveArchiveMode(problem) {
+  const siteStatus = String(problem.siteStatus ?? '').toLowerCase();
+  if (siteStatus === 'solved') {
+    return 'method_exemplar';
+  }
+  if (siteStatus === 'proved' || siteStatus === 'proved (lean)') {
+    return 'proof_archive';
+  }
+  if (siteStatus === 'decidable') {
+    return 'decision_archive';
+  }
+  return null;
+}
+
+function solvedLikeSiteStatus(problem) {
+  const siteStatus = String(problem.siteStatus ?? '').toLowerCase();
+  return siteStatus === 'solved' || siteStatus === 'proved' || siteStatus === 'proved (lean)';
+}
+
+export function buildGraphTheoryStatusSnapshot(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 archiveMode = resolveArchiveMode(problem);
+  const problemSolved = typeof problem.researchState?.problem_solved === 'boolean'
+    ? problem.researchState.problem_solved
+    : solvedLikeSiteStatus(problem);
+  const openProblem = typeof problem.researchState?.open_problem === 'boolean'
+    ? problem.researchState.open_problem
+    : String(problem.siteStatus ?? '').toLowerCase() === 'open';
+  const routeBreakthrough = typeof problem.researchState?.route_breakthrough === 'boolean'
+    ? problem.researchState.route_breakthrough
+    : problemSolved;
+
+  const activeRouteDetail = findRouteDetail(opsDetails, activeRoute) ?? firstMatching(opsDetails?.routes, () => true);
+  const activeTicketDetail = firstMatching(
+    opsDetails?.tickets,
+    (ticket) => ticket.status === 'active' && (!activeRoute || ticket.route_id === activeRoute),
+  );
+  const firstReadyAtom = firstMatching(
+    opsDetails?.atoms,
+    (atom) => atom.status === 'ready' && (!activeRoute || atom.route_id === 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 ?? 'graph_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 ?? 'graph_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
+      ?? 'Freeze the current graph-theory packet without widening status claims.',
+    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/number-theory.js

@@ -39,6 +39,27 @@ function parseOpsDetails(problemId) {
   };
 }
 
+function findRouteDetail(opsDetails, routeId) {
+  if (!opsDetails || !Array.isArray(opsDetails.routes)) {
+    return null;
+  }
+  return opsDetails.routes.find((route) => route.route_id === routeId) ?? null;
+}
+
+function findTicketDetail(opsDetails, ticketId) {
+  if (!opsDetails || !Array.isArray(opsDetails.tickets)) {
+    return null;
+  }
+  return opsDetails.tickets.find((ticket) => ticket.ticket_id === ticketId) ?? null;
+}
+
+function findAtomDetail(opsDetails, atomId) {
+  if (!opsDetails || !Array.isArray(opsDetails.atoms)) {
+    return null;
+  }
+  return opsDetails.atoms.find((atom) => atom.atom_id === atomId) ?? null;
+}
+
 function findActiveRouteDetail(opsDetails, activeRoute) {
   if (!opsDetails || !Array.isArray(opsDetails.routes)) {
     return null;
@@ -167,3 +188,42 @@ export function buildNumberTheoryStatusSnapshot(problem) {
     readyAtomCount: readyAtoms.length,
   };
 }
+
+export function getNumberTheoryRouteSnapshot(problem, routeId) {
+  const snapshot = buildNumberTheoryStatusSnapshot(problem);
+  const routeDetail = findRouteDetail(snapshot.opsDetails, routeId);
+  if (!routeDetail) {
+    return null;
+  }
+  return {
+    ...snapshot,
+    routeId,
+    routeDetail,
+  };
+}
+
+export function getNumberTheoryTicketSnapshot(problem, ticketId) {
+  const snapshot = buildNumberTheoryStatusSnapshot(problem);
+  const ticketDetail = findTicketDetail(snapshot.opsDetails, ticketId);
+  if (!ticketDetail) {
+    return null;
+  }
+  return {
+    ...snapshot,
+    ticketId,
+    ticketDetail,
+  };
+}
+
+export function getNumberTheoryAtomSnapshot(problem, atomId) {
+  const snapshot = buildNumberTheoryStatusSnapshot(problem);
+  const atomDetail = findAtomDetail(snapshot.opsDetails, atomId);
+  if (!atomDetail) {
+    return null;
+  }
+  return {
+    ...snapshot,
+    atomId,
+    atomDetail,
+  };
+}

package/src/runtime/state.js

@@ -1,6 +1,7 @@
 import { getProblem } from '../atlas/catalog.js';
 import { ensureConfig, loadConfig } from './config.js';
 import { fileExists, readJson, writeJson, writeText } from './files.js';
+import { buildGraphTheoryStatusSnapshot } from './graph-theory.js';
 import {
   getWorkspaceQuestionLedgerPath,
   getWorkspaceRoot,
@@ -249,6 +250,36 @@ function deriveProblemSummary(problem) {
     };
   }
 
+  if (problem.cluster === 'graph-theory') {
+    const snapshot = buildGraphTheoryStatusSnapshot(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);
 }