erdos-problems 0.1.6 → 0.1.7

package/README.md

@@ -38,6 +38,14 @@ erdos sunflower status 857
 erdos dossier show 857
 ```
 
+For an unseeded problem, the one-step self-seeding flow is now:
+
+```bash
+erdos seed problem 1 --include-site --cluster number-theory
+erdos problem show 1
+erdos workspace show
+```
+
 What `bootstrap` does:
 - sets the active workspace problem
 - scaffolds the canonical dossier files into `.erdos/scaffolds/<id>/`
@@ -45,6 +53,13 @@ What `bootstrap` does:
 - copies pack-specific context and compute packets when the problem has them
 - gives an agent a ready-to-read local artifact bundle immediately after install
 
+What `seed` does:
+- creates a pull bundle for any problem in the upstream snapshot
+- promotes that bundle into `.erdos/seeded-problems/<id>/`
+- auto-selects the problem in the workspace
+- syncs the staged research loop state and checkpoint shelf
+- makes the new dossier visible to the atlas commands immediately inside that workspace
+
 ## Pull lanes
 
 For any problem number in the upstream snapshot, you can create a workspace bundle even if the problem is not yet seeded locally:
@@ -138,6 +153,7 @@ erdos upstream diff
 erdos scaffold problem 857
 erdos bootstrap problem 857
 erdos bootstrap problem 857 --sync-upstream
+erdos seed problem 1 --include-site --cluster number-theory
 erdos pull problem 857
 erdos pull artifacts 857
 erdos pull literature 857
@@ -166,6 +182,7 @@ The CLI can surface these directly:
 - `erdos problem artifacts <id> --json` emits machine-readable inventory
 - `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 seed problem <id>` self-seeds an unseeded problem into `.erdos/seeded-problems/` and syncs the loop
 - `erdos pull problem <id>` creates a workspace bundle for any problem in the upstream snapshot
 - `erdos maintainer seed problem <id>` promotes a pull bundle into a canonical local dossier
 
@@ -213,5 +230,9 @@ The public package uses the same status ladder we settled on in the lab:
 - route breakthrough
 - problem solved
 
+That means a fresh install now supports two clean research starts:
+- `erdos bootstrap problem <seeded-id>` for native packaged dossiers
+- `erdos seed problem <unseeded-id>` for workspace-local self-seeding with the same loop
+
 See also:
 - `docs/RESEARCH_LOOP.md`

package/docs/RESEARCH_LOOP.md

@@ -36,6 +36,17 @@ erdos checkpoints sync
 erdos workspace show
 ```
 
+For problems that are not yet packaged as native dossiers, the loop can start with one-step self-seeding:
+
+```bash
+erdos seed problem 1 --include-site --cluster number-theory
+erdos preflight
+erdos continuation use route
+erdos checkpoints sync
+```
+
+That flow writes the local dossier into `.erdos/seeded-problems/<id>/`, makes it visible to the atlas inside the current workspace, and immediately syncs the same state/checkpoint machinery used by packaged dossiers.
+
 ## Status ladder
 
 The public package uses the same ladder we converged on in the lab:

package/package.json

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

package/src/atlas/catalog.js

@@ -1,18 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parse } from 'yaml';
-import { getProblemDir, repoRoot } from '../runtime/paths.js';
+import { getProblemDir, getWorkspaceRoot, getWorkspaceSeededProblemsDir, repoRoot } from '../runtime/paths.js';
 
-let cachedProblems = null;
-
-function readProblemRecord(problemId) {
-  const problemDir = getProblemDir(problemId);
+function readProblemRecordFromDir(problemDir) {
   const yamlPath = path.join(problemDir, 'problem.yaml');
   const record = parse(fs.readFileSync(yamlPath, 'utf8'));
   return { problemDir, record };
 }
 
-function toCatalogProblem(problemDir, record) {
+function toCatalogProblem(problemDir, record, sourceKind) {
   const statementRelative = record.statement?.normalized_md_path ?? 'STATEMENT.md';
   const referencesRelative = record.references_path ?? 'REFERENCES.md';
   const evidenceRelative = record.evidence_path ?? 'EVIDENCE.md';
@@ -47,47 +44,58 @@ function toCatalogProblem(problemDir, record) {
     problemDir,
     problemYamlPath: path.join(problemDir, 'problem.yaml'),
     record,
+    sourceKind,
   };
 }
 
-export function loadLocalProblems() {
-  if (cachedProblems) {
-    return cachedProblems;
+function listProblemDirectories(rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    return [];
   }
-  const problemsRoot = path.join(repoRoot, 'problems');
-  const directories = fs
-    .readdirSync(problemsRoot, { withFileTypes: true })
+  return fs
+    .readdirSync(rootDir, { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name)
-    .sort((a, b) => Number(a) - Number(b));
+    .map((entry) => path.join(rootDir, entry.name));
+}
+
+export function loadLocalProblems(workspaceRoot = getWorkspaceRoot()) {
+  const packageRoot = path.join(repoRoot, 'problems');
+  const workspaceRootDir = getWorkspaceSeededProblemsDir(workspaceRoot);
+  const merged = new Map();
+
+  for (const problemDir of listProblemDirectories(packageRoot)) {
+    const { record } = readProblemRecordFromDir(problemDir);
+    merged.set(String(record.problem_id), toCatalogProblem(problemDir, record, 'package'));
+  }
+
+  for (const problemDir of listProblemDirectories(workspaceRootDir)) {
+    const { record } = readProblemRecordFromDir(problemDir);
+    merged.set(String(record.problem_id), toCatalogProblem(problemDir, record, 'workspace'));
+  }
 
-  cachedProblems = directories.map((problemId) => {
-    const { problemDir, record } = readProblemRecord(problemId);
-    return toCatalogProblem(problemDir, record);
-  });
-  return cachedProblems;
+  return [...merged.values()].sort((left, right) => Number(left.problemId) - Number(right.problemId));
 }
 
-export function listProblems(filters = {}) {
+export function listProblems(filters = {}, workspaceRoot = getWorkspaceRoot()) {
   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 loadLocalProblems()
+  return loadLocalProblems(workspaceRoot)
     .filter((entry) => (cluster ? entry.cluster === cluster : true))
     .filter((entry) => (repoStatus ? entry.repoStatus === repoStatus : true))
     .filter((entry) => (harnessDepth ? entry.harnessDepth === harnessDepth : true))
     .filter((entry) => (siteStatus ? entry.siteStatus === siteStatus : true));
 }
 
-export function getProblem(problemId) {
-  return loadLocalProblems().find((entry) => entry.problemId === String(problemId));
+export function getProblem(problemId, workspaceRoot = getWorkspaceRoot()) {
+  return loadLocalProblems(workspaceRoot).find((entry) => entry.problemId === String(problemId));
 }
 
-export function getCluster(clusterName) {
+export function getCluster(clusterName, workspaceRoot = getWorkspaceRoot()) {
   const name = String(clusterName).toLowerCase();
-  const problems = listProblems({ cluster: name });
+  const problems = listProblems({ cluster: name }, workspaceRoot);
   if (problems.length === 0) {
     return null;
   }
@@ -99,11 +107,11 @@ export function getCluster(clusterName) {
   };
 }
 
-export function listClusters() {
-  const names = [...new Set(loadLocalProblems().map((entry) => entry.cluster))].sort();
-  return names.map((name) => getCluster(name));
+export function listClusters(workspaceRoot = getWorkspaceRoot()) {
+  const names = [...new Set(loadLocalProblems(workspaceRoot).map((entry) => entry.cluster))].sort();
+  return names.map((name) => getCluster(name, workspaceRoot));
 }
 
 export function clearCatalogCache() {
-  cachedProblems = null;
+  return null;
 }

package/src/cli/index.js

@@ -8,6 +8,7 @@ import { runPreflightCommand } from '../commands/preflight.js';
 import { runProblemCommand } from '../commands/problem.js';
 import { runPullCommand } from '../commands/pull.js';
 import { runScaffoldCommand } from '../commands/scaffold.js';
+import { runSeedCommand } from '../commands/seed.js';
 import { runStateCommand } from '../commands/state.js';
 import { runSunflowerCommand } from '../commands/sunflower.js';
 import { runUpstreamCommand } from '../commands/upstream.js';
@@ -38,6 +39,7 @@ function printUsage() {
   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 seed problem <id> [--include-site] [--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] [--dest-root <path>] [--no-activate] [--no-loop-sync] [--force] [--json]');
   console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--refresh-upstream]');
   console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream]');
   console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--refresh-upstream]');
@@ -75,6 +77,8 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = runScaffoldCommand(rest);
 } else if (command === 'bootstrap') {
   exitCode = await runBootstrapCommand(rest);
+} else if (command === 'seed') {
+  exitCode = await runSeedCommand(rest);
 } else if (command === 'pull') {
   exitCode = await runPullCommand(rest);
 } else if (command === 'maintainer') {

package/src/commands/pull.js

@@ -257,22 +257,29 @@ function writeRootProblemBundle(rootDir, problemId, localProblem, upstreamRecord
   return problemRecord;
 }
 
-export async function runPullCommand(args) {
+export async function runPullCommand(args, options = {}) {
+  const silent = options.silent === true;
   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]');
-    console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream]');
-    console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--refresh-upstream]');
+    if (!silent) {
+      console.log('Usage:');
+      console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--refresh-upstream]');
+      console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream]');
+      console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--refresh-upstream]');
+    }
     return 0;
   }
 
   const parsed = parsePullArgs(args);
   if (parsed.error) {
-    console.error(parsed.error);
+    if (!silent) {
+      console.error(parsed.error);
+    }
     return 1;
   }
   if (!parsed.problemId) {
-    console.error('Missing problem id.');
+    if (!silent) {
+      console.error('Missing problem id.');
+    }
     return 1;
   }
 
@@ -285,7 +292,9 @@ export async function runPullCommand(args) {
   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.`);
+    if (!silent) {
+      console.error(`Problem ${parsed.problemId} is not present in the local dossier set or upstream snapshot.`);
+    }
     return 1;
   }
 
@@ -294,10 +303,12 @@ export async function runPullCommand(args) {
       ? path.resolve(parsed.destination)
       : getWorkspaceProblemArtifactDir(parsed.problemId);
     const result = writeArtifactsLane(String(parsed.problemId), destination, localProblem, upstreamRecord, snapshot);
-    console.log(`Artifact bundle created: ${destination}`);
-    console.log(`Local canonical dossier included: ${localProblem ? 'yes' : 'no'}`);
-    console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
-    console.log(`Artifacts copied: ${result.copiedArtifacts?.length ?? result.artifactsCopied ?? 0}`);
+    if (!silent) {
+      console.log(`Artifact bundle created: ${destination}`);
+      console.log(`Local canonical dossier included: ${localProblem ? 'yes' : 'no'}`);
+      console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
+      console.log(`Artifacts copied: ${result.copiedArtifacts?.length ?? result.artifactsCopied ?? 0}`);
+    }
     return 0;
   }
 
@@ -306,12 +317,14 @@ export async function runPullCommand(args) {
       ? path.resolve(parsed.destination)
       : getWorkspaceProblemLiteratureDir(parsed.problemId);
     const result = await writeLiteratureLane(String(parsed.problemId), destination, localProblem, upstreamRecord, parsed.includeSite);
-    console.log(`Literature bundle created: ${destination}`);
-    console.log(`Local dossier context included: ${localProblem ? 'yes' : 'no'}`);
-    console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
-    console.log(`Live site snapshot included: ${result.siteStatus.included ? 'yes' : 'no'}`);
-    if (result.siteStatus.error) {
-      console.log(`Live site snapshot note: ${result.siteStatus.error}`);
+    if (!silent) {
+      console.log(`Literature bundle created: ${destination}`);
+      console.log(`Local dossier context included: ${localProblem ? 'yes' : 'no'}`);
+      console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
+      console.log(`Live site snapshot included: ${result.siteStatus.included ? 'yes' : 'no'}`);
+      if (result.siteStatus.error) {
+        console.log(`Live site snapshot note: ${result.siteStatus.error}`);
+      }
     }
     return 0;
   }
@@ -341,14 +354,16 @@ export async function runPullCommand(args) {
     siteSnapshotError: literatureResult.siteStatus.error,
   });
 
-  console.log(`Pull bundle created: ${rootDestination}`);
-  console.log(`Artifact lane: ${artifactDestination}`);
-  console.log(`Literature lane: ${literatureDestination}`);
-  console.log(`Local canonical dossier included: ${localProblem ? 'yes' : 'no'}`);
-  console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
-  console.log(`Live site snapshot included: ${literatureResult.siteStatus.included ? 'yes' : 'no'}`);
-  if (literatureResult.siteStatus.error) {
-    console.log(`Live site snapshot note: ${literatureResult.siteStatus.error}`);
+  if (!silent) {
+    console.log(`Pull bundle created: ${rootDestination}`);
+    console.log(`Artifact lane: ${artifactDestination}`);
+    console.log(`Literature lane: ${literatureDestination}`);
+    console.log(`Local canonical dossier included: ${localProblem ? 'yes' : 'no'}`);
+    console.log(`Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`);
+    console.log(`Live site snapshot included: ${literatureResult.siteStatus.included ? 'yes' : 'no'}`);
+    if (literatureResult.siteStatus.error) {
+      console.log(`Live site snapshot note: ${literatureResult.siteStatus.error}`);
+    }
   }
   return 0;
 }

package/src/commands/seed.js

@@ -0,0 +1,264 @@
+import path from 'node:path';
+import { getProblem } from '../atlas/catalog.js';
+import { syncCheckpoints } from '../runtime/checkpoints.js';
+import { seedProblemFromPullBundle } from '../runtime/maintainer-seed.js';
+import { getWorkspaceProblemPullDir, getWorkspaceRoot, getWorkspaceSeededProblemsDir } from '../runtime/paths.js';
+import { syncState } from '../runtime/state.js';
+import { readCurrentProblem, setCurrentProblem } from '../runtime/workspace.js';
+import { runPullCommand } from './pull.js';
+
+function parseSeedArgs(args) {
+  const [kind, value, ...rest] = args;
+  if (kind !== 'problem') {
+    return { error: 'Only `erdos seed problem <id>` is supported right now.' };
+  }
+
+  const parsed = {
+    problemId: value,
+    includeSite: false,
+    refreshUpstream: false,
+    cluster: null,
+    repoStatus: 'local_seeded',
+    harnessDepth: 'dossier',
+    title: null,
+    familyTags: [],
+    relatedProblems: [],
+    formalizationStatus: 'planned',
+    activeRoute: null,
+    routeBreakthrough: false,
+    problemSolved: false,
+    destRoot: null,
+    noActivate: false,
+    noLoopSync: false,
+    force: false,
+    asJson: false,
+  };
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (token === '--include-site') {
+      parsed.includeSite = true;
+      continue;
+    }
+    if (token === '--refresh-upstream') {
+      parsed.refreshUpstream = true;
+      continue;
+    }
+    if (token === '--cluster') {
+      parsed.cluster = rest[index + 1];
+      if (!parsed.cluster) {
+        return { error: 'Missing cluster value after --cluster.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--repo-status') {
+      parsed.repoStatus = rest[index + 1];
+      if (!parsed.repoStatus) {
+        return { error: 'Missing repo status after --repo-status.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--harness-depth') {
+      parsed.harnessDepth = rest[index + 1];
+      if (!parsed.harnessDepth) {
+        return { error: 'Missing harness depth after --harness-depth.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--title') {
+      parsed.title = rest[index + 1];
+      if (!parsed.title) {
+        return { error: 'Missing title after --title.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--family-tag') {
+      const tag = rest[index + 1];
+      if (!tag) {
+        return { error: 'Missing tag after --family-tag.' };
+      }
+      parsed.familyTags.push(tag);
+      index += 1;
+      continue;
+    }
+    if (token === '--related') {
+      const related = rest[index + 1];
+      if (!related) {
+        return { error: 'Missing problem id after --related.' };
+      }
+      parsed.relatedProblems.push(related);
+      index += 1;
+      continue;
+    }
+    if (token === '--formalization-status') {
+      parsed.formalizationStatus = rest[index + 1];
+      if (!parsed.formalizationStatus) {
+        return { error: 'Missing value after --formalization-status.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--active-route') {
+      parsed.activeRoute = rest[index + 1];
+      if (!parsed.activeRoute) {
+        return { error: 'Missing value after --active-route.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--route-breakthrough') {
+      parsed.routeBreakthrough = true;
+      continue;
+    }
+    if (token === '--problem-solved') {
+      parsed.problemSolved = true;
+      continue;
+    }
+    if (token === '--dest-root') {
+      parsed.destRoot = rest[index + 1];
+      if (!parsed.destRoot) {
+        return { error: 'Missing path after --dest-root.' };
+      }
+      index += 1;
+      continue;
+    }
+    if (token === '--no-activate') {
+      parsed.noActivate = true;
+      continue;
+    }
+    if (token === '--no-loop-sync') {
+      parsed.noLoopSync = true;
+      continue;
+    }
+    if (token === '--force') {
+      parsed.force = true;
+      continue;
+    }
+    if (token === '--json') {
+      parsed.asJson = true;
+      continue;
+    }
+    return { error: `Unknown seed option: ${token}` };
+  }
+
+  return parsed;
+}
+
+export async function runSeedCommand(args) {
+  if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
+    console.log('Usage:');
+    console.log('  erdos seed problem <id> [--include-site] [--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] [--dest-root <path>] [--no-activate] [--no-loop-sync] [--force] [--json]');
+    return 0;
+  }
+
+  const parsed = parseSeedArgs(args);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+  if (!parsed.problemId) {
+    console.error('Missing problem id.');
+    return 1;
+  }
+
+  const workspaceRoot = getWorkspaceRoot();
+  const pullDir = getWorkspaceProblemPullDir(parsed.problemId, workspaceRoot);
+  const defaultSeedRoot = getWorkspaceSeededProblemsDir(workspaceRoot);
+  const destinationRoot = parsed.destRoot
+    ? path.resolve(parsed.destRoot)
+    : defaultSeedRoot;
+  const seedsIntoWorkspaceOverlay = destinationRoot === defaultSeedRoot;
+
+  const pullArgs = ['problem', String(parsed.problemId), '--dest', pullDir];
+  if (parsed.includeSite) {
+    pullArgs.push('--include-site');
+  }
+  if (parsed.refreshUpstream) {
+    pullArgs.push('--refresh-upstream');
+  }
+
+  const pullExit = await runPullCommand(pullArgs, { silent: parsed.asJson });
+  if (pullExit !== 0) {
+    return pullExit;
+  }
+
+  const packageProblem = getProblem(parsed.problemId, workspaceRoot);
+  const result = seedProblemFromPullBundle(parsed.problemId, {
+    fromPullDir: pullDir,
+    destRoot: destinationRoot,
+    cluster: parsed.cluster ?? packageProblem?.cluster ?? 'uncategorized',
+    repoStatus: parsed.repoStatus,
+    harnessDepth: parsed.harnessDepth,
+    title: parsed.title,
+    familyTags: parsed.familyTags,
+    relatedProblems: parsed.relatedProblems,
+    formalizationStatus: parsed.formalizationStatus,
+    activeRoute: parsed.activeRoute ?? (parsed.problemSolved ? null : 'seed_route_pending'),
+    routeBreakthrough: parsed.routeBreakthrough,
+    problemSolved: parsed.problemSolved,
+    force: parsed.force,
+  });
+
+  const activated = !parsed.noActivate && seedsIntoWorkspaceOverlay;
+  const loopSynced = !parsed.noLoopSync && activated;
+
+  let state = null;
+  let checkpoints = null;
+  if (activated) {
+    setCurrentProblem(parsed.problemId, workspaceRoot);
+  }
+  if (loopSynced) {
+    state = syncState(workspaceRoot);
+    checkpoints = syncCheckpoints(workspaceRoot);
+  }
+
+  const payload = {
+    problemId: String(parsed.problemId),
+    pullDir,
+    destinationDir: result.destinationDir,
+    cluster: result.record.cluster,
+    harnessDepth: result.record.harness.depth,
+    title: result.record.title,
+    activated,
+    loopSynced,
+    activeProblem: activated ? readCurrentProblem(workspaceRoot) : null,
+    activeRoute: state?.activeRoute ?? null,
+    nextHonestMove: state?.nextHonestMove ?? null,
+    checkpointShelf: checkpoints?.indexPath ?? null,
+    usedUpstreamRecord: result.usedUpstreamRecord,
+    usedSiteSnapshot: result.usedSiteSnapshot,
+    workspaceOverlayVisible: seedsIntoWorkspaceOverlay,
+  };
+
+  if (parsed.asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+    return 0;
+  }
+
+  console.log(`Seeded local dossier for problem ${parsed.problemId}`);
+  console.log(`Pull bundle: ${pullDir}`);
+  console.log(`Destination: ${result.destinationDir}`);
+  console.log(`Title: ${result.record.title}`);
+  console.log(`Cluster: ${result.record.cluster}`);
+  console.log(`Harness depth: ${result.record.harness.depth}`);
+  console.log(`Upstream record used: ${result.usedUpstreamRecord ? 'yes' : 'no'}`);
+  console.log(`Site snapshot used: ${result.usedSiteSnapshot ? 'yes' : 'no'}`);
+  console.log(`Workspace overlay visible: ${seedsIntoWorkspaceOverlay ? 'yes' : 'no'}`);
+  console.log(`Activated: ${activated ? 'yes' : 'no'}`);
+  console.log(`Loop synced: ${loopSynced ? 'yes' : 'no'}`);
+  if (!seedsIntoWorkspaceOverlay && (!parsed.noActivate || !parsed.noLoopSync)) {
+    console.log('Note: activation and loop sync were skipped because --dest-root points outside .erdos/seeded-problems.');
+  }
+  if (state) {
+    console.log(`Active route: ${state.activeRoute ?? '(none)'}`);
+    console.log(`Next honest move: ${state.nextHonestMove}`);
+  }
+  if (checkpoints) {
+    console.log(`Checkpoint shelf: ${checkpoints.indexPath}`);
+  }
+  return 0;
+}

package/src/commands/workspace.js

@@ -29,10 +29,12 @@ export function runWorkspaceCommand(args) {
   console.log(`Question ledger: ${summary.questionLedgerPath}`);
   console.log(`Checkpoint shelf: ${summary.checkpointIndexPath}`);
   console.log(`Workspace upstream dir: ${summary.upstreamDir}`);
+  console.log(`Workspace seeded-problems dir: ${summary.seededProblemsDir}`);
   console.log(`Workspace scaffold dir: ${summary.scaffoldDir}`);
   console.log(`Workspace pull dir: ${summary.pullDir}`);
   console.log(`Workspace artifact dir: ${summary.artifactDir}`);
   console.log(`Workspace literature dir: ${summary.literatureDir}`);
+  console.log(`Active seeded dossier dir: ${summary.seededProblemDir}`);
   console.log(`Preferred agent: ${config.preferredAgent}`);
   console.log(`Continuation mode: ${summary.continuationMode ?? config.continuation}`);
   console.log(`Active route: ${summary.activeRoute ?? '(none)'}`);

package/src/runtime/paths.js

@@ -92,6 +92,14 @@ export function getWorkspaceProblemLiteratureDir(problemId, workspaceRoot = getW
   return path.join(getWorkspaceProblemPullDir(problemId, workspaceRoot), 'literature');
 }
 
+export function getWorkspaceSeededProblemsDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'seeded-problems');
+}
+
+export function getWorkspaceSeededProblemDir(problemId, workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceSeededProblemsDir(workspaceRoot), String(problemId));
+}
+
 export function getWorkspaceCheckpointsDir(workspaceRoot = getWorkspaceRoot()) {
   return path.join(getWorkspaceDir(workspaceRoot), 'checkpoints');
 }

package/src/runtime/workspace.js

@@ -10,6 +10,8 @@ import {
   getWorkspaceProblemScaffoldDir,
   getWorkspaceQuestionLedgerPath,
   getWorkspaceRoot,
+  getWorkspaceSeededProblemDir,
+  getWorkspaceSeededProblemsDir,
   getWorkspaceStateMarkdownPath,
   getWorkspaceStatePath,
   getWorkspaceUpstreamDir,
@@ -77,10 +79,12 @@ export function getWorkspaceSummary(workspaceRoot = getWorkspaceRoot()) {
     questionLedgerPath: getWorkspaceQuestionLedgerPath(workspaceRoot),
     checkpointIndexPath: getWorkspaceCheckpointIndexPath(workspaceRoot),
     upstreamDir: getWorkspaceUpstreamDir(workspaceRoot),
+    seededProblemsDir: getWorkspaceSeededProblemsDir(workspaceRoot),
     scaffoldDir: activeProblem ? getWorkspaceProblemScaffoldDir(activeProblem, workspaceRoot) : getWorkspaceProblemScaffoldDir('<problem-id>', workspaceRoot),
     pullDir: activeProblem ? getWorkspaceProblemPullDir(activeProblem, workspaceRoot) : getWorkspaceProblemPullDir('<problem-id>', workspaceRoot),
     artifactDir: activeProblem ? getWorkspaceProblemArtifactDir(activeProblem, workspaceRoot) : getWorkspaceProblemArtifactDir('<problem-id>', workspaceRoot),
     literatureDir: activeProblem ? getWorkspaceProblemLiteratureDir(activeProblem, workspaceRoot) : getWorkspaceProblemLiteratureDir('<problem-id>', workspaceRoot),
+    seededProblemDir: activeProblem ? getWorkspaceSeededProblemDir(activeProblem, workspaceRoot) : getWorkspaceSeededProblemDir('<problem-id>', workspaceRoot),
     updatedAt: state?.updatedAt ?? null,
     continuationMode: state?.continuation?.mode ?? null,
     activeRoute: state?.activeRoute ?? null,