erdos-problems 0.1.5 → 0.1.7

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

@@ -0,0 +1,57 @@
+import { getWorkspaceQuestionLedgerPath, getWorkspaceStateMarkdownPath } from '../runtime/paths.js';
+import { loadState, syncState } from '../runtime/state.js';
+
+function printState(state) {
+  console.log('Erdos research state');
+  console.log(`Workspace root: ${state.workspaceRoot}`);
+  console.log(`Open problem: ${state.activeProblem || '(none)'}`);
+  console.log(`Problem title: ${state.problemTitle || '(none)'}`);
+  console.log(`Cluster: ${state.cluster || '(none)'}`);
+  console.log(`Family role: ${state.familyRole || '(none)'}`);
+  console.log(`Harness profile: ${state.harnessProfile || '(none)'}`);
+  console.log(`Active route: ${state.activeRoute || '(none)'}`);
+  console.log(`Route breakthrough: ${state.routeBreakthrough ? 'yes' : 'no'}`);
+  console.log(`Problem solved: ${state.problemSolved ? 'yes' : 'no'}`);
+  console.log(`Continuation mode: ${state.continuation.mode}`);
+  console.log(`Current frontier: ${state.currentFrontier.kind} / ${state.currentFrontier.detail}`);
+  console.log(`Route story: ${state.routeStory || '(none)'}`);
+  console.log(`Checkpoint focus: ${state.checkpointFocus || '(none)'}`);
+  console.log(`Next honest move: ${state.nextHonestMove}`);
+  console.log(`State markdown: ${getWorkspaceStateMarkdownPath()}`);
+  console.log(`Question ledger: ${getWorkspaceQuestionLedgerPath()}`);
+}
+
+export function runStateCommand(args) {
+  const [subcommand, ...rest] = args;
+  const asJson = rest.includes('--json');
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos state sync [--json]');
+    console.log('  erdos state show [--json]');
+    return 0;
+  }
+
+  if (subcommand === 'sync') {
+    const state = syncState();
+    if (asJson) {
+      console.log(JSON.stringify(state, null, 2));
+      return 0;
+    }
+    printState(state);
+    return 0;
+  }
+
+  if (subcommand === 'show') {
+    const state = loadState();
+    if (asJson) {
+      console.log(JSON.stringify(state, null, 2));
+      return 0;
+    }
+    printState(state);
+    return 0;
+  }
+
+  console.error(`Unknown state subcommand: ${subcommand}`);
+  return 1;
+}

package/src/commands/sunflower.js

@@ -35,6 +35,11 @@ function printSunflowerStatus(snapshot, registryPaths) {
   console.log(`Open problem: ${snapshot.openProblem ? 'yes' : 'no'}`);
   console.log(`Problem solved: ${snapshot.problemSolved ? 'yes' : 'no'}`);
   console.log(`Bootstrap focus: ${snapshot.bootstrapFocus ?? '(none)'}`);
+  console.log(`Route story: ${snapshot.routeStory ?? '(none)'}`);
+  console.log(`Frontier label: ${snapshot.frontierLabel ?? '(none)'}`);
+  console.log(`Frontier detail: ${snapshot.frontierDetail ?? '(none)'}`);
+  console.log(`Checkpoint focus: ${snapshot.checkpointFocus ?? '(none)'}`);
+  console.log(`Next honest move: ${snapshot.nextHonestMove}`);
   console.log(`Related core problems: ${snapshot.relatedCoreProblems.join(', ') || '(none)'}`);
   console.log(`Literature focus: ${snapshot.literatureFocus.join(', ') || '(none)'}`);
   console.log(`Artifact focus: ${snapshot.artifactFocus.join(', ') || '(none)'}`);

package/src/commands/workspace.js

@@ -1,4 +1,5 @@
 import { getProblem } from '../atlas/catalog.js';
+import { loadConfig } from '../runtime/config.js';
 import { buildSunflowerStatusSnapshot } from '../runtime/sunflower.js';
 import { getWorkspaceSummary } from '../runtime/workspace.js';
 
@@ -17,15 +18,33 @@ export function runWorkspaceCommand(args) {
   }
 
   const summary = getWorkspaceSummary();
+  const config = loadConfig();
   console.log(`Workspace root: ${summary.workspaceRoot}`);
   console.log(`State dir: ${summary.stateDir}`);
   console.log(`Initialized: ${summary.hasState ? 'yes' : 'no'}`);
   console.log(`Active problem: ${summary.activeProblem ?? '(none)'}`);
+  console.log(`Config path: ${summary.configPath}`);
+  console.log(`State file: ${summary.statePath}`);
+  console.log(`State markdown: ${summary.stateMarkdownPath}`);
+  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)'}`);
+  console.log(`Route breakthrough: ${summary.routeBreakthrough ? 'yes' : 'no'}`);
+  console.log(`Problem solved: ${summary.problemSolved ? 'yes' : 'no'}`);
+  console.log(`Checkpoint synced at: ${summary.lastCheckpointSyncAt ?? '(never)'}`);
+  console.log(`Next honest move: ${summary.nextHonestMove ?? '(none)'}`);
+  if (summary.currentFrontier) {
+    console.log(`Current frontier: ${summary.currentFrontier.kind} / ${summary.currentFrontier.detail}`);
+  }
   console.log(`Updated at: ${summary.updatedAt ?? '(none)'}`);
   if (summary.activeProblem) {
     const problem = getProblem(summary.activeProblem);
@@ -34,6 +53,7 @@ export function runWorkspaceCommand(args) {
       console.log(`Sunflower family role: ${sunflower.familyRole ?? '(none)'}`);
       console.log(`Sunflower harness profile: ${sunflower.harnessProfile ?? '(none)'}`);
       console.log(`Sunflower route: ${sunflower.activeRoute ?? '(none)'}`);
+      console.log(`Sunflower frontier: ${sunflower.frontierDetail ?? '(none)'}`);
       console.log(`Sunflower compute: ${sunflower.computeLanePresent ? 'yes' : 'no'}`);
       if (sunflower.activePacket) {
         console.log(`Sunflower compute lane: ${sunflower.activePacket.laneId} [${sunflower.activePacket.status}]`);