erdos-problems 0.1.3 → 0.1.4

package/README.md

@@ -20,6 +20,7 @@ Official binary:
 - bundled upstream snapshot from `teorth/erdosproblems`
 - workspace `.erdos/` state for active-problem selection, upstream refreshes, reports, scaffolds, and pull bundles
 - sunflower cluster as the first deep harness pack
+- packaged compute-lane metadata for deep sunflower problems, surfaced directly in the CLI
 - seeded atlas now includes open and solved problems beyond sunflower
 - unseeded problems can still be pulled into a workspace from the bundled upstream snapshot
 
@@ -72,6 +73,8 @@ erdos problem artifacts 857 --json
 erdos cluster list
 erdos cluster show sunflower
 erdos workspace show
+erdos sunflower status 857
+erdos sunflower status --json
 erdos dossier show
 erdos upstream show
 erdos upstream sync
@@ -107,6 +110,11 @@ The CLI can surface these directly:
 - `erdos bootstrap problem <id>` selects the problem and creates the scaffold in one step
 - `erdos pull problem <id>` creates a workspace bundle for any problem in the upstream snapshot
 
+For deep sunflower problems, the CLI also surfaces packaged compute lanes:
+- `erdos sunflower status <id>` shows route + compute posture together
+- `erdos workspace show` includes the active sunflower compute summary when applicable
+- `erdos scaffold problem <id>` copies packaged compute packets into `.erdos/scaffolds/<id>/COMPUTE/`
+
 ## Notes
 
 - `erdos-problems` is the canonical npm package name.

package/docs/ERDOS_PROBLEMS_REPO_SPEC.md

@@ -209,6 +209,7 @@ And also:
 - gates
 - atoms
 - ready queue
+- compute lane awareness
 - generated checkpoints
 - literature mapping
 
@@ -240,8 +241,18 @@ erdos sunflower setup 857
 erdos sunflower warnings 857
 erdos sunflower pass 857
 erdos sunflower frontier 857
+erdos sunflower status 857
 ```
 
+`erdos sunflower status` should be the public-shell place where route state and
+compute posture meet:
+
+- active route
+- breakthrough state
+- packaged compute lane
+- next compute action
+- whether paid approval is required
+
 ## Content Policy
 
 The repo should not blindly mirror `erdosproblems.com` text.
@@ -281,4 +292,3 @@ This keeps the repo publishable and reduces licensing ambiguity.
 The first public promise should be:
 
 > `erdos-problems` is a CLI atlas and staged research harness for Paul Erdős problems, with the sunflower family as the first deeply integrated pack.
-

package/package.json

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

package/packs/sunflower/compute/857/m8_exactness_cube_and_certificate_v0.yaml

@@ -0,0 +1,26 @@
+lane_id: m8_exactness_cube_and_certificate_v0
+problem_id: "857"
+cluster: sunflower
+question: "Is M(8,3) = 45 exact, equivalently is the target-46 SAT instance UNSAT?"
+claim_level_goal: Exact
+status: ready_for_local_scout
+price_checked_local_date: "2026-03-25"
+recommendation: cpu_first
+approval_required: true
+summary: "Packaged sunflower compute lane for the first exact M(8,3) certification packet. The next honest move is the local scout, not paid launch."
+source_repo:
+  name: sunflower-coda
+  canonical_packet_path: analysis/compute/m8_exactness_cube_and_certificate_v0/launch_packet.yaml
+public_feature:
+  command: erdos sunflower status 857
+  scaffold_subdir: COMPUTE
+rungs:
+  - name: local_scout
+    role: local_unmetered
+    note: "Run the local scout packet first and require clean artifacts before any paid rung."
+  - name: cpu_transfer
+    role: paid_metered
+    note: "Preferred first paid rung once the local scout has earned promotion."
+  - name: heuristic_gpu_sidecar
+    role: paid_metered
+    note: "Optional and heuristic-only; it supports the exact lane but does not upgrade claims by itself."

package/src/cli/index.js

@@ -4,6 +4,7 @@ import { runDossierCommand } from '../commands/dossier.js';
 import { runProblemCommand } from '../commands/problem.js';
 import { runPullCommand } from '../commands/pull.js';
 import { runScaffoldCommand } from '../commands/scaffold.js';
+import { runSunflowerCommand } from '../commands/sunflower.js';
 import { runUpstreamCommand } from '../commands/upstream.js';
 import { runWorkspaceCommand } from '../commands/workspace.js';
 
@@ -19,6 +20,7 @@ function printUsage() {
   console.log('  erdos cluster list');
   console.log('  erdos cluster show <name>');
   console.log('  erdos workspace show');
+  console.log('  erdos sunflower status [<id>] [--json]');
   console.log('  erdos dossier show <id>');
   console.log('  erdos upstream show');
   console.log('  erdos upstream sync [--write-package-snapshot]');
@@ -41,6 +43,8 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = runClusterCommand(rest);
 } else if (command === 'workspace') {
   exitCode = runWorkspaceCommand(rest);
+} else if (command === 'sunflower') {
+  exitCode = runSunflowerCommand(rest);
 } else if (command === 'dossier') {
   exitCode = runDossierCommand(rest);
 } else if (command === 'upstream') {

package/src/commands/problem.js

@@ -129,6 +129,12 @@ function printArtifactInventory(problem, inventory, asJson) {
   if (inventory.packContext) {
     console.log(`- ${inventory.packContext.label}: ${inventory.packContext.exists ? 'present' : 'missing'} (${inventory.packContext.path})`);
   }
+  if (inventory.computePackets.length > 0) {
+    console.log('Compute packets:');
+    for (const packet of inventory.computePackets) {
+      console.log(`- ${packet.label}: ${packet.exists ? 'present' : 'missing'} (${packet.path}) [${packet.status}]`);
+    }
+  }
   if (inventory.upstreamSnapshot) {
     console.log('Upstream snapshot:');
     console.log(`- kind: ${inventory.upstreamSnapshot.kind}`);

package/src/commands/sunflower.js

@@ -0,0 +1,97 @@
+import { getProblem } from '../atlas/catalog.js';
+import { getWorkspaceRoot } from '../runtime/paths.js';
+import { buildSunflowerStatusSnapshot, writeSunflowerStatusRecord } from '../runtime/sunflower.js';
+import { readCurrentProblem } from '../runtime/workspace.js';
+
+function parseStatusArgs(args) {
+  const parsed = {
+    problemId: null,
+    asJson: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (token === '--json') {
+      parsed.asJson = true;
+      continue;
+    }
+    if (!parsed.problemId) {
+      parsed.problemId = token;
+      continue;
+    }
+    return { error: `Unknown sunflower status option: ${token}` };
+  }
+
+  return parsed;
+}
+
+function printSunflowerStatus(snapshot, registryPaths) {
+  console.log(`${snapshot.displayName} sunflower harness`);
+  console.log(`Title: ${snapshot.title}`);
+  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(`Compute lane present: ${snapshot.computeLanePresent ? 'yes' : 'no'}`);
+  console.log(`Compute lane count: ${snapshot.computeLaneCount}`);
+  console.log(`Compute summary: ${snapshot.computeSummary}`);
+  console.log(`Compute next: ${snapshot.computeNextAction}`);
+  if (snapshot.activePacket) {
+    console.log(`Compute lane: ${snapshot.activePacket.laneId} [${snapshot.activePacket.status}]`);
+    console.log(`Claim level goal: ${snapshot.activePacket.claimLevelGoal}`);
+    console.log(`Recommendation: ${snapshot.activePacket.recommendation || '(none)'}`);
+    console.log(`Approval required: ${snapshot.activePacket.approvalRequired ? 'yes' : 'no'}`);
+    console.log(`Price checked: ${snapshot.activePacket.priceCheckedLocalDate || '(unknown)'}`);
+    console.log(`Packet file: ${snapshot.activePacket.packetFileName}`);
+  }
+  console.log(`Registry record: ${registryPaths.latestPath}`);
+}
+
+export function runSunflowerCommand(args) {
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos sunflower status [<id>] [--json]');
+    return 0;
+  }
+
+  if (subcommand !== 'status') {
+    console.error(`Unknown sunflower subcommand: ${subcommand}`);
+    return 1;
+  }
+
+  const parsed = parseStatusArgs(rest);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+
+  const problemId = parsed.problemId ?? readCurrentProblem();
+  if (!problemId) {
+    console.error('Missing problem id and no active problem is selected.');
+    return 1;
+  }
+
+  const problem = getProblem(problemId);
+  if (!problem) {
+    console.error(`Unknown problem: ${problemId}`);
+    return 1;
+  }
+
+  if (problem.cluster !== 'sunflower') {
+    console.error(`Problem ${problem.problemId} is not in the sunflower harness.`);
+    return 1;
+  }
+
+  const snapshot = buildSunflowerStatusSnapshot(problem);
+  const registryPaths = writeSunflowerStatusRecord(problem, snapshot, getWorkspaceRoot());
+
+  if (parsed.asJson) {
+    console.log(JSON.stringify({ ...snapshot, registryPaths }, null, 2));
+    return 0;
+  }
+
+  printSunflowerStatus(snapshot, registryPaths);
+  return 0;
+}

package/src/commands/workspace.js

@@ -1,3 +1,5 @@
+import { getProblem } from '../atlas/catalog.js';
+import { buildSunflowerStatusSnapshot } from '../runtime/sunflower.js';
 import { getWorkspaceSummary } from '../runtime/workspace.js';
 
 export function runWorkspaceCommand(args) {
@@ -23,5 +25,17 @@ export function runWorkspaceCommand(args) {
   console.log(`Workspace scaffold dir: ${summary.scaffoldDir}`);
   console.log(`Workspace pull dir: ${summary.pullDir}`);
   console.log(`Updated at: ${summary.updatedAt ?? '(none)'}`);
+  if (summary.activeProblem) {
+    const problem = getProblem(summary.activeProblem);
+    if (problem?.cluster === 'sunflower') {
+      const sunflower = buildSunflowerStatusSnapshot(problem);
+      console.log(`Sunflower route: ${sunflower.activeRoute ?? '(none)'}`);
+      console.log(`Sunflower compute: ${sunflower.computeLanePresent ? 'yes' : 'no'}`);
+      if (sunflower.activePacket) {
+        console.log(`Sunflower compute lane: ${sunflower.activePacket.laneId} [${sunflower.activePacket.status}]`);
+      }
+      console.log(`Sunflower compute next: ${sunflower.computeNextAction}`);
+    }
+  }
   return 0;
 }

package/src/runtime/paths.js

@@ -12,6 +12,14 @@ export function getWorkspaceDir() {
   return path.join(getWorkspaceRoot(), '.erdos');
 }
 
+export function getWorkspaceRegistryDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(workspaceRoot, '.erdos', 'registry');
+}
+
+export function getWorkspaceComputeRegistryDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceRegistryDir(workspaceRoot), 'compute');
+}
+
 export function getWorkspaceStatePath() {
   return path.join(getWorkspaceDir(), 'state.json');
 }

package/src/runtime/problem-artifacts.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { loadActiveUpstreamSnapshot } from '../upstream/sync.js';
 import { copyFileIfPresent, ensureDir, writeJson, writeText } from './files.js';
 import { getPackDir } from './paths.js';
+import { listSunflowerComputePackets } from './sunflower.js';
 
 const DOSSIER_FILES = [
   ['problem.yaml', 'problemYamlPath', 'problem.yaml'],
@@ -42,6 +43,15 @@ export function getProblemArtifactInventory(problem) {
       }
     : null;
 
+  const computePackets = listSunflowerComputePackets(problem.problemId).map((packet) => ({
+    label: packet.laneId || packet.packetFileName,
+    path: packet.packetPath,
+    destinationName: packet.packetFileName,
+    exists: fs.existsSync(packet.packetPath),
+    status: packet.status,
+    claimLevelGoal: packet.claimLevelGoal,
+  }));
+
   return {
     generatedAt: new Date().toISOString(),
     problemId: problem.problemId,
@@ -54,6 +64,7 @@ export function getProblemArtifactInventory(problem) {
     problemDir: problem.problemDir,
     canonicalArtifacts,
     packContext,
+    computePackets,
     upstreamSnapshot: snapshot
       ? {
           kind: snapshot.kind,
@@ -96,6 +107,24 @@ export function scaffoldProblem(problem, destination) {
     }
   }
 
+  const computeArtifacts = [];
+  const computeDir = path.join(destination, 'COMPUTE');
+  for (const packet of inventory.computePackets) {
+    if (!packet.exists) {
+      continue;
+    }
+    const destinationPath = path.join(computeDir, packet.destinationName);
+    if (copyFileIfPresent(packet.path, destinationPath)) {
+      computeArtifacts.push({
+        label: packet.label,
+        sourcePath: packet.path,
+        destinationPath,
+        status: packet.status,
+        claimLevelGoal: packet.claimLevelGoal,
+      });
+    }
+  }
+
   if (inventory.upstreamRecord) {
     writeJson(path.join(destination, 'UPSTREAM_RECORD.json'), inventory.upstreamRecord);
   }
@@ -117,8 +146,10 @@ export function scaffoldProblem(problem, destination) {
     problemId: problem.problemId,
     bundledProblemDir: problem.problemDir,
     copiedArtifacts,
+    computeArtifacts,
     packContext: inventory.packContext,
     canonicalArtifacts: inventory.canonicalArtifacts,
+    computePackets: inventory.computePackets,
     upstreamSnapshot: inventory.upstreamSnapshot,
     includedUpstreamRecord: inventory.upstreamRecordIncluded,
   };
@@ -138,6 +169,7 @@ export function scaffoldProblem(problem, destination) {
       `- Repo status: ${problem.repoStatus}`,
       `- Harness depth: ${problem.harnessDepth}`,
       `- Upstream record included: ${inventory.upstreamRecordIncluded ? 'yes' : 'no'}`,
+      `- Compute packets copied: ${computeArtifacts.length}`,
       '',
     ].join('\n'),
   );

package/src/runtime/sunflower.js

@@ -0,0 +1,208 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { writeJson } from './files.js';
+import { getPackDir, getWorkspaceComputeRegistryDir } from './paths.js';
+
+const CLAIM_LEVEL_PRIORITY = {
+  Exact: 4,
+  Verified: 3,
+  Heuristic: 2,
+  Conjecture: 1,
+};
+
+const STATUS_PRIORITY = {
+  paid_active: 7,
+  local_scout_running: 6,
+  ready_for_paid_transfer: 5,
+  ready_for_local_scout: 4,
+  active: 3,
+  blocked: 2,
+  complete: 1,
+  unknown: 0,
+};
+
+function getSunflowerComputeDir(problemId) {
+  return path.join(getPackDir('sunflower'), 'compute', String(problemId));
+}
+
+function readComputePacket(packetPath) {
+  const parsed = parse(fs.readFileSync(packetPath, 'utf8')) ?? {};
+  return {
+    laneId: String(parsed.lane_id ?? '').trim(),
+    problemId: String(parsed.problem_id ?? '').trim(),
+    cluster: String(parsed.cluster ?? 'sunflower').trim(),
+    question: String(parsed.question ?? '').trim(),
+    claimLevelGoal: String(parsed.claim_level_goal ?? '').trim(),
+    status: String(parsed.status ?? 'unknown').trim() || 'unknown',
+    priceCheckedLocalDate: String(parsed.price_checked_local_date ?? '').trim(),
+    recommendation: String(parsed.recommendation ?? '').trim(),
+    approvalRequired: Boolean(parsed.approval_required),
+    summary: String(parsed.summary ?? '').trim(),
+    packetPath,
+    packetFileName: path.basename(packetPath),
+    sourceRepo: parsed.source_repo ?? null,
+    publicFeature: parsed.public_feature ?? null,
+    rungs: Array.isArray(parsed.rungs) ? parsed.rungs : [],
+  };
+}
+
+export function listSunflowerComputePackets(problemId) {
+  const computeDir = getSunflowerComputeDir(problemId);
+  if (!fs.existsSync(computeDir)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(computeDir)
+    .filter((entry) => entry.endsWith('.yaml') || entry.endsWith('.yml'))
+    .sort()
+    .map((entry) => readComputePacket(path.join(computeDir, entry)));
+}
+
+function chooseActivePacket(packets) {
+  if (packets.length === 0) {
+    return null;
+  }
+
+  const ranked = [...packets].sort((left, right) => {
+    const statusDelta =
+      (STATUS_PRIORITY[right.status] ?? STATUS_PRIORITY.unknown)
+      - (STATUS_PRIORITY[left.status] ?? STATUS_PRIORITY.unknown);
+    if (statusDelta !== 0) {
+      return statusDelta;
+    }
+    const claimDelta =
+      (CLAIM_LEVEL_PRIORITY[right.claimLevelGoal] ?? 0)
+      - (CLAIM_LEVEL_PRIORITY[left.claimLevelGoal] ?? 0);
+    if (claimDelta !== 0) {
+      return claimDelta;
+    }
+    return right.laneId.localeCompare(left.laneId);
+  });
+
+  return ranked[0];
+}
+
+function deriveSummary(packet) {
+  if (!packet) {
+    return {
+      computeSummary: 'No packaged compute lane is registered for this sunflower problem yet.',
+      computeNextAction: 'Stay in the atlas/dossier lane until a frozen benchmark and artifact bundle exist.',
+      budgetState: 'not_applicable',
+    };
+  }
+
+  const budgetState = packet.approvalRequired ? 'approval_required' : 'not_required';
+  if (packet.summary) {
+    return {
+      computeSummary: packet.summary,
+      computeNextAction:
+        packet.status === 'ready_for_local_scout'
+          ? 'Run the local scout first, then decide whether paid compute is honestly earned.'
+          : packet.status === 'ready_for_paid_transfer'
+            ? 'If budget approval is granted, launch the preferred paid rung and mirror the artifacts back into the workspace.'
+            : packet.status === 'paid_active'
+              ? 'Let the active metered run finish and pull back logs, artifacts, and impact notes before upgrading any claim.'
+              : packet.status === 'complete'
+                ? 'Review the completed artifact bundle and decide whether the next move is replay, certificate assembly, or a new frozen lane.'
+                : 'Refresh the compute lane status before making it part of the next route decision.',
+      budgetState,
+    };
+  }
+
+  if (packet.status === 'ready_for_local_scout') {
+    return {
+      computeSummary: `${packet.laneId} is packaged and ready for its local scout.`,
+      computeNextAction: 'Run the local scout first, then decide whether paid compute is honestly earned.',
+      budgetState,
+    };
+  }
+
+  if (packet.status === 'ready_for_paid_transfer') {
+    return {
+      computeSummary: `${packet.laneId} cleared the scout and is ready for the ${packet.recommendation || 'paid'} rung.`,
+      computeNextAction: 'If budget approval is granted, launch the preferred paid rung and mirror the artifacts back into the workspace.',
+      budgetState,
+    };
+  }
+
+  if (packet.status === 'paid_active') {
+    return {
+      computeSummary: `${packet.laneId} is actively using metered compute.`,
+      computeNextAction: 'Let the active metered run finish and pull back logs, artifacts, and impact notes before upgrading any claim.',
+      budgetState,
+    };
+  }
+
+  if (packet.status === 'complete') {
+    return {
+      computeSummary: `${packet.laneId} has a completed compute packet.`,
+      computeNextAction: 'Review the completed artifact bundle and decide whether the next move is replay, certificate assembly, or a new frozen lane.',
+      budgetState,
+    };
+  }
+
+  return {
+    computeSummary: `${packet.laneId} is packaged with status ${packet.status}.`,
+    computeNextAction: 'Refresh the compute lane status before making it part of the next route decision.',
+    budgetState,
+  };
+}
+
+function compactPacket(packet) {
+  if (!packet) {
+    return null;
+  }
+
+  return {
+    laneId: packet.laneId,
+    status: packet.status,
+    claimLevelGoal: packet.claimLevelGoal,
+    question: packet.question,
+    recommendation: packet.recommendation,
+    approvalRequired: packet.approvalRequired,
+    priceCheckedLocalDate: packet.priceCheckedLocalDate,
+    packetFileName: packet.packetFileName,
+    sourceRepo: packet.sourceRepo,
+  };
+}
+
+export function buildSunflowerStatusSnapshot(problem) {
+  const packets = listSunflowerComputePackets(problem.problemId);
+  const activePacket = chooseActivePacket(packets);
+  const summary = deriveSummary(activePacket);
+
+  return {
+    generatedAt: new Date().toISOString(),
+    problemId: problem.problemId,
+    displayName: problem.displayName,
+    title: problem.title,
+    cluster: problem.cluster,
+    activeRoute: problem.researchState?.active_route ?? null,
+    routeBreakthrough: Boolean(problem.researchState?.route_breakthrough),
+    openProblem: Boolean(problem.researchState?.open_problem),
+    problemSolved: Boolean(problem.researchState?.problem_solved),
+    computeLanePresent: Boolean(activePacket),
+    computeLaneCount: packets.length,
+    computeSummary: summary.computeSummary,
+    computeNextAction: summary.computeNextAction,
+    budgetState: summary.budgetState,
+    activePacket: compactPacket(activePacket),
+    computePackets: packets.map((packet) => compactPacket(packet)),
+  };
+}
+
+export function writeSunflowerStatusRecord(problem, snapshot, workspaceRoot) {
+  const registryDir = getWorkspaceComputeRegistryDir(workspaceRoot);
+  const timestamp = new Date().toISOString().replaceAll(':', '-');
+  const timestampedPath = path.join(registryDir, `${timestamp}__p${problem.problemId}.json`);
+  const latestPath = path.join(registryDir, `latest__p${problem.problemId}.json`);
+  writeJson(timestampedPath, snapshot);
+  writeJson(latestPath, snapshot);
+  return {
+    registryDir,
+    timestampedPath,
+    latestPath,
+  };
+}