erdos-problems 0.1.8 → 0.1.9

package/AGENT_INTEGRATION.md

@@ -0,0 +1,25 @@
+# ORP Agent Integration
+
+Use this when an agent is working inside an `erdos-problems` workspace.
+
+## Core Rule
+
+Do not let local route progress masquerade as global problem closure.
+
+## Minimum Working Loop
+
+1. select or seed a problem
+2. sync ORP kit
+3. sync state
+4. run preflight
+5. sync checkpoints
+6. work the next honest move
+
+## Canonical Artifact Boundary
+
+Evidence belongs in:
+- `problems/<id>/`
+- pack artifacts under `packs/`
+- workspace pulls and scaffolds under `.erdos/`
+
+Protocol files and ORP templates are process scaffolding only.

package/PROTOCOL.md

@@ -0,0 +1,36 @@
+# Open Research Protocol
+
+`erdos-problems` ships a bundled ORP kit so every workspace can start with the same claim hygiene and verification frame.
+
+## Canonical Truth
+
+- Public problem metadata comes from the upstream Erdős snapshot plus the local canonical dossier.
+- Pack context, route packets, and workspace state guide the loop but do not silently upgrade global problem status.
+- ORP process files are protocol tools, not mathematical evidence.
+
+## Claim Levels
+
+- `Exact`
+- `Verified`
+- `Heuristic`
+- `Conjecture`
+
+When unsure, downgrade rather than overclaim.
+
+## Required Discipline
+
+- keep open problem / active route / route breakthrough / problem solved distinct
+- record verification hooks for exact or verified claims
+- preserve failed paths as useful artifacts, not invisible dead ends
+- keep route claims tied to canonical dossier and pack artifacts
+
+## Workspace ORP Kit
+
+The CLI syncs this protocol into `.erdos/orp/`:
+- `PROTOCOL.md`
+- `AGENT_INTEGRATION.md`
+- `templates/CLAIM.md`
+- `templates/VERIFICATION_RECORD.md`
+- `templates/FAILED_TOPIC.md`
+
+Use `erdos orp sync` to refresh the workspace copy explicitly.

package/README.md

@@ -18,6 +18,7 @@ Official binary:
 
 - atlas layer with canonical local `problems/<id>/problem.yaml` records
 - bundled upstream snapshot from `teorth/erdosproblems`
+- bundled ORP kit with protocol and templates for claim hygiene
 - workspace `.erdos/` state for active-problem selection, upstream refreshes, scaffolds, and pull bundles
 - sunflower cluster as the first deep harness pack
 - quartet-aware sunflower context for `20`, `536`, `856`, and `857`
@@ -51,6 +52,7 @@ erdos workspace show
 
 What `bootstrap` does:
 - sets the active workspace problem
+- syncs the bundled ORP workspace kit into `.erdos/orp/`
 - scaffolds the canonical dossier files into `.erdos/scaffolds/<id>/`
 - includes the upstream record when a bundled or workspace snapshot is available
 - copies pack-specific context and compute packets when the problem has them
@@ -60,6 +62,7 @@ What `seed` does:
 - creates a pull bundle for any problem in the upstream snapshot
 - promotes that bundle into `.erdos/seeded-problems/<id>/`
 - auto-selects the problem in the workspace
+- syncs the bundled ORP workspace kit into `.erdos/orp/`
 - syncs the staged research loop state and checkpoint shelf
 - makes the new dossier visible to the atlas commands immediately inside that workspace
 - writes richer starter artifacts:
@@ -143,6 +146,27 @@ erdos sunflower status 857 --json
 - problem-solved distinction
 - compute posture when a packet exists
 
+## ORP
+
+`erdos-problems` now ships a bundled Open Research Protocol kit:
+- `PROTOCOL.md`
+- `AGENT_INTEGRATION.md`
+- `templates/CLAIM.md`
+- `templates/VERIFICATION_RECORD.md`
+- `templates/FAILED_TOPIC.md`
+
+Workspace copy:
+- `.erdos/orp/PROTOCOL.md`
+- `.erdos/orp/AGENT_INTEGRATION.md`
+- `.erdos/orp/templates/`
+
+Useful ORP commands:
+
+```bash
+erdos orp show
+erdos orp sync
+```
+
 ## CLI
 
 ```bash
@@ -158,6 +182,8 @@ erdos problem artifacts 857 --json
 erdos cluster list
 erdos cluster show sunflower
 erdos workspace show
+erdos orp show
+erdos orp sync
 erdos sunflower status 857
 erdos sunflower status --json
 erdos dossier show
@@ -242,6 +268,9 @@ This runtime writes:
 - `.erdos/QUESTION-LEDGER.md`
 - `.erdos/checkpoints/CHECKPOINTS.md`
 - `.erdos/checkpoints/CHECKPOINTS.json`
+- `.erdos/orp/PROTOCOL.md`
+- `.erdos/orp/AGENT_INTEGRATION.md`
+- `.erdos/orp/templates/`
 - `.erdos/registry/preflight/`
 
 The public package uses the same status ladder we settled on in the lab:

package/docs/RESEARCH_LOOP.md

@@ -11,24 +11,29 @@ Workspace runtime files live under `.erdos/`:
 - `QUESTION-LEDGER.md`
 - `checkpoints/CHECKPOINTS.md`
 - `checkpoints/CHECKPOINTS.json`
+- `orp/PROTOCOL.md`
+- `orp/AGENT_INTEGRATION.md`
+- `orp/templates/`
 - `registry/preflight/`
 - `registry/compute/`
 
 ## Core loop
 
 1. Select or bootstrap a problem.
-2. Sync state.
-3. Run preflight.
-4. Set continuation mode.
-5. Sync checkpoints.
-6. Pull or scaffold artifacts.
-7. Work the active route.
-8. Sync checkpoints again at honest boundaries.
+2. Sync ORP.
+3. Sync state.
+4. Run preflight.
+5. Set continuation mode.
+6. Sync checkpoints.
+7. Pull or scaffold artifacts.
+8. Work the active route.
+9. Sync checkpoints again at honest boundaries.
 
 ## Commands
 
 ```bash
 erdos problem use 857
+erdos orp sync
 erdos state sync
 erdos preflight
 erdos continuation use route
@@ -52,6 +57,13 @@ The seeded dossier now also includes starter-loop artifacts:
 - `ROUTES.md`
 - `CHECKPOINT_NOTES.md`
 
+The ORP kit travels with the workspace too:
+- `PROTOCOL.md`
+- `AGENT_INTEGRATION.md`
+- `templates/CLAIM.md`
+- `templates/VERIFICATION_RECORD.md`
+- `templates/FAILED_TOPIC.md`
+
 ## 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.8",
+  "version": "0.1.9",
   "description": "CLI atlas and staged research harness for Paul Erdos problems.",
   "type": "module",
   "bin": {
@@ -9,12 +9,15 @@
   "files": [
     "README.md",
     "LICENSE",
+    "PROTOCOL.md",
+    "AGENT_INTEGRATION.md",
     "bin",
     "data",
     "docs",
     "packs",
     "problems",
-    "src"
+    "src",
+    "templates"
   ],
   "scripts": {
     "test": "node --test",

package/src/cli/index.js

@@ -4,6 +4,7 @@ import { runClusterCommand } from '../commands/cluster.js';
 import { runContinuationCommand } from '../commands/continuation.js';
 import { runDossierCommand } from '../commands/dossier.js';
 import { runMaintainerCommand } from '../commands/maintainer.js';
+import { runOrpCommand } from '../commands/orp.js';
 import { runPreflightCommand } from '../commands/preflight.js';
 import { runProblemCommand } from '../commands/problem.js';
 import { runPullCommand } from '../commands/pull.js';
@@ -26,6 +27,8 @@ function printUsage() {
   console.log('  erdos cluster list');
   console.log('  erdos cluster show <name>');
   console.log('  erdos workspace show');
+  console.log('  erdos orp show [--json]');
+  console.log('  erdos orp sync [--json]');
   console.log('  erdos state sync [--json]');
   console.log('  erdos state show [--json]');
   console.log('  erdos continuation show [--json]');
@@ -59,6 +62,8 @@ if (!command || command === 'help' || command === '--help') {
   exitCode = runClusterCommand(rest);
 } else if (command === 'workspace') {
   exitCode = runWorkspaceCommand(rest);
+} else if (command === 'orp') {
+  exitCode = runOrpCommand(rest);
 } else if (command === 'state') {
   exitCode = runStateCommand(rest);
 } else if (command === 'continuation') {

package/src/commands/bootstrap.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { getProblem } from '../atlas/catalog.js';
 import { syncCheckpoints } from '../runtime/checkpoints.js';
+import { syncOrpWorkspaceKit } from '../runtime/orp.js';
 import { scaffoldProblem } from '../runtime/problem-artifacts.js';
 import { getWorkspaceProblemScaffoldDir } from '../runtime/paths.js';
 import { syncState } from '../runtime/state.js';
@@ -68,6 +69,7 @@ export async function runBootstrapCommand(args) {
     console.log(`Workspace upstream snapshot refreshed: ${syncResult.workspacePaths.manifestPath}`);
   }
 
+  const orp = syncOrpWorkspaceKit();
   setCurrentProblem(problem.problemId);
   const destination = parsed.destination
     ? path.resolve(parsed.destination)
@@ -81,6 +83,7 @@ export async function runBootstrapCommand(args) {
   console.log(`Active route: ${state.activeRoute ?? '(none)'}`);
   console.log(`Scaffold dir: ${result.destination}`);
   console.log(`Artifacts copied: ${result.copiedArtifacts.length}`);
+  console.log(`ORP protocol: ${orp.protocolPath}`);
   console.log(`Upstream record included: ${result.inventory.upstreamRecordIncluded ? 'yes' : 'no'}`);
   console.log(`Checkpoint shelf: ${checkpoints.indexPath}`);
   console.log(`Next honest move: ${state.nextHonestMove}`);

package/src/commands/checkpoints.js

@@ -1,4 +1,5 @@
 import { syncCheckpoints } from '../runtime/checkpoints.js';
+import { syncOrpWorkspaceKit } from '../runtime/orp.js';
 
 export function runCheckpointsCommand(args) {
   const [subcommand, ...rest] = args;
@@ -21,6 +22,7 @@ export function runCheckpointsCommand(args) {
     return 1;
   }
 
+  syncOrpWorkspaceKit();
   const result = syncCheckpoints();
   if (asJson) {
     console.log(JSON.stringify(result, null, 2));

package/src/commands/orp.js

@@ -0,0 +1,58 @@
+import { getOrpStatus, syncOrpWorkspaceKit } from '../runtime/orp.js';
+
+function printOrpStatus(status) {
+  console.log('Open Research Protocol');
+  console.log(`Workspace root: ${status.workspaceRoot}`);
+  console.log(`Bundled protocol: ${status.bundled.protocolPresent ? status.bundled.protocolPath : '(missing)'}`);
+  console.log(`Bundled integration: ${status.bundled.integrationPresent ? status.bundled.integrationPath : '(missing)'}`);
+  console.log(`Bundled templates: ${status.bundled.templateNames.join(', ') || '(none)'}`);
+  console.log(`Workspace ORP dir: ${status.workspace.orpDir}`);
+  console.log(`Workspace protocol: ${status.workspace.protocolPresent ? status.workspace.protocolPath : '(missing)'}`);
+  console.log(`Workspace integration: ${status.workspace.integrationPresent ? status.workspace.integrationPath : '(missing)'}`);
+  console.log(`Workspace templates: ${status.workspace.templateNames.join(', ') || '(none)'}`);
+}
+
+export function runOrpCommand(args) {
+  const [subcommand, ...rest] = args;
+  const asJson = rest.includes('--json');
+  const unknown = rest.filter((arg) => arg !== '--json');
+
+  if (!subcommand || subcommand === 'help' || subcommand === '--help') {
+    console.log('Usage:');
+    console.log('  erdos orp show [--json]');
+    console.log('  erdos orp sync [--json]');
+    return 0;
+  }
+
+  if (unknown.length > 0) {
+    console.error(`Unknown orp option: ${unknown[0]}`);
+    return 1;
+  }
+
+  if (subcommand === 'show') {
+    const status = getOrpStatus();
+    if (asJson) {
+      console.log(JSON.stringify(status, null, 2));
+      return 0;
+    }
+    printOrpStatus(status);
+    return 0;
+  }
+
+  if (subcommand === 'sync') {
+    const result = syncOrpWorkspaceKit();
+    if (asJson) {
+      console.log(JSON.stringify(result, null, 2));
+      return 0;
+    }
+    console.log('ORP workspace kit synced');
+    console.log(`Workspace ORP dir: ${result.orpDir}`);
+    console.log(`Protocol: ${result.protocolPath}`);
+    console.log(`Agent integration: ${result.integrationPath}`);
+    console.log(`Templates: ${result.templateNames.join(', ') || '(none)'}`);
+    return 0;
+  }
+
+  console.error(`Unknown orp subcommand: ${subcommand}`);
+  return 1;
+}

package/src/commands/problem.js

@@ -1,4 +1,6 @@
 import { getProblem, listProblems } from '../atlas/catalog.js';
+import { syncOrpWorkspaceKit } from '../runtime/orp.js';
+import { syncCheckpoints } from '../runtime/checkpoints.js';
 import { getProblemArtifactInventory } from '../runtime/problem-artifacts.js';
 import { syncState } from '../runtime/state.js';
 import { readCurrentProblem, setCurrentProblem } from '../runtime/workspace.js';
@@ -207,10 +209,14 @@ export function runProblemCommand(args) {
       return 1;
     }
     setCurrentProblem(problem.problemId);
-    const state = syncState();
+    syncOrpWorkspaceKit();
+    syncState();
+    const checkpointResult = syncCheckpoints();
+    const state = checkpointResult.state;
     console.log(`Active problem set to ${problem.problemId} (${problem.title})`);
     console.log(`Active route: ${state.activeRoute ?? '(none)'}`);
     console.log(`Next honest move: ${state.nextHonestMove}`);
+    console.log(`Checkpoint shelf: ${checkpointResult.indexPath}`);
     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';
@@ -166,6 +167,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
@@ -232,6 +234,7 @@ export async function runSeedCommand(args) {
     usedUpstreamRecord: result.usedUpstreamRecord,
     usedSiteSnapshot: result.usedSiteSnapshot,
     workspaceOverlayVisible: seedsIntoWorkspaceOverlay,
+    orpProtocol: orp.protocolPath,
   };
 
   if (parsed.asJson) {
@@ -247,6 +250,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(`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/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/orp.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { copyFileIfPresent, ensureDir } from './files.js';
+import {
+  getBundledOrpIntegrationPath,
+  getBundledOrpProtocolPath,
+  getBundledOrpTemplatesDir,
+  getWorkspaceOrpDir,
+  getWorkspaceOrpIntegrationPath,
+  getWorkspaceOrpProtocolPath,
+  getWorkspaceOrpTemplatesDir,
+  getWorkspaceRoot,
+} from './paths.js';
+
+function listTemplateNames(rootDir) {
+  if (!fs.existsSync(rootDir)) {
+    return [];
+  }
+  return fs
+    .readdirSync(rootDir, { withFileTypes: true })
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name)
+    .sort();
+}
+
+export function getOrpStatus(workspaceRoot = getWorkspaceRoot()) {
+  const bundledTemplatesDir = getBundledOrpTemplatesDir();
+  const workspaceTemplatesDir = getWorkspaceOrpTemplatesDir(workspaceRoot);
+  const bundledTemplateNames = listTemplateNames(bundledTemplatesDir);
+  const workspaceTemplateNames = listTemplateNames(workspaceTemplatesDir);
+
+  return {
+    workspaceRoot,
+    bundled: {
+      protocolPath: getBundledOrpProtocolPath(),
+      integrationPath: getBundledOrpIntegrationPath(),
+      templatesDir: bundledTemplatesDir,
+      protocolPresent: fs.existsSync(getBundledOrpProtocolPath()),
+      integrationPresent: fs.existsSync(getBundledOrpIntegrationPath()),
+      templateNames: bundledTemplateNames,
+    },
+    workspace: {
+      orpDir: getWorkspaceOrpDir(workspaceRoot),
+      protocolPath: getWorkspaceOrpProtocolPath(workspaceRoot),
+      integrationPath: getWorkspaceOrpIntegrationPath(workspaceRoot),
+      templatesDir: workspaceTemplatesDir,
+      protocolPresent: fs.existsSync(getWorkspaceOrpProtocolPath(workspaceRoot)),
+      integrationPresent: fs.existsSync(getWorkspaceOrpIntegrationPath(workspaceRoot)),
+      templateNames: workspaceTemplateNames,
+    },
+  };
+}
+
+export function syncOrpWorkspaceKit(workspaceRoot = getWorkspaceRoot()) {
+  const workspaceOrpDir = getWorkspaceOrpDir(workspaceRoot);
+  const workspaceTemplatesDir = getWorkspaceOrpTemplatesDir(workspaceRoot);
+  ensureDir(workspaceOrpDir);
+  ensureDir(workspaceTemplatesDir);
+
+  copyFileIfPresent(getBundledOrpProtocolPath(), getWorkspaceOrpProtocolPath(workspaceRoot));
+  copyFileIfPresent(getBundledOrpIntegrationPath(), getWorkspaceOrpIntegrationPath(workspaceRoot));
+
+  const bundledTemplatesDir = getBundledOrpTemplatesDir();
+  const copiedTemplates = [];
+  for (const templateName of listTemplateNames(bundledTemplatesDir)) {
+    const sourcePath = path.join(bundledTemplatesDir, templateName);
+    const destinationPath = path.join(workspaceTemplatesDir, templateName);
+    if (copyFileIfPresent(sourcePath, destinationPath)) {
+      copiedTemplates.push(templateName);
+    }
+  }
+
+  const status = getOrpStatus(workspaceRoot);
+  return {
+    workspaceRoot,
+    orpDir: workspaceOrpDir,
+    protocolPath: status.workspace.protocolPath,
+    integrationPath: status.workspace.integrationPath,
+    templatesDir: status.workspace.templatesDir,
+    templateNames: status.workspace.templateNames,
+    copiedTemplates,
+  };
+}

package/src/runtime/paths.js

@@ -12,6 +12,22 @@ export function getWorkspaceDir(workspaceRoot = getWorkspaceRoot()) {
   return path.join(workspaceRoot, '.erdos');
 }
 
+export function getWorkspaceOrpDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceDir(workspaceRoot), 'orp');
+}
+
+export function getWorkspaceOrpProtocolPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceOrpDir(workspaceRoot), 'PROTOCOL.md');
+}
+
+export function getWorkspaceOrpIntegrationPath(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceOrpDir(workspaceRoot), 'AGENT_INTEGRATION.md');
+}
+
+export function getWorkspaceOrpTemplatesDir(workspaceRoot = getWorkspaceRoot()) {
+  return path.join(getWorkspaceOrpDir(workspaceRoot), 'templates');
+}
+
 export function getWorkspaceConfigPath(workspaceRoot = getWorkspaceRoot()) {
   return path.join(getWorkspaceDir(workspaceRoot), 'config.json');
 }
@@ -128,6 +144,18 @@ export function getBundledDataDir() {
   return path.join(repoRoot, 'data');
 }
 
+export function getBundledOrpProtocolPath() {
+  return path.join(repoRoot, 'PROTOCOL.md');
+}
+
+export function getBundledOrpIntegrationPath() {
+  return path.join(repoRoot, 'AGENT_INTEGRATION.md');
+}
+
+export function getBundledOrpTemplatesDir() {
+  return path.join(repoRoot, 'templates');
+}
+
 export function getBundledUpstreamDir() {
   return path.join(getBundledDataDir(), 'upstream', 'erdosproblems');
 }

package/src/runtime/preflight.js

@@ -15,6 +15,7 @@ import {
   getWorkspaceStatePath,
 } from './paths.js';
 import { getProblemArtifactInventory } from './problem-artifacts.js';
+import { getOrpStatus } from './orp.js';
 import { syncState } from './state.js';
 
 function checkpointPath(workspaceRoot) {
@@ -27,6 +28,7 @@ export function buildPreflightReport(options = {}, workspaceRoot = getWorkspaceR
   const state = syncState(workspaceRoot);
   const problem = state.activeProblem ? getProblem(state.activeProblem) : null;
   const inventory = problem ? getProblemArtifactInventory(problem) : null;
+  const orp = getOrpStatus(workspaceRoot);
   const git = gitSummary(workspaceRoot);
 
   const checks = {
@@ -54,6 +56,18 @@ export function buildPreflightReport(options = {}, workspaceRoot = getWorkspaceR
       ok: fileExists(checkpointPath(workspaceRoot)),
       detail: checkpointPath(workspaceRoot),
     },
+    orpProtocol: {
+      ok: orp.workspace.protocolPresent,
+      detail: orp.workspace.protocolPath,
+    },
+    orpIntegration: {
+      ok: orp.workspace.integrationPresent,
+      detail: orp.workspace.integrationPath,
+    },
+    orpTemplates: {
+      ok: orp.workspace.templateNames.length >= 3,
+      detail: `${orp.workspace.templateNames.length} template(s)`,
+    },
     activeProblem: {
       ok: Boolean(problem),
       detail: problem ? `${problem.problemId} (${problem.title})` : '(none)',
@@ -79,7 +93,7 @@ export function buildPreflightReport(options = {}, workspaceRoot = getWorkspaceR
   let verdict = 'ok';
   if (!checks.erdosRuntime.ok || !checks.configFile.ok || !checks.stateFile.ok || !checks.activeProblem.ok || !checks.canonicalDossier.ok || !checks.upstreamSnapshot.ok) {
     verdict = 'blocked';
-  } else if (!checks.questionLedger.ok || !checks.checkpointShelf.ok || !checks.activeRoute.ok || !checks.workspaceGit.ok) {
+  } else if (!checks.questionLedger.ok || !checks.checkpointShelf.ok || !checks.orpProtocol.ok || !checks.orpIntegration.ok || !checks.orpTemplates.ok || !checks.activeRoute.ok || !checks.workspaceGit.ok) {
     verdict = 'needs_attention';
   }
 

package/src/runtime/workspace.js

@@ -4,6 +4,10 @@ import {
   getWorkspaceCheckpointIndexPath,
   getWorkspaceConfigPath,
   getWorkspaceDir,
+  getWorkspaceOrpDir,
+  getWorkspaceOrpIntegrationPath,
+  getWorkspaceOrpProtocolPath,
+  getWorkspaceOrpTemplatesDir,
   getWorkspaceProblemArtifactDir,
   getWorkspaceProblemLiteratureDir,
   getWorkspaceProblemPullDir,
@@ -78,6 +82,10 @@ export function getWorkspaceSummary(workspaceRoot = getWorkspaceRoot()) {
     stateMarkdownPath: getWorkspaceStateMarkdownPath(workspaceRoot),
     questionLedgerPath: getWorkspaceQuestionLedgerPath(workspaceRoot),
     checkpointIndexPath: getWorkspaceCheckpointIndexPath(workspaceRoot),
+    orpDir: getWorkspaceOrpDir(workspaceRoot),
+    orpProtocolPath: getWorkspaceOrpProtocolPath(workspaceRoot),
+    orpIntegrationPath: getWorkspaceOrpIntegrationPath(workspaceRoot),
+    orpTemplatesDir: getWorkspaceOrpTemplatesDir(workspaceRoot),
     upstreamDir: getWorkspaceUpstreamDir(workspaceRoot),
     seededProblemsDir: getWorkspaceSeededProblemsDir(workspaceRoot),
     scaffoldDir: activeProblem ? getWorkspaceProblemScaffoldDir(activeProblem, workspaceRoot) : getWorkspaceProblemScaffoldDir('<problem-id>', workspaceRoot),

package/templates/CLAIM.md

@@ -0,0 +1,9 @@
+# Claim
+
+- Problem:
+- Route:
+- Claim level: `Exact | Verified | Heuristic | Conjecture`
+- Statement:
+- Canonical artifacts:
+- Verification hook:
+- Notes:

package/templates/FAILED_TOPIC.md

@@ -0,0 +1,8 @@
+# Failed Topic
+
+- Problem:
+- Route:
+- Attempted path:
+- Blocking reason:
+- Counterexample or failure artifact:
+- Next honest move:

package/templates/VERIFICATION_RECORD.md

@@ -0,0 +1,10 @@
+# Verification Record
+
+- Problem:
+- Route:
+- Claim:
+- Commands:
+- Expected result:
+- Actual result:
+- Outcome: `PASS | FAIL | INCONCLUSIVE`
+- Follow-up: