erdos-problems 0.2.0 → 0.2.1

package/README.md

@@ -35,7 +35,7 @@ Native dossier count:
 
 Pack coverage:
 - sunflower pack: `4`
-- number-theory starter pack: `2`
+- number-theory starter cockpit: `2`
 
 ## First-run flow
 
@@ -49,6 +49,7 @@ erdos sunflower frontier 857
 erdos sunflower routes 857
 erdos sunflower tickets 857
 erdos dossier show 857
+erdos number-theory status 1
 ```
 
 For an unseeded problem, the one-step self-seeding flow is now:
@@ -97,6 +98,7 @@ For any problem number in the upstream snapshot, you can create a workspace bund
 erdos pull problem 857
 erdos pull artifacts 857
 erdos pull literature 857
+erdos pull literature 857 --json
 erdos pull literature 857 --include-crossref --include-openalex
 erdos pull problem 999 --include-site --include-public-search
 erdos pull problem 999 --refresh-upstream
@@ -121,6 +123,7 @@ What the pull lanes do:
 - when `--include-openalex` is used, the literature lane also includes:
   - `OPENALEX_RESULTS.json`
   - `OPENALEX_RESULTS.md`
+- when `--json` is used, the pull command emits an agent-friendly machine summary instead of prose
 
 ## Maintainer seeding
 
@@ -164,8 +167,8 @@ The first deep pack is the sunflower quartet:
 Sunflower problems now ship pack packets:
 - `20`: `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `FRONTIER_NOTE.md`, `ROUTE_HISTORY.md`, `CHECKPOINT_TEMPLATE.md`, `REPORT_TEMPLATE.md`, `OPS_DETAILS.yaml`
 - `857`: `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `FRONTIER_NOTE.md`, `ROUTE_HISTORY.md`, `CHECKPOINT_TEMPLATE.md`, `REPORT_TEMPLATE.md`, `OPS_DETAILS.yaml`
-- `536`: `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `OPS_DETAILS.yaml`
-- `856`: `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `OPS_DETAILS.yaml`
+- `536`: `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `FRONTIER_NOTE.md`, `ROUTE_HISTORY.md`, `CHECKPOINT_TEMPLATE.md`, `REPORT_TEMPLATE.md`, `OPS_DETAILS.yaml`
+- `856`: `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `FRONTIER_NOTE.md`, `ROUTE_HISTORY.md`, `CHECKPOINT_TEMPLATE.md`, `REPORT_TEMPLATE.md`, `OPS_DETAILS.yaml`
 
 Useful sunflower commands:
 
@@ -238,6 +241,27 @@ erdos sunflower status 857 --json
 - records governance and ORP-facing packet context
 - does not silently escalate into paid or unbounded compute
 
+## Number-theory starter cockpit
+
+The first non-sunflower pack is now a light but real cockpit for two number-theory problems:
+- `1`: open starter cockpit around a distinct-subset-sum lower-bound route
+- `2`: archive cockpit around a disproved / counterexample-facing record
+
+Useful number-theory commands:
+
+```bash
+erdos number-theory status 1
+erdos number-theory frontier 1
+erdos number-theory routes 1
+erdos number-theory tickets 1
+erdos number-theory status 2 --json
+```
+
+The number-theory pack is intentionally lighter than sunflower:
+- no mirrored theorem board yet
+- explicit route/frontier/ticket packet layer
+- honest archive posture for disproved problems
+
 ## Archive mode
 
 Solved problems can now be treated as method exemplars instead of dead entries.
@@ -246,6 +270,10 @@ Solved problems can now be treated as method exemplars instead of dead entries.
 erdos problem show 1008
 erdos archive show 1008
 erdos archive scaffold 1008
+erdos number-theory status 1
+erdos number-theory frontier 1
+erdos number-theory routes 1
+erdos number-theory tickets 1
 ```
 
 Archive scaffolds land in:
@@ -291,6 +319,7 @@ erdos problem artifacts 857
 erdos problem artifacts 857 --json
 erdos cluster list
 erdos cluster show sunflower
+erdos cluster show number-theory
 erdos workspace show
 erdos orp show
 erdos orp sync
@@ -305,6 +334,10 @@ erdos sunflower route 857 anchored_selector_linearization
 erdos sunflower ticket 857 T10
 erdos sunflower atom 857 T10.G3.A2
 erdos sunflower compute run 857
+erdos number-theory status 1
+erdos number-theory frontier 1
+erdos number-theory routes 1
+erdos number-theory tickets 1
 erdos sunflower status --json
 erdos dossier show
 erdos upstream show
@@ -319,6 +352,7 @@ erdos seed problem 25 --cluster number-theory
 erdos pull problem 857
 erdos pull artifacts 857
 erdos pull literature 857
+erdos pull literature 857 --json
 erdos pull literature 857 --include-crossref --include-openalex
 erdos maintainer review problem 25 --from-pull .erdos/pulls/25
 erdos maintainer seed problem 25 --from-pull .erdos/pulls/25 --cluster number-theory
@@ -366,6 +400,12 @@ For sunflower problems, the CLI also surfaces pack-specific artifacts:
 - compute packets under `packs/sunflower/compute/<id>/` when available
 - compute-governance evaluation under `breakthroughs`, surfaced through `erdos sunflower status`
 
+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
+- archive posture for disproved problems through `erdos number-theory status`
+
 ## Notes
 
 - `erdos-problems` is the canonical npm package name.

package/docs/RESEARCH_LOOP.md

@@ -85,6 +85,13 @@ For sunflower compute lanes, ORP now sits above `breakthroughs`:
 - the CLI surfaces the selected rung, dispatch action, and the reason compute is admissible
 - this is compute governance and traceability, not an automatic paid or unbounded compute launch
 
+For number-theory starter-cockpit problems:
+- `erdos number-theory status <id>` exposes the current route/frontier posture
+- `erdos number-theory frontier <id>` compresses the honest next move
+- `erdos number-theory routes <id>` exposes the small route table
+- `erdos number-theory tickets <id>` exposes the current ticket/archive packet
+- this is deliberately lighter than the sunflower pack and should stay honest about that
+
 For solved problems:
 - `erdos archive show <id>` exposes archival posture
 - `erdos archive scaffold <id>` creates a method-exemplar bundle under `.erdos/archives/<id>/`

package/package.json

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

package/packs/number-theory/README.md

@@ -1,13 +1,17 @@
 # Number Theory Pack
 
-This is the first non-sunflower family-pack scaffold in `erdos-problems`.
+Light starter cockpit for number-theory problems in `erdos-problems`.
 
-Current posture:
-- dossier-first
-- route-light
-- no deep board/compute loop yet
+Current seeded cockpit problems:
+- `1`: open starter cockpit around a distinct-subset-sum lower-bound route
+- `2`: counterexample/archive cockpit for a disproved covering-systems problem
 
-Why it exists:
-- keep a clean home for reusable number-theory context
-- prove the core/pack split scales beyond sunflower
-- let selected number-theory problems accumulate pack context before they earn deeper gated flows
+Useful commands:
+- `erdos number-theory status 1`
+- `erdos number-theory frontier 1`
+- `erdos number-theory routes 1`
+- `erdos number-theory tickets 1`
+- `erdos number-theory status 2 --json`
+
+Design rule:
+- keep this pack lighter than sunflower until a deeper theorem-board frontier is honestly earned

package/packs/number-theory/problems/1/CHECKPOINT_TEMPLATE.md

@@ -0,0 +1,7 @@
+# Problem 1 Checkpoint Template
+
+- Active route:
+- Exact lower-bound reduction touched:
+- New reference/evidence frozen:
+- Public-status drift checked:
+- Next honest move:

package/packs/number-theory/problems/1/FRONTIER_NOTE.md

@@ -0,0 +1,8 @@
+# Problem 1 Frontier Note
+
+This is a starter cockpit, not a deep theorem board.
+
+The honest live route is the distinct-subset-sum lower-bound route:
+- keep the problem statement exact
+- keep the additive lower-bound framing explicit
+- do not widen this into a generic additive-combinatorics program

package/packs/number-theory/problems/1/OPS_DETAILS.yaml

@@ -0,0 +1,25 @@
+packet_id: nt1_ops_details_v1
+summary: Starter cockpit packet for the distinct-subset-sum lower-bound route.
+routes:
+  - route_id: distinct_subset_sum_lower_bound
+    title: Distinct Subset-Sum Lower Bound
+    status: active
+    summary: Keep the problem centered on the exponential-growth lower-bound route implied by distinct subset sums.
+    why_now: This is the smallest honest route that turns the dossier into a real cockpit.
+    next_move: Freeze the first exact reduction and connect it to the canonical references.
+tickets:
+  - ticket_id: N1
+    title: Freeze the lower-bound route note
+    route_id: distinct_subset_sum_lower_bound
+    status: active
+    summary: Turn the starter dossier into a stable lower-bound cockpit.
+    current_blocker: The first exact reduction and evidence stack are not yet frozen together.
+    next_move: Close `N1.G1.A1`.
+atoms:
+  - atom_id: N1.G1.A1
+    title: Freeze the first exact lower-bound reduction and its reference hook
+    route_id: distinct_subset_sum_lower_bound
+    ticket_id: N1
+    status: ready
+    summary: This is the smallest honest move that upgrades the dossier into a route-aware cockpit.
+    next_move: Record the first reduction and checkpoint it without overclaiming theorem progress.

package/packs/number-theory/problems/1/REPORT_TEMPLATE.md

@@ -0,0 +1,7 @@
+# Problem 1 Report Template
+
+- Route:
+- What changed:
+- What remains open:
+- Verification hook:
+- Archive or promote:

package/packs/number-theory/problems/1/ROUTE_HISTORY.md

@@ -0,0 +1,5 @@
+# Problem 1 Route History
+
+- Initial public pack posture: dossier-first seed.
+- Current public pack posture: starter cockpit around the distinct-subset-sum lower-bound route.
+- Next maturity threshold: freeze the first exact reduction or historical lower-bound checkpoint before adding deeper pack machinery.

package/packs/number-theory/problems/1/ROUTE_PACKET.yaml

@@ -0,0 +1,13 @@
+route_packet_id: nt1_distinct_subset_sum_lower_bound_v1
+route_id: distinct_subset_sum_lower_bound
+frontier_claim: Preserve the exponential-growth lower-bound route for distinct subset sums and keep the first honest reduction explicit.
+theorem_module: ""
+checkpoint_packet: CHECKPOINT_TEMPLATE.md
+report_packet: REPORT_TEMPLATE.md
+ready_prompts:
+  - Which exact lower-bound reduction should be frozen first for the distinct-subset-sum route?
+  - Which reference or historical bound is still missing from the canonical dossier?
+verification_hook:
+  - erdos number-theory status 1
+  - erdos number-theory routes 1
+  - erdos problem artifacts 1 --json

package/packs/number-theory/problems/1/context.yaml

@@ -1,13 +1,13 @@
 problem_id: "1"
 family_role: additive_number_theory_seed
-harness_profile: dossier_seed_pack
-default_active_route: additive_structure_seed
-bootstrap_focus: Freeze the exact problem statement, the local dossier, and the first honest additive-number-theory route sketch.
-route_story: This problem currently lives in dossier-first mode inside the number-theory pack.
-frontier_label: dossier_seed_frontier
-frontier_detail: Tighten the statement, references, and first route sketch before pretending there is a deeper frontier engine here.
-checkpoint_focus: Preserve provenance and route honesty while the pack remains dossier-first.
-next_honest_move: Seed the first real route note and keep the public-status review current.
+harness_profile: starter_cockpit
+default_active_route: distinct_subset_sum_lower_bound
+bootstrap_focus: Freeze the exact problem statement, the local dossier, and the first honest lower-bound route for distinct subset sums.
+route_story: This problem now has a starter cockpit whose job is to keep the lower-bound route explicit without pretending we already have a deep theorem engine.
+frontier_label: distinct_subset_sum_lower_bound
+frontier_detail: Keep the problem anchored to the binary-growth lower-bound route and freeze the exact first reduction before widening claims.
+checkpoint_focus: Preserve provenance, the exact lower-bound route, and the open-problem boundary in every checkpoint.
+next_honest_move: Freeze the first additive lower-bound route note and tighten the evidence stack around the distinct-subset-sum hypothesis.
 related_core_problems: []
 literature_focus:
   - additive number theory
@@ -18,8 +18,8 @@ artifact_focus:
   - EVIDENCE.md
 question_ledger:
   open_questions:
-    - What is the first honest additive-number-theory route worth freezing for problem 1?
+    - What is the first exact lower-bound reduction worth freezing for the distinct-subset-sum route?
   active_route_notes:
-    - Keep this problem dossier-first until a real pack-specific route is earned.
+    - Keep the active route tied to distinct subset sums and exponential-growth pressure, not generic additive chatter.
   route_breakthroughs: []
   problem_solved: []

package/packs/number-theory/problems/2/CHECKPOINT_TEMPLATE.md

@@ -0,0 +1,7 @@
+# Problem 2 Checkpoint Template
+
+- Archive route:
+- Disproval/counterexample reference touched:
+- Public wording checked:
+- Method lesson captured:
+- Next honest move:

package/packs/number-theory/problems/2/FRONTIER_NOTE.md

@@ -0,0 +1,8 @@
+# Problem 2 Archive Note
+
+This is not a live open-problem frontier.
+
+The honest posture is:
+- preserve the disproval cleanly
+- keep the references synchronized
+- package the problem as a counterexample/method archive instead of a live cockpit

package/packs/number-theory/problems/2/OPS_DETAILS.yaml

@@ -0,0 +1,25 @@
+packet_id: nt2_ops_details_v1
+summary: Archive cockpit packet for the disproved covering-systems problem.
+routes:
+  - route_id: counterexample_archive
+    title: Counterexample Archive
+    status: archival
+    summary: Keep the problem packaged as a disproval archive rather than a live open frontier.
+    why_now: This is the honest public posture for a disproved problem.
+    next_move: Freeze the strongest disproval/counterexample references in the archive packet.
+tickets:
+  - ticket_id: N2
+    title: Tighten the disproval archive packet
+    route_id: counterexample_archive
+    status: active
+    summary: Package the disproval cleanly enough that future agents cannot mistake this for an open problem.
+    current_blocker: The archive packet still needs a sharper reference-centered summary.
+    next_move: Close `N2.G1.A1`.
+atoms:
+  - atom_id: N2.G1.A1
+    title: Freeze the primary disproval reference and method note
+    route_id: counterexample_archive
+    ticket_id: N2
+    status: ready
+    summary: This is the smallest archive improvement that meaningfully clarifies the public dossier.
+    next_move: Record the best disproval reference and checkpoint the archive packet.

package/packs/number-theory/problems/2/REPORT_TEMPLATE.md

@@ -0,0 +1,7 @@
+# Problem 2 Report Template
+
+- Archive route:
+- What was clarified:
+- Which disproval/counterexample artifact was frozen:
+- Verification hook:
+- Next archive action:

package/packs/number-theory/problems/2/ROUTE_HISTORY.md

@@ -0,0 +1,5 @@
+# Problem 2 Route History
+
+- Initial pack posture: dossier-first seed.
+- Current pack posture: archive cockpit around the counterexample/disproval record.
+- Next maturity threshold: freeze the best archive packet rather than inventing open-frontier pressure.

package/packs/number-theory/problems/2/ROUTE_PACKET.yaml

@@ -0,0 +1,13 @@
+route_packet_id: nt2_counterexample_archive_v1
+route_id: counterexample_archive
+frontier_claim: Preserve the disproval and counterexample-facing references cleanly so the problem remains useful as a method exemplar.
+theorem_module: ""
+checkpoint_packet: CHECKPOINT_TEMPLATE.md
+report_packet: REPORT_TEMPLATE.md
+ready_prompts:
+  - Which exact disproval reference should be frozen first in the archive packet?
+  - Which method lesson from the counterexample should be made explicit for future number-theory dossiers?
+verification_hook:
+  - erdos number-theory status 2
+  - erdos number-theory routes 2
+  - erdos problem show 2

package/packs/number-theory/problems/2/context.yaml

@@ -1,13 +1,13 @@
 problem_id: "2"
-family_role: additive_number_theory_seed
-harness_profile: dossier_seed_pack
-default_active_route: additive_structure_seed
-bootstrap_focus: Freeze the exact problem statement, local dossier, and first honest additive route sketch.
-route_story: This problem currently lives in dossier-first mode inside the number-theory pack.
-frontier_label: dossier_seed_frontier
-frontier_detail: Keep this number-theory problem in a disciplined dossier-first workflow until a deeper route is honestly earned.
-checkpoint_focus: Preserve provenance and route honesty while the pack remains dossier-first.
-next_honest_move: Seed the first route note and keep the public-status review current.
+family_role: covering_systems_counterexample_archive
+harness_profile: archive_cockpit
+default_active_route: counterexample_archive
+bootstrap_focus: Freeze the exact disproval record, the dossier provenance, and the counterexample-facing archive packet.
+route_story: This problem is not a live open frontier; the honest public job is to preserve the disproval and keep it usable as a method/counterexample exemplar.
+frontier_label: counterexample_archive
+frontier_detail: Preserve the counterexample/archive posture cleanly and avoid drifting back into open-problem language.
+checkpoint_focus: Keep the disproval record, references, and archive packet synchronized.
+next_honest_move: Tighten the counterexample archive note and make the public references impossible to misread as an open frontier.
 related_core_problems: []
 literature_focus:
   - additive number theory
@@ -18,8 +18,8 @@ artifact_focus:
   - EVIDENCE.md
 question_ledger:
   open_questions:
-    - What is the first honest additive-number-theory route worth freezing for problem 2?
+    - Which exact disproval or counterexample references should be frozen first in the archive packet?
   active_route_notes:
-    - Keep this problem dossier-first until a real pack-specific route is earned.
+    - Treat this as an archive cockpit, not a live open-problem route.
   route_breakthroughs: []
   problem_solved: []

package/packs/sunflower/README.md

@@ -19,8 +19,8 @@ Deep route packets:
 - `857` ships `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `FRONTIER_NOTE.md`, `ROUTE_HISTORY.md`, `CHECKPOINT_TEMPLATE.md`, `REPORT_TEMPLATE.md`, `OPS_DETAILS.yaml`
 
 Bridge packets:
-- `536` ships `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `OPS_DETAILS.yaml`
-- `856` ships `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `OPS_DETAILS.yaml`
+- `536` ships `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `FRONTIER_NOTE.md`, `ROUTE_HISTORY.md`, `CHECKPOINT_TEMPLATE.md`, `REPORT_TEMPLATE.md`, `OPS_DETAILS.yaml`
+- `856` ships `AGENT_START.md`, `ROUTE_PACKET.yaml`, `CHECKPOINT_PACKET.md`, `REPORT_PACKET.md`, `ATOMIC_BOARD.yaml`, `ATOMIC_BOARD.md`, `FRONTIER_NOTE.md`, `ROUTE_HISTORY.md`, `CHECKPOINT_TEMPLATE.md`, `REPORT_TEMPLATE.md`, `OPS_DETAILS.yaml`
 
 Public cockpit commands:
 - `erdos sunflower status <id>`

package/packs/sunflower/problems/536/CHECKPOINT_TEMPLATE.md

@@ -0,0 +1,7 @@
+# Problem 536 Checkpoint Template
+
+- Active bridge route:
+- Transfer note clarified:
+- Reference artifact touched:
+- Public-status drift checked:
+- Next honest move:

package/packs/sunflower/problems/536/FRONTIER_NOTE.md

@@ -0,0 +1,8 @@
+# Problem 536 Frontier Note
+
+Treat 536 as a bridge problem, not a fake deep proof lane.
+
+The honest live work is:
+- preserve the natural-density LCM analogue statement
+- keep its bridge to `857` explicit
+- tighten public references and transfer notes without pretending the analogue has a theorem-board frontier yet

package/packs/sunflower/problems/536/REPORT_TEMPLATE.md

@@ -0,0 +1,7 @@
+# Problem 536 Report Template
+
+- Route:
+- What bridge context changed:
+- What remains dossier-only:
+- Verification hook:
+- Next analogue move:

package/packs/sunflower/problems/536/ROUTE_HISTORY.md

@@ -0,0 +1,5 @@
+# Problem 536 Route History
+
+- Initial public posture: dossier bridge with sunflower-family linkage.
+- Current public posture: natural-density analogue bridge with explicit route packet and ops detail packet.
+- Next maturity threshold: freeze stronger transfer notes into `857` before adding deeper pack machinery.

package/packs/sunflower/problems/856/CHECKPOINT_TEMPLATE.md

@@ -0,0 +1,7 @@
+# Problem 856 Checkpoint Template
+
+- Active bridge route:
+- Exponent-transfer note clarified:
+- Reference artifact touched:
+- Public-status drift checked:
+- Next honest move:

package/packs/sunflower/problems/856/FRONTIER_NOTE.md

@@ -0,0 +1,8 @@
+# Problem 856 Frontier Note
+
+Treat 856 as a bridge problem whose value is in clean exponent-transfer context, not a fake theorem frontier.
+
+The honest live work is:
+- preserve the harmonic-density LCM analogue
+- keep the exponent-transfer relationship to `857` explicit
+- improve bridge artifacts and references without overstating proof structure

package/packs/sunflower/problems/856/REPORT_TEMPLATE.md

@@ -0,0 +1,7 @@
+# Problem 856 Report Template
+
+- Route:
+- What bridge context changed:
+- What remains dossier-only:
+- Verification hook:
+- Next analogue move:

package/packs/sunflower/problems/856/ROUTE_HISTORY.md

@@ -0,0 +1,5 @@
+# Problem 856 Route History
+
+- Initial public posture: dossier bridge with weak-sunflower linkage.
+- Current public posture: harmonic-density analogue bridge with explicit route packet and ops detail packet.
+- Next maturity threshold: freeze cleaner exponent-transfer notes into `857` before deepening the pack.

package/src/cli/index.js

@@ -5,6 +5,7 @@ import { runClusterCommand } from '../commands/cluster.js';
 import { runContinuationCommand } from '../commands/continuation.js';
 import { runDossierCommand } from '../commands/dossier.js';
 import { runMaintainerCommand } from '../commands/maintainer.js';
+import { runNumberTheoryCommand } from '../commands/number-theory.js';
 import { runOrpCommand } from '../commands/orp.js';
 import { runPreflightCommand } from '../commands/preflight.js';
 import { runProblemCommand } from '../commands/problem.js';
@@ -29,6 +30,10 @@ function printUsage() {
   console.log('  erdos cluster show <name>');
   console.log('  erdos archive show <id>');
   console.log('  erdos archive scaffold <id>');
+  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 orp show [--json]');
   console.log('  erdos orp sync [--json]');
@@ -57,9 +62,9 @@ function printUsage() {
   console.log('  erdos scaffold problem <id> [--dest <path>]');
   console.log('  erdos bootstrap problem <id> [--dest <path>] [--sync-upstream]');
   console.log('  erdos seed problem <id> [--include-site|--no-site] [--include-public-search|--no-public-search] [--refresh-upstream] [--cluster <name>] [--repo-status <status>] [--harness-depth <depth>] [--title <title>] [--family-tag <tag>] [--related <id>] [--formalization-status <status>] [--active-route <route>] [--route-breakthrough] [--problem-solved] [--allow-non-open] [--dest-root <path>] [--no-activate] [--no-loop-sync] [--force] [--json]');
-  console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream]');
-  console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream]');
-  console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream]');
+  console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream] [--json]');
+  console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream] [--json]');
+  console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream] [--json]');
   console.log('  erdos maintainer seed problem <id> [--from-pull <path>] [--dest-root <path>] [--cluster <name>] [--allow-non-open]');
   console.log('  erdos maintainer review problem <id> [--from-pull <path>] [--dest-root <path>] [--title <title>]');
 }
@@ -77,6 +82,8 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = runClusterCommand(rest);
 } else if (command === 'archive') {
   exitCode = runArchiveCommand(rest);
+} else if (command === 'number-theory') {
+  exitCode = runNumberTheoryCommand(rest);
 } else if (command === 'workspace') {
   exitCode = runWorkspaceCommand(rest);
 } else if (command === 'orp') {

package/src/commands/cluster.js

@@ -10,6 +10,10 @@ function printCluster(cluster) {
     console.log('  Weak sunflower core: 857');
     console.log('  Strong sunflower sibling: 20');
     console.log('  Related analogues: 536, 856');
+  } else if (cluster.name === 'number-theory') {
+    console.log('  Open starter cockpit: 1');
+    console.log('  Counterexample/archive cockpit: 2');
+    console.log('  Additional dossier seeds: 3, 4, 5, 6, 7, 18, 542');
   }
 }
 

package/src/commands/number-theory.js

@@ -0,0 +1,199 @@
+import { getProblem } from '../atlas/catalog.js';
+import { buildNumberTheoryStatusSnapshot } from '../runtime/number-theory.js';
+import { readCurrentProblem } from '../runtime/workspace.js';
+
+function resolveNumberTheoryProblem(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 !== 'number-theory') {
+    return { error: `Problem ${resolvedId} is not in the number-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 number-theory option: ${token}` };
+  }
+
+  return parsed;
+}
+
+function printStatus(snapshot) {
+  console.log(`${snapshot.displayName} number-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(`Ops details present: ${snapshot.opsDetailsPresent ? 'yes' : 'no'}`);
+  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} number-theory frontier`);
+  console.log(`Active route: ${snapshot.activeRoute ?? '(none)'}`);
+  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(`Open problem: ${snapshot.openProblem ? 'yes' : 'no'}`);
+  console.log(`Archive mode: ${snapshot.archiveMode ?? '(none)'}`);
+  console.log(`Frontier note: ${snapshot.frontierNotePresent ? snapshot.frontierNotePath : '(missing)'}`);
+  console.log(`Route history: ${snapshot.routeHistoryPresent ? snapshot.routeHistoryPath : '(missing)'}`);
+}
+
+function printRoutes(snapshot) {
+  console.log(`${snapshot.displayName} number-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.push(route.status);
+    }
+    console.log(`- ${route.route_id}${flags.length > 0 ? ` [${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} number-theory tickets`);
+  if (!snapshot.opsDetails?.tickets?.length) {
+    console.log('Tickets: none recorded.');
+    return;
+  }
+  console.log(`Active ticket: ${snapshot.activeTicketDetail?.ticket_id ?? '(none)'}`);
+  for (const ticket of snapshot.opsDetails.tickets) {
+    const flags = [];
+    if (ticket.ticket_id === snapshot.activeTicketDetail?.ticket_id) {
+      flags.push('active');
+    }
+    if (ticket.status) {
+      flags.push(ticket.status);
+    }
+    console.log(`- ${ticket.ticket_id}${flags.length > 0 ? ` [${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 runNumberTheoryCommand(args) {
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    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]');
+    return 0;
+  }
+
+  if (!['status', 'frontier', 'routes', 'tickets'].includes(subcommand)) {
+    console.error(`Unknown number-theory subcommand: ${subcommand}`);
+    return 1;
+  }
+
+  const parsed = parseArgs(rest);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+
+  const { problem, error } = resolveNumberTheoryProblem(parsed.problemId);
+  if (error) {
+    console.error(error);
+    return 1;
+  }
+
+  const snapshot = buildNumberTheoryStatusSnapshot(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/pull.js

@@ -45,7 +45,7 @@ function inferClusterFromUpstream(upstreamRecord) {
 function parsePullArgs(args) {
   const [kind, value, ...rest] = args;
   if (!['problem', 'artifacts', 'literature'].includes(kind)) {
-    return { error: 'Usage: erdos pull problem|artifacts|literature <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream]' };
+    return { error: 'Usage: erdos pull problem|artifacts|literature <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream] [--json]' };
   }
 
   let destination = null;
@@ -54,6 +54,7 @@ function parsePullArgs(args) {
   let includeCrossref = false;
   let includeOpenAlex = false;
   let refreshUpstream = false;
+  let asJson = false;
 
   for (let index = 0; index < rest.length; index += 1) {
     const token = rest[index];
@@ -85,6 +86,10 @@ function parsePullArgs(args) {
       refreshUpstream = true;
       continue;
     }
+    if (token === '--json') {
+      asJson = true;
+      continue;
+    }
     return { error: `Unknown pull option: ${token}` };
   }
 
@@ -97,6 +102,7 @@ function parsePullArgs(args) {
     includeCrossref,
     includeOpenAlex,
     refreshUpstream,
+    asJson,
   };
 }
 
@@ -530,9 +536,9 @@ export async function runPullCommand(args, options = {}) {
   if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
     if (!silent) {
       console.log('Usage:');
-      console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream]');
-      console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream]');
-      console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream]');
+      console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream] [--json]');
+      console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream] [--json]');
+      console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--include-public-search] [--include-crossref] [--include-openalex] [--refresh-upstream] [--json]');
     }
     return 0;
   }
@@ -571,6 +577,17 @@ export async function runPullCommand(args, options = {}) {
       ? path.resolve(parsed.destination)
       : getWorkspaceProblemArtifactDir(parsed.problemId);
     const result = writeArtifactsLane(String(parsed.problemId), destination, localProblem, upstreamRecord, snapshot);
+    if (parsed.asJson) {
+      console.log(JSON.stringify({
+        kind: 'artifacts',
+        problemId: String(parsed.problemId),
+        destination,
+        localProblemIncluded: Boolean(localProblem),
+        upstreamRecordIncluded: Boolean(upstreamRecord),
+        artifactsCopied: result.copiedArtifacts?.length ?? result.artifactsCopied ?? 0,
+      }, null, 2));
+      return 0;
+    }
     if (!silent) {
       console.log(`Artifact bundle created: ${destination}`);
       console.log(`Local canonical dossier included: ${localProblem ? 'yes' : 'no'}`);
@@ -594,6 +611,24 @@ export async function runPullCommand(args, options = {}) {
       parsed.includeCrossref,
       parsed.includeOpenAlex,
     );
+    if (parsed.asJson) {
+      console.log(JSON.stringify({
+        kind: 'literature',
+        problemId: String(parsed.problemId),
+        destination,
+        localProblemIncluded: Boolean(localProblem),
+        upstreamRecordIncluded: Boolean(upstreamRecord),
+        includedSiteSnapshot: result.siteStatus.included,
+        siteStatusError: result.siteStatus.error,
+        includedPublicSearch: result.publicSearch.included,
+        publicSearchError: result.publicSearch.error,
+        includedCrossref: result.crossref.included,
+        crossrefError: result.crossref.error,
+        includedOpenAlex: result.openalex.included,
+        openAlexError: result.openalex.error,
+      }, null, 2));
+      return 0;
+    }
     if (!silent) {
       console.log(`Literature bundle created: ${destination}`);
       console.log(`Local dossier context included: ${localProblem ? 'yes' : 'no'}`);
@@ -662,6 +697,23 @@ export async function runPullCommand(args, options = {}) {
     openAlexError: literatureResult.openalex.error,
   });
 
+  if (parsed.asJson) {
+    console.log(JSON.stringify({
+      kind: 'problem',
+      problemId: String(parsed.problemId),
+      destination: rootDestination,
+      artifactsDir: artifactDestination,
+      literatureDir: literatureDestination,
+      localProblemIncluded: Boolean(localProblem),
+      upstreamRecordIncluded: Boolean(upstreamRecord),
+      includedSiteSnapshot: literatureResult.siteStatus.included,
+      includedPublicSearch: literatureResult.publicSearch.included,
+      includedCrossref: literatureResult.crossref.included,
+      includedOpenAlex: literatureResult.openalex.included,
+    }, null, 2));
+    return 0;
+  }
+
   if (!silent) {
     console.log(`Pull bundle created: ${rootDestination}`);
     console.log(`Artifact lane: ${artifactDestination}`);

package/src/commands/workspace.js

@@ -1,5 +1,6 @@
 import { getProblem } from '../atlas/catalog.js';
 import { loadConfig } from '../runtime/config.js';
+import { buildNumberTheoryStatusSnapshot } from '../runtime/number-theory.js';
 import { buildSunflowerStatusSnapshot } from '../runtime/sunflower.js';
 import { getWorkspaceSummary } from '../runtime/workspace.js';
 
@@ -76,6 +77,21 @@ export function runWorkspaceCommand(args) {
       }
       console.log(`Sunflower compute next: ${sunflower.computeNextAction}`);
     }
+    if (problem?.cluster === 'number-theory') {
+      const numberTheory = buildNumberTheoryStatusSnapshot(problem);
+      console.log(`Number-theory family role: ${numberTheory.familyRole ?? '(none)'}`);
+      console.log(`Number-theory harness profile: ${numberTheory.harnessProfile ?? '(none)'}`);
+      console.log(`Number-theory route: ${numberTheory.activeRoute ?? '(none)'}`);
+      console.log(`Number-theory frontier: ${numberTheory.frontierDetail ?? '(none)'}`);
+      console.log(`Number-theory frontier note: ${numberTheory.frontierNotePath ?? '(none)'}`);
+      console.log(`Number-theory route history: ${numberTheory.routeHistoryPath ?? '(none)'}`);
+      console.log(`Number-theory archive mode: ${numberTheory.archiveMode ?? '(none)'}`);
+      console.log(`Number-theory active ticket: ${numberTheory.activeTicketDetail?.ticket_id ?? '(none)'}`);
+      console.log(`Number-theory ready atoms: ${numberTheory.readyAtomCount}`);
+      if (numberTheory.firstReadyAtom) {
+        console.log(`Number-theory first ready atom: ${numberTheory.firstReadyAtom.atom_id} — ${numberTheory.firstReadyAtom.title}`);
+      }
+    }
   }
   return 0;
 }

package/src/runtime/number-theory.js

@@ -0,0 +1,169 @@
+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('number-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 findActiveRouteDetail(opsDetails, activeRoute) {
+  if (!opsDetails || !Array.isArray(opsDetails.routes)) {
+    return null;
+  }
+  return opsDetails.routes.find((route) => route.route_id === activeRoute) ?? opsDetails.routes[0] ?? null;
+}
+
+function findActiveTicketDetail(opsDetails, activeRoute) {
+  if (!opsDetails || !Array.isArray(opsDetails.tickets)) {
+    return null;
+  }
+  return (
+    opsDetails.tickets.find((ticket) => ticket.status === 'active' && (!activeRoute || ticket.route_id === activeRoute))
+    ?? opsDetails.tickets.find((ticket) => !activeRoute || ticket.route_id === activeRoute)
+    ?? opsDetails.tickets[0]
+    ?? null
+  );
+}
+
+function findFirstReadyAtom(opsDetails, activeRoute) {
+  if (!opsDetails || !Array.isArray(opsDetails.atoms)) {
+    return null;
+  }
+  return (
+    opsDetails.atoms.find((atom) => atom.status === 'ready' && (!activeRoute || atom.route_id === activeRoute))
+    ?? opsDetails.atoms.find((atom) => atom.status === 'ready')
+    ?? null
+  );
+}
+
+function resolveArchiveMode(problem) {
+  const siteStatus = String(problem.siteStatus ?? '').toLowerCase();
+  if (siteStatus === 'solved') {
+    return 'method_exemplar';
+  }
+  if (siteStatus === 'disproved') {
+    return 'counterexample_archive';
+  }
+  return null;
+}
+
+export function buildNumberTheoryStatusSnapshot(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 routeBreakthrough = typeof problem.researchState?.route_breakthrough === 'boolean'
+    ? problem.researchState.route_breakthrough
+    : false;
+  const archiveMode = resolveArchiveMode(problem);
+  const problemSolved = typeof problem.researchState?.problem_solved === 'boolean'
+    ? problem.researchState.problem_solved
+    : String(problem.siteStatus ?? '').toLowerCase() === 'solved';
+  const openProblem = typeof problem.researchState?.open_problem === 'boolean'
+    ? problem.researchState.open_problem
+    : String(problem.siteStatus ?? '').toLowerCase() === 'open';
+
+  const activeRouteDetail = findActiveRouteDetail(opsDetails, activeRoute);
+  const activeTicketDetail = findActiveTicketDetail(opsDetails, activeRoute);
+  const firstReadyAtom = findFirstReadyAtom(opsDetails, 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 ?? 'number_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 ?? 'number_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
+      ?? 'Pull the dossier, freeze the route note, and preserve public-status honesty.',
+    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/state.js

@@ -7,6 +7,7 @@ import {
   getWorkspaceStateMarkdownPath,
   getWorkspaceStatePath,
 } from './paths.js';
+import { buildNumberTheoryStatusSnapshot } from './number-theory.js';
 import { buildSunflowerStatusSnapshot } from './sunflower.js';
 import { readCurrentProblem } from './workspace.js';
 import { continuationDisplay, resolveContinuation } from './continuation.js';
@@ -218,6 +219,36 @@ function deriveProblemSummary(problem) {
     };
   }
 
+  if (problem.cluster === 'number-theory') {
+    const snapshot = buildNumberTheoryStatusSnapshot(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);
 }