erdos-problems 0.1.9 → 0.1.10

package/README.md

@@ -45,7 +45,7 @@ erdos dossier show 857
 For an unseeded problem, the one-step self-seeding flow is now:
 
 ```bash
-erdos seed problem 25 --include-site --cluster number-theory
+erdos seed problem 25 --cluster number-theory
 erdos problem show 25
 erdos workspace show
 ```
@@ -60,6 +60,8 @@ What `bootstrap` does:
 
 What `seed` does:
 - creates a pull bundle for any problem in the upstream snapshot
+- defaults to a live site snapshot plus a public-search review bundle
+- treats a problem as seed-admissible only when the public site says `open`, unless you intentionally pass `--allow-non-open`
 - promotes that bundle into `.erdos/seeded-problems/<id>/`
 - auto-selects the problem in the workspace
 - syncs the bundled ORP workspace kit into `.erdos/orp/`
@@ -69,6 +71,8 @@ What `seed` does:
   - `AGENT_START.md`
   - `ROUTES.md`
   - `CHECKPOINT_NOTES.md`
+  - `PUBLIC_STATUS_REVIEW.md`
+  - `AGENT_WEBSEARCH_BRIEF.md`
 
 ## Pull lanes
 
@@ -78,7 +82,7 @@ For any problem number in the upstream snapshot, you can create a workspace bund
 erdos pull problem 857
 erdos pull artifacts 857
 erdos pull literature 857
-erdos pull problem 999 --include-site
+erdos pull problem 999 --include-site --include-public-search
 erdos pull problem 999 --refresh-upstream
 ```
 
@@ -91,6 +95,10 @@ What the pull lanes do:
 - `erdos pull literature <id>` creates only the literature lane
 - when a problem is locally seeded, the artifact lane includes the canonical dossier, pack context, and compute packets
 - when `--include-site` is used, the literature lane can include a live site snapshot and plain-text extract
+- when `--include-public-search` is used, the literature lane also includes:
+  - `PUBLIC_STATUS_REVIEW.md`
+  - `PUBLIC_STATUS_REVIEW.json`
+  - `AGENT_WEBSEARCH_BRIEF.md`
 
 ## Maintainer seeding
 
@@ -115,6 +123,9 @@ What maintainer seeding does:
   - `AGENT_START.md`
   - `ROUTES.md`
   - `CHECKPOINT_NOTES.md`
+- public-truth starter files:
+  - `PUBLIC_STATUS_REVIEW.md`
+  - `AGENT_WEBSEARCH_BRIEF.md`
 - preserves upstream/site provenance in the local record
 
 ## Sunflower pack
@@ -193,7 +204,7 @@ erdos upstream diff
 erdos scaffold problem 857
 erdos bootstrap problem 857
 erdos bootstrap problem 857 --sync-upstream
-erdos seed problem 25 --include-site --cluster number-theory
+erdos seed problem 25 --cluster number-theory
 erdos pull problem 857
 erdos pull artifacts 857
 erdos pull literature 857
@@ -221,6 +232,8 @@ Many seeded dossiers now also carry starter-loop artifacts:
 - `AGENT_START.md`
 - `ROUTES.md`
 - `CHECKPOINT_NOTES.md`
+- `PUBLIC_STATUS_REVIEW.md`
+- `AGENT_WEBSEARCH_BRIEF.md`
 
 The CLI can surface these directly:
 - `erdos problem artifacts <id>` shows the canonical inventory
@@ -236,6 +249,7 @@ For sunflower problems, the CLI also surfaces pack-specific artifacts:
 - per-problem context files under `packs/sunflower/problems/<id>/`
 - route packets and checkpoint/report packets for `20` and `857`
 - compute packets under `packs/sunflower/compute/<id>/` when available
+- compute-governance evaluation under `breakthroughs`, surfaced through `erdos sunflower status`
 
 ## Notes
 

package/docs/RESEARCH_LOOP.md

@@ -26,8 +26,9 @@ Workspace runtime files live under `.erdos/`:
 5. Set continuation mode.
 6. Sync checkpoints.
 7. Pull or scaffold artifacts.
-8. Work the active route.
-9. Sync checkpoints again at honest boundaries.
+8. Review public status and agent websearch brief if the problem was freshly seeded.
+9. Work the active route.
+10. Sync checkpoints again at honest boundaries.
 
 ## Commands
 
@@ -44,7 +45,7 @@ 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 25 --include-site --cluster number-theory
+erdos seed problem 25 --cluster number-theory
 erdos preflight
 erdos continuation use route
 erdos checkpoints sync
@@ -56,6 +57,8 @@ The seeded dossier now also includes starter-loop artifacts:
 - `AGENT_START.md`
 - `ROUTES.md`
 - `CHECKPOINT_NOTES.md`
+- `PUBLIC_STATUS_REVIEW.md`
+- `AGENT_WEBSEARCH_BRIEF.md`
 
 The ORP kit travels with the workspace too:
 - `PROTOCOL.md`
@@ -64,6 +67,11 @@ The ORP kit travels with the workspace too:
 - `templates/VERIFICATION_RECORD.md`
 - `templates/FAILED_TOPIC.md`
 
+For sunflower compute lanes, ORP now sits above `breakthroughs`:
+- `erdos sunflower status <id>` evaluates the packaged compute lane with `breakthroughs`
+- the CLI surfaces the selected rung, dispatch action, and the reason compute is admissible
+- this is compute governance and traceability, not an automatic compute launch
+
 ## 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.9",
+  "version": "0.1.10",
   "description": "CLI atlas and staged research harness for Paul Erdos problems.",
   "type": "module",
   "bin": {
@@ -31,6 +31,7 @@
     "sunflower"
   ],
   "dependencies": {
+    "breakthroughs": "^0.1.1",
     "yaml": "^2.8.3"
   },
   "license": "MIT"

package/src/cli/index.js

@@ -42,11 +42,11 @@ 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 seed problem <id> [--include-site|--no-site] [--include-public-search|--no-public-search] [--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] [--allow-non-open] [--dest-root <path>] [--no-activate] [--no-loop-sync] [--force] [--json]');
+  console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--include-public-search] [--refresh-upstream]');
   console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream]');
-  console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--refresh-upstream]');
-  console.log('  erdos maintainer seed problem <id> [--from-pull <path>] [--dest-root <path>] [--cluster <name>]');
+  console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--include-public-search] [--refresh-upstream]');
+  console.log('  erdos maintainer seed problem <id> [--from-pull <path>] [--dest-root <path>] [--cluster <name>] [--allow-non-open]');
 }
 
 const args = process.argv.slice(2);

package/src/commands/maintainer.js

@@ -21,6 +21,7 @@ function parseMaintainerSeedArgs(args) {
     activeRoute: null,
     routeBreakthrough: false,
     problemSolved: false,
+    allowNonOpen: false,
     force: false,
   };
 
@@ -116,6 +117,10 @@ function parseMaintainerSeedArgs(args) {
       parsed.problemSolved = true;
       continue;
     }
+    if (token === '--allow-non-open') {
+      parsed.allowNonOpen = true;
+      continue;
+    }
     if (token === '--force') {
       parsed.force = true;
       continue;
@@ -131,7 +136,7 @@ export function runMaintainerCommand(args) {
 
   if (!subcommand || subcommand === 'help' || subcommand === '--help') {
     console.log('Usage:');
-    console.log('  erdos maintainer seed problem <id> [--from-pull <path>] [--dest-root <path>] [--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] [--force]');
+    console.log('  erdos maintainer seed problem <id> [--from-pull <path>] [--dest-root <path>] [--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] [--allow-non-open] [--force]');
     return 0;
   }
 
@@ -164,6 +169,7 @@ export function runMaintainerCommand(args) {
       activeRoute: parsed.activeRoute,
       routeBreakthrough: parsed.routeBreakthrough,
       problemSolved: parsed.problemSolved,
+      allowNonOpen: parsed.allowNonOpen,
       force: parsed.force,
     });
 
@@ -174,6 +180,7 @@ export function runMaintainerCommand(args) {
     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(`Public status review used: ${result.usedPublicStatusReview ? 'yes' : 'no'}`);
     return 0;
   } catch (error) {
     console.error(String(error.message ?? error));

package/src/commands/pull.js

@@ -9,6 +9,7 @@ import {
 import { getProblemArtifactInventory, scaffoldProblem } from '../runtime/problem-artifacts.js';
 import { loadActiveUpstreamSnapshot, syncUpstream } from '../upstream/sync.js';
 import { fetchProblemSiteSnapshot } from '../upstream/site.js';
+import { buildProblemSearchQueries, fetchProblemPublicSearchReview } from '../upstream/public-search.js';
 
 function normalizeClusterLabel(rawTag) {
   return String(rawTag ?? '')
@@ -48,6 +49,7 @@ function parsePullArgs(args) {
 
   let destination = null;
   let includeSite = false;
+  let includePublicSearch = false;
   let refreshUpstream = false;
 
   for (let index = 0; index < rest.length; index += 1) {
@@ -64,6 +66,10 @@ function parsePullArgs(args) {
       includeSite = true;
       continue;
     }
+    if (token === '--include-public-search') {
+      includePublicSearch = true;
+      continue;
+    }
     if (token === '--refresh-upstream') {
       refreshUpstream = true;
       continue;
@@ -76,6 +82,7 @@ function parsePullArgs(args) {
     problemId: value,
     destination,
     includeSite,
+    includePublicSearch,
     refreshUpstream,
   };
 }
@@ -165,6 +172,8 @@ async function maybeWriteSiteBundle(problemId, destination, includeSite) {
       url: siteSnapshot.url,
       fetchedAt: siteSnapshot.fetchedAt,
       title: siteSnapshot.title,
+      siteStatus: siteSnapshot.siteStatus,
+      siteStatusRaw: siteSnapshot.siteStatusRaw,
       previewLines: siteSnapshot.previewLines,
     });
     writeText(
@@ -175,6 +184,8 @@ async function maybeWriteSiteBundle(problemId, destination, includeSite) {
         `Source: ${siteSnapshot.url}`,
         `Fetched at: ${siteSnapshot.fetchedAt}`,
         `Title: ${siteSnapshot.title}`,
+        `Site status: ${siteSnapshot.siteStatus}`,
+        `Status line: ${siteSnapshot.siteStatusRaw ?? '(unknown)'}`,
         '',
         '## Preview',
         '',
@@ -182,14 +193,132 @@ async function maybeWriteSiteBundle(problemId, destination, includeSite) {
         '',
       ].join('\n'),
     );
-    return { attempted: true, included: true, error: null };
+    return {
+      attempted: true,
+      included: true,
+      error: null,
+      siteStatus: siteSnapshot.siteStatus,
+      siteStatusRaw: siteSnapshot.siteStatusRaw,
+      title: siteSnapshot.title,
+      previewLines: siteSnapshot.previewLines,
+    };
   } catch (error) {
     writeText(path.join(destination, 'SITE_FETCH_ERROR.txt'), String(error.message ?? error));
-    return { attempted: true, included: false, error: String(error.message ?? error) };
+    return {
+      attempted: true,
+      included: false,
+      error: String(error.message ?? error),
+      siteStatus: 'unknown',
+      siteStatusRaw: null,
+      title: null,
+      previewLines: [],
+    };
+  }
+}
+
+async function maybeWritePublicSearchBundle(problemId, title, destination, includePublicSearch) {
+  const queries = buildProblemSearchQueries(problemId, title);
+  const briefLines = [
+    `# Erdős Problem #${problemId} Agent Websearch Brief`,
+    '',
+    'Why this exists:',
+    '- do not rely on erdosproblems.com alone as the canonical public truth surface',
+    '- compare the site status with current publicized discussion, literature, and formalization chatter',
+    '',
+    'Suggested queries:',
+    ...queries.map((query) => `- ${query}`),
+    '',
+    'Review prompts:',
+    '- Does the problem still appear publicly open?',
+    '- Are there recent solution claims, partial claims, or major status updates?',
+    '- Are there recent formalization artifacts, surveys, or project pages worth pulling into the dossier?',
+    '',
+  ];
+
+  writeText(path.join(destination, 'AGENT_WEBSEARCH_BRIEF.md'), briefLines.join('\n'));
+
+  if (!includePublicSearch) {
+    writeText(
+      path.join(destination, 'PUBLIC_STATUS_REVIEW.md'),
+      [
+        `# Erdős Problem #${problemId} Public Status Review`,
+        '',
+        '- A live public search was not requested for this pull bundle.',
+        '- Use `AGENT_WEBSEARCH_BRIEF.md` to run the suggested queries before widening public-status claims.',
+        '',
+      ].join('\n'),
+    );
+    return {
+      attempted: false,
+      included: false,
+      error: null,
+      queries,
+      combinedResults: [],
+    };
+  }
+
+  try {
+    const review = await fetchProblemPublicSearchReview(problemId, title);
+    writeJson(path.join(destination, 'PUBLIC_STATUS_REVIEW.json'), review);
+    writeText(
+      path.join(destination, 'PUBLIC_STATUS_REVIEW.md'),
+      [
+        `# Erdős Problem #${problemId} Public Status Review`,
+        '',
+        `Fetched at: ${review.fetchedAt}`,
+        `Provider: ${review.provider}`,
+        '',
+        'Queries run:',
+        ...review.queries.map((query) => `- ${query}`),
+        '',
+        'Top public results:',
+        ...(review.combinedResults.length > 0
+          ? review.combinedResults.map((result) => `- [${result.title}](${result.url})${result.snippet ? ` — ${result.snippet}` : ''}`)
+          : ['- *(no results captured)*']),
+        '',
+        ...(review.errors.length > 0
+          ? [
+              'Search notes:',
+              ...review.errors.map((entry) => `- ${entry.query}: ${entry.error}`),
+              '',
+            ]
+          : []),
+      ].join('\n'),
+    );
+    return {
+      attempted: true,
+      included: true,
+      error: null,
+      queries: review.queries,
+      combinedResults: review.combinedResults,
+    };
+  } catch (error) {
+    const message = String(error?.message ?? error);
+    writeText(
+      path.join(destination, 'PUBLIC_STATUS_REVIEW.md'),
+      [
+        `# Erdős Problem #${problemId} Public Status Review`,
+        '',
+        '- A live public search was attempted but did not complete cleanly.',
+        `- Error: ${message}`,
+        '',
+        'Suggested queries:',
+        ...queries.map((query) => `- ${query}`),
+        '',
+      ].join('\n'),
+    );
+    writeText(path.join(destination, 'PUBLIC_STATUS_REVIEW_ERROR.txt'), message);
+    return {
+      attempted: true,
+      included: false,
+      error: message,
+      queries,
+      combinedResults: [],
+    };
   }
 }
 
-async function writeLiteratureLane(problemId, destination, localProblem, upstreamRecord, includeSite) {
+async function writeLiteratureLane(problemId, destination, localProblem, upstreamRecord, includeSite, includePublicSearch) {
   ensureDir(destination);
 
   const includedFiles = [];
@@ -220,6 +349,12 @@ async function writeLiteratureLane(problemId, destination, localProblem, upstrea
   }
 
   const siteStatus = await maybeWriteSiteBundle(problemId, destination, includeSite);
+  const publicSearch = await maybeWritePublicSearchBundle(
+    problemId,
+    localProblem?.title ?? upstreamRecord?.title ?? `Erdos Problem #${problemId}`,
+    destination,
+    includePublicSearch,
+  );
   const problemRecord = buildProblemRecord(problemId, localProblem, upstreamRecord);
   writeJson(path.join(destination, 'PROBLEM.json'), problemRecord);
   writeJson(path.join(destination, 'LITERATURE_INDEX.json'), {
@@ -229,6 +364,10 @@ async function writeLiteratureLane(problemId, destination, localProblem, upstrea
     includedUpstreamRecord: Boolean(upstreamRecord),
     includedSiteSnapshot: siteStatus.included,
     siteSnapshotError: siteStatus.error,
+    siteStatus: siteStatus.siteStatus,
+    includedPublicSearch: publicSearch.included,
+    publicSearchError: publicSearch.error,
+    publicSearchQueries: publicSearch.queries,
   });
   writeText(
     path.join(destination, 'README.md'),
@@ -240,6 +379,7 @@ async function writeLiteratureLane(problemId, destination, localProblem, upstrea
       `- Local dossier included: ${localProblem ? 'yes' : 'no'}`,
       `- Upstream record included: ${upstreamRecord ? 'yes' : 'no'}`,
       `- Live site snapshot included: ${siteStatus.included ? 'yes' : 'no'}`,
+      `- Public search review included: ${publicSearch.included ? 'yes' : 'no'}`,
       '',
     ].join('\n'),
   );
@@ -248,6 +388,7 @@ async function writeLiteratureLane(problemId, destination, localProblem, upstrea
     destination,
     includedFiles,
     siteStatus,
+    publicSearch,
   };
 }
 
@@ -292,9 +433,9 @@ export async function runPullCommand(args, options = {}) {
   if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
     if (!silent) {
       console.log('Usage:');
-      console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--refresh-upstream]');
+      console.log('  erdos pull problem <id> [--dest <path>] [--include-site] [--include-public-search] [--refresh-upstream]');
       console.log('  erdos pull artifacts <id> [--dest <path>] [--refresh-upstream]');
-      console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--refresh-upstream]');
+      console.log('  erdos pull literature <id> [--dest <path>] [--include-site] [--include-public-search] [--refresh-upstream]');
     }
     return 0;
   }
@@ -346,15 +487,26 @@ export async function runPullCommand(args, options = {}) {
     const destination = parsed.destination
       ? path.resolve(parsed.destination)
       : getWorkspaceProblemLiteratureDir(parsed.problemId);
-    const result = await writeLiteratureLane(String(parsed.problemId), destination, localProblem, upstreamRecord, parsed.includeSite);
+    const result = await writeLiteratureLane(
+      String(parsed.problemId),
+      destination,
+      localProblem,
+      upstreamRecord,
+      parsed.includeSite,
+      parsed.includePublicSearch,
+    );
     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'}`);
+      console.log(`Public search review included: ${result.publicSearch.included ? 'yes' : 'no'}`);
       if (result.siteStatus.error) {
         console.log(`Live site snapshot note: ${result.siteStatus.error}`);
       }
+      if (result.publicSearch.error) {
+        console.log(`Public search note: ${result.publicSearch.error}`);
+      }
     }
     return 0;
   }
@@ -367,7 +519,14 @@ export async function runPullCommand(args, options = {}) {
 
   writeRootProblemBundle(rootDestination, String(parsed.problemId), localProblem, upstreamRecord, snapshot, artifactDestination, literatureDestination);
   const artifactResult = writeArtifactsLane(String(parsed.problemId), artifactDestination, localProblem, upstreamRecord, snapshot);
-  const literatureResult = await writeLiteratureLane(String(parsed.problemId), literatureDestination, localProblem, upstreamRecord, parsed.includeSite);
+  const literatureResult = await writeLiteratureLane(
+    String(parsed.problemId),
+    literatureDestination,
+    localProblem,
+    upstreamRecord,
+    parsed.includeSite,
+    parsed.includePublicSearch,
+  );
 
   writeJson(path.join(rootDestination, 'PULL_STATUS.json'), {
     generatedAt: new Date().toISOString(),
@@ -382,6 +541,10 @@ export async function runPullCommand(args, options = {}) {
     siteSnapshotAttempted: literatureResult.siteStatus.attempted,
     siteSnapshotIncluded: literatureResult.siteStatus.included,
     siteSnapshotError: literatureResult.siteStatus.error,
+    siteStatus: literatureResult.siteStatus.siteStatus,
+    publicSearchAttempted: literatureResult.publicSearch.attempted,
+    publicSearchIncluded: literatureResult.publicSearch.included,
+    publicSearchError: literatureResult.publicSearch.error,
   });
 
   if (!silent) {
@@ -391,9 +554,13 @@ export async function runPullCommand(args, options = {}) {
     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'}`);
+    console.log(`Public search review included: ${literatureResult.publicSearch.included ? 'yes' : 'no'}`);
     if (literatureResult.siteStatus.error) {
       console.log(`Live site snapshot note: ${literatureResult.siteStatus.error}`);
     }
+    if (literatureResult.publicSearch.error) {
+      console.log(`Public search note: ${literatureResult.publicSearch.error}`);
+    }
   }
   return 0;
 }

package/src/commands/seed.js

@@ -16,7 +16,8 @@ function parseSeedArgs(args) {
 
   const parsed = {
     problemId: value,
-    includeSite: false,
+    includeSite: true,
+    includePublicSearch: true,
     refreshUpstream: false,
     cluster: null,
     repoStatus: 'local_seeded',
@@ -28,6 +29,7 @@ function parseSeedArgs(args) {
     activeRoute: null,
     routeBreakthrough: false,
     problemSolved: false,
+    allowNonOpen: false,
     destRoot: null,
     noActivate: false,
     noLoopSync: false,
@@ -41,6 +43,18 @@ function parseSeedArgs(args) {
       parsed.includeSite = true;
       continue;
     }
+    if (token === '--no-site') {
+      parsed.includeSite = false;
+      continue;
+    }
+    if (token === '--include-public-search') {
+      parsed.includePublicSearch = true;
+      continue;
+    }
+    if (token === '--no-public-search') {
+      parsed.includePublicSearch = false;
+      continue;
+    }
     if (token === '--refresh-upstream') {
       parsed.refreshUpstream = true;
       continue;
@@ -119,6 +133,10 @@ function parseSeedArgs(args) {
       parsed.problemSolved = true;
       continue;
     }
+    if (token === '--allow-non-open') {
+      parsed.allowNonOpen = true;
+      continue;
+    }
     if (token === '--dest-root') {
       parsed.destRoot = rest[index + 1];
       if (!parsed.destRoot) {
@@ -152,7 +170,7 @@ function parseSeedArgs(args) {
 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]');
+    console.log('  erdos seed problem <id> [--include-site|--no-site] [--include-public-search|--no-public-search] [--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] [--allow-non-open] [--dest-root <path>] [--no-activate] [--no-loop-sync] [--force] [--json]');
     return 0;
   }
 
@@ -179,6 +197,9 @@ export async function runSeedCommand(args) {
   if (parsed.includeSite) {
     pullArgs.push('--include-site');
   }
+  if (parsed.includePublicSearch) {
+    pullArgs.push('--include-public-search');
+  }
   if (parsed.refreshUpstream) {
     pullArgs.push('--refresh-upstream');
   }
@@ -202,6 +223,7 @@ export async function runSeedCommand(args) {
     activeRoute: parsed.activeRoute ?? (parsed.problemSolved ? null : 'seed_route_pending'),
     routeBreakthrough: parsed.routeBreakthrough,
     problemSolved: parsed.problemSolved,
+    allowNonOpen: parsed.allowNonOpen,
     force: parsed.force,
   });
 
@@ -233,6 +255,7 @@ export async function runSeedCommand(args) {
     checkpointShelf: checkpoints?.indexPath ?? null,
     usedUpstreamRecord: result.usedUpstreamRecord,
     usedSiteSnapshot: result.usedSiteSnapshot,
+    usedPublicStatusReview: result.usedPublicStatusReview,
     workspaceOverlayVisible: seedsIntoWorkspaceOverlay,
     orpProtocol: orp.protocolPath,
   };
@@ -250,6 +273,7 @@ export async function runSeedCommand(args) {
   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(`Public status review used: ${result.usedPublicStatusReview ? 'yes' : 'no'}`);
   console.log(`ORP protocol: ${orp.protocolPath}`);
   console.log(`Workspace overlay visible: ${seedsIntoWorkspaceOverlay ? 'yes' : 'no'}`);
   console.log(`Activated: ${activated ? 'yes' : 'no'}`);

package/src/commands/sunflower.js

@@ -57,6 +57,8 @@ function printSunflowerStatus(snapshot, registryPaths) {
   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 reason: ${snapshot.computeReason ?? '(none)'}`);
+  console.log(`Compute when: ${snapshot.computeWhen}`);
   console.log(`Compute next: ${snapshot.computeNextAction}`);
   if (snapshot.activePacket) {
     console.log(`Compute lane: ${snapshot.activePacket.laneId} [${snapshot.activePacket.status}]`);
@@ -66,6 +68,11 @@ function printSunflowerStatus(snapshot, registryPaths) {
     console.log(`Price checked: ${snapshot.activePacket.priceCheckedLocalDate || '(unknown)'}`);
     console.log(`Packet file: ${snapshot.activePacket.packetFileName}`);
   }
+  if (snapshot.computeGovernance) {
+    console.log(`Breakthroughs engine: ${snapshot.computeGovernance.engine}`);
+    console.log(`Dispatch action: ${snapshot.computeGovernance.dispatchResult.action}`);
+    console.log(`Dispatch rung: ${snapshot.computeGovernance.selectedRung.label} [${snapshot.computeGovernance.selectedRung.spendClass}]`);
+  }
   console.log(`Registry record: ${registryPaths.latestPath}`);
 }
 

package/src/runtime/breakthroughs.js

@@ -0,0 +1,197 @@
+import {
+  buildOrpComputeGateResult,
+  buildOrpComputePacket,
+  defineComputePacket,
+  defineDecision,
+  definePolicy,
+  defineRung,
+  evaluateDispatch,
+} from 'breakthroughs';
+
+function normalizeRungId(value, fallback) {
+  const text = String(value ?? '').trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  return text || fallback;
+}
+
+function parseSpendClass(rawRung) {
+  const raw = String(rawRung?.role ?? rawRung?.mode ?? '').trim().toLowerCase();
+  if (raw === 'local_unmetered' || raw === 'local') {
+    return 'local_unmetered';
+  }
+  return 'paid_metered';
+}
+
+function buildRungs(packet) {
+  const rawRungs = Array.isArray(packet?.rungs) ? packet.rungs : [];
+  const rungs = rawRungs.map((rawRung, index) => {
+    const label = String(rawRung?.name ?? rawRung?.label ?? `rung_${index + 1}`).trim();
+    return defineRung({
+      id: normalizeRungId(label, `rung-${index + 1}`),
+      label,
+      spendClass: parseSpendClass(rawRung),
+      admitted: true,
+      metadata: {
+        note: String(rawRung?.note ?? rawRung?.goal ?? '').trim(),
+      },
+    });
+  });
+
+  if (rungs.length > 0) {
+    return rungs;
+  }
+
+  return [
+    defineRung({
+      id: 'local-scout',
+      label: 'local_scout',
+      spendClass: 'local_unmetered',
+      admitted: true,
+    }),
+  ];
+}
+
+function selectRung(packet, rungs) {
+  const localRung = rungs.find((rung) => rung.spendClass === 'local_unmetered') ?? rungs[0];
+  const paidRung = rungs.find((rung) => rung.spendClass === 'paid_metered') ?? rungs[0];
+  const status = String(packet?.status ?? '').trim().toLowerCase();
+
+  if (status === 'ready_for_paid_transfer' || status === 'paid_active') {
+    return paidRung;
+  }
+  return localRung;
+}
+
+function buildPolicy(packet, selectedRung) {
+  const approvedRungs = [];
+  const status = String(packet?.status ?? '').trim().toLowerCase();
+  if (
+    selectedRung.spendClass === 'paid_metered'
+    && (status === 'paid_active' || packet?.approvalRequired === false)
+  ) {
+    approvedRungs.push(selectedRung.id);
+  }
+
+  return definePolicy({
+    local: {
+      defaultAction: 'allow',
+    },
+    paid: {
+      defaultAction: 'require_explicit_approval',
+      approvedRungs,
+    },
+  });
+}
+
+function buildRequiredOutputs(packet) {
+  const base = [
+    'run_manifest.json',
+    'impact_note.md',
+    'traceability_record.json',
+  ];
+  const canonicalPacket = packet?.sourceRepo?.canonical_packet_path;
+  if (canonicalPacket) {
+    base.push(canonicalPacket);
+  }
+  return [...new Set(base)];
+}
+
+function describeWhen(dispatchAction, selectedRung) {
+  if (!dispatchAction || !selectedRung) {
+    return 'No admitted compute rung is currently selected.';
+  }
+  if (dispatchAction === 'run_local') {
+    return `Run now on the local ${selectedRung.label} rung if the packet is still bounded and the local scout artifacts can be captured cleanly.`;
+  }
+  if (dispatchAction === 'request_paid_approval') {
+    return `Do not launch yet; request explicit approval before using the ${selectedRung.label} paid rung.`;
+  }
+  if (dispatchAction === 'run_paid') {
+    return `A paid rung is already admitted for this packet; run only with traceable artifact capture on ${selectedRung.label}.`;
+  }
+  return 'Hold the packet until the compute policy mismatch is resolved.';
+}
+
+export function buildBreakthroughsComputeView(problem, packet) {
+  if (!packet) {
+    return null;
+  }
+
+  const requiredOutputs = buildRequiredOutputs(packet);
+  const decision = defineDecision({
+    id: `erdos-${problem.problemId}-${packet.laneId}`,
+    question: packet.question,
+    requiredOutputs,
+    metadata: {
+      problemId: problem.problemId,
+      cluster: problem.cluster,
+      claimLevelGoal: packet.claimLevelGoal,
+    },
+  });
+
+  const rungs = buildRungs(packet);
+  const selectedRung = selectRung(packet, rungs);
+  const policy = buildPolicy(packet, selectedRung);
+  const computePacket = defineComputePacket({
+    id: packet.laneId,
+    decisionId: decision.id,
+    rungId: selectedRung.id,
+    question: packet.question,
+    successBar: {
+      claimLevelGoal: packet.claimLevelGoal,
+      statusTarget: packet.status,
+    },
+    stopCondition: 'Hold if the packet stops reducing uncertainty honestly or the required artifact bundle cannot be returned cleanly.',
+    requiredOutputs,
+    metadata: {
+      problemId: problem.problemId,
+      sourceRepo: packet.sourceRepo,
+      recommendation: packet.recommendation,
+    },
+  });
+  const dispatchResult = evaluateDispatch({
+    decision,
+    rung: selectedRung,
+    policy,
+    packet: computePacket,
+  });
+
+  const gate = buildOrpComputeGateResult({
+    gateId: `breakthroughs_${packet.laneId}`,
+    command: `erdos sunflower status ${problem.problemId}`,
+    status: dispatchResult.action === 'hold_packet' ? 'fail' : 'pass',
+    exitCode: dispatchResult.action === 'hold_packet' ? 1 : 0,
+    durationMs: 0,
+    evidencePaths: requiredOutputs,
+    evidenceStatus: 'process_only',
+    evidenceNote: 'This is a compute-admission record only. Evidence remains in canonical artifact paths.',
+  });
+
+  const orpPacket = buildOrpComputePacket({
+    repoRoot: packet.sourceRepo?.canonical_packet_path ?? '',
+    decision,
+    packet: computePacket,
+    dispatchResult: {
+      ...dispatchResult,
+      runId: `${packet.laneId}-${problem.problemId}`,
+    },
+    gateResults: [gate],
+    boardId: `${problem.cluster}_compute`,
+    problemId: problem.problemId,
+    stateNote: `Compute policy evaluated for ${packet.laneId} with action ${dispatchResult.action}.`,
+  });
+
+  return {
+    engine: 'breakthroughs',
+    decisionId: decision.id,
+    question: decision.question,
+    selectedRung: {
+      id: selectedRung.id,
+      label: selectedRung.label,
+      spendClass: selectedRung.spendClass,
+    },
+    dispatchResult,
+    when: describeWhen(dispatchResult.action, selectedRung),
+    requiredOutputs,
+    orpPacket,
+  };
+}

package/src/runtime/maintainer-seed.js

@@ -35,6 +35,8 @@ const STARTER_LOOP_ARTIFACTS = [
   'AGENT_START.md',
   'ROUTES.md',
   'CHECKPOINT_NOTES.md',
+  'PUBLIC_STATUS_REVIEW.md',
+  'AGENT_WEBSEARCH_BRIEF.md',
 ];
 
 function normalizeTitle(rawTitle, problemId) {
@@ -118,6 +120,9 @@ function loadPullBundle(problemId, fromPullDir) {
   const literatureSiteExtractText = readOptionalText(path.join(pullDir, 'literature', 'SITE_EXTRACT.txt'));
   const literatureReferences = readOptionalText(path.join(pullDir, 'literature', 'REFERENCES.md'));
   const literatureStatement = readOptionalText(path.join(pullDir, 'literature', 'STATEMENT.md'));
+  const publicStatusReview = readOptionalJson(path.join(pullDir, 'literature', 'PUBLIC_STATUS_REVIEW.json'));
+  const publicStatusReviewMarkdown = readOptionalText(path.join(pullDir, 'literature', 'PUBLIC_STATUS_REVIEW.md'));
+  const agentWebsearchBrief = readOptionalText(path.join(pullDir, 'literature', 'AGENT_WEBSEARCH_BRIEF.md'));
 
   return {
     pullDir,
@@ -129,6 +134,9 @@ function loadPullBundle(problemId, fromPullDir) {
     siteExtractText: literatureSiteExtractText,
     references: literatureReferences,
     statement: literatureStatement,
+    publicStatusReview,
+    publicStatusReviewMarkdown,
+    agentWebsearchBrief,
   };
 }
 
@@ -185,7 +193,12 @@ function buildResearchState(options, siteStatus) {
 
 function buildProblemRecord(problemId, bundle, options) {
   const upstreamRecord = bundle.upstreamRecord ?? {};
-  const siteStatus = String(upstreamRecord.status?.state ?? bundle.problemRecord?.siteStatus ?? 'unknown').trim();
+  const siteStatus = String(
+    bundle.siteExtract?.siteStatus
+      ?? upstreamRecord.status?.state
+      ?? bundle.problemRecord?.siteStatus
+      ?? 'unknown',
+  ).trim();
   const title = deriveTitle(problemId, bundle, options.title);
   const shortStatement = deriveShortStatement(problemId, bundle, title);
   const familyTags = [
@@ -219,6 +232,7 @@ function buildProblemRecord(problemId, bundle, options) {
         kind: 'pull_bundle',
         upstream_record_included: Boolean(bundle.upstreamRecord),
         site_snapshot_included: Boolean(bundle.siteExtract || bundle.siteSummary),
+        public_search_review_included: Boolean(bundle.publicStatusReview || bundle.publicStatusReviewMarkdown),
       },
     },
     status: {
@@ -258,6 +272,29 @@ function buildProblemRecord(problemId, bundle, options) {
   return record;
 }
 
+function assertSeedAdmission(record, bundle, options) {
+  if (options.allowNonOpen) {
+    return;
+  }
+
+  const siteStatus = String(bundle.siteExtract?.siteStatus ?? '').trim().toLowerCase();
+  const upstreamStatus = String(bundle.upstreamRecord?.status?.state ?? '').trim().toLowerCase();
+  if (!siteStatus) {
+    if (upstreamStatus === 'open') {
+      return;
+    }
+    throw new Error(
+      `Seed admission failed for problem ${record.problem_id}: live erdosproblems.com status was not captured in the pull bundle and upstream status is not clearly open. Re-run with a live site snapshot or pass --allow-non-open to bypass this gate.`,
+    );
+  }
+
+  if (siteStatus !== 'open') {
+    throw new Error(
+      `Seed admission failed for problem ${record.problem_id}: erdosproblems.com currently reports site status "${siteStatus}", not "open". Pass --allow-non-open to bypass this gate intentionally.`,
+    );
+  }
+}
+
 function renderStatementMarkdown(problemId, record, bundle) {
   const previewLines = Array.isArray(bundle.siteExtract?.previewLines)
     ? bundle.siteExtract.previewLines.filter((line) => String(line ?? '').trim())
@@ -316,6 +353,7 @@ function renderEvidenceMarkdown(problemId, record, bundle) {
     `- This dossier was seeded for Erdos Problem #${problemId} from a pull bundle.`,
     `- Upstream record included: ${bundle.upstreamRecord ? 'yes' : 'no'}`,
     `- Site snapshot included: ${bundle.siteExtract || bundle.siteSummary ? 'yes' : 'no'}`,
+    `- Public status review included: ${bundle.publicStatusReview || bundle.publicStatusReviewMarkdown ? 'yes' : 'no'}`,
     `- Repo status at seed time: ${record.status.repo_status}`,
     `- Harness depth at seed time: ${record.harness.depth}`,
     '',
@@ -357,9 +395,11 @@ function renderAgentStartMarkdown(problemId, record) {
     `- Active route: ${activeRoute}`,
     `- Repo status: ${record.status.repo_status}`,
     `- Harness depth: ${record.harness.depth}`,
+    `- Site status: ${record.status.site_status}`,
     '',
     'First honest move:',
     `- tighten the local dossier for problem ${problemId} against its pull bundle, references, and upstream provenance before widening claims.`,
+    '- read `PUBLIC_STATUS_REVIEW.md` and run the suggested queries in `AGENT_WEBSEARCH_BRIEF.md` before trusting a single public status surface.',
     '',
   ].join('\n');
 }
@@ -397,6 +437,7 @@ function renderCheckpointNotesMarkdown(problemId, record) {
     '- What changed in the active route since the last honest checkpoint?',
     '- Which claim level is justified right now: Exact, Verified, Heuristic, or Conjecture?',
     '- Which upstream/public truth changed, if any?',
+    '- What did the public-status review and agent websearch brief surface beyond erdosproblems.com?',
     '- Which artifact or literature bundle should the next agent read first?',
     '',
   ].join('\n');
@@ -424,6 +465,7 @@ export function seedProblemFromPullBundle(problemId, options = {}) {
     routeBreakthrough: options.routeBreakthrough ?? false,
     problemSolved: options.problemSolved ?? false,
   });
+  assertSeedAdmission(record, bundle, options);
 
   writeText(path.join(destinationDir, 'problem.yaml'), stringify(record));
   writeText(path.join(destinationDir, 'STATEMENT.md'), renderStatementMarkdown(problemId, record, bundle));
@@ -433,12 +475,36 @@ export function seedProblemFromPullBundle(problemId, options = {}) {
   writeText(path.join(destinationDir, 'AGENT_START.md'), renderAgentStartMarkdown(problemId, record));
   writeText(path.join(destinationDir, 'ROUTES.md'), renderRoutesMarkdown(problemId, record));
   writeText(path.join(destinationDir, 'CHECKPOINT_NOTES.md'), renderCheckpointNotesMarkdown(problemId, record));
+  writeText(
+    path.join(destinationDir, 'PUBLIC_STATUS_REVIEW.md'),
+    bundle.publicStatusReviewMarkdown
+      ?? [
+          '# Public Status Review',
+          '',
+          '- No live public search review markdown was present in the pull bundle.',
+          '- Re-run the pull with a public search lane before widening any public-status claim.',
+          '',
+        ].join('\n'),
+  );
+  writeText(
+    path.join(destinationDir, 'AGENT_WEBSEARCH_BRIEF.md'),
+    bundle.agentWebsearchBrief
+      ?? [
+          '# Agent Websearch Brief',
+          '',
+          `- Problem: ${problemId}`,
+          `- Site status at seed time: ${record.status.site_status}`,
+          '- Run a fresh web search before treating the public status surface as settled.',
+          '',
+        ].join('\n'),
+  );
 
   return {
     destinationDir,
     record,
     usedSiteSnapshot: Boolean(bundle.siteExtract || bundle.siteSummary),
     usedUpstreamRecord: Boolean(bundle.upstreamRecord),
+    usedPublicStatusReview: Boolean(bundle.publicStatusReview || bundle.publicStatusReviewMarkdown),
     starterLoopArtifacts: STARTER_LOOP_ARTIFACTS,
   };
 }

package/src/runtime/problem-artifacts.js

@@ -17,6 +17,8 @@ const STARTER_LOOP_FILES = [
   ['AGENT_START.md', 'AGENT_START.md'],
   ['ROUTES.md', 'ROUTES.md'],
   ['CHECKPOINT_NOTES.md', 'CHECKPOINT_NOTES.md'],
+  ['PUBLIC_STATUS_REVIEW.md', 'PUBLIC_STATUS_REVIEW.md'],
+  ['AGENT_WEBSEARCH_BRIEF.md', 'AGENT_WEBSEARCH_BRIEF.md'],
 ];
 
 function getPackContextPath(problem) {

package/src/runtime/sunflower.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parse } from 'yaml';
 import { writeJson } from './files.js';
+import { buildBreakthroughsComputeView } from './breakthroughs.js';
 import { getPackDir, getPackProblemDir, getWorkspaceComputeRegistryDir } from './paths.js';
 
 const CLAIM_LEVEL_PRIORITY = {
@@ -313,6 +314,7 @@ export function buildSunflowerStatusSnapshot(problem) {
   const packets = listSunflowerComputePackets(problem.problemId);
   const activePacket = chooseActivePacket(packets);
   const summary = deriveSummary(activePacket);
+  const computeGovernance = buildBreakthroughsComputeView(problem, activePacket);
   const routeState = deriveRouteState(problem, context);
   const agentStartPath = getSunflowerAgentStartPath(problem.problemId);
   const checkpointPacketPath = getSunflowerCheckpointPacketPath(problem.problemId);
@@ -356,6 +358,9 @@ export function buildSunflowerStatusSnapshot(problem) {
     computeSummary: summary.computeSummary,
     computeNextAction: summary.computeNextAction,
     budgetState: summary.budgetState,
+    computeReason: activePacket?.question ?? null,
+    computeWhen: computeGovernance?.when ?? 'No compute packet is currently admitted.',
+    computeGovernance,
     activePacket: compactPacket(activePacket),
     computePackets: packets.map((packet) => compactPacket(packet)),
   };

package/src/upstream/public-search.js

@@ -0,0 +1,139 @@
+const DDG_HTML_URL = 'https://html.duckduckgo.com/html/';
+
+function decodeEntities(text) {
+  return String(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 stripTags(text) {
+  return decodeEntities(String(text ?? '').replace(/<[^>]+>/g, ' ')).replace(/\s+/g, ' ').trim();
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.map((value) => String(value ?? '').trim()).filter(Boolean))];
+}
+
+function resolveDuckDuckGoUrl(rawUrl) {
+  const value = String(rawUrl ?? '').trim();
+  if (!value) {
+    return null;
+  }
+  if (value.startsWith('//')) {
+    return `https:${value}`;
+  }
+  if (value.startsWith('/l/?')) {
+    const params = new URLSearchParams(value.slice(4));
+    return params.get('uddg') ?? null;
+  }
+  return value;
+}
+
+function extractResultSnippet(resultHtml) {
+  const snippetMatch = resultHtml.match(/<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i)
+    ?? resultHtml.match(/<div[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/div>/i);
+  return stripTags(snippetMatch?.[1] ?? '');
+}
+
+function parseDuckDuckGoResults(html, query) {
+  const blockPattern = /<div[^>]*class="result(?:\s|")([\s\S]*?)<\/div>\s*<\/div>/gi;
+  const results = [];
+  let match = blockPattern.exec(html);
+  while (match) {
+    const block = match[0];
+    const anchor = block.match(/<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+    if (anchor) {
+      const url = resolveDuckDuckGoUrl(anchor[1]);
+      const title = stripTags(anchor[2]);
+      if (url && title) {
+        results.push({
+          query,
+          title,
+          url,
+          snippet: extractResultSnippet(block),
+        });
+      }
+    }
+    match = blockPattern.exec(html);
+  }
+  return results;
+}
+
+export function buildProblemSearchQueries(problemId, title) {
+  const cleanTitle = String(title ?? '').trim();
+  return uniqueStrings([
+    `"Erdos Problem #${problemId}"`,
+    `erdos problem ${problemId}`,
+    cleanTitle ? `"${cleanTitle}"` : null,
+    cleanTitle ? `"${cleanTitle}" erdos` : null,
+    cleanTitle ? `"${cleanTitle}" sunflower` : null,
+  ]);
+}
+
+async function fetchDuckDuckGoQuery(query) {
+  const url = `${DDG_HTML_URL}?q=${encodeURIComponent(query)}`;
+  const response = await fetch(url, {
+    headers: {
+      'User-Agent': 'erdos-problems-cli',
+      Accept: 'text/html',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`DuckDuckGo search failed for "${query}": ${response.status}`);
+  }
+
+  const html = await response.text();
+  return {
+    provider: 'duckduckgo',
+    query,
+    url,
+    results: parseDuckDuckGoResults(html, query).slice(0, 5),
+  };
+}
+
+export async function fetchProblemPublicSearchReview(problemId, title) {
+  const queries = buildProblemSearchQueries(problemId, title).slice(0, 3);
+  const searchRuns = [];
+  const errors = [];
+
+  for (const query of queries) {
+    try {
+      searchRuns.push(await fetchDuckDuckGoQuery(query));
+    } catch (error) {
+      errors.push({
+        query,
+        error: String(error?.message ?? error),
+      });
+    }
+  }
+
+  const combinedResults = [];
+  const seenUrls = new Set();
+  for (const run of searchRuns) {
+    for (const result of run.results) {
+      if (seenUrls.has(result.url)) {
+        continue;
+      }
+      seenUrls.add(result.url);
+      combinedResults.push(result);
+    }
+  }
+
+  return {
+    fetchedAt: new Date().toISOString(),
+    problemId: String(problemId),
+    title: String(title ?? '').trim() || `Erdos Problem #${problemId}`,
+    provider: 'duckduckgo',
+    queries,
+    searchRuns,
+    combinedResults: combinedResults.slice(0, 10),
+    errors,
+  };
+}

package/src/upstream/site.js

@@ -1,5 +1,16 @@
 const SITE_BASE_URL = 'https://www.erdosproblems.com';
 
+const SITE_STATUS_MAP = {
+  OPEN: 'open',
+  SOLVED: 'solved',
+  PROVED: 'proved',
+  'PROVED (LEAN)': 'proved',
+  DISPROVED: 'disproved',
+  PARTIAL: 'partial',
+  DECIDABLE: 'decidable',
+  VERIFIABLE: 'verifiable',
+};
+
 function decodeEntities(text) {
   return text
     .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
@@ -51,6 +62,33 @@ function selectPreviewLines(lines) {
   return lines.slice(0, 24);
 }
 
+export function normalizeSiteStatus(value) {
+  const raw = String(value ?? '').trim().toUpperCase();
+  return SITE_STATUS_MAP[raw] ?? (raw.toLowerCase() || 'unknown');
+}
+
+export function extractProblemPageStatus(lines) {
+  const statusLine = (Array.isArray(lines) ? lines : [])
+    .map((line) => String(line ?? '').trim())
+    .find((line) => /^(OPEN|SOLVED|PROVED|PARTIAL|DISPROVED|DECIDABLE|VERIFIABLE)\b/i.test(line));
+
+  if (!statusLine) {
+    return {
+      raw: null,
+      normalized: 'unknown',
+    };
+  }
+
+  const raw = statusLine
+    .replace(/\s+\$\d[\d,]*(?:\s*-\s*\$\d[\d,]*)?.*$/i, '')
+    .trim();
+
+  return {
+    raw,
+    normalized: normalizeSiteStatus(raw),
+  };
+}
+
 export async function fetchProblemSiteSnapshot(problemId) {
   const url = `${SITE_BASE_URL}/${problemId}`;
   const response = await fetch(url, {
@@ -68,6 +106,7 @@ export async function fetchProblemSiteSnapshot(problemId) {
   const text = htmlToReadableText(html);
   const title = extractTitle(html, problemId);
   const lines = text.split('\n').filter(Boolean);
+  const status = extractProblemPageStatus(lines);
 
   return {
     url,
@@ -75,6 +114,8 @@ export async function fetchProblemSiteSnapshot(problemId) {
     html,
     title,
     text,
+    siteStatus: status.normalized,
+    siteStatusRaw: status.raw,
     previewLines: selectPreviewLines(lines),
   };
 }