erdos-problems 0.1.1 → 0.1.2

package/problems/89/problem.yaml

@@ -1,16 +1,37 @@
 problem_id: "89"
 display_name: "Erdos Problem #89"
-title: "Distinct Distances Lower Bound"
+title: Distinct Distances Lower Bound
 source:
-  site: "erdosproblems.com"
-  url: "https://www.erdosproblems.com/89"
+  site: erdosproblems.com
+  url: https://www.erdosproblems.com/89
   external_id: "89"
+upstream:
+  repo: https://github.com/teorth/erdosproblems
+  data_file: data/problems.yaml
+  number: "89"
 status:
-  site_status: "open"
-  site_badge: "OPEN"
-  repo_status: "cataloged"
-cluster: "geometry"
+  site_status: open
+  site_badge: OPEN
+  repo_status: cataloged
+  upstream_status: open
+  upstream_last_update: 2025-08-31
+cluster: geometry
+prize:
+  display: $500
 related_problems: []
 family_tags:
-  - "geometry"
-  - "distances"
+  - geometry
+  - distances
+harness:
+  depth: dossier
+statement:
+  short: Ask whether every n-point set in the plane determines at least a constant
+    multiple of n/sqrt(log n) distinct distances.
+  normalized_md_path: STATEMENT.md
+references_path: REFERENCES.md
+evidence_path: EVIDENCE.md
+formalization_path: FORMALIZATION.md
+formalization:
+  status: statement-formalized
+  upstream_state: yes
+  upstream_last_update: 2025-10-24

package/src/atlas/catalog.js

@@ -1,154 +1,88 @@
-export const catalog = [
-  {
-    problemId: '18',
-    displayName: 'Erdos Problem #18',
-    title: 'Practical Numbers Divisor-Sum Efficiency',
-    siteStatus: 'open',
-    siteBadge: 'OPEN',
-    repoStatus: 'cataloged',
-    cluster: 'number-theory',
-    familyTags: ['number-theory', 'divisors', 'factorials'],
-    relatedProblems: [],
-    sourceUrl: 'https://www.erdosproblems.com/18',
-    shortStatement:
-      'Study whether infinitely many practical numbers admit polylogarithmic divisor-sum efficiency, and whether h(n!) is polylogarithmic.',
-    harnessDepth: 'dossier',
-    formalizationStatus: 'statement-formalized',
-  },
-  {
-    problemId: '20',
-    displayName: 'Erdos Problem #20',
-    title: 'Strong Sunflower Problem',
-    siteStatus: 'open',
-    siteBadge: 'OPEN',
-    repoStatus: 'active',
-    cluster: 'sunflower',
-    familyTags: ['sunflower', 'uniform-families'],
-    relatedProblems: ['857'],
-    sourceUrl: 'https://www.erdosproblems.com/20',
-    shortStatement:
-      'Determine the strong sunflower threshold for k-uniform set systems, with the k=3 lane as the immediate active frontier.',
-    harnessDepth: 'deep',
-    formalizationStatus: 'active',
-  },
-  {
-    problemId: '89',
-    displayName: 'Erdos Problem #89',
-    title: 'Distinct Distances Lower Bound',
-    siteStatus: 'open',
-    siteBadge: 'OPEN',
-    repoStatus: 'cataloged',
-    cluster: 'geometry',
-    familyTags: ['geometry', 'distances'],
-    relatedProblems: [],
-    sourceUrl: 'https://www.erdosproblems.com/89',
-    shortStatement:
-      'Ask whether every n-point set in the plane determines at least a constant multiple of n/sqrt(log n) distinct distances.',
-    harnessDepth: 'dossier',
-    formalizationStatus: 'statement-formalized',
-  },
-  {
-    problemId: '536',
-    displayName: 'Erdos Problem #536',
-    title: 'LCM Sunflower Analogue',
-    siteStatus: 'open',
-    siteBadge: 'OPEN',
-    repoStatus: 'cataloged',
-    cluster: 'sunflower',
-    familyTags: ['sunflower-analogue', 'number-theory'],
-    relatedProblems: ['857'],
-    sourceUrl: 'https://www.erdosproblems.com/536',
-    shortStatement:
-      'Number-theoretic analogue of the sunflower problem framed through least common multiples.',
-    harnessDepth: 'dossier',
-    formalizationStatus: 'planned',
-  },
-  {
-    problemId: '542',
-    displayName: 'Erdos Problem #542',
-    title: 'LCM-Free Sets Reciprocal Sum Bound',
-    siteStatus: 'solved',
-    siteBadge: 'SOLVED',
-    repoStatus: 'historical',
-    cluster: 'number-theory',
-    familyTags: ['number-theory', 'least-common-multiple'],
-    relatedProblems: ['784'],
-    sourceUrl: 'https://www.erdosproblems.com/542',
-    shortStatement:
-      'Control reciprocal sums of sets with all pairwise least common multiples above n, a problem resolved by Schinzel and Szekeres.',
-    harnessDepth: 'dossier',
-    formalizationStatus: 'unstarted',
-  },
-  {
-    problemId: '856',
-    displayName: 'Erdos Problem #856',
-    title: 'Harmonic LCM Sunflower Analogue',
-    siteStatus: 'open',
-    siteBadge: 'OPEN',
-    repoStatus: 'cataloged',
-    cluster: 'sunflower',
-    familyTags: ['sunflower-analogue', 'number-theory'],
-    relatedProblems: ['857'],
-    sourceUrl: 'https://www.erdosproblems.com/856',
-    shortStatement:
-      'A harmonic or density-shaped LCM analogue whose exponents are explicitly linked to progress on the weak sunflower problem.',
-    harnessDepth: 'dossier',
-    formalizationStatus: 'planned',
-  },
-  {
-    problemId: '857',
-    displayName: 'Erdos Problem #857',
-    title: 'Sunflower Conjecture',
-    siteStatus: 'open',
-    siteBadge: 'OPEN',
-    repoStatus: 'active',
-    cluster: 'sunflower',
-    familyTags: ['sunflower', 'extremal-set-theory'],
-    relatedProblems: ['20', '536', '856'],
-    sourceUrl: 'https://www.erdosproblems.com/857',
-    shortStatement:
-      'Bound the weak sunflower number m(n,k) by C(k)^n and sharpen the current active route toward asymptotic closure.',
-    harnessDepth: 'deep',
-    formalizationStatus: 'active',
-    researchState: {
-      openProblem: true,
-      activeRoute: 'anchored_selector_linearization',
-      routeBreakthrough: true,
-      problemSolved: false,
-    },
-  },
-  {
-    problemId: '1008',
-    displayName: 'Erdos Problem #1008',
-    title: 'C4-Free Subgraph Density Problem',
-    siteStatus: 'solved',
-    siteBadge: 'PROVED (LEAN)',
-    repoStatus: 'historical',
-    cluster: 'graph-theory',
-    familyTags: ['graph-theory', 'cycles'],
-    relatedProblems: [],
-    sourceUrl: 'https://www.erdosproblems.com/1008',
-    shortStatement:
-      'Determine whether every graph with m edges contains a C4-free subgraph with a constant multiple of m^(2/3) edges.',
-    harnessDepth: 'dossier',
-    formalizationStatus: 'site-proved-lean',
-  },
-];
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { getProblemDir, repoRoot } from '../runtime/paths.js';
+
+let cachedProblems = null;
+
+function readProblemRecord(problemId) {
+  const problemDir = getProblemDir(problemId);
+  const yamlPath = path.join(problemDir, 'problem.yaml');
+  const record = parse(fs.readFileSync(yamlPath, 'utf8'));
+  return { problemDir, record };
+}
+
+function toCatalogProblem(problemDir, record) {
+  const statementRelative = record.statement?.normalized_md_path ?? 'STATEMENT.md';
+  const referencesRelative = record.references_path ?? 'REFERENCES.md';
+  const evidenceRelative = record.evidence_path ?? 'EVIDENCE.md';
+  const formalizationRelative = record.formalization_path ?? 'FORMALIZATION.md';
+
+  return {
+    problemId: String(record.problem_id),
+    displayName: record.display_name,
+    title: record.title,
+    sourceUrl: record.source?.url,
+    sourceSite: record.source?.site,
+    siteStatus: record.status?.site_status ?? 'unknown',
+    siteBadge: record.status?.site_badge ?? String(record.status?.site_status ?? 'unknown').toUpperCase(),
+    repoStatus: record.status?.repo_status ?? 'cataloged',
+    upstreamStatus: record.status?.upstream_status ?? null,
+    upstreamLastUpdate: record.status?.upstream_last_update ?? null,
+    cluster: record.cluster ?? 'uncategorized',
+    prize: record.prize?.display ?? null,
+    familyTags: record.family_tags ?? [],
+    relatedProblems: record.related_problems ?? [],
+    harnessDepth: record.harness?.depth ?? 'dossier',
+    shortStatement: record.statement?.short ?? '',
+    formalizationStatus: record.formalization?.status ?? 'unstarted',
+    upstreamFormalizedState: record.formalization?.upstream_state ?? null,
+    upstreamFormalizedLastUpdate: record.formalization?.upstream_last_update ?? null,
+    researchState: record.research_state ?? null,
+    upstream: record.upstream ?? null,
+    statementPath: path.join(problemDir, statementRelative),
+    referencesPath: path.join(problemDir, referencesRelative),
+    evidencePath: path.join(problemDir, evidenceRelative),
+    formalizationPath: path.join(problemDir, formalizationRelative),
+    problemDir,
+    problemYamlPath: path.join(problemDir, 'problem.yaml'),
+    record,
+  };
+}
+
+export function loadLocalProblems() {
+  if (cachedProblems) {
+    return cachedProblems;
+  }
+  const problemsRoot = path.join(repoRoot, 'problems');
+  const directories = fs
+    .readdirSync(problemsRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort((a, b) => Number(a) - Number(b));
+
+  cachedProblems = directories.map((problemId) => {
+    const { problemDir, record } = readProblemRecord(problemId);
+    return toCatalogProblem(problemDir, record);
+  });
+  return cachedProblems;
+}
 
 export function listProblems(filters = {}) {
   const cluster = filters.cluster ? String(filters.cluster).toLowerCase() : null;
   const repoStatus = filters.repoStatus ? String(filters.repoStatus).toLowerCase() : null;
   const harnessDepth = filters.harnessDepth ? String(filters.harnessDepth).toLowerCase() : null;
+  const siteStatus = filters.siteStatus ? String(filters.siteStatus).toLowerCase() : null;
 
-  return [...catalog]
+  return loadLocalProblems()
     .filter((entry) => (cluster ? entry.cluster === cluster : true))
     .filter((entry) => (repoStatus ? entry.repoStatus === repoStatus : true))
     .filter((entry) => (harnessDepth ? entry.harnessDepth === harnessDepth : true))
-    .sort((a, b) => Number(a.problemId) - Number(b.problemId));
+    .filter((entry) => (siteStatus ? entry.siteStatus === siteStatus : true));
 }
 
 export function getProblem(problemId) {
-  return catalog.find((entry) => entry.problemId === String(problemId));
+  return loadLocalProblems().find((entry) => entry.problemId === String(problemId));
 }
 
 export function getCluster(clusterName) {
@@ -166,6 +100,10 @@ export function getCluster(clusterName) {
 }
 
 export function listClusters() {
-  const names = [...new Set(catalog.map((entry) => entry.cluster))].sort();
+  const names = [...new Set(loadLocalProblems().map((entry) => entry.cluster))].sort();
   return names.map((name) => getCluster(name));
 }
+
+export function clearCatalogCache() {
+  cachedProblems = null;
+}

package/src/cli/index.js

@@ -1,20 +1,29 @@
+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 { runScaffoldCommand } from '../commands/scaffold.js';
+import { runUpstreamCommand } from '../commands/upstream.js';
 import { runWorkspaceCommand } from '../commands/workspace.js';
 
 function printUsage() {
   console.log('erdos-problems CLI');
   console.log('');
   console.log('Usage:');
-  console.log('  erdos problem list [--cluster <name>]');
+  console.log('  erdos problem list [--cluster <name>] [--repo-status <status>] [--harness-depth <depth>] [--site-status <status>]');
   console.log('  erdos problem show <id>');
   console.log('  erdos problem use <id>');
   console.log('  erdos problem current');
+  console.log('  erdos problem artifacts [<id>] [--json]');
   console.log('  erdos cluster list');
   console.log('  erdos cluster show <name>');
   console.log('  erdos workspace show');
   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]');
 }
 
 const args = process.argv.slice(2);
@@ -32,6 +41,12 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = runWorkspaceCommand(rest);
 } else if (command === 'dossier') {
   exitCode = runDossierCommand(rest);
+} else if (command === 'upstream') {
+  exitCode = await runUpstreamCommand(rest);
+} else if (command === 'scaffold') {
+  exitCode = runScaffoldCommand(rest);
+} else if (command === 'bootstrap') {
+  exitCode = await runBootstrapCommand(rest);
 } else {
   console.error(`Unknown command: ${command}`);
   printUsage();

package/src/commands/bootstrap.js

@@ -0,0 +1,81 @@
+import path from 'node:path';
+import { getProblem } from '../atlas/catalog.js';
+import { scaffoldProblem } from '../runtime/problem-artifacts.js';
+import { getWorkspaceProblemScaffoldDir } from '../runtime/paths.js';
+import { setCurrentProblem } from '../runtime/workspace.js';
+import { syncUpstream } from '../upstream/sync.js';
+
+function parseBootstrapArgs(args) {
+  const [kind, value, ...rest] = args;
+  if (kind !== 'problem') {
+    return { error: 'Only `erdos bootstrap problem <id>` is supported right now.' };
+  }
+
+  let destination = null;
+  let syncUpstreamSnapshot = 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 === '--sync-upstream') {
+      syncUpstreamSnapshot = true;
+      continue;
+    }
+    return { error: `Unknown bootstrap option: ${token}` };
+  }
+
+  return {
+    problemId: value,
+    destination,
+    syncUpstreamSnapshot,
+  };
+}
+
+export async function runBootstrapCommand(args) {
+  if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
+    console.log('Usage:');
+    console.log('  erdos bootstrap problem <id> [--dest <path>] [--sync-upstream]');
+    return 0;
+  }
+
+  const parsed = parseBootstrapArgs(args);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+  if (!parsed.problemId) {
+    console.error('Missing problem id.');
+    return 1;
+  }
+
+  const problem = getProblem(parsed.problemId);
+  if (!problem) {
+    console.error(`Unknown problem: ${parsed.problemId}`);
+    return 1;
+  }
+
+  if (parsed.syncUpstreamSnapshot) {
+    const syncResult = await syncUpstream();
+    console.log(`Workspace upstream snapshot refreshed: ${syncResult.workspacePaths.manifestPath}`);
+  }
+
+  setCurrentProblem(problem.problemId);
+  const destination = parsed.destination
+    ? path.resolve(parsed.destination)
+    : getWorkspaceProblemScaffoldDir(problem.problemId);
+  const result = scaffoldProblem(problem, destination);
+
+  console.log(`Bootstrapped problem ${problem.problemId} (${problem.title})`);
+  console.log(`Active problem: ${problem.problemId}`);
+  console.log(`Scaffold dir: ${result.destination}`);
+  console.log(`Artifacts copied: ${result.copiedArtifacts.length}`);
+  console.log(`Upstream record included: ${result.inventory.upstreamRecordIncluded ? 'yes' : 'no'}`);
+  return 0;
+}

package/src/commands/dossier.js

@@ -1,10 +1,14 @@
 import fs from 'node:fs';
-import path from 'node:path';
 import { getProblem } from '../atlas/catalog.js';
-import { getProblemDir } from '../runtime/paths.js';
 import { readCurrentProblem } from '../runtime/workspace.js';
 
-const sections = ['STATEMENT.md', 'REFERENCES.md', 'EVIDENCE.md', 'FORMALIZATION.md'];
+const sections = [
+  ['problem.yaml', 'problemYamlPath'],
+  ['STATEMENT.md', 'statementPath'],
+  ['REFERENCES.md', 'referencesPath'],
+  ['EVIDENCE.md', 'evidencePath'],
+  ['FORMALIZATION.md', 'formalizationPath'],
+];
 
 export function runDossierCommand(args) {
   const [subcommand, value] = args;
@@ -32,20 +36,24 @@ export function runDossierCommand(args) {
     return 1;
   }
 
-  const problemDir = getProblemDir(problem.problemId);
   console.log(`${problem.displayName} dossier`);
-  console.log(`Directory: ${problemDir}`);
+  console.log(`Directory: ${problem.problemDir}`);
   console.log('Sections:');
-  for (const section of sections) {
-    const filePath = path.join(problemDir, section);
+  for (const [label, key] of sections) {
+    const filePath = problem[key];
     const exists = fs.existsSync(filePath);
-    console.log(`- ${section}: ${exists ? 'present' : 'missing'}`);
+    console.log(`- ${label}: ${exists ? 'present' : 'missing'}`);
   }
-  const statementPath = path.join(problemDir, 'STATEMENT.md');
-  if (fs.existsSync(statementPath)) {
+  console.log('');
+  console.log('Canonical metadata:');
+  console.log(`- cluster: ${problem.cluster}`);
+  console.log(`- repo status: ${problem.repoStatus}`);
+  console.log(`- harness depth: ${problem.harnessDepth}`);
+  console.log(`- upstream number: ${problem.upstream?.number ?? '(unset)'}`);
+  if (fs.existsSync(problem.statementPath)) {
     console.log('');
     console.log('Statement preview:');
-    console.log(fs.readFileSync(statementPath, 'utf8').trim());
+    console.log(fs.readFileSync(problem.statementPath, 'utf8').trim());
   }
   return 0;
 }

package/src/commands/problem.js

@@ -1,4 +1,5 @@
 import { getProblem, listProblems } from '../atlas/catalog.js';
+import { getProblemArtifactInventory } from '../runtime/problem-artifacts.js';
 import { readCurrentProblem, setCurrentProblem } from '../runtime/workspace.js';
 
 function parseListFilters(args) {
@@ -32,11 +33,42 @@ function parseListFilters(args) {
       index += 1;
       continue;
     }
+    if (token === '--site-status') {
+      const siteStatus = args[index + 1];
+      if (!siteStatus) {
+        return { error: 'Missing site status after --site-status.' };
+      }
+      filters.siteStatus = siteStatus;
+      index += 1;
+      continue;
+    }
     return { error: `Unknown list option: ${token}` };
   }
   return { filters };
 }
 
+function parseArtifactArgs(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 artifact option: ${token}` };
+  }
+
+  return parsed;
+}
+
 function printProblemTable(rows, activeProblem) {
   console.log('ID   Site   Repo       Cluster         Depth    Active  Title');
   for (const row of rows) {
@@ -59,28 +91,64 @@ function printProblem(problem) {
   console.log(`Repo status: ${problem.repoStatus}`);
   console.log(`Cluster: ${problem.cluster}`);
   console.log(`Harness depth: ${problem.harnessDepth}`);
+  console.log(`Prize: ${problem.prize ?? '(none)'}`);
   console.log(`Formalization: ${problem.formalizationStatus}`);
+  console.log(`Upstream formalized: ${problem.upstreamFormalizedState ?? '(unknown)'}`);
+  console.log(`Upstream last update: ${problem.upstreamLastUpdate ?? '(unknown)'}`);
   console.log(`Related: ${problem.relatedProblems.join(', ') || '(none)'}`);
   console.log(`Tags: ${problem.familyTags.join(', ') || '(none)'}`);
   console.log(`Statement: ${problem.shortStatement}`);
   if (problem.researchState) {
     console.log('Research state:');
-    console.log(`  open problem: ${problem.researchState.openProblem ? 'yes' : 'no'}`);
-    console.log(`  active route: ${problem.researchState.activeRoute}`);
-    console.log(`  route breakthrough: ${problem.researchState.routeBreakthrough ? 'yes' : 'no'}`);
-    console.log(`  problem solved: ${problem.researchState.problemSolved ? 'yes' : 'no'}`);
+    console.log(`  open problem: ${problem.researchState.open_problem ? 'yes' : 'no'}`);
+    console.log(`  active route: ${problem.researchState.active_route}`);
+    console.log(`  route breakthrough: ${problem.researchState.route_breakthrough ? 'yes' : 'no'}`);
+    console.log(`  problem solved: ${problem.researchState.problem_solved ? 'yes' : 'no'}`);
+  }
+  if (problem.upstream) {
+    console.log('Upstream provenance:');
+    console.log(`  repo: ${problem.upstream.repo}`);
+    console.log(`  data file: ${problem.upstream.data_file}`);
+    console.log(`  number: ${problem.upstream.number}`);
   }
 }
 
+function printArtifactInventory(problem, inventory, asJson) {
+  if (asJson) {
+    console.log(JSON.stringify(inventory, null, 2));
+    return;
+  }
+
+  console.log(`${problem.displayName} canonical artifacts`);
+  console.log(`Problem directory: ${inventory.problemDir}`);
+  console.log(`Source: ${inventory.sourceUrl}`);
+  console.log('Canonical files:');
+  for (const artifact of inventory.canonicalArtifacts) {
+    console.log(`- ${artifact.label}: ${artifact.exists ? 'present' : 'missing'} (${artifact.path})`);
+  }
+  if (inventory.packContext) {
+    console.log(`- ${inventory.packContext.label}: ${inventory.packContext.exists ? 'present' : 'missing'} (${inventory.packContext.path})`);
+  }
+  if (inventory.upstreamSnapshot) {
+    console.log('Upstream snapshot:');
+    console.log(`- kind: ${inventory.upstreamSnapshot.kind}`);
+    console.log(`- manifest: ${inventory.upstreamSnapshot.manifestPath}`);
+    console.log(`- index: ${inventory.upstreamSnapshot.indexPath}`);
+    console.log(`- commit: ${inventory.upstreamSnapshot.upstreamCommit ?? '(unknown)'}`);
+  }
+  console.log(`Upstream record available: ${inventory.upstreamRecordIncluded ? 'yes' : 'no'}`);
+}
+
 export function runProblemCommand(args) {
   const [subcommand, value, ...rest] = args;
 
   if (!subcommand || subcommand === 'help' || subcommand === '--help') {
     console.log('Usage:');
-    console.log('  erdos problem list [--cluster <name>] [--repo-status <status>] [--harness-depth <depth>]');
+    console.log('  erdos problem list [--cluster <name>] [--repo-status <status>] [--harness-depth <depth>] [--site-status <status>]');
     console.log('  erdos problem show <id>');
     console.log('  erdos problem use <id>');
     console.log('  erdos problem current');
+    console.log('  erdos problem artifacts [<id>] [--json]');
     return 0;
   }
 
@@ -139,6 +207,27 @@ export function runProblemCommand(args) {
     return 0;
   }
 
+  if (subcommand === 'artifacts') {
+    const parsed = parseArtifactArgs([value, ...rest].filter(Boolean));
+    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;
+    }
+    const inventory = getProblemArtifactInventory(problem);
+    printArtifactInventory(problem, inventory, parsed.asJson);
+    return 0;
+  }
+
   console.error(`Unknown problem subcommand: ${subcommand}`);
   return 1;
 }

package/src/commands/scaffold.js

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { getProblem } from '../atlas/catalog.js';
+import { scaffoldProblem } from '../runtime/problem-artifacts.js';
+import { getWorkspaceProblemScaffoldDir } from '../runtime/paths.js';
+import { readCurrentProblem } from '../runtime/workspace.js';
+
+export function parseScaffoldArgs(args) {
+  const [kind, value, ...rest] = args;
+  if (kind !== 'problem') {
+    return { error: 'Only `erdos scaffold problem <id>` is supported right now.' };
+  }
+  let destination = null;
+  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;
+    }
+    return { error: `Unknown scaffold option: ${token}` };
+  }
+  return { problemId: value ?? readCurrentProblem(), destination };
+}
+
+export function runScaffoldCommand(args) {
+  if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
+    console.log('Usage:');
+    console.log('  erdos scaffold problem <id> [--dest <path>]');
+    return 0;
+  }
+
+  const parsed = parseScaffoldArgs(args);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+  if (!parsed.problemId) {
+    console.error('Missing problem id and no active problem is selected.');
+    return 1;
+  }
+
+  const problem = getProblem(parsed.problemId);
+  if (!problem) {
+    console.error(`Unknown problem: ${parsed.problemId}`);
+    return 1;
+  }
+
+  const destination = parsed.destination
+    ? path.resolve(parsed.destination)
+    : getWorkspaceProblemScaffoldDir(problem.problemId);
+
+  const result = scaffoldProblem(problem, destination);
+  console.log(`Scaffold created: ${result.destination}`);
+  console.log(`Artifacts copied: ${result.copiedArtifacts.length}`);
+  console.log(`Upstream record included: ${result.inventory.upstreamRecordIncluded ? 'yes' : 'no'}`);
+  return 0;
+}