erdos-problems 0.1.2 → 0.1.4

package/README.md

@@ -18,9 +18,11 @@ Official binary:
 
 - atlas layer with canonical local `problems/<id>/problem.yaml` records
 - bundled upstream snapshot from `teorth/erdosproblems`
-- workspace `.erdos/` state for active-problem selection, upstream refreshes, reports, and scaffolds
+- 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
 
 Seeded problems:
 - `18`, `20`, `89`, `536`, `542`, `856`, `857`, `1008`
@@ -30,7 +32,7 @@ Seeded problems:
 ```bash
 erdos problem list --cluster sunflower
 erdos bootstrap problem 857
-erdos problem artifacts 857
+erdos problem artifacts 857 --json
 erdos dossier show 857
 ```
 
@@ -40,6 +42,22 @@ What `bootstrap` does:
 - includes the upstream record when a bundled or workspace snapshot is available
 - gives an agent a ready-to-read local artifact bundle immediately after install
 
+## Pull bundles
+
+For any problem number in the upstream snapshot, you can create a workspace bundle even if the problem is not yet seeded locally:
+
+```bash
+erdos pull problem 857
+erdos pull problem 999 --include-site
+erdos pull problem 999 --refresh-upstream
+```
+
+What `pull` does:
+- creates `.erdos/pulls/<id>/`
+- includes the upstream record when available
+- includes the local canonical dossier too when the problem is seeded locally
+- can optionally add a live site snapshot and plain-text extract
+
 ## CLI
 
 ```bash
@@ -55,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
@@ -62,6 +82,8 @@ erdos upstream diff
 erdos scaffold problem 857
 erdos bootstrap problem 857
 erdos bootstrap problem 857 --sync-upstream
+erdos pull problem 857
+erdos pull problem 857 --include-site
 ```
 
 ## Canonical Sources
@@ -84,8 +106,14 @@ For each seeded problem, the canonical local dossier lives in `problems/<id>/`:
 The CLI can surface these directly:
 - `erdos problem artifacts <id>` shows the canonical inventory
 - `erdos problem artifacts <id> --json` emits machine-readable inventory
-- `erdos scaffold problem <id>` copies the bundle into the active workspace
+- `erdos scaffold problem <id>` copies the seeded dossier into the active workspace
 - `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
 

package/docs/ERDOS_PROBLEMS_PROBLEM_SCHEMA.md

@@ -12,10 +12,11 @@ The goal is:
 - open and solved problems use the same shape
 - local dossier truth and upstream public truth stay explicitly separated
 - packaged CLI installs can scaffold problem workspaces from canonical artifacts immediately
+- unseeded problems can still be pulled into a workspace bundle from upstream truth
 
 ## Canonical Files
 
-Each problem should have:
+Each seeded problem should have:
 
 - `problems/<id>/problem.yaml`
 - `problems/<id>/STATEMENT.md`
@@ -29,6 +30,12 @@ Bundled upstream snapshot artifacts live in:
 - `data/upstream/erdosproblems/PROBLEMS_INDEX.json`
 - `data/upstream/erdosproblems/SYNC_MANIFEST.json`
 
+Workspace-generated artifacts may live in:
+
+- `.erdos/scaffolds/<id>/`
+- `.erdos/pulls/<id>/`
+- `.erdos/upstream/erdosproblems/`
+
 ## Canonical Truth Split
 
 ### External public truth
@@ -178,4 +185,15 @@ The sync commands should produce:
 - upstream record snapshot for that problem when available
 - generated artifact index for agent consumption
 
-This makes a fresh npm-installed CLI immediately useful to an agentic workflow.
+This is the seeded-problem path.
+
+## Pull Contract
+
+`erdos pull problem <id>` should create a broader workspace-ready bundle containing:
+
+- upstream record snapshot for that problem when available
+- generated artifact index for agent consumption
+- seeded local dossier files too when the problem already exists in `problems/<id>/`
+- optional live site snapshot and extracted text when `--include-site` is used
+
+This makes a fresh npm-installed CLI immediately useful to an agentic workflow even for problems that are not yet fully seeded as local dossiers.

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.2",
+  "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

@@ -2,7 +2,9 @@ import { runBootstrapCommand } from '../commands/bootstrap.js';
 import { runClusterCommand } from '../commands/cluster.js';
 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';
 
@@ -18,12 +20,14 @@ 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]');
   console.log('  erdos upstream diff [--write-package-report]');
   console.log('  erdos scaffold problem <id> [--dest <path>]');
   console.log('  erdos bootstrap problem <id> [--dest <path>] [--sync-upstream]');
+  console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--refresh-upstream]');
 }
 
 const args = process.argv.slice(2);
@@ -39,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') {
@@ -47,6 +53,8 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = runScaffoldCommand(rest);
 } else if (command === 'bootstrap') {
   exitCode = await runBootstrapCommand(rest);
+} else if (command === 'pull') {
+  exitCode = await runPullCommand(rest);
 } else {
   console.error(`Unknown command: ${command}`);
   printUsage();

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/pull.js

@@ -0,0 +1,203 @@
+import path from 'node:path';
+import { getProblem } from '../atlas/catalog.js';
+import { ensureDir, writeJson, writeText } from '../runtime/files.js';
+import { getWorkspaceProblemPullDir } from '../runtime/paths.js';
+import { scaffoldProblem } from '../runtime/problem-artifacts.js';
+import { loadActiveUpstreamSnapshot, syncUpstream } from '../upstream/sync.js';
+import { fetchProblemSiteSnapshot } from '../upstream/site.js';
+
+function parsePullArgs(args) {
+  const [kind, value, ...rest] = args;
+  if (kind !== 'problem') {
+    return { error: 'Only `erdos pull problem <id>` is supported right now.' };
+  }
+
+  let destination = null;
+  let includeSite = false;
+  let refreshUpstream = false;
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (token === '--dest') {
+      destination = rest[index + 1];
+      if (!destination) {
+        return { error: 'Missing destination path after --dest.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--include-site') {
+      includeSite = true;
+      continue;
+    }
+    if (token === '--refresh-upstream') {
+      refreshUpstream = true;
+      continue;
+    }
+    return { error: `Unknown pull option: ${token}` };
+  }
+
+  return {
+    problemId: value,
+    destination,
+    includeSite,
+    refreshUpstream,
+  };
+}
+
+function writeUpstreamOnlyBundle(problemId, destination, upstreamRecord, snapshot) {
+  ensureDir(destination);
+
+  if (upstreamRecord) {
+    writeJson(path.join(destination, 'UPSTREAM_RECORD.json'), upstreamRecord);
+  }
+
+  const generatedAt = new Date().toISOString();
+  writeJson(path.join(destination, 'PROBLEM.json'), {
+    generatedAt,
+    problemId,
+    title: `Erdos Problem #${problemId}`,
+    cluster: null,
+    siteStatus: upstreamRecord?.status?.state ?? 'unknown',
+    repoStatus: 'upstream-only',
+    harnessDepth: 'unseeded',
+    sourceUrl: `https://www.erdosproblems.com/${problemId}`,
+    activeRoute: null,
+  });
+
+  writeJson(path.join(destination, 'ARTIFACT_INDEX.json'), {
+    generatedAt,
+    problemId,
+    copiedArtifacts: [],
+    canonicalArtifacts: [],
+    upstreamSnapshot: snapshot
+      ? {
+          kind: snapshot.kind,
+          manifestPath: snapshot.manifestPath,
+          indexPath: snapshot.indexPath,
+          yamlPath: snapshot.yamlPath,
+          upstreamCommit: snapshot.manifest.upstream_commit ?? null,
+          fetchedAt: snapshot.manifest.fetched_at,
+        }
+      : null,
+    includedUpstreamRecord: Boolean(upstreamRecord),
+  });
+
+  writeText(
+    path.join(destination, 'README.md'),
+    [
+      `# Erdos Problem ${problemId} Pull Bundle`,
+      '',
+      'This bundle was generated from upstream public metadata.',
+      '',
+      `- Source: https://www.erdosproblems.com/${problemId}`,
+      `- Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`,
+      '',
+      'This problem is not yet seeded locally as a canonical dossier in this package.',
+      '',
+    ].join('\n'),
+  );
+}
+
+async function maybeWriteSiteBundle(problemId, destination, includeSite) {
+  if (!includeSite) {
+    return { attempted: false, included: false, error: null };
+  }
+
+  try {
+    const siteSnapshot = await fetchProblemSiteSnapshot(problemId);
+    writeText(path.join(destination, 'SITE_SNAPSHOT.html'), siteSnapshot.html);
+    writeText(path.join(destination, 'SITE_EXTRACT.txt'), siteSnapshot.text);
+    writeJson(path.join(destination, 'SITE_EXTRACT.json'), {
+      url: siteSnapshot.url,
+      fetchedAt: siteSnapshot.fetchedAt,
+      title: siteSnapshot.title,
+      previewLines: siteSnapshot.previewLines,
+    });
+    writeText(
+      path.join(destination, 'SITE_SUMMARY.md'),
+      [
+        `# Erdős Problem #${problemId} Site Summary`,
+        '',
+        `Source: ${siteSnapshot.url}`,
+        `Fetched at: ${siteSnapshot.fetchedAt}`,
+        `Title: ${siteSnapshot.title}`,
+        '',
+        '## Preview',
+        '',
+        ...siteSnapshot.previewLines.map((line) => `- ${line}`),
+        '',
+      ].join('\n'),
+    );
+    return { attempted: true, included: true, error: null };
+  } catch (error) {
+    writeText(path.join(destination, 'SITE_FETCH_ERROR.txt'), String(error.message ?? error));
+    return { attempted: true, included: false, error: String(error.message ?? error) };
+  }
+}
+
+export async function runPullCommand(args) {
+  if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
+    console.log('Usage:');
+    console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--refresh-upstream]');
+    return 0;
+  }
+
+  const parsed = parsePullArgs(args);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+  if (!parsed.problemId) {
+    console.error('Missing problem id.');
+    return 1;
+  }
+
+  if (parsed.refreshUpstream) {
+    await syncUpstream();
+  }
+
+  const localProblem = getProblem(parsed.problemId);
+  const snapshot = loadActiveUpstreamSnapshot();
+  const upstreamRecord = snapshot?.index?.by_number?.[String(parsed.problemId)] ?? null;
+
+  if (!localProblem && !upstreamRecord) {
+    console.error(`Problem ${parsed.problemId} is not present in the local dossier set or upstream snapshot.`);
+    return 1;
+  }
+
+  const destination = parsed.destination
+    ? path.resolve(parsed.destination)
+    : getWorkspaceProblemPullDir(parsed.problemId);
+
+  let scaffoldResult = null;
+  if (localProblem) {
+    scaffoldResult = scaffoldProblem(localProblem, destination);
+  } else {
+    writeUpstreamOnlyBundle(String(parsed.problemId), destination, upstreamRecord, snapshot);
+  }
+
+
+  const siteStatus = await maybeWriteSiteBundle(String(parsed.problemId), destination, parsed.includeSite);
+
+  writeJson(path.join(destination, 'PULL_STATUS.json'), {
+    generatedAt: new Date().toISOString(),
+    problemId: String(parsed.problemId),
+    usedLocalDossier: Boolean(localProblem),
+    includedUpstreamRecord: Boolean(upstreamRecord),
+    upstreamSnapshotKind: snapshot?.kind ?? null,
+    siteSnapshotAttempted: siteStatus.attempted,
+    siteSnapshotIncluded: siteStatus.included,
+    siteSnapshotError: siteStatus.error,
+    scaffoldArtifactsCopied: scaffoldResult?.copiedArtifacts.length ?? 0,
+  });
+
+  console.log(`Pull bundle created: ${destination}`);
+  console.log(`Local canonical dossier included: ${localProblem ? 'yes' : 'no'}`);
+  console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
+  console.log(`Live site snapshot included: ${siteStatus.included ? 'yes' : 'no'}`);
+  if (siteStatus.error) {
+    console.log(`Live site snapshot note: ${siteStatus.error}`);
+  }
+  return 0;
+}

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) {
@@ -21,6 +23,19 @@ export function runWorkspaceCommand(args) {
   console.log(`Active problem: ${summary.activeProblem ?? '(none)'}`);
   console.log(`Workspace upstream dir: ${summary.upstreamDir}`);
   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');
 }
@@ -52,6 +60,14 @@ export function getWorkspaceProblemScaffoldDir(problemId) {
   return path.join(getWorkspaceScaffoldsDir(), String(problemId));
 }
 
+export function getWorkspacePullsDir() {
+  return path.join(getWorkspaceDir(), 'pulls');
+}
+
+export function getWorkspaceProblemPullDir(problemId) {
+  return path.join(getWorkspacePullsDir(), String(problemId));
+}
+
 export function getProblemDir(problemId) {
   return path.join(repoRoot, 'problems', String(problemId));
 }

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,
+  };
+}

package/src/runtime/workspace.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import {
   getCurrentProblemPath,
   getWorkspaceDir,
+  getWorkspaceProblemPullDir,
   getWorkspaceProblemScaffoldDir,
   getWorkspaceRoot,
   getWorkspaceStatePath,
@@ -66,6 +67,7 @@ export function getWorkspaceSummary() {
     activeProblem,
     upstreamDir: getWorkspaceUpstreamDir(),
     scaffoldDir: activeProblem ? getWorkspaceProblemScaffoldDir(activeProblem) : getWorkspaceProblemScaffoldDir('<problem-id>'),
+    pullDir: activeProblem ? getWorkspaceProblemPullDir(activeProblem) : getWorkspaceProblemPullDir('<problem-id>'),
     updatedAt: state?.updatedAt ?? null,
   };
 }

package/src/upstream/site.js

@@ -0,0 +1,80 @@
+const SITE_BASE_URL = 'https://www.erdosproblems.com';
+
+function decodeEntities(text) {
+  return text
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
+    .replace(/&#(\d+);/g, (_, decimal) => String.fromCodePoint(Number.parseInt(decimal, 10)))
+    .replace(/ /g, ' ')
+    .replace(/&/g, '&')
+    .replace(/"/g, '"')
+    .replace(/'/g, "'")
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>');
+}
+
+function collapseWhitespace(text) {
+  return text.replace(/[ \t]+/g, ' ').replace(/\s*\n\s*/g, '\n').trim();
+}
+
+function htmlToReadableText(html) {
+  const withoutScripts = html
+    .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+    .replace(/<style[\s\S]*?<\/style>/gi, ' ');
+  const blockSeparated = withoutScripts
+    .replace(/<(br|\/p|\/div|\/li|\/h1|\/h2|\/h3|\/section|\/article|\/tr)>/gi, '\n')
+    .replace(/<li[^>]*>/gi, '- ')
+    .replace(/<p[^>]*>/gi, '\n')
+    .replace(/<div[^>]*>/gi, '\n')
+    .replace(/<h[1-6][^>]*>/gi, '\n');
+  const stripped = blockSeparated.replace(/<[^>]+>/g, ' ');
+  const decoded = decodeEntities(stripped);
+  const normalizedLines = decoded
+    .split('\n')
+    .map((line) => collapseWhitespace(line))
+    .filter(Boolean);
+  return normalizedLines.join('\n');
+}
+
+function extractTitle(html, problemId) {
+  const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  if (!match) {
+    return `Erdos Problem #${problemId}`;
+  }
+  return collapseWhitespace(decodeEntities(match[1]));
+}
+
+function selectPreviewLines(lines) {
+  const anchorIndex = lines.findIndex((line) => /^(OPEN|SOLVED|PROVED|PARTIAL)\b/i.test(line));
+  if (anchorIndex >= 0) {
+    return lines.slice(anchorIndex, anchorIndex + 24);
+  }
+  return lines.slice(0, 24);
+}
+
+export async function fetchProblemSiteSnapshot(problemId) {
+  const url = `${SITE_BASE_URL}/${problemId}`;
+  const response = await fetch(url, {
+    headers: {
+      'User-Agent': 'erdos-problems-cli',
+      Accept: 'text/html',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Unable to fetch problem page ${problemId}: ${response.status}`);
+  }
+
+  const html = await response.text();
+  const text = htmlToReadableText(html);
+  const title = extractTitle(html, problemId);
+  const lines = text.split('\n').filter(Boolean);
+
+  return {
+    url,
+    fetchedAt: new Date().toISOString(),
+    html,
+    title,
+    text,
+    previewLines: selectPreviewLines(lines),
+  };
+}