erdos-problems 0.2.1 → 0.2.2

package/README.md

@@ -22,6 +22,8 @@ Official binary:
 - workspace `.erdos/` state for active-problem selection, upstream refreshes, scaffolds, and pull bundles
 - sunflower cluster as the first deep harness pack
 - quartet-aware sunflower context for `20`, `536`, `856`, and `857`
+- number-theory starter cockpit as the first lighter non-sunflower pack
+- graph-theory archive cockpit as the first archive/decision pack outside sunflower
 - packaged atomic/bridge board packets for the full sunflower quartet
 - packaged compute-lane metadata for deep sunflower problems, surfaced directly in the CLI
 - seeded atlas now includes open and solved problems beyond sunflower
@@ -36,6 +38,7 @@ Native dossier count:
 Pack coverage:
 - sunflower pack: `4`
 - number-theory starter cockpit: `2`
+- graph-theory archive cockpit: `3`
 
 ## First-run flow
 
@@ -50,6 +53,7 @@ erdos sunflower routes 857
 erdos sunflower tickets 857
 erdos dossier show 857
 erdos number-theory status 1
+erdos graph-theory status 1008
 ```
 
 For an unseeded problem, the one-step self-seeding flow is now:
@@ -254,6 +258,9 @@ erdos number-theory status 1
 erdos number-theory frontier 1
 erdos number-theory routes 1
 erdos number-theory tickets 1
+erdos number-theory route 1 distinct_subset_sum_lower_bound
+erdos number-theory ticket 1 N1
+erdos number-theory atom 1 N1.G1.A1
 erdos number-theory status 2 --json
 ```
 
@@ -262,6 +269,28 @@ The number-theory pack is intentionally lighter than sunflower:
 - explicit route/frontier/ticket packet layer
 - honest archive posture for disproved problems
 
+## Graph-theory archive cockpit
+
+The next family pack is a deliberately honest archive/decision cockpit for seeded graph-theory problems:
+- `19`: decision archive cockpit
+- `22`: proof archive cockpit
+- `1008`: Lean-facing proof archive cockpit
+
+Useful graph-theory commands:
+
+```bash
+erdos graph-theory status 19
+erdos graph-theory frontier 22
+erdos graph-theory routes 1008
+erdos graph-theory tickets 1008
+erdos graph-theory status 1008 --json
+```
+
+The graph-theory pack is intentionally archive-first:
+- no fake open frontier for solved or decided problems
+- route/ticket packets exist to preserve archive discipline, not to cosplay theorem pressure
+- the public job is to keep solved/decided records reusable as method exemplars and clean references
+
 ## Archive mode
 
 Solved problems can now be treated as method exemplars instead of dead entries.
@@ -320,7 +349,9 @@ erdos problem artifacts 857 --json
 erdos cluster list
 erdos cluster show sunflower
 erdos cluster show number-theory
+erdos cluster show graph-theory
 erdos workspace show
+erdos workspace show --json
 erdos orp show
 erdos orp sync
 erdos sunflower status 857
@@ -338,6 +369,13 @@ erdos number-theory status 1
 erdos number-theory frontier 1
 erdos number-theory routes 1
 erdos number-theory tickets 1
+erdos number-theory route 1 distinct_subset_sum_lower_bound
+erdos number-theory ticket 1 N1
+erdos number-theory atom 1 N1.G1.A1
+erdos graph-theory status 1008
+erdos graph-theory frontier 22
+erdos graph-theory routes 1008
+erdos graph-theory tickets 19
 erdos sunflower status --json
 erdos dossier show
 erdos upstream show
@@ -404,8 +442,15 @@ For number-theory starter-cockpit problems, the CLI now also surfaces:
 - pack README context
 - per-problem context files under `packs/number-theory/problems/<id>/`
 - route packets, frontier notes, route histories, checkpoint/report templates, and ops-detail packets
+- route/ticket/atom drill-down packets through `erdos number-theory route|ticket|atom`
 - archive posture for disproved problems through `erdos number-theory status`
 
+For graph-theory archive-cockpit problems, the CLI now also surfaces:
+- pack README context
+- per-problem context files under `packs/graph-theory/problems/<id>/`
+- route packets, frontier notes, route histories, checkpoint/report templates, and ops-detail packets
+- archive and decision posture through `erdos graph-theory status|frontier|routes|tickets`
+
 ## Notes
 
 - `erdos-problems` is the canonical npm package name.

package/package.json

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

package/packs/graph-theory/README.md

@@ -0,0 +1,17 @@
+# Graph-Theory Pack
+
+Archive and decision cockpit for graph-theory problems in `erdos-problems`.
+
+Current seeded cockpit problems:
+- `19`: decision/archive cockpit around the chromatic-number record
+- `22`: proof archive cockpit around the Ramsey-Turan `K_4` construction record
+- `1008`: Lean-facing proof archive cockpit for the `C_4`-free density problem
+
+Useful commands:
+- `erdos graph-theory status 19`
+- `erdos graph-theory frontier 22`
+- `erdos graph-theory routes 1008`
+- `erdos graph-theory tickets 1008`
+
+Design rule:
+- keep this pack honest as an archive/decision cockpit until a real open graph-theory frontier earns deeper gated flow

package/packs/graph-theory/problems/1008/CHECKPOINT_TEMPLATE.md

@@ -0,0 +1,9 @@
+# Problem 1008 Checkpoint Template
+
+## Lean Archive
+- Solved status wording:
+- Lean-facing artifact frozen:
+- Archive drift risk:
+
+## Next Honest Move
+- 

package/packs/graph-theory/problems/1008/CONTEXT.md

@@ -0,0 +1,9 @@
+# Problem 1008 Graph-Theory Pack Context
+
+Role in pack:
+- Lean-facing proof archive for the `C_4`-free density problem
+- solved graph-theory cockpit rather than a live open frontier
+
+Bootstrap focus:
+- preserve the solved status and Lean-facing badge
+- keep the extremal-graph question and archive references synchronized

package/packs/graph-theory/problems/1008/FRONTIER_NOTE.md

@@ -0,0 +1,8 @@
+# Problem 1008 Frontier Note
+
+Problem 1008 is packaged as a Lean-facing proof archive.
+
+Current honest posture:
+- preserve the solved public record
+- keep the `C_4`-free density framing explicit
+- treat improvements here as archive or method-exemplar work, not open-frontier work

package/packs/graph-theory/problems/1008/OPS_DETAILS.yaml

@@ -0,0 +1,25 @@
+packet_id: gt1008_ops_details_v1
+summary: Lean-facing proof archive cockpit packet for the `C_4`-free density result.
+routes:
+  - route_id: c4_free_lean_archive
+    title: "`C_4`-Free Lean Proof Archive"
+    status: closed
+    summary: Keep the solved `C_4`-free density record explicit and preserve the Lean-facing archive posture.
+    why_now: This is the honest archive framing for Problem 1008.
+    next_move: Freeze the best Lean-facing source hook and checkpoint the archive packet.
+tickets:
+  - ticket_id: G1008
+    title: "Tighten the `C_4`-free Lean archive packet"
+    route_id: c4_free_lean_archive
+    status: active
+    summary: Package the solved record clearly enough that the archive stays usable as a method exemplar.
+    current_blocker: The archive still needs a sharper Lean-facing source hook.
+    next_move: Close `G1008.G1.A1`.
+atoms:
+  - atom_id: G1008.G1.A1
+    title: "Freeze the primary Lean-facing archive hook for the `C_4`-free density result"
+    route_id: c4_free_lean_archive
+    ticket_id: G1008
+    status: ready
+    summary: This is the smallest honest archive move for Problem 1008.
+    next_move: Record the best public/formalization hook and checkpoint the archive packet.

package/packs/graph-theory/problems/1008/REPORT_TEMPLATE.md

@@ -0,0 +1,9 @@
+# Problem 1008 Report Template
+
+## Archive Summary
+- Lean archive status:
+- Source alignment:
+- Reusable method note:
+
+## Follow-up
+- 

package/packs/graph-theory/problems/1008/ROUTE_HISTORY.md

@@ -0,0 +1,5 @@
+# Problem 1008 Route History
+
+- Initial public pack lift: moved the dossier into a graph-theory Lean archive cockpit.
+- Current route: `c4_free_lean_archive`.
+- Honest next improvement: freeze the best Lean-facing source hook and checkpoint the archive packet.

package/packs/graph-theory/problems/1008/ROUTE_PACKET.yaml

@@ -0,0 +1,13 @@
+route_packet_id: gt1008_c4_free_lean_archive_v1
+route_id: c4_free_lean_archive
+frontier_claim: Preserve the solved `C_4`-free density record as a Lean-facing archive packet and keep the source trail synchronized with the dossier.
+theorem_module: ""
+checkpoint_packet: CHECKPOINT_TEMPLATE.md
+report_packet: REPORT_TEMPLATE.md
+ready_prompts:
+  - Which exact source or formalization hook should anchor the Lean archive packet first?
+  - Which wording best preserves the solved posture without inflating the public claim?
+verification_hook:
+  - erdos graph-theory status 1008
+  - erdos archive show 1008 --json
+  - erdos archive scaffold 1008 --json

package/packs/graph-theory/problems/1008/context.yaml

@@ -0,0 +1,27 @@
+problem_id: "1008"
+family_role: c4_free_lean_archive
+harness_profile: lean_archive_cockpit
+default_active_route: c4_free_lean_archive
+bootstrap_focus: Freeze the `C_4`-free density result as a Lean-facing archive packet and keep the solved status synchronized with the public dossier.
+route_story: Problem 1008 is a formalization-flavored proof archive. The public job is to preserve the solved record, the Lean-facing posture, and the core extremal-graph framing without re-opening a closed problem.
+frontier_label: c4_free_lean_archive
+frontier_detail: Preserve the Lean-facing solved record and the `C_4`-free density framing without widening the claim beyond the public dossier.
+checkpoint_focus: Keep the solved status, Lean-facing archive wording, and main source trail synchronized.
+next_honest_move: Tighten the Lean proof archive note and freeze the best public/formalization source hook for the `C_4`-free density result.
+related_core_problems: []
+literature_focus:
+  - graph theory
+  - extremal graph theory
+  - formalization
+artifact_focus:
+  - STATEMENT.md
+  - REFERENCES.md
+  - FORMALIZATION.md
+question_ledger:
+  open_questions:
+    - Which exact Lean-facing artifact should anchor the archive packet first?
+  active_route_notes:
+    - Treat Problem 1008 as a solved Lean archive, not as a live frontier.
+  route_breakthroughs: []
+  problem_solved:
+    - The public site marks this problem as solved with a Lean-facing badge.

package/packs/graph-theory/problems/19/CHECKPOINT_TEMPLATE.md

@@ -0,0 +1,9 @@
+# Problem 19 Checkpoint Template
+
+## Decision Archive
+- Exact decision posture:
+- Primary source frozen:
+- Public wording preserved:
+
+## Next Honest Move
+- 

package/packs/graph-theory/problems/19/CONTEXT.md

@@ -0,0 +1,9 @@
+# Problem 19 Graph-Theory Pack Context
+
+Role in pack:
+- chromatic-number decision archive
+- graph-theory archive cockpit rather than a live theorem frontier today
+
+Bootstrap focus:
+- keep the public decision posture explicit
+- preserve the best source trail for the record

package/packs/graph-theory/problems/19/FRONTIER_NOTE.md

@@ -0,0 +1,8 @@
+# Problem 19 Frontier Note
+
+This is an archive-facing graph-theory packet.
+
+Current honest posture:
+- preserve the public decision status
+- keep the chromatic-number framing explicit
+- do not re-inflate the dossier into an open-problem cockpit

package/packs/graph-theory/problems/19/OPS_DETAILS.yaml

@@ -0,0 +1,25 @@
+packet_id: gt19_ops_details_v1
+summary: Decision/archive cockpit packet for the chromatic-number record.
+routes:
+  - route_id: chromatic_decision_record
+    title: Chromatic Decision Record
+    status: archival
+    summary: Keep the public decision posture and chromatic-number framing synchronized.
+    why_now: This is the honest archive framing for Problem 19 today.
+    next_move: Freeze the best source hook describing the decision record.
+tickets:
+  - ticket_id: G19
+    title: Tighten the chromatic decision archive packet
+    route_id: chromatic_decision_record
+    status: active
+    summary: Package the decision record clearly enough that future agents do not misread the dossier.
+    current_blocker: The primary source hook for the decision posture is still too loose.
+    next_move: Close `G19.G1.A1`.
+atoms:
+  - atom_id: G19.G1.A1
+    title: Freeze the primary chromatic-number decision source hook
+    route_id: chromatic_decision_record
+    ticket_id: G19
+    status: ready
+    summary: This is the smallest honest archive move for Problem 19.
+    next_move: Record the strongest public source hook and checkpoint the archive packet.

package/packs/graph-theory/problems/19/REPORT_TEMPLATE.md

@@ -0,0 +1,9 @@
+# Problem 19 Report Template
+
+## Archive Summary
+- Decision posture:
+- Source alignment:
+- Drift risk:
+
+## Follow-up
+- 

package/packs/graph-theory/problems/19/ROUTE_HISTORY.md

@@ -0,0 +1,5 @@
+# Problem 19 Route History
+
+- Initial public pack lift: moved the dossier into a graph-theory decision archive cockpit.
+- Current route: `chromatic_decision_record`.
+- Honest next improvement: freeze the best source explaining the decision posture and checkpoint it.

package/packs/graph-theory/problems/19/ROUTE_PACKET.yaml

@@ -0,0 +1,13 @@
+route_packet_id: gt19_chromatic_decision_archive_v1
+route_id: chromatic_decision_record
+frontier_claim: Preserve the chromatic-number decision record as a clean archive packet and keep the source trail synchronized with the dossier.
+theorem_module: ""
+checkpoint_packet: CHECKPOINT_TEMPLATE.md
+report_packet: REPORT_TEMPLATE.md
+ready_prompts:
+  - Which exact source or note should anchor the decision archive first?
+  - Which wording most clearly prevents future agents from treating this as an open frontier?
+verification_hook:
+  - erdos graph-theory status 19
+  - erdos graph-theory tickets 19
+  - erdos archive show 19 --json

package/packs/graph-theory/problems/19/context.yaml

@@ -0,0 +1,25 @@
+problem_id: "19"
+family_role: chromatic_number_decision_archive
+harness_profile: decision_archive_cockpit
+default_active_route: chromatic_decision_record
+bootstrap_focus: Freeze the exact chromatic-number decision posture, the dossier provenance, and the archive packet without drifting back into open-problem language.
+route_story: Problem 19 is currently best treated as a decision/archive cockpit. The public job is to preserve the decision record and its references cleanly enough that future agents do not mis-handle it as a live open frontier.
+frontier_label: chromatic_decision_record
+frontier_detail: Keep the decision posture and the primary chromatic-number source trail explicit.
+checkpoint_focus: Synchronize the public decision status, archive packet, and primary references every time this dossier is touched.
+next_honest_move: Tighten the decision archive note and freeze the best public-facing source hook for the chromatic-number record.
+related_core_problems: []
+literature_focus:
+  - graph theory
+  - chromatic number
+artifact_focus:
+  - STATEMENT.md
+  - REFERENCES.md
+  - EVIDENCE.md
+question_ledger:
+  open_questions:
+    - Which exact source best explains why the public record marks this problem as decidable?
+  active_route_notes:
+    - Treat Problem 19 as a decision archive, not as a live open frontier.
+  route_breakthroughs: []
+  problem_solved: []

package/packs/graph-theory/problems/22/CHECKPOINT_TEMPLATE.md

@@ -0,0 +1,9 @@
+# Problem 22 Checkpoint Template
+
+## Proof Archive
+- Solved status wording:
+- Primary proof source frozen:
+- Archive drift risk:
+
+## Next Honest Move
+- 

package/packs/graph-theory/problems/22/CONTEXT.md

@@ -0,0 +1,9 @@
+# Problem 22 Graph-Theory Pack Context
+
+Role in pack:
+- Ramsey-Turan proof archive
+- solved graph-theory cockpit rather than a live open frontier
+
+Bootstrap focus:
+- preserve the solved status cleanly
+- keep the extremal-graph framing and reference trail synchronized

package/packs/graph-theory/problems/22/FRONTIER_NOTE.md

@@ -0,0 +1,8 @@
+# Problem 22 Frontier Note
+
+Problem 22 is packaged as a proof archive.
+
+Current honest posture:
+- preserve the public solved status
+- keep the Ramsey-Turan framing explicit
+- treat improvements here as archive clarification, not live frontier pressure

package/packs/graph-theory/problems/22/OPS_DETAILS.yaml

@@ -0,0 +1,25 @@
+packet_id: gt22_ops_details_v1
+summary: Proof archive cockpit packet for the Ramsey-Turan `K_4` record.
+routes:
+  - route_id: ramsey_turan_k4_archive
+    title: Ramsey-Turan `K_4` Proof Archive
+    status: archival
+    summary: Keep the solved Ramsey-Turan record explicit and preserve the extremal-graph proof framing.
+    why_now: This is the honest public posture for Problem 22.
+    next_move: Freeze the strongest proof reference and checkpoint the archive packet.
+tickets:
+  - ticket_id: G22
+    title: Tighten the Ramsey-Turan proof archive packet
+    route_id: ramsey_turan_k4_archive
+    status: active
+    summary: Package the solved record clearly enough that agents cannot mistake it for an open frontier.
+    current_blocker: The archive still needs a stronger primary proof hook.
+    next_move: Close `G22.G1.A1`.
+atoms:
+  - atom_id: G22.G1.A1
+    title: Freeze the primary solved-reference hook for the Ramsey-Turan record
+    route_id: ramsey_turan_k4_archive
+    ticket_id: G22
+    status: ready
+    summary: This is the smallest honest archive move for Problem 22.
+    next_move: Record the strongest public proof hook and checkpoint the archive packet.

package/packs/graph-theory/problems/22/REPORT_TEMPLATE.md

@@ -0,0 +1,9 @@
+# Problem 22 Report Template
+
+## Archive Summary
+- Proof archive status:
+- Source alignment:
+- Remaining clarification work:
+
+## Follow-up
+- 

package/packs/graph-theory/problems/22/ROUTE_HISTORY.md

@@ -0,0 +1,5 @@
+# Problem 22 Route History
+
+- Initial public pack lift: moved the dossier into a graph-theory proof archive cockpit.
+- Current route: `ramsey_turan_k4_archive`.
+- Honest next improvement: freeze the best source trail and keep the solved wording maximally clear.

package/packs/graph-theory/problems/22/ROUTE_PACKET.yaml

@@ -0,0 +1,13 @@
+route_packet_id: gt22_ramsey_turan_proof_archive_v1
+route_id: ramsey_turan_k4_archive
+frontier_claim: Preserve the solved Ramsey-Turan `K_4` record as a proof archive packet and keep the strongest reference trail explicit.
+theorem_module: ""
+checkpoint_packet: CHECKPOINT_TEMPLATE.md
+report_packet: REPORT_TEMPLATE.md
+ready_prompts:
+  - Which exact proof reference should anchor the archive packet first?
+  - Which wording best prevents agents from drifting back into open-problem language here?
+verification_hook:
+  - erdos graph-theory status 22
+  - erdos graph-theory frontier 22
+  - erdos archive show 22 --json

package/packs/graph-theory/problems/22/context.yaml

@@ -0,0 +1,26 @@
+problem_id: "22"
+family_role: ramsey_turan_proof_archive
+harness_profile: proof_archive_cockpit
+default_active_route: ramsey_turan_k4_archive
+bootstrap_focus: Freeze the solved Ramsey-Turan `K_4` record as a proof archive and keep its dossier wording aligned with the public solved status.
+route_story: Problem 22 is a proof archive cockpit. The public job is to preserve the solved status, the Ramsey-Turan framing, and the main source trail without pretending there is a live frontier here.
+frontier_label: ramsey_turan_k4_archive
+frontier_detail: Preserve the affirmative proof posture and the extremal graph framing without blurring it into an open program.
+checkpoint_focus: Keep the proof archive wording, the public solved status, and the main source trail synchronized.
+next_honest_move: Tighten the Ramsey-Turan proof archive note and freeze the strongest source hook for the solved record.
+related_core_problems: []
+literature_focus:
+  - graph theory
+  - Ramsey-Turan theory
+artifact_focus:
+  - STATEMENT.md
+  - REFERENCES.md
+  - EVIDENCE.md
+question_ledger:
+  open_questions:
+    - Which exact reference should anchor the proof archive packet first?
+  active_route_notes:
+    - Treat Problem 22 as a proof archive, not as a live open cockpit.
+  route_breakthroughs: []
+  problem_solved:
+    - The public site marks this problem as proved.

package/packs/number-theory/README.md

@@ -11,6 +11,9 @@ Useful commands:
 - `erdos number-theory frontier 1`
 - `erdos number-theory routes 1`
 - `erdos number-theory tickets 1`
+- `erdos number-theory route 1 distinct_subset_sum_lower_bound`
+- `erdos number-theory ticket 1 N1`
+- `erdos number-theory atom 1 N1.G1.A1`
 - `erdos number-theory status 2 --json`
 
 Design rule:

package/src/cli/index.js

@@ -4,6 +4,7 @@ import { runCheckpointsCommand } from '../commands/checkpoints.js';
 import { runClusterCommand } from '../commands/cluster.js';
 import { runContinuationCommand } from '../commands/continuation.js';
 import { runDossierCommand } from '../commands/dossier.js';
+import { runGraphTheoryCommand } from '../commands/graph-theory.js';
 import { runMaintainerCommand } from '../commands/maintainer.js';
 import { runNumberTheoryCommand } from '../commands/number-theory.js';
 import { runOrpCommand } from '../commands/orp.js';
@@ -26,15 +27,22 @@ function printUsage() {
   console.log('  erdos problem use <id>');
   console.log('  erdos problem current');
   console.log('  erdos problem artifacts [<id>] [--json]');
-  console.log('  erdos cluster list');
-  console.log('  erdos cluster show <name>');
-  console.log('  erdos archive show <id>');
-  console.log('  erdos archive scaffold <id>');
+  console.log('  erdos cluster list [--json]');
+  console.log('  erdos cluster show <name> [--json]');
+  console.log('  erdos archive show <id> [--json]');
+  console.log('  erdos archive scaffold <id> [--json]');
+  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]');
   console.log('  erdos number-theory status [<id>] [--json]');
   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 workspace show');
+  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]');
+  console.log('  erdos workspace show [--json]');
   console.log('  erdos orp show [--json]');
   console.log('  erdos orp sync [--json]');
   console.log('  erdos state sync [--json]');
@@ -82,6 +90,8 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = runClusterCommand(rest);
 } else if (command === 'archive') {
   exitCode = runArchiveCommand(rest);
+} else if (command === 'graph-theory') {
+  exitCode = runGraphTheoryCommand(rest);
 } else if (command === 'number-theory') {
   exitCode = runNumberTheoryCommand(rest);
 } else if (command === 'workspace') {

package/src/commands/archive.js

@@ -1,7 +1,8 @@
 import { getArchiveView, scaffoldArchive } from '../runtime/archive.js';
 
 export function runArchiveCommand(args) {
-  const [subcommand, problemId] = args;
+  const [subcommand, problemId, ...rest] = args;
+  const asJson = rest.includes('--json');
 
   if (!subcommand || subcommand === 'help' || subcommand === '--help') {
     console.log('Usage:');
@@ -21,6 +22,10 @@ export function runArchiveCommand(args) {
       console.error(`Unknown problem: ${problemId}`);
       return 1;
     }
+    if (asJson) {
+      console.log(JSON.stringify(archive, null, 2));
+      return 0;
+    }
     console.log(`${archive.displayName} archive view`);
     console.log(`Title: ${archive.title}`);
     console.log(`Solved: ${archive.solved ? 'yes' : 'no'}`);
@@ -32,6 +37,10 @@ export function runArchiveCommand(args) {
   if (subcommand === 'scaffold') {
     try {
       const result = scaffoldArchive(problemId);
+      if (asJson) {
+        console.log(JSON.stringify(result, null, 2));
+        return 0;
+      }
       console.log(`Archive scaffold created: ${result.archiveDir}`);
       console.log(`Archive mode: ${result.payload.archiveMode}`);
       return 0;

package/src/commands/cluster.js

@@ -14,11 +14,16 @@ function printCluster(cluster) {
     console.log('  Open starter cockpit: 1');
     console.log('  Counterexample/archive cockpit: 2');
     console.log('  Additional dossier seeds: 3, 4, 5, 6, 7, 18, 542');
+  } else if (cluster.name === 'graph-theory') {
+    console.log('  Decision archive cockpit: 19');
+    console.log('  Proof archive cockpit: 22');
+    console.log('  Lean proof archive cockpit: 1008');
   }
 }
 
 export function runClusterCommand(args) {
-  const [subcommand, value] = args;
+  const [subcommand, value, ...rest] = args;
+  const asJson = [value, ...rest].includes('--json');
 
   if (!subcommand || subcommand === 'help' || subcommand === '--help') {
     console.log('Usage:');
@@ -28,6 +33,10 @@ export function runClusterCommand(args) {
   }
 
   if (subcommand === 'list') {
+    if (asJson) {
+      console.log(JSON.stringify(listClusters(), null, 2));
+      return 0;
+    }
     console.log('Clusters:');
     for (const cluster of listClusters()) {
       console.log(`- ${cluster.name}: ${cluster.problems.length} problems, ${cluster.deepHarnessProblems.length} deep-harness`);
@@ -51,6 +60,11 @@ export function runClusterCommand(args) {
     return 1;
   }
 
+  if (asJson) {
+    console.log(JSON.stringify(cluster, null, 2));
+    return 0;
+  }
+
   printCluster(cluster);
   return 0;
 }

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);
 }