erdos-problems 0.1.12 → 0.2.0

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) {
@@ -37,6 +44,125 @@ function parseLadderArgs(args) {
   return parseStatusArgs(args);
 }
 
+function parseRoutesArgs(args) {
+  return parseStatusArgs(args);
+}
+
+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;
+}
+
+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 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}`);
@@ -86,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}`);
@@ -221,7 +351,7 @@ function printSunflowerReady(snapshot) {
 }
 
 function printSunflowerLadder(snapshot) {
-  const board = snapshot.atomicBoardSummary;
+  const board = getBoard(snapshot);
   if (!board) {
     console.log(`${snapshot.displayName} has no packaged sunflower board yet.`);
     return;
@@ -243,6 +373,195 @@ function printSunflowerLadder(snapshot) {
   }
 }
 
+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}]`,
+    );
+  }
+}
+
+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;
 
@@ -252,10 +571,17 @@ export function runSunflowerCommand(args) {
     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 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'].includes(subcommand)) {
+  if (!['status', 'board', 'ready', 'ladder', 'routes', 'tickets', 'frontier', 'route', 'ticket', 'atom', 'compute'].includes(subcommand)) {
     console.error(`Unknown sunflower subcommand: ${subcommand}`);
     return 1;
   }
@@ -267,29 +593,107 @@ export function runSunflowerCommand(args) {
     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 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);
@@ -315,6 +719,21 @@ export function runSunflowerCommand(args) {
     return 0;
   }
 
+  if (subcommand === 'routes') {
+    printSunflowerRoutes(snapshot);
+    return 0;
+  }
+
+  if (subcommand === 'tickets') {
+    printSunflowerTickets(snapshot);
+    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

@@ -38,6 +38,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 +60,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)'}`);