erdos-problems 0.1.11 → 0.1.13

package/README.md

@@ -41,6 +41,8 @@ erdos bootstrap problem 857
 erdos problem artifacts 857 --json
 erdos sunflower status 857
 erdos sunflower board 857
+erdos sunflower routes 857
+erdos sunflower tickets 857
 erdos dossier show 857
 ```
 
@@ -151,6 +153,10 @@ erdos cluster show sunflower
 erdos sunflower status 20
 erdos sunflower status 536
 erdos sunflower board 536
+erdos sunflower ready 857
+erdos sunflower ladder 20
+erdos sunflower routes 857
+erdos sunflower tickets 857
 erdos sunflower board 857
 erdos sunflower status 857 --json
 ```
@@ -172,6 +178,22 @@ erdos sunflower status 857 --json
 - first-principles ladder
 - ready queue
 
+`erdos sunflower ready` surfaces:
+- the current dependency-satisfied ready queue for the active sunflower board
+
+`erdos sunflower ladder` surfaces:
+- the first-principles ladder for the active sunflower board
+
+`erdos sunflower routes` surfaces:
+- the strategic route table for the active sunflower board
+- loose and strict progress for every publicized route
+- which route is the currently active frontier
+
+`erdos sunflower tickets` surfaces:
+- the operational ticket table for the active sunflower board
+- the active ticket, leaf theorem, and gate/atom counts
+- which tickets are closed versus still honest live pressure
+
 ## ORP
 
 `erdos-problems` now ships a bundled Open Research Protocol kit:
@@ -212,6 +234,10 @@ erdos orp show
 erdos orp sync
 erdos sunflower status 857
 erdos sunflower board 857
+erdos sunflower ready 857
+erdos sunflower ladder 857
+erdos sunflower routes 857
+erdos sunflower tickets 857
 erdos sunflower status --json
 erdos dossier show
 erdos upstream show

package/docs/RESEARCH_LOOP.md

@@ -70,6 +70,10 @@ The ORP kit travels with the workspace too:
 For sunflower compute lanes, ORP now sits above `breakthroughs`:
 - `erdos sunflower status <id>` evaluates the packaged compute lane with `breakthroughs`
 - `erdos sunflower board <id>` exposes the packaged atomic or bridge board for the active sunflower problem
+- `erdos sunflower ready <id>` exposes the dependency-satisfied ready queue for the packaged board
+- `erdos sunflower ladder <id>` exposes the first-principles ladder for the packaged board
+- `erdos sunflower routes <id>` exposes the public route table for the packaged board
+- `erdos sunflower tickets <id>` exposes the ticket table for the packaged board
 - the CLI surfaces the selected rung, dispatch action, and the reason compute is admissible
 - this is compute governance and traceability, not an automatic compute launch
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erdos-problems",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "CLI atlas and staged research harness for Paul Erdos problems.",
   "type": "module",
   "bin": {

package/src/cli/index.js

@@ -37,6 +37,10 @@ function printUsage() {
   console.log('  erdos checkpoints sync [--json]');
   console.log('  erdos sunflower status [<id>] [--json]');
   console.log('  erdos sunflower board [<id>] [--json]');
+  console.log('  erdos sunflower ready [<id>] [--json]');
+  console.log('  erdos sunflower ladder [<id>] [--json]');
+  console.log('  erdos sunflower routes [<id>] [--json]');
+  console.log('  erdos sunflower tickets [<id>] [--json]');
   console.log('  erdos dossier show <id>');
   console.log('  erdos upstream show');
   console.log('  erdos upstream sync [--write-package-snapshot]');

package/src/commands/sunflower.js

@@ -29,6 +29,68 @@ function parseBoardArgs(args) {
   return parseStatusArgs(args);
 }
 
+function parseReadyArgs(args) {
+  return parseStatusArgs(args);
+}
+
+function parseLadderArgs(args) {
+  return parseStatusArgs(args);
+}
+
+function parseRoutesArgs(args) {
+  return parseStatusArgs(args);
+}
+
+function parseTicketsArgs(args) {
+  return parseStatusArgs(args);
+}
+
+function getBoard(snapshot) {
+  return snapshot.atomicBoardSummary;
+}
+
+function getBoardActiveRoute(snapshot) {
+  return snapshot.atomicBoardSummary?.activeRoute ?? snapshot.activeRoute ?? null;
+}
+
+function routeProgressLabel(route, snapshot) {
+  const strictClosed = route.strictTotal > 0 && route.strictDone >= route.strictTotal;
+  const looseClosed = route.looseTotal > 0 && route.looseDone >= route.looseTotal;
+  const activeRoute = getBoardActiveRoute(snapshot);
+
+  if (route.route && route.route === activeRoute) {
+    return strictClosed ? 'active, strict-closed' : 'active';
+  }
+
+  if (strictClosed) {
+    return 'strict-closed';
+  }
+
+  if (looseClosed) {
+    return 'loose-closed';
+  }
+
+  return 'open';
+}
+
+function ticketProgressLabel(ticket, snapshot) {
+  const isActive = snapshot.activeTicket?.ticketId === ticket.ticketId;
+
+  if (isActive && ticket.leafStatus === 'done') {
+    return 'active, closed';
+  }
+
+  if (isActive) {
+    return 'active';
+  }
+
+  if (ticket.leafStatus === 'done') {
+    return 'closed';
+  }
+
+  return 'open';
+}
+
 function printSunflowerStatus(snapshot, registryPaths) {
   console.log(`${snapshot.displayName} sunflower harness`);
   console.log(`Title: ${snapshot.title}`);
@@ -185,6 +247,127 @@ function printSunflowerBoard(snapshot) {
   }
 }
 
+function printSunflowerReady(snapshot) {
+  const board = snapshot.atomicBoardSummary;
+  if (!board) {
+    console.log(`${snapshot.displayName} has no packaged sunflower board yet.`);
+    return;
+  }
+
+  console.log(`${snapshot.displayName} sunflower ready queue`);
+  console.log(`Board: ${board.boardTitle}`);
+  console.log(`Active route: ${board.activeRoute ?? '(none)'}`);
+  console.log(`Ready atoms: ${snapshot.readyAtomCount}`);
+  console.log(`Mirage frontiers: ${snapshot.mirageFrontierCount}`);
+
+  if (board.readyQueue.length === 0) {
+    console.log('Ready queue:');
+    console.log('  (none)');
+    return;
+  }
+
+  console.log('Ready queue:');
+  for (const atom of board.readyQueue) {
+    console.log(
+      `  - ${atom.atomId} (${atom.ticketId} / ${atom.gateId} / ${atom.tier ?? 'tier-unknown'} / ${atom.kind ?? 'kind-unknown'}): ${atom.title}`,
+    );
+  }
+}
+
+function printSunflowerLadder(snapshot) {
+  const board = getBoard(snapshot);
+  if (!board) {
+    console.log(`${snapshot.displayName} has no packaged sunflower board yet.`);
+    return;
+  }
+
+  console.log(`${snapshot.displayName} sunflower ladder`);
+  console.log(`Board: ${board.boardTitle}`);
+  console.log(`Active route: ${board.activeRoute ?? '(none)'}`);
+
+  if (board.ladder.length === 0) {
+    console.log('First-principles ladder:');
+    console.log('  (none)');
+    return;
+  }
+
+  console.log('First-principles ladder:');
+  for (const rung of board.ladder) {
+    console.log(`  - ${rung.tier}: ${rung.done}/${rung.total}`);
+  }
+}
+
+function printSunflowerRoutes(snapshot) {
+  const board = getBoard(snapshot);
+  if (!board) {
+    console.log(`${snapshot.displayName} has no packaged sunflower board yet.`);
+    return;
+  }
+
+  console.log(`${snapshot.displayName} sunflower routes`);
+  console.log(`Board: ${board.boardTitle}`);
+  console.log(`Profile: ${board.boardProfile ?? '(none)'}`);
+  console.log(`Active route: ${getBoardActiveRoute(snapshot) ?? '(none)'}`);
+  console.log(`Route breakthrough: ${snapshot.routeBreakthrough ? 'yes' : 'no'}`);
+  console.log(`Frontier claim: ${board.frontierClaim ?? '(none)'}`);
+  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 (board.routeStatus.length === 0) {
+    console.log('Route table:');
+    console.log('  (none)');
+    return;
+  }
+
+  console.log('Route table:');
+  for (const route of board.routeStatus) {
+    console.log(
+      `  - ${route.route} [${routeProgressLabel(route, snapshot)}]: `
+      + `loose ${route.looseDone}/${route.looseTotal}, `
+      + `strict ${route.strictDone}/${route.strictTotal}`,
+    );
+  }
+}
+
+function printSunflowerTickets(snapshot) {
+  const board = getBoard(snapshot);
+  if (!board) {
+    console.log(`${snapshot.displayName} has no packaged sunflower board yet.`);
+    return;
+  }
+
+  const closedTickets = board.tickets.filter((ticket) => ticketProgressLabel(ticket, snapshot) === 'closed').length;
+
+  console.log(`${snapshot.displayName} sunflower tickets`);
+  console.log(`Board: ${board.boardTitle}`);
+  console.log(`Active route: ${getBoardActiveRoute(snapshot) ?? '(none)'}`);
+  console.log(`Active ticket: ${snapshot.activeTicket?.ticketId ?? '(none)'}`);
+  console.log(`Closed tickets: ${closedTickets}/${board.tickets.length}`);
+  console.log(`Ready atoms: ${snapshot.readyAtomCount}`);
+  if (snapshot.firstReadyAtom) {
+    console.log(`First ready atom: ${snapshot.firstReadyAtom.atomId} — ${snapshot.firstReadyAtom.title}`);
+  }
+
+  if (board.tickets.length === 0) {
+    console.log('Ticket table:');
+    console.log('  (none)');
+    return;
+  }
+
+  console.log('Ticket table:');
+  for (const ticket of board.tickets) {
+    console.log(
+      `  - ${ticket.ticketId} ${ticket.ticketName} [${ticketProgressLabel(ticket, snapshot)}]: `
+      + `${ticket.routeLeaf ?? '(none)'} `
+      + `[leaf=${ticket.leafStatus ?? '(none)'}, gates=${ticket.gatesDone}/${ticket.gatesTotal}, `
+      + `atoms=${ticket.atomsDone}/${ticket.atomsTotal}]`,
+    );
+  }
+}
+
 export function runSunflowerCommand(args) {
   const [subcommand, ...rest] = args;
 
@@ -192,15 +375,32 @@ export function runSunflowerCommand(args) {
     console.log('Usage:');
     console.log('  erdos sunflower status [<id>] [--json]');
     console.log('  erdos sunflower board [<id>] [--json]');
+    console.log('  erdos sunflower ready [<id>] [--json]');
+    console.log('  erdos sunflower ladder [<id>] [--json]');
+    console.log('  erdos sunflower routes [<id>] [--json]');
+    console.log('  erdos sunflower tickets [<id>] [--json]');
     return 0;
   }
 
-  if (subcommand !== 'status' && subcommand !== 'board') {
+  if (!['status', 'board', 'ready', 'ladder', 'routes', 'tickets'].includes(subcommand)) {
     console.error(`Unknown sunflower subcommand: ${subcommand}`);
     return 1;
   }
 
-  const parsed = subcommand === 'board' ? parseBoardArgs(rest) : parseStatusArgs(rest);
+  let parsed;
+  if (subcommand === 'board') {
+    parsed = parseBoardArgs(rest);
+  } else if (subcommand === 'ready') {
+    parsed = parseReadyArgs(rest);
+  } else if (subcommand === 'ladder') {
+    parsed = parseLadderArgs(rest);
+  } else if (subcommand === 'routes') {
+    parsed = parseRoutesArgs(rest);
+  } else if (subcommand === 'tickets') {
+    parsed = parseTicketsArgs(rest);
+  } else {
+    parsed = parseStatusArgs(rest);
+  }
   if (parsed.error) {
     console.error(parsed.error);
     return 1;
@@ -236,6 +436,26 @@ export function runSunflowerCommand(args) {
     return 0;
   }
 
+  if (subcommand === 'ready') {
+    printSunflowerReady(snapshot);
+    return 0;
+  }
+
+  if (subcommand === 'ladder') {
+    printSunflowerLadder(snapshot);
+    return 0;
+  }
+
+  if (subcommand === 'routes') {
+    printSunflowerRoutes(snapshot);
+    return 0;
+  }
+
+  if (subcommand === 'tickets') {
+    printSunflowerTickets(snapshot);
+    return 0;
+  }
+
   printSunflowerStatus(snapshot, registryPaths);
   return 0;
 }

package/src/runtime/checkpoints.js

@@ -83,6 +83,15 @@ function renderRouteCheckpoint(problem, state) {
   const frontier = sunflower?.frontierDetail ?? state.currentFrontier.detail;
   const routeStory = sunflower?.routeStory ?? state.routeStory ?? '(none yet)';
   const checkpointFocus = sunflower?.checkpointFocus ?? state.checkpointFocus ?? '(none yet)';
+  const activeTicketLine = sunflower?.activeTicket
+    ? `- Active Ticket: ${sunflower.activeTicket.ticketId} ${sunflower.activeTicket.ticketName} [gates=${sunflower.activeTicket.gatesDone}/${sunflower.activeTicket.gatesTotal}, atoms=${sunflower.activeTicket.atomsDone}/${sunflower.activeTicket.atomsTotal}]`
+    : '- Active Ticket: *(none packaged)*';
+  const readyAtomLine = sunflower?.firstReadyAtom
+    ? `- First Ready Atom: ${sunflower.firstReadyAtom.atomId} — ${sunflower.firstReadyAtom.title}`
+    : '- First Ready Atom: *(none)*';
+  const mirageLine = sunflower
+    ? `- Mirage Frontiers: ${sunflower.mirageFrontierCount}`
+    : null;
 
   return `# Problem ${problem.problemId} Active Route Checkpoint
 
@@ -96,6 +105,9 @@ function renderRouteCheckpoint(problem, state) {
 ## Current Frontier
 
 - ${frontier}
+${activeTicketLine}
+${readyAtomLine}
+${mirageLine ? `\n${mirageLine}` : ''}
 
 ## Route Story
 

package/src/runtime/state.js

@@ -158,6 +158,22 @@ function deriveGenericProblemSummary(problem) {
 function deriveProblemSummary(problem) {
   if (problem.cluster === 'sunflower') {
     const sunflower = buildSunflowerStatusSnapshot(problem);
+    const frontierKind = sunflower.firstReadyAtom
+      ? 'ready_atom'
+      : sunflower.atomicBoardPresent
+        ? 'atomic_board'
+        : sunflower.activePacket
+          ? 'compute_lane'
+          : (sunflower.frontierLabel ? 'route_frontier' : 'pack_context');
+    const frontierDetail = sunflower.firstReadyAtom
+      ? `${sunflower.firstReadyAtom.atomId} — ${sunflower.firstReadyAtom.title}`
+      : 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);
+    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);
     return {
       familyRole: sunflower.familyRole,
       harnessProfile: sunflower.harnessProfile,
@@ -166,11 +182,11 @@ function deriveProblemSummary(problem) {
       problemSolved: sunflower.problemSolved,
       openProblem: sunflower.openProblem,
       currentFrontier: {
-        kind: sunflower.activePacket ? 'compute_lane' : (sunflower.frontierLabel ? 'route_frontier' : 'pack_context'),
-        detail: sunflower.frontierDetail || sunflower.computeSummary || sunflower.bootstrapFocus || problem.shortStatement,
+        kind: frontierKind,
+        detail: frontierDetail,
       },
-      routeStory: sunflower.routeStory || sunflower.bootstrapFocus || null,
-      checkpointFocus: sunflower.checkpointFocus || null,
+      routeStory,
+      checkpointFocus,
       nextHonestMove: sunflower.nextHonestMove || sunflower.computeNextAction || 'Refresh the active route and package a new honest checkpoint.',
       questionLedger: sunflower.questionLedger,
     };