sneakoscope 0.7.69 → 0.7.72

package/README.md

@@ -192,7 +192,7 @@ sks qa-loop prepare "http://localhost:3000"
 sks qa-loop run latest --max-cycles 2
 sks goal create "persist this migration workflow"
 sks research prepare "evaluate this approach"
-sks research run latest --max-cycles 3
+sks research run latest --max-cycles 3 --cycle-timeout-minutes 120
 sks research status latest
 sks db scan --json
 sks wiki refresh
@@ -211,7 +211,7 @@ sks skill-dream run --json
 sks code-structure scan --json
 ```
 
-`sks research` prepares a genius-lens scout council, requires every scout to run at `xhigh`, records one literal `Eureka!` idea per scout, runs an evidence-bound debate, maximizes available web/source retrieval before synthesis, and requires `research-report.md`, `research-paper.md`, `source-ledger.json`, `scout-ledger.json`, `debate-ledger.json`, `novelty-ledger.json`, `falsification-ledger.json`, and `research-gate.json` so research runs stay source-backed, adversarially checked, falsifiable, and paper-ready. `research status` reports source entries, counterevidence, xhigh scout count, Eureka moments, debate exchanges, paper presence/sections, scout findings, and falsification cases alongside the gate.
+`sks research` prepares a genius-lens scout council, requires every scout to run at `xhigh`, records one literal `Eureka!` idea per scout, runs an evidence-bound debate, and now creates `research-source-skill.md` as a route-local source collection skill before synthesis. Normal Research is intentionally allowed to take one or two hours when the problem needs it; `--mock` is only for selftests or dry harness checks, and a real run blocks with `research-blocker.json` instead of silently substituting mock output when the Codex execution path is unavailable. The source layer contract separates latest papers, official/government or leading-institution sources, standards/primary docs, current news such as BBC/CNN/GDELT-style sources, public discourse such as X/Reddit, developer/practitioner knowledge such as Stack Overflow/GitHub, and counterevidence/fact-checking; `source-ledger.json` must record layer coverage, source quality, blockers, citations, and cross-layer triangulation. Context7 is optional for `$Research` and only becomes relevant when the research topic specifically depends on package, API, framework, or SDK documentation. Research runs require `research-report.md`, `research-paper.md`, `genius-opinion-summary.md`, `research-source-skill.md`, `source-ledger.json`, `scout-ledger.json`, `debate-ledger.json`, `novelty-ledger.json`, `falsification-ledger.json`, and `research-gate.json` so they stay source-backed, adversarially checked, falsifiable, paper-ready, and clear about every scout lens opinion. `research status` reports source entries, source-layer coverage, triangulation checks, counterevidence, xhigh scout count, Eureka moments, debate exchanges, paper presence/sections, genius-opinion summary coverage, scout findings, and falsification cases alongside the gate.
 
 `sks pipeline plan` shows the active route lane, kept/skipped stages, verification commands, and no-unrequested-fallback invariant. `sks proof-field scan` is the lightweight rubric for small changes; risky or broad signals return to the full Team/Honest path.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.7.69",
+  "version": "0.7.72",
   "description": "Sneakoscope Codex: database-safe Codex CLI/App harness with Team, Goal, AutoResearch, TriWiki, and Honest Mode.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",

package/src/cli/main.mjs

@@ -22,7 +22,7 @@ import { bumpProjectVersion, installVersionGitHook, runVersionPreCommit, version
 import { rustInfo } from '../core/rust-accelerator.mjs';
 import { renderCartridge, validateCartridge, driftCartridge, snapshotCartridge } from '../core/gx-renderer.mjs';
 import { defaultEvaluationScenario, runEvaluationBenchmark } from '../core/evaluation.mjs';
-import { buildResearchPrompt, evaluateResearchGate, writeMockResearchResult, writeResearchPlan } from '../core/research.mjs';
+import { evaluateResearchGate, writeMockResearchResult, writeResearchPlan } from '../core/research.mjs';
 import {
   PPT_AUDIENCE_STRATEGY_ARTIFACT,
   PPT_CLEANUP_REPORT_ARTIFACT,
@@ -211,7 +211,7 @@ Usage:
   sks team attach-tmux [mission-id|latest]
   sks team cleanup-tmux [mission-id|latest]
   sks research prepare "topic" [--depth frontier]
-  sks research run <mission-id|latest> [--mock] [--max-cycles N]
+  sks research run <mission-id|latest> [--mock] [--max-cycles N] [--cycle-timeout-minutes N]
   sks research status <mission-id|latest>
   sks db policy
   sks db scan [--migrations] [--json]
@@ -1963,7 +1963,7 @@ function readMaxCycles(args, fallback) {
 
 function positionalArgs(args = []) {
   const out = [];
-  const valueFlags = new Set(['--format', '--iterations', '--out', '--baseline', '--candidate', '--install-scope', '--max-cycles', '--depth', '--scope', '--transport', '--query', '--topic', '--tokens', '--timeout-ms', '--sql', '--command', '--project-ref', '--agent', '--phase', '--message', '--role', '--max-anchors', '--lines', '--dir']);
+  const valueFlags = new Set(['--format', '--iterations', '--out', '--baseline', '--candidate', '--install-scope', '--max-cycles', '--cycle-timeout-minutes', '--depth', '--scope', '--transport', '--query', '--topic', '--tokens', '--timeout-ms', '--sql', '--command', '--project-ref', '--agent', '--phase', '--message', '--role', '--max-anchors', '--lines', '--dir']);
   for (let i = 0; i < args.length; i++) {
     const arg = String(args[i]);
     if (valueFlags.has(arg)) {
@@ -2647,19 +2647,21 @@ async function selftest() {
   const hookResearchTeamResult = await runProcess(process.execPath, [hookBin, 'hook', 'user-prompt-submit'], { cwd: hookResearchMarkdownTmp, input: hookResearchTeamPayload, env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 256 * 1024 });
   if (hookResearchTeamResult.code !== 0) throw new Error(`selftest: active Team setup before markdown $Research hook exited ${hookResearchTeamResult.code}: ${hookResearchTeamResult.stderr}`);
   const hookResearchTeamState = await readJson(stateFile(hookResearchMarkdownTmp), {});
-  const hookResearchMarkdownPayload = JSON.stringify({ cwd: hookResearchMarkdownTmp, prompt: '[$research](/tmp/research/SKILL.md) Codex Computer Use 도구 노출 문제를 QA루프 관점에서 연구' });
+  const hookResearchMarkdownPayload = JSON.stringify({ cwd: hookResearchMarkdownTmp, prompt: '논문 [$research](x) 팀 커밋 푸쉬 연구' });
   const hookResearchMarkdownResult = await runProcess(process.execPath, [hookBin, 'hook', 'user-prompt-submit'], { cwd: hookResearchMarkdownTmp, input: hookResearchMarkdownPayload, env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 256 * 1024 });
   if (hookResearchMarkdownResult.code !== 0) throw new Error(`selftest: markdown $Research hook exited ${hookResearchMarkdownResult.code}: ${hookResearchMarkdownResult.stderr}`);
   const hookResearchMarkdownJson = JSON.parse(hookResearchMarkdownResult.stdout);
   const hookResearchMarkdownContext = hookResearchMarkdownJson.hookSpecificOutput?.additionalContext || '';
-  if (!hookResearchMarkdownContext.includes('$Research route prepared')) throw new Error('selftest: markdown $Research hook did not prepare Research route');
-  if (hookResearchMarkdownContext.includes(`Active Team mission ${hookResearchTeamState.mission_id}`)) throw new Error('selftest: markdown $Research hook retained stale active Team context');
-  if (!String(hookResearchMarkdownJson.systemMessage || '').includes('Research route') || String(hookResearchMarkdownJson.systemMessage || '').includes('QA-LOOP route')) throw new Error('selftest: markdown $Research visible hook message was hijacked by QA-LOOP policy text');
+  if (!hookResearchMarkdownContext.includes('$Research route prepared')) throw new Error('selftest: markdown research hook');
+  if (hookResearchMarkdownContext.includes(`Active Team mission ${hookResearchTeamState.mission_id}`)) throw new Error('selftest: stale Team context');
+  if (!String(hookResearchMarkdownJson.systemMessage || '').includes('Research route') || String(hookResearchMarkdownJson.systemMessage || '').includes('QA-LOOP route')) throw new Error('selftest: research hook message');
   const hookResearchMarkdownState = await readJson(stateFile(hookResearchMarkdownTmp), {});
-  if (hookResearchMarkdownState.mode !== 'RESEARCH' || hookResearchMarkdownState.route !== 'Research' || hookResearchMarkdownState.mission_id === hookResearchTeamState.mission_id || hookResearchMarkdownState.stop_gate !== 'research-gate.json' || !hookResearchMarkdownState.pipeline_plan_ready) throw new Error('selftest: markdown $Research hook did not replace active Team with prepared Research mission state');
+  if (hookResearchMarkdownState.mode !== 'RESEARCH' || hookResearchMarkdownState.route !== 'Research' || hookResearchMarkdownState.mission_id === hookResearchTeamState.mission_id || hookResearchMarkdownState.stop_gate !== 'research-gate.json' || !hookResearchMarkdownState.pipeline_plan_ready) throw new Error('selftest: research hook state');
   const hookResearchMissionDir = missionDir(hookResearchMarkdownTmp, hookResearchMarkdownState.mission_id);
-  if (!(await exists(path.join(hookResearchMissionDir, PIPELINE_PLAN_ARTIFACT)))) throw new Error('selftest: markdown $Research hook did not write pipeline plan');
-  for (const artifact of ['source-ledger.json', 'scout-ledger.json', 'debate-ledger.json', 'falsification-ledger.json']) {
+  if (!(await exists(path.join(hookResearchMissionDir, PIPELINE_PLAN_ARTIFACT)))) throw new Error('selftest: research hook plan');
+  const rss = 'research-source-skill.md';
+  const gos = 'genius-opinion-summary.md';
+  for (const artifact of [rss, 'source-ledger.json', 'scout-ledger.json', 'debate-ledger.json', 'falsification-ledger.json']) {
     if (!(await exists(path.join(hookResearchMissionDir, artifact)))) throw new Error(`selftest: hook research ${artifact}`);
   }
   const hookPayload = JSON.stringify({ cwd: hookGoalTmp, prompt: '$Goal 로그인 세션 만료 UX 개선' });
@@ -3782,15 +3784,16 @@ async function selftest() {
   if (wikiPruneDryRun.candidates < 1 || !wikiPruneDryRun.actions.some((action) => action.reason === 'low_wiki_trust')) throw new Error('selftest: wiki prune did not flag low-trust artifact');
   const { dir: researchDir, mission: researchMission } = await createMission(tmp, { mode: 'research', prompt: '새로운 코드 리뷰 방법론 연구' });
   const researchPlan = await writeResearchPlan(researchDir, researchMission.prompt, {});
-  if (researchPlan.methodology !== 'genius-scout-council-frontier-discovery-loop' || researchPlan.web_research_policy?.mode !== 'maximum_source_retrieval') throw new Error('selftest: research plan contract');
+  if (researchPlan.methodology !== 'genius-scout-council-frontier-discovery-loop' || researchPlan.web_research_policy?.mode !== 'layered_source_retrieval_and_triangulation') throw new Error('selftest: research plan contract');
   const rArts = researchPlan.required_artifacts || [];
-  for (const a of ['source-ledger.json', 'scout-ledger.json', 'debate-ledger.json', 'falsification-ledger.json']) if (!rArts.includes(a) || !(await exists(path.join(researchDir, a)))) throw new Error('selftest: research artifact');
-  if (!rArts.includes('research-paper.md')) throw new Error('selftest: research paper');
+  for (const a of [rss, 'source-ledger.json', 'scout-ledger.json', 'debate-ledger.json', 'falsification-ledger.json']) if (!rArts.includes(a) || !(await exists(path.join(researchDir, a)))) throw new Error('selftest: research artifact');
+  if (!rArts.includes('research-paper.md') || !rArts.includes(gos)) throw new Error('selftest: research paper');
   const initialResearchGate = await evaluateResearchGate(researchDir);
   if (initialResearchGate.passed || ['web_search_pass_missing', 'eureka_missing', 'debate_exchanges_missing', 'research_paper_missing'].some((r) => !initialResearchGate.reasons.includes(r))) throw new Error('selftest: research gate');
   const researchGate = await writeMockResearchResult(researchDir, researchPlan);
   if (!researchGate.passed) throw new Error('selftest: mock research gate did not pass');
-  if (['independent_scouts', 'xhigh_scouts', 'eureka_moments', 'debate_participants'].some((m) => researchGate.metrics?.[m] < 5) || researchGate.metrics?.counterevidence_sources < 1 || researchGate.metrics?.paper_sections < 8 || researchGate.metrics?.citation_coverage !== true || researchGate.metrics?.falsification_cases < 1) throw new Error('selftest: research metrics');
+  const rm = researchGate.metrics || {};
+  if (['independent_scouts', 'xhigh_scouts', 'eureka_moments', 'debate_participants', 'genius_opinion_summaries'].some((m) => rm[m] < 5) || ['counterevidence_sources', 'falsification_cases', 'triangulation_checks'].some((m) => rm[m] < 1) || rm.paper_sections < 8 || rm.citation_coverage !== true || rm.source_layers_covered < 7) throw new Error('selftest: research metrics');
   await writeJsonAtomic(path.join(dir, 'done-gate.json'), { passed: true, unsupported_critical_claims: 0, database_safety_violation: false, database_safety_reviewed: true, visual_drift: 'low', wiki_drift: 'low', tests_required: false });
   const gate = await evaluateDoneGate(tmp, id);
   if (!gate.passed) throw new Error('selftest: done gate');

package/src/cli/maintenance-commands.mjs

@@ -8,14 +8,14 @@ import { buildQuestionSchema, writeQuestions } from '../core/questions.mjs';
 import { sealContract } from '../core/decision-contract.mjs';
 import { buildQaLoopQuestionSchema, buildQaLoopPrompt, evaluateQaGate, qaStatus, writeMockQaResult, writeQaLoopArtifacts } from '../core/qa-loop.mjs';
 import { containsUserQuestion, noQuestionContinuationReason } from '../core/no-question-guard.mjs';
-import { RESEARCH_PAPER_ARTIFACT, countResearchPaperSections, buildResearchPrompt, evaluateResearchGate, writeMockResearchResult, writeResearchPlan } from '../core/research.mjs';
+import { RESEARCH_GENIUS_SUMMARY_ARTIFACT, RESEARCH_PAPER_ARTIFACT, RESEARCH_SOURCE_SKILL_ARTIFACT, countGeniusOpinionSummaries, countResearchPaperSections, buildResearchPrompt, evaluateResearchGate, writeMockResearchResult, writeResearchPlan } from '../core/research.mjs';
 import { storageReport, enforceRetention, pruneWikiArtifacts } from '../core/retention.mjs';
 import { evaluateDoneGate } from '../core/hproof.mjs';
 import { renderCartridge, validateCartridge, driftCartridge, snapshotCartridge } from '../core/gx-renderer.mjs';
 import { DEFAULT_EVAL_THRESHOLDS, compareEvaluationReports, runEvaluationBenchmark } from '../core/evaluation.mjs';
 import { contextCapsule } from '../core/triwiki-attention.mjs';
 import { rgbaKey, rgbaToWikiCoord, validateWikiCoordinateIndex } from '../core/wiki-coordinate.mjs';
-import { ALLOWED_REASONING_EFFORTS, CODEX_COMPUTER_USE_ONLY_POLICY, DOLLAR_SKILL_NAMES, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_SOURCE_INVENTORY_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, FROM_CHAT_IMG_VISUAL_MAP_ARTIFACT, FROM_CHAT_IMG_WORK_ORDER_ARTIFACT, RECOMMENDED_SKILLS, ROUTES, hasFromChatImgSignal, reflectionRequiredForRoute, routePrompt, routeReasoning, routeRequiresSubagents, stackCurrentDocsPolicy, stripVisibleDecisionAnswerBlocks, triwikiContextTracking } from '../core/routes.mjs';
+import { ALLOWED_REASONING_EFFORTS, CODEX_COMPUTER_USE_ONLY_POLICY, DOLLAR_SKILL_NAMES, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_SOURCE_INVENTORY_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, FROM_CHAT_IMG_VISUAL_MAP_ARTIFACT, FROM_CHAT_IMG_WORK_ORDER_ARTIFACT, RECOMMENDED_SKILLS, ROUTES, hasFromChatImgSignal, reflectionRequiredForRoute, routeNeedsContext7, routePrompt, routeReasoning, routeRequiresSubagents, stackCurrentDocsPolicy, stripVisibleDecisionAnswerBlocks, triwikiContextTracking } from '../core/routes.mjs';
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, writeTeamRuntimeArtifacts } from '../core/team-dag.mjs';
 import { appendTeamEvent, formatAgentReasoning, formatRoleCounts, initTeamLive, normalizeTeamSpec, parseTeamSpecArgs, readTeamControl, readTeamDashboard, readTeamLive, readTeamTranscriptTail, renderTeamAgentLane, renderTeamCleanupSummary, renderTeamWatch, requestTeamSessionCleanup, teamCleanupRequested, teamReasoningPolicy } from '../core/team-live.mjs';
 import { evaluateTeamReviewPolicyGate, MIN_TEAM_REVIEWER_LANES, MIN_TEAM_REVIEW_POLICY_TEXT, teamReviewPolicy } from '../core/team-review-policy.mjs';
@@ -42,6 +42,10 @@ const flag = (args, name) => args.includes(name);
 const promptOf = (args) => args.filter((x) => !String(x).startsWith('--')).join(' ').trim();
 const TEAM_SESSION_CLEANUP_ARTIFACT = 'team-session-cleanup.json';
 const REPOSITORY_URL = 'https://github.com/mandarange/Sneakoscope-Codex.git';
+const RESEARCH_DEFAULT_MAX_CYCLES = 3;
+const RESEARCH_DEFAULT_CYCLE_TIMEOUT_MINUTES = 120;
+const RESEARCH_MIN_CYCLE_TIMEOUT_MINUTES = 15;
+const RESEARCH_MAX_CYCLE_TIMEOUT_MINUTES = 240;
 
 async function resolveMissionId(root, arg) { return (!arg || arg === 'latest') ? findLatestMission(root) : arg; }
 
@@ -429,7 +433,7 @@ async function researchPrepare(args) {
   if (!prompt) throw new Error('Missing research topic.');
   const { id, dir } = await createMission(root, { mode: 'research', prompt });
   const route = ROUTES.find((entry) => entry.id === 'Research') || routePrompt('$Research');
-  const context7Required = true;
+  const context7Required = routeNeedsContext7(route, prompt);
   const reasoning = routeReasoning(route, prompt);
   const plan = await writeResearchPlan(dir, prompt, { depth: readFlagValue(args, '--depth', 'frontier') });
   const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task: prompt, required: context7Required, ambiguity: { required: false, status: 'direct_research_cli' } });
@@ -457,7 +461,7 @@ async function researchPrepare(args) {
     mode: route.mode,
     phase: 'RESEARCH_PREPARED',
     questions_allowed: false,
-    implementation_allowed: true,
+    implementation_allowed: false,
     context7_required: context7Required,
     context7_verified: false,
     subagents_required: routeRequiresSubagents(route, prompt),
@@ -480,14 +484,16 @@ async function researchPrepare(args) {
   console.log(`Plan: ${path.relative(root, path.join(dir, 'research-plan.md'))}`);
   console.log(`Pipeline: ${path.relative(root, path.join(dir, PIPELINE_PLAN_ARTIFACT))}`);
   console.log(`Paper: ${RESEARCH_PAPER_ARTIFACT}`);
+  console.log(`Genius summary: ${RESEARCH_GENIUS_SUMMARY_ARTIFACT}`);
+  console.log(`Source skill: ${RESEARCH_SOURCE_SKILL_ARTIFACT}`);
   console.log('Ledgers: source-ledger.json, scout-ledger.json, debate-ledger.json, novelty-ledger.json, falsification-ledger.json');
-  console.log(`Run: sks research run ${id} --max-cycles 3`);
+  console.log(`Run: sks research run ${id} --max-cycles ${RESEARCH_DEFAULT_MAX_CYCLES} --cycle-timeout-minutes ${RESEARCH_DEFAULT_CYCLE_TIMEOUT_MINUTES}`);
 }
 
 async function researchRun(args) {
   const root = await sksRoot();
   const id = await resolveMissionId(root, args[0]);
-  if (!id) throw new Error('Usage: sks research run <mission-id|latest> [--mock] [--max-cycles N]');
+  if (!id) throw new Error('Usage: sks research run <mission-id|latest> [--mock] [--max-cycles N] [--cycle-timeout-minutes N]');
   const { dir, mission } = await loadMission(root, id);
   const planPath = path.join(dir, 'research-plan.json');
   if (!(await exists(planPath))) await writeResearchPlan(dir, mission.prompt || '', {});
@@ -499,32 +505,46 @@ async function researchRun(args) {
     process.exitCode = 2;
     return;
   }
-  const maxCycles = readMaxCycles(args, 3);
+  const maxCycles = readMaxCycles(args, RESEARCH_DEFAULT_MAX_CYCLES);
+  const cycleTimeoutMinutes = readResearchCycleTimeoutMinutes(args);
+  const cycleTimeoutMs = cycleTimeoutMinutes * 60 * 1000;
   const mock = flag(args, '--mock');
-  await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_RUNNING_NO_QUESTIONS', questions_allowed: false });
-  await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.run.started', maxCycles, mock });
+  await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_RUNNING_NO_QUESTIONS', questions_allowed: false, implementation_allowed: false, research_real_run_required: !mock, research_cycle_timeout_minutes: cycleTimeoutMinutes });
+  await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.run.started', maxCycles, mock, cycleTimeoutMinutes, real_run_required: !mock });
   if (mock) {
     const gate = await writeMockResearchResult(dir, plan);
-    await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: gate.passed ? 'RESEARCH_DONE' : 'RESEARCH_PAUSED', questions_allowed: true });
+    await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: gate.passed ? 'RESEARCH_DONE' : 'RESEARCH_PAUSED', questions_allowed: true, implementation_allowed: false });
     console.log(`Mock research done: ${id}`);
     console.log(`Gate: ${gate.passed ? 'passed' : 'blocked'}`);
     return;
   }
   const codex = await getCodexInfo();
   if (!codex.bin) {
-    console.error('Codex CLI not found. Running mock research instead.');
-    const gate = await writeMockResearchResult(dir, plan);
-    await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: gate.passed ? 'RESEARCH_DONE' : 'RESEARCH_PAUSED', questions_allowed: true });
-    console.log(`Mock research done: ${id}`);
+    const blocker = {
+      schema_version: 1,
+      mission_id: id,
+      ts: nowIso(),
+      phase: 'RESEARCH_BLOCKED_REAL_RUN_REQUIRED',
+      reason: 'Codex CLI not found; normal Research cannot fall back to mock output.',
+      required_action: 'Install/configure the Codex CLI or set SKS_CODEX_BIN to a valid executable, then rerun sks research run without --mock.',
+      mock_policy: '--mock is allowed only for selftests and dry harness checks.',
+      implementation_allowed: false
+    };
+    await writeJsonAtomic(path.join(dir, 'research-blocker.json'), blocker);
+    await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: blocker.ts, type: 'research.blocked.real_run_required', reason: blocker.reason, blocker: 'research-blocker.json' });
+    await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_BLOCKED_REAL_RUN_REQUIRED', questions_allowed: true, implementation_allowed: false, research_real_run_required: true, blocker: 'research-blocker.json' });
+    console.error('Research cannot run real sources: Codex CLI not found.');
+    console.error('Mock fallback is disabled for normal Research. Use --mock only for selftests, or install/configure Codex CLI/SKS_CODEX_BIN.');
+    process.exitCode = 2;
     return;
   }
   let last = '';
   for (let cycle = 1; cycle <= maxCycles; cycle++) {
     const cycleDir = path.join(dir, 'research', `cycle-${cycle}`);
     const outputFile = path.join(cycleDir, 'final.md');
-    await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.cycle.start', cycle });
+    await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.cycle.start', cycle, timeoutMinutes: cycleTimeoutMinutes });
     const prompt = buildResearchPrompt({ id, mission, plan, cycle, previous: last });
-    const result = await runCodexExec({ root, prompt, outputFile, json: true, profile: 'sks-research', logDir: cycleDir, timeoutMs: 45 * 60 * 1000 });
+    const result = await runCodexExec({ root, prompt, outputFile, json: true, profile: 'sks-research', logDir: cycleDir, timeoutMs: cycleTimeoutMs });
     await writeJsonAtomic(path.join(cycleDir, 'process.json'), { code: result.code, stdout_tail: result.stdout, stderr_tail: result.stderr, stdout_bytes: result.stdoutBytes, stderr_bytes: result.stderrBytes, truncated: result.truncated, timed_out: result.timedOut });
     last = await safeReadText(outputFile, result.stdout || result.stderr || '');
     if (containsUserQuestion(last)) {
@@ -534,7 +554,7 @@ async function researchRun(args) {
     }
     const gate = await evaluateResearchGate(dir);
     if (gate.passed) {
-      await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_DONE', questions_allowed: true });
+      await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_DONE', questions_allowed: true, implementation_allowed: false });
       await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.done', cycle });
       await enforceRetention(root).catch(() => {});
       console.log(`Research done: ${id}`);
@@ -542,7 +562,7 @@ async function researchRun(args) {
     }
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.cycle.continue', cycle, reasons: gate.reasons });
   }
-  await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_PAUSED_MAX_CYCLES', questions_allowed: true });
+  await setCurrent(root, { mission_id: id, mode: 'RESEARCH', phase: 'RESEARCH_PAUSED_MAX_CYCLES', questions_allowed: true, implementation_allowed: false });
   console.log(`Research paused after max cycles: ${id}`);
 }
 
@@ -558,19 +578,29 @@ async function researchStatus(args) {
   const scoutLedger = await readJson(path.join(dir, 'scout-ledger.json'), null);
   const debateLedger = await readJson(path.join(dir, 'debate-ledger.json'), null);
   const falsificationLedger = await readJson(path.join(dir, 'falsification-ledger.json'), null);
+  const sourceSkillText = await readText(path.join(dir, RESEARCH_SOURCE_SKILL_ARTIFACT), '');
+  const geniusSummaryText = await readText(path.join(dir, RESEARCH_GENIUS_SUMMARY_ARTIFACT), '');
   const paperText = await readText(path.join(dir, RESEARCH_PAPER_ARTIFACT), '');
   const scoutRows = Array.isArray(scoutLedger?.scouts) ? scoutLedger.scouts : [];
+  const sourceLayerRows = Array.isArray(sourceLedger?.source_layers) ? sourceLedger.source_layers : [];
+  const sourceLayersCovered = sourceLayerRows.filter((layer) => layer.status === 'covered' && ((Array.isArray(layer.source_ids) && layer.source_ids.length) || (Array.isArray(layer.counterevidence_ids) && layer.counterevidence_ids.length))).length;
   console.log(JSON.stringify({
     mission,
     state,
     gate,
     novelty_entries: ledger?.entries?.length ?? null,
     source_entries: sourceLedger?.sources?.length ?? null,
+    source_layers_required: sourceLayerRows.length || gate?.metrics?.source_layers_required || gate?.source_layers_required || null,
+    source_layers_covered: gate?.metrics?.source_layers_covered ?? gate?.source_layers_covered ?? (sourceLayerRows.length ? sourceLayersCovered : null),
+    triangulation_checks: sourceLedger?.triangulation?.cross_layer_checks?.length ?? gate?.metrics?.triangulation_checks ?? gate?.triangulation_checks ?? null,
+    genius_opinion_summaries: gate?.metrics?.genius_opinion_summaries ?? gate?.genius_opinion_summaries ?? (geniusSummaryText.trim() ? countGeniusOpinionSummaries(geniusSummaryText) : null),
     counterevidence_sources: sourceLedger?.counterevidence_sources?.length ?? null,
     xhigh_scouts: scoutRows.length ? scoutRows.filter((scout) => scout.effort === 'xhigh').length : null,
     eureka_moments: scoutRows.length ? scoutRows.filter((scout) => scout.eureka?.exclamation === 'Eureka!' && String(scout.eureka?.idea || '').trim()).length : null,
     scout_findings: scoutRows.length ? scoutRows.reduce((sum, scout) => sum + (Array.isArray(scout.findings) ? scout.findings.length : 0), 0) : null,
     debate_exchanges: debateLedger?.exchanges?.length ?? null,
+    research_source_skill_present: Boolean(sourceSkillText.trim()),
+    genius_opinion_summary_present: Boolean(geniusSummaryText.trim()),
     paper_present: Boolean(paperText.trim()),
     paper_sections: countResearchPaperSections(paperText),
     falsification_cases: falsificationLedger?.cases?.length ?? null
@@ -625,11 +655,19 @@ async function safeReadText(file, fallback = '') {
   try { return await fsp.readFile(file, 'utf8'); } catch { return fallback; }
 }
 
-function readMaxCycles(args, fallback) {
-  const i = args.indexOf('--max-cycles');
+function readBoundedIntegerFlag(args, name, fallback, min, max) {
+  const i = args.indexOf(name);
   const raw = i >= 0 && args[i + 1] ? Number(args[i + 1]) : Number(fallback);
-  if (!Number.isFinite(raw)) return Math.max(1, Number.parseInt(fallback, 10) || 1);
-  return Math.max(1, Math.min(50, Math.floor(raw)));
+  if (!Number.isFinite(raw)) return Math.max(min, Number.parseInt(fallback, 10) || min);
+  return Math.max(min, Math.min(max, Math.floor(raw)));
+}
+
+function readMaxCycles(args, fallback) {
+  return readBoundedIntegerFlag(args, '--max-cycles', fallback, 1, 50);
+}
+
+function readResearchCycleTimeoutMinutes(args) {
+  return readBoundedIntegerFlag(args, '--cycle-timeout-minutes', RESEARCH_DEFAULT_CYCLE_TIMEOUT_MINUTES, RESEARCH_MIN_CYCLE_TIMEOUT_MINUTES, RESEARCH_MAX_CYCLE_TIMEOUT_MINUTES);
 }
 
 export async function goalCommand(sub, args) {
@@ -1580,7 +1618,7 @@ export async function statsCommand(args) {
 
 function positionalArgs(args = []) {
   const out = [];
-  const valueFlags = new Set(['--format', '--iterations', '--out', '--baseline', '--candidate', '--install-scope', '--max-cycles', '--depth', '--scope', '--transport', '--query', '--topic', '--tokens', '--timeout-ms', '--sql', '--command', '--project-ref', '--agent', '--phase', '--message', '--role', '--max-anchors', '--lines', '--intent', '--changed', '--route', '--skills', '--prompt-signature']);
+  const valueFlags = new Set(['--format', '--iterations', '--out', '--baseline', '--candidate', '--install-scope', '--max-cycles', '--cycle-timeout-minutes', '--depth', '--scope', '--transport', '--query', '--topic', '--tokens', '--timeout-ms', '--sql', '--command', '--project-ref', '--agent', '--phase', '--message', '--role', '--max-anchors', '--lines', '--intent', '--changed', '--route', '--skills', '--prompt-signature']);
   for (let i = 0; i < args.length; i++) {
     const arg = String(args[i]);
     if (valueFlags.has(arg)) {

package/src/core/fsx.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 
-export const PACKAGE_VERSION = '0.7.69';
+export const PACKAGE_VERSION = '0.7.72';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 

package/src/core/hooks-runtime.mjs

@@ -7,7 +7,7 @@ import { checkHarnessModification, harnessGuardBlockReason } from './harness-gua
 import { activeRouteContext, evaluateStop, prepareRoute, promptPipelineContext as routePipelineContext, recordContext7Evidence, recordSubagentEvidence, routePrompt } from './pipeline.mjs';
 import { classifyToolError } from './evaluation.mjs';
 import { REQUIRED_CODEX_MODEL, isForbiddenCodexModel } from './codex-model-guard.mjs';
-import { stripVisibleDecisionAnswerBlocks } from './routes.mjs';
+import { dollarCommand, stripVisibleDecisionAnswerBlocks } from './routes.mjs';
 
 const TEAM_DIGEST_MAX_EVENTS = 4;
 const TEAM_DIGEST_MESSAGE_CHARS = 180;
@@ -77,13 +77,6 @@ function toolFailed(payload = {}) {
   return false;
 }
 
-function dollarCommand(prompt) {
-  const text = String(prompt || '').trim();
-  const match = text.match(/^\$([A-Za-z][A-Za-z0-9_-]*)(?:\s|:|$)/)
-    || text.match(/^\[\$([A-Za-z][A-Za-z0-9_-]*)\]\([^)]+\)(?:\s|:|$)/);
-  return match ? match[1].toUpperCase() : null;
-}
-
 function looksLikeUpdateDecline(prompt) {
   return /^(no|nope|skip|later|not now|don't|dont|아니|아니요|안해|안 함|나중에|건너뛰|스킵)/i.test(String(prompt || '').trim());
 }

package/src/core/init.mjs

@@ -815,7 +815,7 @@ export async function installSkills(root) {
     'computer-use-fast': `---\nname: computer-use-fast\ndescription: Alias for the maximum-speed $Computer-Use/$CU Codex Computer Use lane.\n---\n\nUse the same rules as computer-use: skip Team debate, QA-LOOP clarification, upfront TriWiki refresh, Context7, subagents, and reflection unless explicitly requested. Use Codex Computer Use directly; never substitute Playwright, Chrome MCP, Browser Use, Selenium, Puppeteer, or other browser automation for UI/browser evidence. At the end only, refresh/pack TriWiki, validate it, then provide a concise completion summary plus Honest Mode.\n`,
     'cu': `---\nname: cu\ndescription: Short alias for the maximum-speed $Computer-Use Codex Computer Use lane.\n---\n\nUse the same rules as computer-use. This is a speed lane for focused UI/browser/visual tasks that require Codex Computer Use evidence, with TriWiki refresh/validate and Honest Mode deferred to final closeout.\n`,
     'goal': `---\nname: goal\ndescription: Fast $Goal/$goal bridge overlay for Codex native persisted /goal workflows.\n---\n\nUse when the user invokes $Goal/$goal or asks to persist a workflow with Codex native /goal continuation. Prepare with sks goal create or the $Goal route, write only the lightweight bridge artifacts, then use native Codex /goal create, pause, resume, and clear controls where available. Goal does not replace Team, QA, DB, or other SKS execution routes; continue implementation through the selected route and use Context7 only when external API/library docs are involved. Do not recreate the old no-question loop.\n`,
-    'research': `---\nname: research\ndescription: Dollar-command route for $Research or $research frontier discovery workflows.\n---\n\nUse when the user invokes $Research/$research or asks for research, hypotheses, new mechanisms, falsification, or testable predictions. Prefer sks research prepare and sks research run. Run the genius-lens scout council with Einstein/Feynman/Turing/von Neumann-inspired cognitive roles plus a skeptic lens; do not impersonate the historical people. Every Research scout must run with effort=xhigh, record one literal "Eureka!" idea, and participate in a vigorous evidence-bound debate before synthesis. Maximize safe web/source search and record source-ledger.json, scout-ledger.json, debate-ledger.json, novelty-ledger.json, falsification-ledger.json, research-report.md, research-paper.md, and research-gate.json. Keep the loop short: frame outcome, compare a few mechanisms, falsify, keep the smallest useful probe, turn the result into a concise paper manuscript, and avoid adding background process unless it reduces net route weight. Do not use for ordinary code edits.\n`,
+    'research': `---\nname: research\ndescription: Dollar-command route for $Research or $research frontier discovery workflows.\n---\n\nUse when the user invokes $Research/$research or asks for research, hypotheses, new mechanisms, falsification, or testable predictions. Prefer sks research prepare and sks research run. Run the genius-lens scout council with Einstein/Feynman/Turing/von Neumann-inspired cognitive roles plus a skeptic lens; do not impersonate the historical people. Every Research scout must run with effort=xhigh, record one literal "Eureka!" idea, and participate in a vigorous evidence-bound debate before synthesis. Create research-source-skill.md as a route-local Skill Creator artifact, then maximize layered public web/source search across papers, official/government or leading-institution data, standards/primary docs, current news, public discourse, developer/practitioner sources, and counterevidence before synthesis. Record research-source-skill.md, source-ledger.json, scout-ledger.json, debate-ledger.json, novelty-ledger.json, falsification-ledger.json, research-report.md, research-paper.md, genius-opinion-summary.md, and research-gate.json. Context7 is optional and only needed when the research topic depends on external package/API/framework docs; do not use it as the default research evidence layer. Normal Research may take one or two hours when needed; favor real source collection, cross-layer comparison, falsification, and a concise paper manuscript over speed. Do not use --mock except for selftests or dry harness checks; if live source execution is unavailable, record a blocker and keep the gate unpassed. Do not use for ordinary code edits.\n`,
     'autoresearch': `---\nname: autoresearch\ndescription: Dollar-command route for $AutoResearch or $autoresearch iterative experiment loops.\n---\n\nUse for $AutoResearch, iterative improvement, SEO/GEO, ranking, workflow, benchmark, or experiments. Define program, hypothesis, experiment, metric, keep/discard, falsification, next step, and Honest Mode. Load seo-geo-optimizer for README/npm/GitHub/schema/AI-search work.\n`,
     'db': `---\nname: db\ndescription: Dollar-command route for $DB or $db database and Supabase safety checks.\n---\n\nUse when the user invokes $DB/$db or the task touches SQL, Supabase, Postgres, migrations, Prisma, Drizzle, Knex, MCP database tools, or production data. Run or follow sks db policy, sks db scan, sks db classify, and sks db check. Destructive database operations remain forbidden.\n`,
     'mad-sks': `---\nname: mad-sks\ndescription: Explicit high-risk authorization modifier for $MAD-SKS scoped Supabase MCP DB permission widening.\n---\n\nUse only when the user explicitly invokes $MAD-SKS or top-level sks --mad. It can be combined with another route, such as $MAD-SKS $Team or $DB ... $MAD-SKS; in that case the other command remains the primary workflow and MAD-SKS is only the temporary permission grant. The widened permission applies only while the active mission gate is open, must be deactivated when the task ends, and opens live server work, Supabase MCP database writes, column/schema cleanup, direct execute SQL, migration application when required, and normal targeted DB writes. Keep only catastrophic safeguards: whole database/schema/table removal, truncate, all-row delete/update, reset, dangerous project/branch management, credential exfiltration, persistent security weakening, and unrequested fallback implementation remain blocked. Do not carry MAD-SKS permission into later prompts or routes. The permission profile is centralized in src/core/permission-gates.mjs so skill/hook/MCP-style gates share one decision function.\n`,

package/src/core/pipeline.mjs

@@ -921,7 +921,7 @@ async function prepareResearch(root, route, task, required) {
   await writeResearchPlan(dir, task, {});
   const pipelinePlan = await writePipelinePlan(dir, { missionId: id, route, task, required, ambiguity: { required: false, status: 'direct_route' } });
   await setCurrent(root, routeState(id, route, 'RESEARCH_PREPARED', required, { prompt: task, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }));
-  return routeContext(route, id, task, required, 'Run sks research run latest, maximize web/source search, require every scout effort=xhigh plus one Eureka! idea, fill source-ledger.json, scout-ledger.json, debate-ledger.json, novelty-ledger.json, falsification-ledger.json, research-report.md, research-paper.md, and pass research-gate.json.');
+  return routeContext(route, id, task, required, 'Run sks research run latest as a real long-running source-gathering pass, never an automatic mock fallback; create research-source-skill.md, maximize layered public source search, require every scout effort=xhigh plus one Eureka! idea, fill source-ledger.json, scout-ledger.json, debate-ledger.json, novelty-ledger.json, falsification-ledger.json, research-report.md, research-paper.md, genius-opinion-summary.md, and pass research-gate.json.');
 }
 
 async function prepareAutoResearch(root, route, task, required) {

package/src/core/research.mjs

@@ -3,6 +3,8 @@ import { appendJsonlBounded, nowIso, readJson, readText, writeJsonAtomic, writeT
 import { OUTCOME_RUBRIC } from './proof-field.mjs';
 
 export const RESEARCH_PAPER_ARTIFACT = 'research-paper.md';
+export const RESEARCH_SOURCE_SKILL_ARTIFACT = 'research-source-skill.md';
+export const RESEARCH_GENIUS_SUMMARY_ARTIFACT = 'genius-opinion-summary.md';
 export const RESEARCH_PAPER_SECTION_GROUPS = Object.freeze([
   ['abstract'],
   ['introduction'],
@@ -52,6 +54,67 @@ export const RESEARCH_SCOUT_COUNCIL = Object.freeze([
   }
 ]);
 
+export const RESEARCH_SOURCE_LAYERS = Object.freeze([
+  {
+    id: 'academic_literature',
+    label: 'Academic literature',
+    purpose: 'Find recent papers, preprints, formal reviews, citations, and open scholarly metadata before synthesis.',
+    evidence_role: 'formal_evidence',
+    examples: ['arXiv', 'Semantic Scholar', 'OpenAlex', 'Crossref', 'PubMed'],
+    query_templates: ['"<topic>" arxiv', '"<topic>" site:semanticscholar.org', '"<topic>" OpenAlex Crossref PubMed']
+  },
+  {
+    id: 'official_government_data',
+    label: 'Official government and leading-institution knowledge',
+    purpose: 'Ground claims in public datasets, policy papers, national statistics, and leading-country institutional sources.',
+    evidence_role: 'authoritative_baseline',
+    examples: ['World Bank', 'OECD', 'Eurostat', 'data.gov', 'data.gov.uk', 'NIST'],
+    query_templates: ['"<topic>" site:worldbank.org OR site:oecd.org', '"<topic>" site:data.gov OR site:data.gov.uk', '"<topic>" site:nist.gov']
+  },
+  {
+    id: 'standards_primary_docs',
+    label: 'Standards and primary documents',
+    purpose: 'Check primary specifications, standards, RFCs, policy originals, and official project documents before relying on summaries.',
+    evidence_role: 'primary_source',
+    examples: ['IETF RFCs', 'W3C', 'ISO abstracts', 'official standards bodies', 'project primary docs'],
+    query_templates: ['"<topic>" RFC standard specification', '"<topic>" W3C IETF NIST standard', '"<topic>" official specification']
+  },
+  {
+    id: 'news_current_events',
+    label: 'Current news and global reporting',
+    purpose: 'Capture recent events, public impact, and regional framing from reputable news and global news indices.',
+    evidence_role: 'recency_signal',
+    examples: ['GDELT', 'BBC', 'CNN', 'Reuters', 'AP', 'regional reputable outlets'],
+    query_templates: ['"<topic>" BBC CNN latest', '"<topic>" GDELT news', '"<topic>" Reuters AP analysis']
+  },
+  {
+    id: 'public_discourse',
+    label: 'Public discourse',
+    purpose: 'Sample public practitioner and community discourse without treating popularity as truth.',
+    evidence_role: 'sentiment_and_edge_cases',
+    examples: ['X/Twitter recent search', 'Reddit', 'Hacker News', 'public forums'],
+    query_templates: ['"<topic>" site:x.com OR site:twitter.com', '"<topic>" site:reddit.com', '"<topic>" "Hacker News"']
+  },
+  {
+    id: 'developer_practitioner',
+    label: 'Developer and practitioner knowledge',
+    purpose: 'Find implementation pitfalls, developer questions, bug reports, and operational lessons.',
+    evidence_role: 'practice_feedback',
+    examples: ['Stack Overflow', 'Stack Exchange', 'GitHub issues', 'release notes', 'engineering blogs'],
+    query_templates: ['"<topic>" site:stackoverflow.com', '"<topic>" site:stackexchange.com', '"<topic>" site:github.com issues']
+  },
+  {
+    id: 'counterevidence_factcheck',
+    label: 'Counterevidence and fact-checking',
+    purpose: 'Actively search for failures, critiques, null results, retractions, fact checks, and source conflicts.',
+    evidence_role: 'falsification',
+    examples: ['Google Fact Check Tools', 'Retraction Watch', 'critical reviews', 'benchmark failures', 'negative results'],
+    query_templates: ['"<topic>" critique failure limitation', '"<topic>" fact check retraction', '"<topic>" counterevidence null result']
+  }
+]);
+
+export const RESEARCH_SOURCE_LAYER_IDS = Object.freeze(RESEARCH_SOURCE_LAYERS.map((layer) => layer.id));
+
 export function createResearchPlan(prompt, opts = {}) {
   const depth = opts.depth || 'frontier';
   return {
@@ -61,6 +124,11 @@ export function createResearchPlan(prompt, opts = {}) {
     created_at: nowIso(),
     methodology: 'genius-scout-council-frontier-discovery-loop',
     objective: 'Find the shortest useful mechanism that can be falsified or applied, grounded in maximum available source retrieval rather than broad summary.',
+    execution_policy: {
+      normal_run: 'real_long_running_research',
+      default_cycle_timeout_minutes: 120,
+      mock_policy: '--mock is for selftests and dry harness checks only; normal Research must block rather than silently substitute mock output.'
+    },
     outcome_rubric: OUTCOME_RUBRIC,
     research_council: {
       mode: 'persona_inspired_scouts_not_impersonation',
@@ -88,8 +156,8 @@ export function createResearchPlan(prompt, opts = {}) {
       ]
     },
     web_research_policy: {
-      mode: 'maximum_source_retrieval',
-      requirement: 'Use the broadest safe web/source search available in the runtime before synthesis.',
+      mode: 'layered_source_retrieval_and_triangulation',
+      requirement: 'Use every safely available public web/source route before synthesis, separated into source layers so the final claim is not dominated by one corpus or platform.',
       query_sets: [
         'first-principles and theory sources',
         'plain-language explanations and empirical examples',
@@ -97,10 +165,18 @@ export function createResearchPlan(prompt, opts = {}) {
         'systems, strategy, scaling, or deployment evidence',
         'counterevidence, failures, critiques, and null results'
       ],
+      source_layers: RESEARCH_SOURCE_LAYERS,
       source_priority: ['primary_sources', 'official_docs_or_standards', 'peer_reviewed_or_archival_sources', 'reputable_recent_sources', 'credible_counterevidence'],
+      skill_creator: {
+        artifact: RESEARCH_SOURCE_SKILL_ARTIFACT,
+        status: 'route_local_candidate',
+        rule: 'Before source gathering, create a route-local source collection skill that names the selected layers, query families, source-quality fields, blockers, and cross-layer triangulation checks. Do not edit generated .agents/skills during a research run.'
+      },
       citation_rules: [
         'Every factual claim in the report must cite source-ledger ids or local project evidence.',
         'The final research paper must include references tied to source-ledger ids.',
+        'Every required source layer must have at least one cited source or an explicit blocker; blockers keep the research gate unpassed.',
+        'The source-ledger must include at least one cross-layer triangulation check comparing formal, current, discourse, practitioner, official, and counterevidence sources.',
         'Every novelty-ledger entry must cite at least one evidence source and at least one falsifier.',
         'If live web search is unavailable, record the blocker in source-ledger.json and keep research-gate.json unpassed.'
       ],
@@ -108,7 +184,9 @@ export function createResearchPlan(prompt, opts = {}) {
         independent_scouts: RESEARCH_SCOUT_COUNCIL.length,
         web_search_passes: 1,
         source_entries: 1,
-        counterevidence_sources: 1
+        source_layers: RESEARCH_SOURCE_LAYER_IDS.length,
+        counterevidence_sources: 1,
+        triangulation_checks: 1
       }
     },
     rules: [
@@ -117,25 +195,31 @@ export function createResearchPlan(prompt, opts = {}) {
       'Run the genius-lens scout council independently before synthesis.',
       'Every Research scout must run at reasoning_effort=xhigh, record one literal "Eureka!" idea, and participate in the debate.',
       'The scout council must debate vigorously but stay evidence-bound; record challenges and responses in debate-ledger.json.',
-      'Maximize safe web/source search and record queries, sources, citations, and blockers in source-ledger.json.',
+      'Maximize safe web/source search as layered source retrieval and record queries, source layers, citations, quality notes, triangulation checks, and blockers in source-ledger.json.',
+      `Create ${RESEARCH_SOURCE_SKILL_ARTIFACT} as a route-local source collection skill before synthesis; do not edit generated .agents/skills during the research run.`,
       'Actively seek disconfirming evidence before synthesis.',
       'Turn the surviving research result into research-paper.md with paper-style sections and references.',
+      `End every run with ${RESEARCH_GENIUS_SUMMARY_ARTIFACT}, summarizing each genius-lens scout's final opinion, strongest evidence, disagreement, and changed mind.`,
       'Keep unsupported source-free claims as hypotheses only.',
-      'Prefer the smallest testable mechanism or implementation probe over a new long-running loop.',
+      'Prefer the smallest testable mechanism or implementation probe, but do not stop source gathering early for speed when the research question needs a longer pass.',
       'Do not ask the user mid-run; resolve scope using the research plan and safety policy.'
     ],
     phases: [
       { id: 'R0_FRAME', goal: 'Frame the target outcome, constraints, and what would make the idea useful.' },
-      { id: 'R1_SOURCE_SEARCH', goal: 'Run maximum available web/source retrieval with independent query sets for each scout lens.' },
-      { id: 'R2_EUREKA', goal: 'Have each xhigh genius-lens scout shout Eureka! and record one non-obvious idea with source ids.' },
-      { id: 'R3_DEBATE', goal: 'Run a vigorous evidence-bound council debate with every scout challenging or responding.' },
-      { id: 'R4_FALSIFY', goal: 'Attack each mechanism with counterexamples, missing evidence, source conflicts, and failure modes.' },
-      { id: 'R5_APPLY', goal: 'Keep the smallest surviving mechanism, define a cheap probe, and write all ledgers.' },
-      { id: 'R6_PAPER', goal: 'Convert the final research result into a concise paper manuscript with abstract, method, findings, limitations, and references.' }
+      { id: 'R1_SOURCE_SKILL', goal: `Create ${RESEARCH_SOURCE_SKILL_ARTIFACT} with layer-specific search routes, quality fields, and blockers before source gathering.` },
+      { id: 'R2_SOURCE_SEARCH', goal: 'Run layered web/source retrieval across papers, official data, standards, news, public discourse, developer knowledge, and counterevidence.' },
+      { id: 'R3_EUREKA', goal: 'Have each xhigh genius-lens scout shout Eureka! and record one non-obvious idea with source ids.' },
+      { id: 'R4_DEBATE', goal: 'Run a vigorous evidence-bound council debate with every scout challenging or responding.' },
+      { id: 'R5_FALSIFY', goal: 'Attack each mechanism with counterexamples, missing evidence, source conflicts, and failure modes.' },
+      { id: 'R6_APPLY', goal: 'Keep the smallest surviving mechanism, define a cheap probe, and write all ledgers.' },
+      { id: 'R7_PAPER', goal: 'Convert the final research result into a concise paper manuscript with abstract, method, findings, limitations, and references.' },
+      { id: 'R8_GENIUS_SUMMARY', goal: `Write ${RESEARCH_GENIUS_SUMMARY_ARTIFACT} so the final answer can report every scout lens opinion and the council consensus.` }
     ],
     required_artifacts: [
       'research-report.md',
       RESEARCH_PAPER_ARTIFACT,
+      RESEARCH_GENIUS_SUMMARY_ARTIFACT,
+      RESEARCH_SOURCE_SKILL_ARTIFACT,
       'source-ledger.json',
       'scout-ledger.json',
       'debate-ledger.json',
@@ -153,6 +237,10 @@ export function researchPlanMarkdown(plan) {
   lines.push(`Prompt: ${plan.prompt}`);
   lines.push(`Depth: ${plan.depth}`);
   lines.push(`Methodology: ${plan.methodology}`);
+  if (plan.execution_policy) {
+    lines.push(`Execution: ${plan.execution_policy.normal_run}; default cycle timeout ${plan.execution_policy.default_cycle_timeout_minutes} minutes`);
+    lines.push(`Mock policy: ${plan.execution_policy.mock_policy}`);
+  }
   lines.push('');
   lines.push('## Rules');
   for (const rule of plan.rules) lines.push(`- ${rule}`);
@@ -168,6 +256,10 @@ export function researchPlanMarkdown(plan) {
     lines.push(`Mode: ${plan.web_research_policy.mode}`);
     lines.push(`Requirement: ${plan.web_research_policy.requirement}`);
     for (const querySet of plan.web_research_policy.query_sets || []) lines.push(`- query set: ${querySet}`);
+    if (plan.web_research_policy.skill_creator?.artifact) lines.push(`- source skill artifact: ${plan.web_research_policy.skill_creator.artifact}`);
+    for (const layer of plan.web_research_policy.source_layers || []) {
+      lines.push(`- layer ${layer.id}: ${layer.purpose}`);
+    }
     lines.push('');
   }
   lines.push('## Outcome Rubric');
@@ -182,15 +274,56 @@ export function researchPlanMarkdown(plan) {
   return `${lines.join('\n')}\n`;
 }
 
+export function researchSourceSkillMarkdown(plan) {
+  const layers = plan?.web_research_policy?.source_layers?.length ? plan.web_research_policy.source_layers : RESEARCH_SOURCE_LAYERS;
+  const lines = [];
+  lines.push('# Research Source Layer Skill');
+  lines.push('');
+  lines.push('Status: route-local candidate skill. Use it inside this research mission before scout synthesis. Do not install or edit generated .agents/skills from this artifact.');
+  lines.push('Real-run policy: collect live sources for as long as needed within the mission timeout; mock or fixture evidence is valid only for explicit --mock selftests.');
+  lines.push('');
+  lines.push('## Trigger');
+  lines.push('- Any `$Research` run that must collect broad public evidence before creative synthesis, debate, falsification, or paper writing.');
+  lines.push('');
+  lines.push('## Source Layers');
+  for (const layer of layers) {
+    lines.push(`- ${layer.id}: ${layer.purpose}`);
+    lines.push(`  Examples: ${(layer.examples || []).join(', ')}`);
+    lines.push(`  Query templates: ${(layer.query_templates || []).join(' | ')}`);
+  }
+  lines.push('');
+  lines.push('## Output Contract');
+  lines.push('- Fill source-ledger.json with `source_layers`, `sources[].layer`, `counterevidence_sources[].layer`, `citation_coverage`, `triangulation.cross_layer_checks`, and `blockers`.');
+  lines.push('- Each source entry should record title, locator/URL, publisher or author when known, published_at when known, accessed_at, layer, reliability, credibility, stance, supports or undermines, and notes.');
+  lines.push('- Public discourse sources such as X/Twitter or Reddit are signals and edge cases, not truth. They must be triangulated with formal, official, practitioner, or counterevidence layers.');
+  lines.push('- If a layer cannot be searched with the available runtime or credentials, record the blocker and keep research-gate.json unpassed.');
+  lines.push('');
+  lines.push('## Debate Use');
+  lines.push('- Every scout must cite source-ledger ids in findings and Eureka ideas.');
+  lines.push('- The skeptic lens must challenge the strongest claim using counterevidence or source-quality downgrades.');
+  lines.push('- Synthesis keeps only claims that survive cross-layer triangulation and falsification.');
+  lines.push('');
+  return `${lines.join('\n')}\n`;
+}
+
 export function countResearchPaperSections(text = '') {
   const headings = String(text || '').toLowerCase().split(/\n/).filter((line) => /^#{1,3}\s+/.test(line));
   return RESEARCH_PAPER_SECTION_GROUPS.filter((group) => headings.some((heading) => group.some((term) => heading.includes(term)))).length;
 }
 
+export function countGeniusOpinionSummaries(text = '') {
+  const lower = String(text || '').toLowerCase();
+  return RESEARCH_SCOUT_COUNCIL.filter((scout) => {
+    const label = String(scout.label || '').toLowerCase();
+    return lower.includes(String(scout.id || '').toLowerCase()) || (label && lower.includes(label));
+  }).length;
+}
+
 export async function writeResearchPlan(dir, prompt, opts = {}) {
   const plan = createResearchPlan(prompt, opts);
   await writeJsonAtomic(path.join(dir, 'research-plan.json'), plan);
   await writeTextAtomic(path.join(dir, 'research-plan.md'), researchPlanMarkdown(plan));
+  await writeTextAtomic(path.join(dir, RESEARCH_SOURCE_SKILL_ARTIFACT), researchSourceSkillMarkdown(plan));
   await writeJsonAtomic(path.join(dir, 'novelty-ledger.json'), {
     schema_version: 1,
     entries: [],
@@ -210,14 +343,46 @@ export async function writeResearchPlan(dir, prompt, opts = {}) {
 }
 
 export function defaultSourceLedger(plan = null) {
+  const sourceLayers = plan?.web_research_policy?.source_layers?.length ? plan.web_research_policy.source_layers : RESEARCH_SOURCE_LAYERS;
   return {
     schema_version: 1,
-    policy: plan?.web_research_policy?.mode || 'maximum_source_retrieval',
+    policy: plan?.web_research_policy?.mode || 'layered_source_retrieval_and_triangulation',
     created_at: nowIso(),
+    source_layer_skill: {
+      artifact: RESEARCH_SOURCE_SKILL_ARTIFACT,
+      status: 'planned'
+    },
     web_search_passes: 0,
+    source_layers: sourceLayers.map((layer) => ({
+      id: layer.id,
+      label: layer.label,
+      required: true,
+      status: 'pending',
+      evidence_role: layer.evidence_role,
+      query_templates: layer.query_templates || [],
+      source_ids: [],
+      counterevidence_ids: [],
+      blocker: null,
+      notes: ''
+    })),
+    layer_coverage: {
+      required: sourceLayers.map((layer) => layer.id),
+      covered: [],
+      missing: sourceLayers.map((layer) => layer.id),
+      notes: []
+    },
     queries: [],
     sources: [],
     counterevidence_sources: [],
+    triangulation: {
+      cross_layer_checks: [],
+      conflicts: [],
+      synthesis_notes: []
+    },
+    quality_model: {
+      reporting_basis: 'Record enough source metadata to make search reproducible, including query, layer, locator, publisher or author, publication date when known, accessed_at, reliability, credibility, stance, and cited claim ids.',
+      source_quality_fields: ['layer', 'kind', 'title', 'locator', 'publisher_or_author', 'published_at', 'accessed_at', 'reliability', 'credibility', 'stance', 'supports', 'undermines']
+    },
     citation_coverage: {
       all_key_claims_cited: false,
       notes: []
@@ -282,20 +447,53 @@ export function defaultFalsificationLedger() {
   };
 }
 
+function sourceLayerIdsForPlan(plan = null) {
+  const layers = plan?.web_research_policy?.source_layers?.length ? plan.web_research_policy.source_layers : RESEARCH_SOURCE_LAYERS;
+  return layers.map((layer) => layer.id).filter(Boolean);
+}
+
+function sourceLayerCoverageStats(sourceLedger = null, requiredLayerIds = RESEARCH_SOURCE_LAYER_IDS) {
+  const covered = new Set();
+  const sourceRows = [
+    ...(Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : []),
+    ...(Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : [])
+  ];
+  for (const source of sourceRows) {
+    const layer = source?.layer || source?.layer_id || source?.source_layer;
+    if (requiredLayerIds.includes(layer)) covered.add(layer);
+  }
+  for (const layer of Array.isArray(sourceLedger?.source_layers) ? sourceLedger.source_layers : []) {
+    const id = layer?.id || layer?.layer;
+    const sourceIds = [
+      ...(Array.isArray(layer?.source_ids) ? layer.source_ids : []),
+      ...(Array.isArray(layer?.counterevidence_ids) ? layer.counterevidence_ids : [])
+    ];
+    if (requiredLayerIds.includes(id) && layer?.status === 'covered' && sourceIds.length > 0) covered.add(id);
+  }
+  const missing = requiredLayerIds.filter((id) => !covered.has(id));
+  return { covered: [...covered], missing, required: [...requiredLayerIds] };
+}
+
 export function defaultResearchGate() {
   return {
     passed: false,
     report_present: false,
     paper_present: false,
     paper_sections: 0,
+    genius_opinion_summary_present: false,
+    genius_opinion_summaries: 0,
+    research_source_skill_present: false,
     source_ledger_present: false,
     scout_ledger_present: false,
     debate_ledger_present: false,
     novelty_ledger_present: false,
     falsification_ledger_present: false,
-    web_search_policy: 'maximum_source_retrieval',
+    web_search_policy: 'layered_source_retrieval_and_triangulation',
     web_search_passes: 0,
     source_entries: 0,
+    source_layers_required: RESEARCH_SOURCE_LAYER_IDS.length,
+    source_layers_covered: 0,
+    triangulation_checks: 0,
     independent_scouts: 0,
     xhigh_scouts: 0,
     eureka_moments: 0,
@@ -318,9 +516,13 @@ export function defaultResearchGate() {
 
 export async function evaluateResearchGate(dir) {
   const gate = await readJson(path.join(dir, 'research-gate.json'), defaultResearchGate());
+  const plan = await readJson(path.join(dir, 'research-plan.json'), null);
   const reportPresent = await exists(path.join(dir, 'research-report.md'));
   const paperPresent = await exists(path.join(dir, RESEARCH_PAPER_ARTIFACT));
   const paperSections = paperPresent ? countResearchPaperSections(await readText(path.join(dir, RESEARCH_PAPER_ARTIFACT), '')) : 0;
+  const geniusSummaryPresent = await exists(path.join(dir, RESEARCH_GENIUS_SUMMARY_ARTIFACT));
+  const geniusSummaryCount = geniusSummaryPresent ? countGeniusOpinionSummaries(await readText(path.join(dir, RESEARCH_GENIUS_SUMMARY_ARTIFACT), '')) : 0;
+  const sourceSkillPresent = await exists(path.join(dir, RESEARCH_SOURCE_SKILL_ARTIFACT));
   const sourcePresent = await exists(path.join(dir, 'source-ledger.json'));
   const scoutPresent = await exists(path.join(dir, 'scout-ledger.json'));
   const debatePresent = await exists(path.join(dir, 'debate-ledger.json'));
@@ -333,6 +535,9 @@ export async function evaluateResearchGate(dir) {
   const sourceEntries = Array.isArray(sourceLedger?.sources) ? sourceLedger.sources.length : 0;
   const counterEvidenceEntries = Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources.length : 0;
   const webSearchPasses = Math.max(Number(gate.web_search_passes || 0), Number(sourceLedger?.web_search_passes || 0));
+  const requiredSourceLayers = sourceLayerIdsForPlan(plan);
+  const sourceLayerStats = sourceLayerCoverageStats(sourceLedger, requiredSourceLayers);
+  const triangulationChecks = Array.isArray(sourceLedger?.triangulation?.cross_layer_checks) ? sourceLedger.triangulation.cross_layer_checks.length : 0;
   const scoutRows = Array.isArray(scoutLedger?.scouts) ? scoutLedger.scouts : [];
   const independentScouts = scoutRows.filter((scout) => Array.isArray(scout.findings) && scout.findings.length > 0).length;
   const xhighScouts = scoutRows.filter((scout) => scout.effort === 'xhigh').length;
@@ -351,6 +556,9 @@ export async function evaluateResearchGate(dir) {
   if (!reportPresent && gate.report_present !== true) reasons.push('research_report_missing');
   if (!paperPresent) reasons.push('research_paper_missing');
   if (paperSections < RESEARCH_PAPER_SECTION_GROUPS.length) reasons.push('research_paper_sections_missing');
+  if (!geniusSummaryPresent && gate.genius_opinion_summary_present !== true) reasons.push('genius_opinion_summary_missing');
+  if (Math.max(Number(gate.genius_opinion_summaries || 0), geniusSummaryCount) < RESEARCH_SCOUT_COUNCIL.length) reasons.push('genius_opinion_summary_incomplete');
+  if (!sourceSkillPresent && gate.research_source_skill_present !== true) reasons.push('research_source_skill_missing');
   if (!sourcePresent && gate.source_ledger_present !== true) reasons.push('source_ledger_missing');
   if (!scoutPresent && gate.scout_ledger_present !== true) reasons.push('scout_ledger_missing');
   if (!debatePresent && gate.debate_ledger_present !== true) reasons.push('debate_ledger_missing');
@@ -358,6 +566,8 @@ export async function evaluateResearchGate(dir) {
   if (!falsificationPresent && gate.falsification_ledger_present !== true) reasons.push('falsification_ledger_missing');
   if (webSearchPasses < 1) reasons.push('web_search_pass_missing');
   if (Math.max(Number(gate.source_entries || 0), sourceEntries) < 1) reasons.push('source_entry_missing');
+  if (Math.max(Number(gate.source_layers_covered || 0), sourceLayerStats.covered.length) < requiredSourceLayers.length) reasons.push('source_layer_coverage_missing');
+  if (Math.max(Number(gate.triangulation_checks || 0), triangulationChecks) < 1) reasons.push('cross_layer_triangulation_missing');
   if (Math.max(Number(gate.independent_scouts || 0), independentScouts) < RESEARCH_SCOUT_COUNCIL.length) reasons.push('independent_scouts_missing');
   if (Math.max(Number(gate.xhigh_scouts || 0), xhighScouts) < RESEARCH_SCOUT_COUNCIL.length) reasons.push('scout_effort_not_xhigh');
   if (Math.max(Number(gate.eureka_moments || 0), eurekaMoments) < RESEARCH_SCOUT_COUNCIL.length) reasons.push('eureka_missing');
@@ -380,7 +590,14 @@ export async function evaluateResearchGate(dir) {
     metrics: {
       web_search_passes: webSearchPasses,
       paper_sections: Math.max(Number(gate.paper_sections || 0), paperSections),
+      genius_opinion_summary_present: geniusSummaryPresent || gate.genius_opinion_summary_present === true,
+      genius_opinion_summaries: Math.max(Number(gate.genius_opinion_summaries || 0), geniusSummaryCount),
+      research_source_skill_present: sourceSkillPresent || gate.research_source_skill_present === true,
       source_entries: Math.max(Number(gate.source_entries || 0), sourceEntries),
+      source_layers_required: requiredSourceLayers.length,
+      source_layers_covered: Math.max(Number(gate.source_layers_covered || 0), sourceLayerStats.covered.length),
+      source_layers_missing: sourceLayerStats.missing,
+      triangulation_checks: Math.max(Number(gate.triangulation_checks || 0), triangulationChecks),
       independent_scouts: Math.max(Number(gate.independent_scouts || 0), independentScouts),
       xhigh_scouts: Math.max(Number(gate.xhigh_scouts || 0), xhighScouts),
       eureka_moments: Math.max(Number(gate.eureka_moments || 0), eurekaMoments),
@@ -399,41 +616,89 @@ export async function evaluateResearchGate(dir) {
 }
 
 export async function writeMockResearchResult(dir, plan) {
+  const mockLayerSources = RESEARCH_SOURCE_LAYERS.map((layer, index) => ({
+    id: `mock-source-${index + 1}`,
+    layer: layer.id,
+    kind: 'selftest',
+    title: `Mock ${layer.label} coverage`,
+    locator: 'writeMockResearchResult',
+    accessed_at: nowIso(),
+    reliability: 'mock',
+    credibility: 'mock',
+    stance: layer.id === 'counterevidence_factcheck' ? 'undermines' : 'supports',
+    supports: layer.id === 'counterevidence_factcheck' ? [] : ['mock-insight-1'],
+    undermines: layer.id === 'counterevidence_factcheck' ? ['mock-insight-1'] : [],
+    notes: `Selftest fixture for the ${layer.id} source layer; no live web call is made in --mock mode.`
+  }));
   const sourceLedger = {
     schema_version: 1,
-    policy: 'maximum_source_retrieval',
+    policy: 'layered_source_retrieval_and_triangulation',
     created_at: nowIso(),
     mode: 'selftest_mock',
+    source_layer_skill: {
+      artifact: RESEARCH_SOURCE_SKILL_ARTIFACT,
+      status: 'created'
+    },
     web_search_passes: 1,
-    queries: [
-      { scout_id: 'einstein', query: 'mock first principles falsifiable novelty research mode', status: 'mocked' },
-      { scout_id: 'feynman', query: 'mock simple experiment compare discovery prompt summary prompt', status: 'mocked' },
-      { scout_id: 'turing', query: 'mock formal gate criteria source ledger citation coverage', status: 'mocked' },
-      { scout_id: 'von_neumann', query: 'mock workflow gate scaling review route evidence', status: 'mocked' },
-      { scout_id: 'skeptic', query: 'mock counterevidence research mode overclaims without sources', status: 'mocked' }
-    ],
-    sources: [
-      {
-        id: 'mock-source-1',
-        kind: 'selftest',
-        title: 'Mock SKS research source coverage',
-        locator: 'writeMockResearchResult',
-        accessed_at: nowIso(),
-        supports: ['mock-insight-1'],
-        notes: 'Selftest fixture; no live web call is made in --mock mode.'
-      }
-    ],
+    source_layers: RESEARCH_SOURCE_LAYERS.map((layer, index) => ({
+      id: layer.id,
+      label: layer.label,
+      required: true,
+      status: 'covered',
+      evidence_role: layer.evidence_role,
+      query_templates: layer.query_templates || [],
+      source_ids: [`mock-source-${index + 1}`],
+      counterevidence_ids: layer.id === 'counterevidence_factcheck' ? ['mock-counter-1'] : [],
+      blocker: null,
+      notes: 'Mock mode records layer coverage without live web access.'
+    })),
+    layer_coverage: {
+      required: [...RESEARCH_SOURCE_LAYER_IDS],
+      covered: [...RESEARCH_SOURCE_LAYER_IDS],
+      missing: [],
+      notes: ['mock fixture covers every research source layer']
+    },
+    queries: RESEARCH_SOURCE_LAYERS.map((layer) => ({
+      scout_id: layer.id === 'counterevidence_factcheck' ? 'skeptic' : null,
+      layer: layer.id,
+      query: `mock ${layer.id} layered research source search for ${plan.prompt}`,
+      status: 'mocked'
+    })),
+    sources: mockLayerSources,
     counterevidence_sources: [
       {
         id: 'mock-counter-1',
+        layer: 'counterevidence_factcheck',
         kind: 'selftest',
         title: 'Mock overclaim counterexample',
         locator: 'writeMockResearchResult',
         accessed_at: nowIso(),
+        reliability: 'mock',
+        credibility: 'mock',
+        stance: 'undermines',
         undermines: ['mock-insight-1'],
         notes: 'Shows the gate must fail if a run produces no tests or falsifiers.'
       }
     ],
+    triangulation: {
+      cross_layer_checks: [
+        {
+          id: 'mock-triangulation-1',
+          claim: 'Research Mode should not synthesize from a single corpus.',
+          source_ids: ['mock-source-1', 'mock-source-2', 'mock-source-5', 'mock-counter-1'],
+          result: 'survives_with_layered_evidence_requirement'
+        },
+        {
+          id: 'mock-triangulation-2',
+          claim: 'Public discourse is useful only when checked against formal and official layers.',
+          source_ids: ['mock-source-1', 'mock-source-2', 'mock-source-5', 'mock-source-6'],
+          result: 'downgrade_popularity_to_signal_not_truth'
+        }
+      ],
+      conflicts: [],
+      synthesis_notes: ['mock fixture requires cross-layer checks before synthesis']
+    },
+    quality_model: defaultSourceLedger(plan).quality_model,
     citation_coverage: {
       all_key_claims_cited: true,
       notes: ['mock report and novelty entry cite mock-source-1 and mock-counter-1']
@@ -521,26 +786,51 @@ export async function writeMockResearchResult(dir, plan) {
       }
     ]
   };
+  const geniusSummary = [
+    '# Genius Opinion Summary',
+    '',
+    `Prompt: ${plan.prompt}`,
+    '',
+    '## Scout Opinions',
+    ...RESEARCH_SCOUT_COUNCIL.flatMap((scout) => [
+      `### ${scout.label} (${scout.id})`,
+      `Final opinion: ${scout.label} wants the run to preserve ${scout.mandate.toLowerCase()} while producing a cited, falsifiable insight.`,
+      'Strongest evidence: mock-source-1 plus the layered source ledger.',
+      'Main disagreement: whether formal structure or cheap empirical probes should dominate the first pass.',
+      'Changed mind: accepted that citation coverage, counterevidence, and triangulation are gates before synthesis.',
+      ''
+    ]),
+    '## Council Consensus',
+    'The council keeps one modest, testable claim: Research Mode is useful when it writes a source-cited paper, records every scout opinion, triangulates across source layers, and exposes the next decisive test.'
+  ].join('\n');
+  await writeTextAtomic(path.join(dir, RESEARCH_SOURCE_SKILL_ARTIFACT), researchSourceSkillMarkdown(plan));
   await writeJsonAtomic(path.join(dir, 'source-ledger.json'), sourceLedger);
   await writeJsonAtomic(path.join(dir, 'scout-ledger.json'), scoutLedger);
   await writeJsonAtomic(path.join(dir, 'debate-ledger.json'), debateLedger);
   await writeJsonAtomic(path.join(dir, 'falsification-ledger.json'), falsificationLedger);
   await writeJsonAtomic(path.join(dir, 'novelty-ledger.json'), ledger);
-  await writeTextAtomic(path.join(dir, 'research-report.md'), `# SKS Research Report\n\nPrompt: ${plan.prompt}\n\n## Scout Council Synthesis\n\nThe mock council keeps one cited methodological insight: a research mode should force falsifiable novelty rather than summarize known material [mock-source-1].\n\n## Source Coverage\n\nThis is a selftest fixture. It records mock source and counterevidence ledgers but does not perform live web browsing in --mock mode.\n\n## Candidate Insight\n\nA useful research run must produce source-cited, falsifiable novelty with scout findings and a cheap probe.\n\n## Falsification\n\nThe claim is weak if no new testable prediction, counterevidence source, or experiment is produced [mock-counter-1].\n\n## Next Test\n\nCompare this mode against a summary-only run and score candidate insights, falsification passes, citation coverage, and testability.\n`);
-  await writeTextAtomic(path.join(dir, RESEARCH_PAPER_ARTIFACT), `# Research Paper: ${plan.prompt}\n\n## Abstract\nA source-cited research run should produce falsifiable novelty rather than only summarize known material.\n\n## Introduction\nThe mock topic is evaluated as a research workflow outcome [mock-source-1].\n\n## Methodology\nFive xhigh scouts produce Eureka ideas, debate, and falsify the strongest claim.\n\n## Findings\nThe surviving finding is that useful research needs cited novelty plus a cheap decisive probe.\n\n## Discussion\nThe debate favors gate-backed evidence over narrative confidence.\n\n## Limitations and Falsification\nThe claim fails without sources, counterevidence, or testable predictions [mock-counter-1].\n\n## Conclusion and Next Experiment\nCompare this loop against a summary-only baseline and score testable insights.\n\n## References\n- [mock-source-1] Mock SKS research source coverage.\n- [mock-counter-1] Mock overclaim counterexample.\n`);
+  await writeTextAtomic(path.join(dir, RESEARCH_GENIUS_SUMMARY_ARTIFACT), `${geniusSummary}\n`);
+  await writeTextAtomic(path.join(dir, 'research-report.md'), `# SKS Research Report\n\nPrompt: ${plan.prompt}\n\n## Scout Council Synthesis\n\nThe mock council keeps one cited methodological insight: a research mode should force layered, falsifiable novelty rather than summarize known material from one corpus [mock-source-1].\n\n## Source Coverage\n\nThis is a selftest fixture. It records mock coverage for academic literature, official data, standards, news, public discourse, developer knowledge, and counterevidence layers, but does not perform live web browsing in --mock mode.\n\n## Candidate Insight\n\nA useful research run must produce source-cited, cross-layer triangulated, falsifiable novelty with scout findings and a cheap probe.\n\n## Falsification\n\nThe claim is weak if no new testable prediction, counterevidence source, cross-layer check, or experiment is produced [mock-counter-1].\n\n## Next Test\n\nCompare this mode against a summary-only run and score candidate insights, falsification passes, citation coverage, source-layer coverage, triangulation checks, and testability.\n`);
+  await writeTextAtomic(path.join(dir, RESEARCH_PAPER_ARTIFACT), `# Research Paper: ${plan.prompt}\n\n## Abstract\nA source-cited research run should produce cross-layer, falsifiable novelty rather than only summarize known material.\n\n## Introduction\nThe mock topic is evaluated as a research workflow outcome with layered source coverage [mock-source-1].\n\n## Methodology\nFive xhigh scouts produce Eureka ideas, debate, triangulate source layers, and falsify the strongest claim.\n\n## Findings\nThe surviving finding is that useful research needs cited novelty, source-layer coverage, cross-layer triangulation, and a cheap decisive probe.\n\n## Discussion\nThe debate favors gate-backed evidence over narrative confidence, and treats public discourse as signal rather than truth.\n\n## Limitations and Falsification\nThe claim fails without sources, counterevidence, triangulation checks, or testable predictions [mock-counter-1].\n\n## Conclusion and Next Experiment\nCompare this loop against a summary-only baseline and score testable insights.\n\n## References\n- [mock-source-1] Mock academic literature coverage.\n- [mock-source-2] Mock official government and leading-institution knowledge coverage.\n- [mock-source-3] Mock standards and primary documents coverage.\n- [mock-source-4] Mock current news and global reporting coverage.\n- [mock-source-5] Mock public discourse coverage.\n- [mock-source-6] Mock developer and practitioner knowledge coverage.\n- [mock-source-7] Mock counterevidence and fact-checking coverage.\n- [mock-counter-1] Mock overclaim counterexample.\n`);
   await writeJsonAtomic(path.join(dir, 'research-gate.json'), {
     ...defaultResearchGate(),
     passed: true,
     report_present: true,
     paper_present: true,
     paper_sections: RESEARCH_PAPER_SECTION_GROUPS.length,
+    genius_opinion_summary_present: true,
+    genius_opinion_summaries: RESEARCH_SCOUT_COUNCIL.length,
+    research_source_skill_present: true,
     source_ledger_present: true,
     scout_ledger_present: true,
     debate_ledger_present: true,
     novelty_ledger_present: true,
     falsification_ledger_present: true,
     web_search_passes: 1,
-    source_entries: 1,
+    source_entries: mockLayerSources.length,
+    source_layers_required: RESEARCH_SOURCE_LAYER_IDS.length,
+    source_layers_covered: RESEARCH_SOURCE_LAYER_IDS.length,
+    triangulation_checks: sourceLedger.triangulation.cross_layer_checks.length,
     independent_scouts: RESEARCH_SCOUT_COUNCIL.length,
     xhigh_scouts: RESEARCH_SCOUT_COUNCIL.length,
     eureka_moments: RESEARCH_SCOUT_COUNCIL.length,
@@ -553,12 +843,12 @@ export async function writeMockResearchResult(dir, plan) {
     falsification_cases: 1,
     testable_predictions: 1,
     citation_coverage: true,
-    evidence: ['mock research report', 'mock research paper', 'mock source ledger', 'mock scout ledger', 'mock debate ledger', 'mock novelty ledger', 'mock falsification ledger'],
+    evidence: ['mock research report', 'mock research paper', 'mock genius opinion summary', 'mock research source skill', 'mock layered source ledger', 'mock scout ledger', 'mock debate ledger', 'mock novelty ledger', 'mock falsification ledger'],
     notes: ['mock mode records the new contract but does not call a model or perform live web browsing']
   });
   return evaluateResearchGate(dir);
 }
 
 export function buildResearchPrompt({ id, mission, plan, cycle, previous }) {
-  return `You are running SKS Research Mode.\nMISSION: ${id}\nTOPIC: ${mission.prompt}\nCYCLE: ${cycle}\nMODE: Genius Scout Council + frontier discovery loop. Use maximum reasoning depth available under the current Codex profile.\nNO-QUESTION LOCK: Do not ask the user. Resolve scope from research-plan.json and current project evidence.\nSAFETY: Destructive database operations and unsafe external actions are forbidden. Prefer read-only inspection, local files, and cited public sources.\nPERSONA POLICY: Use Einstein/Feynman/Turing/von Neumann-inspired scout lenses only as cognitive roles. Do not impersonate, roleplay private identity, or speak as the historical people.\nSCOUT EFFORT POLICY: Every Research scout agent must use reasoning_effort=xhigh. Record effort: "xhigh" for every scout in scout-ledger.json. Any lower-effort scout output must keep research-gate.json unpassed.\nEUREKA POLICY: Every scout must literally write "Eureka!" and one non-obvious, source-linked idea before debate.\nDEBATE POLICY: The scouts must debate vigorously but stay evidence-bound. Every scout must challenge or respond at least once, and debate-ledger.json must record the exchanges before synthesis.\nPAPER POLICY: After the report and ledgers, write research-paper.md as a concise manuscript with Abstract, Introduction, Methodology, Findings/Results, Discussion, Limitations/Falsification, Conclusion/Next Experiment, and References.\nWEB/SOURCE POLICY: Run the broadest safe web/source search available in this runtime before synthesis. Use independent query sets for every scout. Prefer primary sources, official docs or standards, peer-reviewed or archival sources, reputable recent sources, and credible counterevidence. If live web search is unavailable, record the blocker in source-ledger.json and do not pass the gate.\nRESEARCH PLAN:\n${JSON.stringify(plan, null, 2)}\n\nOBJECTIVE: Produce genuinely useful candidate discoveries: non-obvious hypotheses, mechanisms, predictions, or experiments. Do not merely summarize. Mark uncertainty clearly.\n\nREQUIRED PROCESS:\n1. Source search first: create source-ledger.json with queries, source ids, counterevidence sources, citation coverage, and blockers.\n2. Independent xhigh scouts: create scout-ledger.json with effort=xhigh, a literal Eureka! idea, findings, source_ids, falsifiers, and cheap_probes for every scout lens.\n3. Debate: create debate-ledger.json with evidence-bound challenge/response exchanges involving every scout before synthesis.\n4. Falsification: create falsification-ledger.json with attacks, missing evidence, source conflicts, and decisive next tests.\n5. Synthesis: write research-report.md and novelty-ledger.json only after cited scout findings, Eureka ideas, debate, and falsification are recorded.\n6. Paper: write research-paper.md as a paper-style manuscript with source-ledger references and limitations.\n\nREQUIRED OUTPUT FILES in .sneakoscope/missions/${id}/:\n- research-report.md: concise report with framing, source coverage, scout synthesis, debate synthesis, hypotheses, falsification, predictions, and next experiments. Cite source-ledger ids for factual claims.\n- research-paper.md: paper manuscript with Abstract, Introduction, Methodology, Findings/Results, Discussion, Limitations/Falsification, Conclusion/Next Experiment, and References using source-ledger ids.\n- source-ledger.json: web/source queries, source ids, source priority, counterevidence sources, citation coverage, and blockers.\n- scout-ledger.json: one entry per scout lens with effort, eureka, query_set, findings, source_ids, falsifiers, and cheap_probes.\n- debate-ledger.json: evidence-bound challenge/response exchanges, participants, changed minds, and unresolved conflicts.\n- novelty-ledger.json: entries with claim, novelty, confidence, falsifiability, evidence source ids, falsifiers, next_experiment.\n- falsification-ledger.json: attacks/counterexamples/source conflicts, result, and next_decisive_tests.\n- research-gate.json: set passed only when all ledgers exist, research-paper.md exists with required paper sections, web/source retrieval was attempted, all scouts have effort=xhigh, all scouts have literal Eureka! ideas, every scout participated in debate, at least one counterevidence source exists, citation coverage is complete, at least one insight survived falsification, at least one testable prediction exists, and unsupported breakthrough claims are zero.\n\nPrevious cycle tail:\n${String(previous || '').slice(-2500)}\n`;
+  return `You are running SKS Research Mode.\nMISSION: ${id}\nTOPIC: ${mission.prompt}\nCYCLE: ${cycle}\nMODE: Genius Scout Council + frontier discovery loop. Use maximum reasoning depth available under the current Codex profile.\nLONG-RUN REAL-RESEARCH POLICY: Normal Research is allowed to take one or two hours when the question requires it. Do real source gathering and evidence comparison; do not shortcut into mock, fixture, or summary-only output. If live source access is unavailable, write the blocker and keep the gate unpassed.\nNO-QUESTION LOCK: Do not ask the user. Resolve scope from research-plan.json and current project evidence.\nSAFETY: Destructive database operations and unsafe external actions are forbidden. Prefer read-only inspection, local files, and cited public sources.\nPERSONA POLICY: Use Einstein/Feynman/Turing/von Neumann-inspired scout lenses only as cognitive roles. Do not impersonate, roleplay private identity, or speak as the historical people.\nSCOUT EFFORT POLICY: Every Research scout agent must use reasoning_effort=xhigh. Record effort: "xhigh" for every scout in scout-ledger.json. Any lower-effort scout output must keep research-gate.json unpassed.\nEUREKA POLICY: Every scout must literally write "Eureka!" and one non-obvious, source-linked idea before debate.\nDEBATE POLICY: The scouts must debate vigorously but stay evidence-bound. Every scout must challenge or respond at least once, and debate-ledger.json must record the exchanges before synthesis.\nPAPER POLICY: After the report and ledgers, write research-paper.md as a concise manuscript with Abstract, Introduction, Methodology, Findings/Results, Discussion, Limitations/Falsification, Conclusion/Next Experiment, and References.\nSOURCE SKILL POLICY: Create or update ${RESEARCH_SOURCE_SKILL_ARTIFACT} as a route-local source collection skill before synthesis. It must name the selected source layers, query routes, quality fields, blockers, and cross-layer triangulation checks. Do not edit generated .agents/skills during the research run.\nWEB/SOURCE POLICY: Run layered source retrieval across every safely available layer before synthesis: latest public papers, official government or leading-institution data, standards or primary docs, current news including BBC/CNN/GDELT-style sources when relevant, public discourse including X/Twitter and Reddit when available, developer/practitioner sources such as Stack Overflow/Stack Exchange/GitHub, and counterevidence or fact-checking sources. Treat public discourse as signal, not truth. If a layer cannot be searched, record the blocker in source-ledger.json and do not pass the gate.\nRESEARCH PLAN:\n${JSON.stringify(plan, null, 2)}\n\nOBJECTIVE: Produce genuinely useful candidate discoveries: non-obvious hypotheses, mechanisms, predictions, or experiments. Do not merely summarize. Mark uncertainty clearly.\n\nREQUIRED PROCESS:\n1. Source skill first: create ${RESEARCH_SOURCE_SKILL_ARTIFACT} with source layers, query templates, quality fields, blockers, and triangulation rules.\n2. Layered source search: create source-ledger.json with source_layers, queries, source ids, source quality notes, counterevidence sources, triangulation.cross_layer_checks, citation coverage, and blockers.\n3. Independent xhigh scouts: create scout-ledger.json with effort=xhigh, a literal Eureka! idea, findings, source_ids, falsifiers, and cheap_probes for every scout lens.\n4. Debate: create debate-ledger.json with evidence-bound challenge/response exchanges involving every scout before synthesis.\n5. Falsification: create falsification-ledger.json with attacks, missing evidence, source conflicts, and decisive next tests.\n6. Synthesis: write research-report.md and novelty-ledger.json only after cited scout findings, Eureka ideas, debate, cross-layer triangulation, and falsification are recorded.\n7. Paper: write research-paper.md as a paper-style manuscript with source-ledger references and limitations.\n\nREQUIRED OUTPUT FILES in .sneakoscope/missions/${id}/:\n- research-report.md: concise report with framing, source coverage, scout synthesis, debate synthesis, hypotheses, falsification, predictions, and next experiments. Cite source-ledger ids for factual claims.\n- research-paper.md: paper manuscript with Abstract, Introduction, Methodology, Findings/Results, Discussion, Limitations/Falsification, Conclusion/Next Experiment, and References using source-ledger ids.\n- ${RESEARCH_SOURCE_SKILL_ARTIFACT}: route-local source collection skill; it is evidence for the Skill Creator step and must not mutate generated .agents/skills.\n- source-ledger.json: layered web/source queries, source ids, source priority, source quality notes, counterevidence sources, citation coverage, triangulation checks, and blockers.\n- scout-ledger.json: one entry per scout lens with effort, eureka, query_set, findings, source_ids, falsifiers, and cheap_probes.\n- debate-ledger.json: evidence-bound challenge/response exchanges, participants, changed minds, and unresolved conflicts.\n- novelty-ledger.json: entries with claim, novelty, confidence, falsifiability, evidence source ids, falsifiers, next_experiment.\n- falsification-ledger.json: attacks/counterexamples/source conflicts, result, and next_decisive_tests.\n- research-gate.json: set passed only when all ledgers exist, ${RESEARCH_SOURCE_SKILL_ARTIFACT} exists, research-paper.md exists with required paper sections, layered web/source retrieval covered every required source layer, at least one cross-layer triangulation check exists, all scouts have effort=xhigh, all scouts have literal Eureka! ideas, every scout participated in debate, at least one counterevidence source exists, citation coverage is complete, at least one insight survived falsification, at least one testable prediction exists, and unsupported breakthrough claims are zero.\n\nPrevious cycle tail:\n${String(previous || '').slice(-2500)}\n`;
 }

package/src/core/routes.mjs

@@ -390,10 +390,10 @@ export const ROUTES = [
     command: '$Research',
     mode: 'RESEARCH',
     route: 'research mission',
-    description: 'Frontier discovery with xhigh genius-lens scouts, Eureka ideas, vigorous evidence-bound debate, maximum source retrieval, falsification, a paper manuscript, and testable predictions.',
-    requiredSkills: ['research', 'research-discovery', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
-    lifecycle: ['research_plan', 'source_ledger', 'xhigh_scout_council', 'eureka_moments', 'debate_ledger', 'report', 'paper', 'novelty_ledger', 'falsification_ledger', 'research_gate', 'post_route_reflection', 'honest_mode'],
-    context7Policy: 'required',
+    description: 'Frontier discovery with xhigh genius-lens scouts, Eureka ideas, vigorous evidence-bound debate, layered public source retrieval, falsification, a paper manuscript, a final genius-opinion summary, and testable predictions.',
+    requiredSkills: ['research', 'research-discovery', 'pipeline-runner', REFLECTION_SKILL_NAME, 'honest-mode'],
+    lifecycle: ['research_plan', 'source_skill', 'layered_source_ledger', 'xhigh_scout_council', 'eureka_moments', 'debate_ledger', 'report', 'paper', 'genius_opinion_summary', 'novelty_ledger', 'falsification_ledger', 'research_gate', 'post_route_reflection', 'honest_mode'],
+    context7Policy: 'if_external_docs',
     reasoningPolicy: 'xhigh',
     stopGate: 'research-gate.json',
     cliEntrypoint: 'sks research prepare|run',
@@ -537,7 +537,7 @@ export const COMMAND_CATALOG = [
   { name: 'init', usage: 'sks init [--force] [--local-only] [--install-scope global|project]', description: 'Initialize the local SKS control surface.' },
   { name: 'selftest', usage: 'sks selftest [--mock]', description: 'Run local smoke tests without calling a model.' },
   { name: 'goal', usage: 'sks goal create|pause|resume|clear|status ...', description: 'Prepare and control the fast SKS bridge overlay for Codex native persisted /goal workflows.' },
-  { name: 'research', usage: 'sks research prepare|run|status ...', description: 'Run frontier-style research missions with xhigh scout Eureka ideas, debate, source-ledger, paper, novelty, and falsification gates.' },
+  { name: 'research', usage: 'sks research prepare|run|status ...', description: 'Run long-form real research missions with xhigh scout Eureka ideas, debate, layered sources, paper, novelty, and falsification gates.' },
   { name: 'db', usage: 'sks db policy|scan|mcp-config|classify|check ...', description: 'Inspect and enforce database/Supabase safety policy.' },
   { name: 'eval', usage: 'sks eval run|compare|thresholds ...', description: 'Run deterministic context-quality and performance evidence checks.' },
   { name: 'harness', usage: 'sks harness fixture|review [--json]', description: 'Run Harness Growth Factory fixtures for forgetting, skills, experiments, tool taxonomy, permissions, MultiAgentV2, and tmux views.' },
@@ -585,9 +585,21 @@ function leadingDollarCommandMatch(prompt) {
     || text.match(/^\[\$([A-Za-z][A-Za-z0-9_-]*)\]\([^)]+\)(?:\s|:|$)/);
 }
 
+function embeddedDollarCommandMatch(prompt) {
+  const text = String(prompt || '');
+  const matches = [];
+  for (const match of text.matchAll(/\[\$([A-Za-z][A-Za-z0-9_-]*)\]\([^)]+\)/g)) matches.push({ index: match.index, command: match[1] });
+  for (const match of text.matchAll(/(^|[\s([{<])\$([A-Za-z][A-Za-z0-9_-]*)(?=\s|:|$|[.,!?;)\]}])/g)) matches.push({ index: match.index + match[1].length, command: match[2] });
+  return matches
+    .sort((a, b) => a.index - b.index)
+    .find((match) => routeByDollarCommand(match.command) || String(match.command || '').toUpperCase() === 'MAD-SKS') || null;
+}
+
 export function dollarCommand(prompt) {
-  const match = leadingDollarCommandMatch(prompt);
-  return match ? match[1].toUpperCase() : null;
+  const leading = leadingDollarCommandMatch(prompt);
+  if (leading) return leading[1].toUpperCase();
+  const embedded = embeddedDollarCommandMatch(prompt);
+  return embedded ? embedded.command.toUpperCase() : null;
 }
 
 export function hasMadSksSignal(prompt = '') {