erdos-problems 0.1.8 → 0.1.10

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

@@ -2,6 +2,7 @@ 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 { syncOrpWorkspaceKit } from '../runtime/orp.js';
 import { getWorkspaceProblemPullDir, getWorkspaceRoot, getWorkspaceSeededProblemsDir } from '../runtime/paths.js';
 import { syncState } from '../runtime/state.js';
 import { readCurrentProblem, setCurrentProblem } from '../runtime/workspace.js';
@@ -15,7 +16,8 @@ function parseSeedArgs(args) {
 
   const parsed = {
     problemId: value,
-    includeSite: false,
+    includeSite: true,
+    includePublicSearch: true,
     refreshUpstream: false,
     cluster: null,
     repoStatus: 'local_seeded',
@@ -27,6 +29,7 @@ function parseSeedArgs(args) {
     activeRoute: null,
     routeBreakthrough: false,
     problemSolved: false,
+    allowNonOpen: false,
     destRoot: null,
     noActivate: false,
     noLoopSync: false,
@@ -40,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;
@@ -118,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) {
@@ -151,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;
   }
 
@@ -166,6 +185,7 @@ export async function runSeedCommand(args) {
   }
 
   const workspaceRoot = getWorkspaceRoot();
+  const orp = syncOrpWorkspaceKit(workspaceRoot);
   const pullDir = getWorkspaceProblemPullDir(parsed.problemId, workspaceRoot);
   const defaultSeedRoot = getWorkspaceSeededProblemsDir(workspaceRoot);
   const destinationRoot = parsed.destRoot
@@ -177,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');
   }
@@ -200,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,
   });
 
@@ -231,7 +255,9 @@ export async function runSeedCommand(args) {
     checkpointShelf: checkpoints?.indexPath ?? null,
     usedUpstreamRecord: result.usedUpstreamRecord,
     usedSiteSnapshot: result.usedSiteSnapshot,
+    usedPublicStatusReview: result.usedPublicStatusReview,
     workspaceOverlayVisible: seedsIntoWorkspaceOverlay,
+    orpProtocol: orp.protocolPath,
   };
 
   if (parsed.asJson) {
@@ -247,6 +273,8 @@ 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'}`);
   console.log(`Loop synced: ${loopSynced ? 'yes' : 'no'}`);

package/src/commands/state.js

@@ -1,4 +1,5 @@
 import { getWorkspaceQuestionLedgerPath, getWorkspaceStateMarkdownPath } from '../runtime/paths.js';
+import { syncOrpWorkspaceKit } from '../runtime/orp.js';
 import { loadState, syncState } from '../runtime/state.js';
 
 function printState(state) {
@@ -33,6 +34,7 @@ export function runStateCommand(args) {
   }
 
   if (subcommand === 'sync') {
+    syncOrpWorkspaceKit();
     const state = syncState();
     if (asJson) {
       console.log(JSON.stringify(state, null, 2));

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/commands/workspace.js

@@ -28,6 +28,10 @@ export function runWorkspaceCommand(args) {
   console.log(`State markdown: ${summary.stateMarkdownPath}`);
   console.log(`Question ledger: ${summary.questionLedgerPath}`);
   console.log(`Checkpoint shelf: ${summary.checkpointIndexPath}`);
+  console.log(`Workspace ORP dir: ${summary.orpDir}`);
+  console.log(`Workspace ORP protocol: ${summary.orpProtocolPath}`);
+  console.log(`Workspace ORP integration: ${summary.orpIntegrationPath}`);
+  console.log(`Workspace ORP templates: ${summary.orpTemplatesDir}`);
   console.log(`Workspace upstream dir: ${summary.upstreamDir}`);
   console.log(`Workspace seeded-problems dir: ${summary.seededProblemsDir}`);
   console.log(`Workspace scaffold dir: ${summary.scaffoldDir}`);

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