sneakoscope 2.0.14 → 2.0.16

package/dist/core/research/research-synthesis-writer.js

@@ -0,0 +1,208 @@
+import path from 'node:path';
+import { readJson, writeJsonAtomic, writeTextAtomic, nowIso } from '../fsx.js';
+import { runCodexTask } from '../codex-control/codex-task-runner.js';
+import { researchPaperArtifactForPlan } from '../research.js';
+import { analyzeResearchReportQuality, countWords } from './research-report-quality.js';
+import { analyzeResearchRepetition } from './research-repetition-detector.js';
+import { buildRealisticResearchPaper, buildRealisticResearchReport } from './research-realistic-report.js';
+import { buildResearchSynthesisPrompt } from './research-synthesis-prompt.js';
+export const researchSynthesisOutputSchema = {
+    type: 'object',
+    required: ['schema', 'mission_id', 'generated_at', 'report_markdown', 'paper_markdown', 'synthesis_summary', 'quality_signals', 'blockers'],
+    properties: {
+        schema: { const: 'sks.research-synthesis-output.v1' },
+        mission_id: { type: 'string' },
+        generated_at: { type: 'string' },
+        report_markdown: { type: 'string' },
+        paper_markdown: { type: 'string' },
+        synthesis_summary: {
+            type: 'object',
+            required: ['key_claim_ids', 'source_ids_used', 'counterevidence_ids_used', 'blueprint_sections_used', 'experiment_steps_used'],
+            properties: {
+                key_claim_ids: { type: 'array', items: { type: 'string' } },
+                source_ids_used: { type: 'array', items: { type: 'string' } },
+                counterevidence_ids_used: { type: 'array', items: { type: 'string' } },
+                blueprint_sections_used: { type: 'array', items: { type: 'string' } },
+                experiment_steps_used: { type: 'array', items: { type: 'string' } }
+            }
+        },
+        quality_signals: {
+            type: 'object',
+            required: ['report_word_count', 'source_citation_count', 'unique_source_ids_cited', 'key_claims_covered', 'repeated_paragraph_ratio', 'template_phrase_hits'],
+            properties: {
+                report_word_count: { type: 'number' },
+                source_citation_count: { type: 'number' },
+                unique_source_ids_cited: { type: 'number' },
+                key_claims_covered: { type: 'number' },
+                repeated_paragraph_ratio: { type: 'number' },
+                template_phrase_hits: { type: 'array', items: { type: 'string' } }
+            }
+        },
+        blockers: { type: 'array', items: { type: 'string' } }
+    }
+};
+export async function runResearchCodexSynthesisWriter(input) {
+    const artifacts = await readSynthesisInputs(input.dir);
+    if (input.mock === true || input.plan?.backend === 'mock' || input.plan?.backend === 'deterministic') {
+        const output = normalizeResearchSynthesisOutput(mockResearchSynthesisOutput(input.plan, artifacts));
+        const validation = validateResearchSynthesisOutput(output, artifacts.contract, artifacts.claimMatrix, artifacts.sourceLedger);
+        const merged = { ...output, blockers: [...new Set([...output.blockers, ...validation.blockers])] };
+        await writeSynthesisArtifacts(input.dir, input.plan, merged);
+        return merged;
+    }
+    const result = await runCodexTask({
+        route: '$Research',
+        tier: 'worker',
+        missionId: String(input.plan?.mission_id || 'research-synthesis'),
+        workItemId: 'research_synthesis',
+        cwd: input.root,
+        prompt: buildResearchSynthesisPrompt({ ...artifacts, plan: input.plan, cycle: input.cycle }),
+        outputSchema: researchSynthesisOutputSchema,
+        outputSchemaId: 'sks.research-synthesis-output.v1',
+        sandboxPolicy: 'read-only',
+        requestedScopeContract: {
+            id: 'research-synthesis',
+            route: '$Research',
+            read_only: true,
+            allowed_paths: [`.sneakoscope/missions/${input.plan?.mission_id || ''}/`],
+            write_paths: [],
+            allowed_write_prefixes: [`.sneakoscope/missions/${input.plan?.mission_id || ''}/`],
+            source_mutation_allowed: false
+        },
+        backendPreference: input.backendPreference || ['codex-sdk', 'python-codex-sdk'],
+        allowLocalLlm: false,
+        localLlmPolicy: { mode: 'disabled', requiresGptFinal: true },
+        mutationLedgerRoot: path.join(input.dir, 'research', 'synthesis-codex-control'),
+        reliabilityPolicy: { timeoutClass: 'standard', idleTimeoutMs: input.timeoutMs || 120000 }
+    });
+    const worker = await readJson(result.workerResultPath, null);
+    const output = normalizeResearchSynthesisOutput(worker);
+    const validation = validateResearchSynthesisOutput(output, artifacts.contract, artifacts.claimMatrix, artifacts.sourceLedger);
+    const patchEnvelopeBlocker = Array.isArray(worker?.patch_envelopes) && worker.patch_envelopes.length ? ['research_synthesis_patch_envelope_forbidden'] : [];
+    const blockers = [...new Set([
+            ...output.blockers,
+            ...(Array.isArray(result.blockers) ? result.blockers.map(String) : []),
+            ...validation.blockers,
+            ...patchEnvelopeBlocker
+        ])];
+    const merged = { ...output, blockers };
+    await writeSynthesisArtifacts(input.dir, input.plan, merged);
+    return merged;
+}
+export function normalizeResearchSynthesisOutput(value) {
+    const reportMarkdown = String(value?.report_markdown || '');
+    const paperMarkdown = String(value?.paper_markdown || '');
+    const repetition = analyzeResearchRepetition(reportMarkdown);
+    const sourceIdsUsed = normalizeStringList(value?.synthesis_summary?.source_ids_used || value?.source_ids_used);
+    const keyClaimIds = normalizeStringList(value?.synthesis_summary?.key_claim_ids || value?.key_claim_ids);
+    return {
+        schema: 'sks.research-synthesis-output.v1',
+        mission_id: String(value?.mission_id || ''),
+        generated_at: String(value?.generated_at || nowIso()),
+        report_markdown: reportMarkdown,
+        paper_markdown: paperMarkdown,
+        synthesis_summary: {
+            key_claim_ids: keyClaimIds,
+            source_ids_used: sourceIdsUsed,
+            counterevidence_ids_used: normalizeStringList(value?.synthesis_summary?.counterevidence_ids_used || value?.counterevidence_ids_used),
+            blueprint_sections_used: normalizeStringList(value?.synthesis_summary?.blueprint_sections_used || value?.blueprint_sections_used),
+            experiment_steps_used: normalizeStringList(value?.synthesis_summary?.experiment_steps_used || value?.experiment_steps_used)
+        },
+        quality_signals: {
+            report_word_count: Number(value?.quality_signals?.report_word_count || countWords(reportMarkdown)),
+            source_citation_count: Number(value?.quality_signals?.source_citation_count || sourceCitationCount(reportMarkdown)),
+            unique_source_ids_cited: Number(value?.quality_signals?.unique_source_ids_cited || sourceIdsUsed.filter((id) => reportMarkdown.includes(id)).length),
+            key_claims_covered: Number(value?.quality_signals?.key_claims_covered || keyClaimIds.filter((id) => reportMarkdown.includes(id)).length),
+            repeated_paragraph_ratio: Number(value?.quality_signals?.repeated_paragraph_ratio ?? repetition.repeated_paragraph_ratio),
+            template_phrase_hits: normalizeStringList(value?.quality_signals?.template_phrase_hits || repetition.template_phrase_hits)
+        },
+        blockers: normalizeStringList(value?.blockers)
+    };
+}
+export function validateResearchSynthesisOutput(output, contract = null, claimMatrix = null, sourceLedger = null) {
+    const reportQuality = analyzeResearchReportQuality(output.report_markdown);
+    const repetition = analyzeResearchRepetition(output.report_markdown);
+    const sourceIds = sourceIdsFromLedger(sourceLedger);
+    const keyClaims = Array.isArray(claimMatrix?.key_claim_ids) ? claimMatrix.key_claim_ids.map(String) : [];
+    const report = output.report_markdown;
+    const paper = output.paper_markdown;
+    const sourceIdsCited = sourceIds.filter((id) => report.includes(id));
+    const keyClaimsCovered = keyClaims.filter((id) => report.includes(id) || claimSourceIds(claimMatrix, id).some((sourceId) => report.includes(sourceId)));
+    const paperSections = ['Abstract', 'Introduction', 'Methodology', 'Findings', 'Discussion', 'Limitations', 'Conclusion', 'References'];
+    const blockers = [
+        ...(output.schema === 'sks.research-synthesis-output.v1' ? [] : ['research_synthesis_schema_invalid']),
+        ...(output.mission_id ? [] : ['research_synthesis_mission_missing']),
+        ...(output.report_markdown.trim() ? [] : ['research_synthesis_report_missing']),
+        ...(output.paper_markdown.trim() ? [] : ['research_synthesis_paper_missing']),
+        ...(countWords(report) >= Number(contract?.min_report_words || 2200) ? [] : ['research_synthesis_report_too_short']),
+        ...reportQuality.blockers,
+        ...repetition.blockers,
+        ...(sourceIdsCited.length >= Math.min(8, sourceIds.length) ? [] : ['research_synthesis_unique_sources_below_contract']),
+        ...(keyClaimsCovered.length >= Number(contract?.min_key_claims || 8) ? [] : ['research_synthesis_key_claims_below_contract']),
+        ...(repetition.repeated_paragraph_ratio <= 0.18 ? [] : ['research_synthesis_repeated_paragraph_ratio_high']),
+        ...(repetition.template_phrase_hits.length ? ['research_synthesis_template_phrase_hits'] : []),
+        ...(paperSections.every((heading) => paper.toLowerCase().includes(heading.toLowerCase())) ? [] : ['research_synthesis_paper_sections_missing']),
+        ...output.blockers
+    ];
+    return { ok: blockers.length === 0, blockers: [...new Set(blockers)] };
+}
+async function readSynthesisInputs(dir) {
+    return {
+        sourceLedger: await readJson(path.join(dir, 'source-ledger.json'), null),
+        claimMatrix: await readJson(path.join(dir, 'claim-evidence-matrix.json'), null),
+        falsificationLedger: await readJson(path.join(dir, 'falsification-ledger.json'), null),
+        implementationBlueprint: await readJson(path.join(dir, 'implementation-blueprint.json'), null),
+        experimentPlan: await readJson(path.join(dir, 'experiment-plan.json'), null),
+        replicationPack: await readJson(path.join(dir, 'replication-pack.json'), null),
+        contract: await readJson(path.join(dir, 'research-quality-contract.json'), null)
+    };
+}
+function mockResearchSynthesisOutput(plan, artifacts) {
+    const claims = Array.isArray(artifacts.claimMatrix?.claims) ? artifacts.claimMatrix.claims : [];
+    const sourceIds = sourceIdsFromLedger(artifacts.sourceLedger);
+    const counterIds = counterevidenceIdsFromLedger(artifacts.sourceLedger);
+    const report = buildRealisticResearchReport({ plan, claims, sourceIds, counterevidenceIds: counterIds, blueprint: artifacts.implementationBlueprint, falsificationLedger: artifacts.falsificationLedger, experimentPlan: artifacts.experimentPlan, replicationPack: artifacts.replicationPack });
+    const paper = buildRealisticResearchPaper({ plan, claims, sourceIds, counterevidenceIds: counterIds });
+    return normalizeResearchSynthesisOutput({
+        schema: 'sks.research-synthesis-output.v1',
+        mission_id: String(plan?.mission_id || ''),
+        generated_at: nowIso(),
+        report_markdown: report,
+        paper_markdown: paper,
+        synthesis_summary: {
+            key_claim_ids: (Array.isArray(artifacts.claimMatrix?.key_claim_ids) ? artifacts.claimMatrix.key_claim_ids : claims.slice(0, 8).map((claim) => claim.id)).map(String),
+            source_ids_used: sourceIds,
+            counterevidence_ids_used: counterIds,
+            blueprint_sections_used: (Array.isArray(artifacts.implementationBlueprint?.sections) ? artifacts.implementationBlueprint.sections : []).map((section) => String(section.id || section.title || '')).filter(Boolean),
+            experiment_steps_used: (Array.isArray(artifacts.experimentPlan?.steps) ? artifacts.experimentPlan.steps : []).map((step) => String(step.id || '')).filter(Boolean)
+        },
+        blockers: []
+    });
+}
+async function writeSynthesisArtifacts(dir, plan, output) {
+    await writeJsonAtomic(path.join(dir, 'research-synthesis-output.json'), output);
+    if (output.report_markdown.trim())
+        await writeTextAtomic(path.join(dir, 'research-report.md'), `${output.report_markdown.trim()}\n`);
+    if (output.paper_markdown.trim())
+        await writeTextAtomic(path.join(dir, researchPaperArtifactForPlan(plan)), `${output.paper_markdown.trim()}\n`);
+}
+function sourceIdsFromLedger(sourceLedger) {
+    return normalizeStringList([
+        ...(Array.isArray(sourceLedger?.sources) ? sourceLedger.sources : []),
+        ...(Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : [])
+    ].map((row) => row?.id));
+}
+function counterevidenceIdsFromLedger(sourceLedger) {
+    return normalizeStringList((Array.isArray(sourceLedger?.counterevidence_sources) ? sourceLedger.counterevidence_sources : []).map((row) => row?.id));
+}
+function claimSourceIds(claimMatrix, claimId) {
+    const claim = (Array.isArray(claimMatrix?.claims) ? claimMatrix.claims : []).find((row) => String(row?.id || '') === claimId);
+    return normalizeStringList([...(Array.isArray(claim?.source_ids) ? claim.source_ids : []), ...(Array.isArray(claim?.counterevidence_ids) ? claim.counterevidence_ids : [])]);
+}
+function sourceCitationCount(text) {
+    return [...String(text || '').matchAll(/\b(?:source|src|mock-source|shard-[A-Za-z0-9_-]+|counter|mock-counter)-[A-Za-z0-9_.:-]+\b/g)].length;
+}
+function normalizeStringList(value) {
+    return [...new Set((Array.isArray(value) ? value : value == null ? [] : [value]).flat().map((item) => String(item || '').trim()).filter(Boolean))];
+}
+//# sourceMappingURL=research-synthesis-writer.js.map

package/dist/core/research.js

@@ -16,6 +16,7 @@ import { validateFalsificationCoverage } from './research/falsification.js';
 import { writeResearchHandoffArtifacts } from './research/research-handoff.js';
 import { RESEARCH_WORK_GRAPH_ARTIFACT, writeResearchWorkGraph } from './research/research-work-graph.js';
 import { researchPromptContractText, validateResearchPromptContract } from './research/research-prompt-contract.js';
+import { buildRealisticResearchPaper, buildRealisticResearchReport } from './research/research-realistic-report.js';
 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';
@@ -904,6 +905,7 @@ export async function evaluateResearchGate(dir) {
     const reportPresent = await exists(path.join(dir, 'research-report.md'));
     const reportText = reportPresent ? await readText(path.join(dir, 'research-report.md'), '') : '';
     const reportQuality = analyzeResearchReportQuality(reportText);
+    const synthesisOutput = await readJson(path.join(dir, 'research-synthesis-output.json'), null);
     const reportWordCount = countWords(reportText);
     const paperArtifact = await findResearchPaperArtifact(dir, plan);
     const paperPresent = paperArtifact.exists;
@@ -1095,6 +1097,18 @@ export async function evaluateResearchGate(dir) {
             report_word_count: reportWordCount,
             report_min_words: contract.min_report_words,
             report_quality: reportQuality,
+            report_repetition: reportQuality.repetition,
+            source_density_per_1000_words: reportQuality.source_density_per_1000_words,
+            claim_density_per_1000_words: reportQuality.claim_density_per_1000_words,
+            template_phrase_hits: reportQuality.repetition?.template_phrase_hits || [],
+            synthesis: {
+                writer: synthesisOutput ? (sourceLedger?.mode === 'selftest_mock' ? 'mock' : 'codex-sdk evidence-bound writer') : 'missing',
+                repetition_ratio: reportQuality.repetition?.repeated_paragraph_ratio ?? null,
+                source_density_per_1000_words: reportQuality.source_density_per_1000_words,
+                claim_density_per_1000_words: reportQuality.claim_density_per_1000_words,
+                template_phrase_hits: reportQuality.repetition?.template_phrase_hits || [],
+                codex_final_review_verdict: finalReview?.codex_review?.verdict || null
+            },
             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,
@@ -1441,56 +1455,50 @@ export async function writeMockResearchResult(dir, plan) {
     await writeJsonAtomic(path.join(dir, 'falsification-ledger.json'), falsificationLedger);
     await writeJsonAtomic(path.join(dir, 'novelty-ledger.json'), ledger);
     await writeTextAtomic(path.join(dir, RESEARCH_GENIUS_SUMMARY_ARTIFACT), `${geniusSummary}\n`);
-    const evidenceParagraphs = Array.from({ length: 72 }, (_unused, index) => {
-        const claimId = mockClaimIds[index % mockClaimIds.length];
-        const sourceA = `mock-source-${(index % RESEARCH_SOURCE_LAYERS.length) + 1}`;
-        const sourceB = `mock-source-${(index % RESEARCH_SOURCE_LAYERS.length) + 8}`;
-        const counter = index % 2 === 0 ? 'mock-counter-1' : 'mock-counter-2';
-        return `Quality note ${index + 1}: claim ${claimId} is treated as a falsifiable research-pipeline assertion, not a fact about live web evidence. The mock run cites ${sourceA} and ${sourceB}, compares the claim with ${counter}, and preserves the implementation handoff as read-only evidence. This repeated fixture text deliberately keeps the selftest report above the quality-contract word floor while still naming the same source-ledger ids that the gate verifies.`;
+    const mockSourceIds = [...mockLayerSources.map((source) => source.id), 'mock-counter-1', 'mock-counter-2'];
+    const mockCounterIds = ['mock-counter-1', 'mock-counter-2'];
+    const researchReportText = buildRealisticResearchReport({
+        plan,
+        claims: claimMatrix.claims,
+        sourceIds: mockSourceIds,
+        counterevidenceIds: mockCounterIds,
+        blueprint,
+        falsificationLedger,
+        experimentPlan,
+        replicationPack
+    });
+    const researchPaperText = buildRealisticResearchPaper({
+        plan,
+        claims: claimMatrix.claims,
+        sourceIds: mockSourceIds,
+        counterevidenceIds: mockCounterIds
+    });
+    const reportQuality = analyzeResearchReportQuality(researchReportText);
+    await writeJsonAtomic(path.join(dir, 'research-synthesis-output.json'), {
+        schema: 'sks.research-synthesis-output.v1',
+        mission_id: plan?.mission_id || '',
+        generated_at: nowIso(),
+        report_markdown: researchReportText,
+        paper_markdown: researchPaperText,
+        synthesis_summary: {
+            key_claim_ids: claimMatrix.key_claim_ids,
+            source_ids_used: mockSourceIds,
+            counterevidence_ids_used: mockCounterIds,
+            blueprint_sections_used: blueprint.sections.map((section) => section.id),
+            experiment_steps_used: experimentPlan.steps.map((step) => step.id)
+        },
+        quality_signals: {
+            report_word_count: reportQuality.word_count,
+            source_citation_count: reportQuality.source_id_mentions.length,
+            unique_source_ids_cited: mockSourceIds.filter((id) => researchReportText.includes(id)).length,
+            key_claims_covered: claimMatrix.key_claim_ids.filter((id) => researchReportText.includes(id)).length,
+            repeated_paragraph_ratio: reportQuality.repetition.repeated_paragraph_ratio,
+            template_phrase_hits: reportQuality.repetition.template_phrase_hits
+        },
+        blockers: reportQuality.blockers
     });
-    const researchReportText = [
-        '# SKS Research Report',
-        '',
-        `Prompt: ${plan.prompt}`,
-        '',
-        '## Question',
-        'Can SKS Research Mode close a research mission only when it has enough sourced claims, counterevidence, falsification, implementation handoff material, and replication evidence to support a downstream execution route?',
-        '',
-        '## Methodology',
-        'This mock run is a selftest fixture, so it does not claim live web retrieval. It exercises the same artifact contract that real research must satisfy: layered source ledger entries, source quality fields, claim-evidence matrix rows, falsification cases, a blueprint, an experiment plan, a replication pack, and a final reviewer decision.',
-        '',
-        '## Source Map',
-        'The source ledger contains two mock sources per source layer plus two counterevidence records. The source ids include mock-source-1 through mock-source-14, and the counterevidence ids include mock-counter-1 and mock-counter-2. Each source row includes layer, kind, locator, publisher_or_author, accessed_at, reliability, credibility, stance, and claim_ids.',
-        '',
-        '## Key Claims',
-        ...ledger.entries.map((entry) => `- ${entry.id}: ${entry.claim} Sources: ${(entry.source_ids || []).join(', ')}. Counterevidence: ${(entry.counterevidence_ids || entry.falsifiers || []).join(', ')}.`),
-        '',
-        '## Evidence Matrix Summary',
-        `The claim-evidence matrix records ${claimMatrix.key_claim_ids.length} key claims and ${claimMatrix.triangulated_claim_count} triangulated claims. Each critical or high-importance claim has at least one source id and one counterevidence id, and each hypothesis has a test_or_probe field for follow-up validation.`,
-        '',
-        '## Counterevidence',
-        'The first counterexample, mock-counter-1, attacks overclaiming without decisive tests. The second counterexample, mock-counter-2, attacks missing replication and thin experiment plans. Both are intentionally simple but give the gate two independent counterevidence entries to verify.',
-        '',
-        '## Falsification',
-        'The falsification ledger includes four cases. They attack summary-only output, missing independent confirmation, absent counterevidence, and absent replication. The cases survive only as gate-backed requirements, not as proof that the mock topic was researched on the live web.',
-        '',
-        '## Implementation Blueprint',
-        'The implementation blueprint has eight sections: problem, decision, architecture, interfaces, data contracts, execution plan, verification plan, and risks and rollbacks. The key point is that Research does not change repository source. It creates a handoff for a later $Team route that can validate the research and then decide what to implement.',
-        '',
-        '## Experiment / Validation Plan',
-        'The experiment plan contains five steps: compare a baseline and research output, score cited key claims, run the smallest implementation probe, compare falsification outcomes, and record replication commands. The replication pack lists the commands and expected artifacts needed to reproduce the gate.',
-        '',
-        '## Limitations',
-        'This is mock evidence for harness verification. It proves the local artifact contract and gate behavior, not live research accuracy. A normal non-mock run must still collect real sources and must keep the gate blocked if source access is unavailable.',
-        '',
-        '## References',
-        '- mock-source-1 through mock-source-14: layered mock sources generated by writeMockResearchResult.',
-        '- mock-counter-1 and mock-counter-2: counterevidence fixtures generated by writeMockResearchResult.',
-        '',
-        ...evidenceParagraphs
-    ].join('\n\n');
     await writeTextAtomic(path.join(dir, 'research-report.md'), `${researchReportText}\n`);
-    await writeTextAtomic(path.join(dir, paperArtifact), `# 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 agents 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 writeTextAtomic(path.join(dir, paperArtifact), `${researchPaperText}\n`);
     await writeJsonAtomic(path.join(dir, 'research-gate.json'), {
         ...defaultResearchGate(),
         passed: true,
@@ -1536,6 +1544,10 @@ export async function writeMockResearchResult(dir, plan) {
         missing_evidence: [],
         blueprint_findings: ['mock complete package fixture has implementation blueprint sections'],
         falsification_findings: ['mock complete package fixture has counterevidence and falsification cases'],
+        template_like_prose: false,
+        source_density_ok: true,
+        implementation_concreteness_ok: true,
+        evidence_bound_synthesis_ok: true,
         required_revisions: [],
         confidence: 'high',
         mock: true

package/dist/core/routes.js

@@ -355,11 +355,15 @@ export const ROUTES = [
         id: 'Team',
         command: '$Team',
         mode: 'TEAM',
-        route: 'multi-agent team orchestration',
-        description: 'Run substantial work through Team only when the proof cone is broad enough: native agents, TriWiki, debate, runtime task graph, fresh executors, review, cleanup, reflection, and Honest Mode.',
+        route: 'deprecated alias to Naruto',
+        description: 'Deprecated compatibility alias. New substantial work is routed to $Naruto, the native shadow-clone swarm SSOT.',
         requiredSkills: ['team', 'pipeline-runner', 'context7-docs', 'prompt-pipeline', REFLECTION_SKILL_NAME, 'honest-mode'],
         dollarAliases: ['$From-Chat-IMG'],
         appSkillAliases: ['from-chat-img'],
+        deprecated: true,
+        hidden: true,
+        aliasTo: '$Naruto',
+        deprecationMessage: '$Team is deprecated and redirects new execution missions to $Naruto. Existing Team observation commands remain available for old missions.',
         lifecycle: ['native_agent_intake', 'triwiki_refresh', 'planning_debate', 'live_transcript', 'consensus_artifact', 'fresh_implementation_team', 'review_artifact', 'integration_evidence', 'session_cleanup', 'post_route_reflection', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
@@ -373,13 +377,13 @@ export const ROUTES = [
         mode: 'NARUTO',
         route: 'hardware-safe massive parallel work swarm',
         description: '$Naruto mode launches a hardware-safe massive parallel work swarm. Clones may implement, modify, verify, test, research, document, and resolve conflicts according to role and lease policy; write-capable output is accepted only through patch envelopes, verification DAG, mutation guard, and GPT final arbiter.',
-        requiredSkills: ['team', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
+        requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
         dollarAliases: ['$ShadowClone', '$Kagebunshin'],
         appSkillAliases: ['shadow-clone', 'kage-bunshin'],
         lifecycle: ['clone_roster_build', 'massive_work_graph', 'hardware_safe_governor', 'dynamic_active_pool', 'lease_based_write_swarm', 'parallel_verification_dag', 'gpt_final_arbiter_pack', 'per_clone_proof', 'session_cleanup', 'honest_mode'],
         context7Policy: 'optional',
         reasoningPolicy: 'high',
-        stopGate: 'team-gate.json',
+        stopGate: 'naruto-gate.json',
         cliEntrypoint: 'sks naruto run "task" [--clones N] [--backend codex-sdk|fake|ollama] [--parallel-write] | sks naruto status',
         examples: ['$Naruto run sweep the codebase for TODO comments with 50 clones', '$ShadowClone --clones 100 fan out and draft tests for every module']
     },
@@ -598,7 +602,7 @@ export const ROUTES = [
         examples: ['$Help show available SKS commands']
     }
 ];
-export const DOLLAR_COMMANDS = ROUTES.flatMap(({ command, route, description, dollarAliases = [] }) => [
+export const DOLLAR_COMMANDS = ROUTES.filter((route) => route.hidden !== true).flatMap(({ command, route, description, dollarAliases = [] }) => [
     { command, route, description },
     ...dollarAliases.map((alias) => ({ command: alias, route, description }))
 ]);
@@ -632,11 +636,11 @@ export const COMMAND_CATALOG = [
     { name: 'auth', usage: 'sks auth status|health|repair|setup --host <domain> --api-key <key>', description: 'Shortcut for codex-lb provider auth status, health, repair, and setup commands.' },
     { name: 'openclaw', usage: 'sks openclaw install|path|print [--dir path] [--force] [--json]', description: 'Generate an OpenClaw skill package so OpenClaw agents can discover and use local SKS workflows.' },
     { name: 'hermes', usage: 'sks hermes install|status|path|print [--dir path] [--force] [--json]', description: 'Generate a Hermes Agent skill package so Hermes agents can discover and use local SKS workflows.' },
-    { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks team open-zellij latest | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD and Team lane UI.' },
+    { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks naruto dashboard latest | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD and Naruto lane UI.' },
     { name: 'tmux', usage: 'sks tmux [--json]', description: 'Show the removed-runtime migration notice and point operators to Zellij.' },
     { name: 'mad', usage: 'sks --mad [--high]', description: 'Open a one-shot Zellij Codex CLI workspace with the SKS MAD full-access auto-review profile.' },
     { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch SKS Zellij with the auto-review profile.' },
-    { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Team.' },
+    { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Naruto.' },
     { name: 'fast-mode', usage: 'sks fast-mode on|off|status|clear [--json]', description: 'Toggle the project-local Fast mode default used by $Fast-On, $Fast-Off, and native-agent routes.' },
     { name: 'with-local-llm', usage: 'sks with-local-llm on|off|status|set-model [--json]', description: 'Toggle the optional local Ollama worker backend used by $with-local-llm-on/$with-local-llm-off and eligible simple worker slices.' },
     { name: 'commit', usage: 'sks commit [--message "msg"] [--json]', description: 'Stage current changes, summarize them, and create a simple git commit without the full SKS pipeline.' },
@@ -681,7 +685,7 @@ export const COMMAND_CATALOG = [
     { name: 'wiki', usage: 'sks wiki coords|pack|refresh|publish|rebuild-index|validate|validate-shared|wrongness ...', description: 'Build, refresh, publish shared shards, rebuild ignored indexes, validate, and attach wrongness-memory context to RGBA/trig LLM Wiki packs with attention.use_first and attention.hydrate_first for compact recall plus source hydration.' },
     { name: 'hproof', usage: 'sks hproof check [mission-id|latest]', description: 'Evaluate the H-Proof done gate for a mission.' },
     { name: 'agent', usage: 'sks agent run|status|close|cleanup <mission-id|latest> [--agents N] [--work-items N] [--target-active-slots N] [--mock] [--apply|--dry-run] [--drain] [--stale-ms N] [--json] | sks agent rollback-patches [mission-id|latest] [--patch-entry-id id] [--dry-run|--apply] [--json]', description: 'Run, inspect, close, clean, or rollback native multi-session agent missions with agents as target active slots, work items as the route queue size, cleanup executor proof for stale runtime resources, and patch rollback proof for applied patch entries.' },
-    { name: 'team', usage: 'sks team "task" [executor:5 reviewer:6 user:1] [--work-items N] [--target-active-slots N]|log|tail|watch|lane|status|dashboard|event|message|open-zellij|attach-zellij|cleanup-zellij ...', description: 'Create and observe a native-agent-first Team mission with at least five reviewer/QA validation lanes, current-session managed Zellij lanes when available, transcript messages, and cleanup-aware follow panes.' },
+    { name: 'team', usage: 'sks team \"task\" | sks team log|tail|watch|lane|status|dashboard|event|message|open-zellij|attach-zellij|cleanup-zellij ...', description: 'Deprecated compatibility command: new tasks redirect to Naruto; observation subcommands remain for old Team missions.' },
     { name: 'reasoning', usage: 'sks reasoning ["prompt"] [--json]', description: 'Show SKS temporary reasoning-effort routing: medium for simple tasks, high for logic, xhigh for research.' },
     { name: 'gx', usage: 'sks gx init|render|validate|drift|snapshot [name]', description: 'Create and verify deterministic SVG/HTML visual context cartridges.' },
     { name: 'profile', usage: 'sks profile show|set <model>', description: 'Inspect or set the current SKS model profile metadata.' },
@@ -819,14 +823,14 @@ export function routePrompt(prompt) {
             if (looksLikeAnswerOnlyRequest(afterModifier))
                 return routeById('Answer');
             if (looksLikeCodeChangingWork(afterModifier) || looksLikeDirectWorkRequest(afterModifier))
-                return routeById('Team');
+                return routeById('Naruto');
             return routeById('MadSKS');
         }
         const route = routeByDollarCommand(command) || routeById('SKS');
         if (route?.id === 'SKS' && looksLikeTeamDefaultWork(stripDollarCommand(text)))
-            return routeById('Team');
-        if (route?.id === 'Team')
-            return route;
+            return routeById('Naruto');
+        if (route?.id === 'Team' && command === 'TEAM')
+            return routeById('Naruto');
         return route;
     }
     if (hasFromChatImgSignal(text))
@@ -843,13 +847,13 @@ export function routePrompt(prompt) {
     if (looksLikeTinyDirectFix(text))
         return routeById('DFix');
     if (looksLikeQuestionShapedDirective(text))
-        return routeById('Team');
+        return routeById('Naruto');
     if (looksLikeAnswerOnlyRequest(text))
         return routeById('Answer');
     if (/\b(SQL|Supabase|Postgres|migration|RLS|Prisma|Drizzle|Knex|database|DB|execute_sql)\b/i.test(text))
         return routeById('DB');
     if (/\b(team|multi-agent|subagent|parallel agents|agent team)\b|병렬|팀/i.test(text))
-        return routeById('Team');
+        return routeById('Naruto');
     if (looksLikeChatCaptureRequest(text) && !looksLikeAnswerOnlyRequest(text))
         return routeById('Team');
     if (/\b(qa[-\s]?loop|qaloop|e2e\s+qa|qa\s+e2e)\b/i.test(text))
@@ -863,7 +867,7 @@ export function routePrompt(prompt) {
     if (/\b(GX|vgraph|visual context|render cartridge|wiki coordinate|rgba|trig|llm wiki)\b/i.test(text))
         return routeById('GX');
     if (looksLikeTeamDefaultWork(text))
-        return routeById('Team');
+        return routeById('Naruto');
     return routeById('SKS');
 }
 export function looksLikeComputerUseFastLane(prompt = '') {
@@ -941,7 +945,7 @@ export function routeNeedsContext7(route, prompt = '') {
 export function routeRequiresSubagents(route, prompt = '') {
     if (!route)
         return false;
-    if (route.id === 'Team')
+    if (route.id === 'Team' || route.id === 'Naruto')
         return true;
     if (route.id === 'SKS')
         return looksLikeTeamDefaultWork(prompt);
@@ -983,7 +987,7 @@ export function simpleGitOnlyRouteId(prompt = '') {
 }
 export function reflectionRequiredForRoute(route) {
     const id = String(route?.id || route?.mode || route?.route || route || '').replace(/^\$/, '');
-    return /^(team|qaloop|qa-loop|ppt|imageuxreview|image-ux-review|research|autoresearch|db|database|madsks|mad-sks|gx)$/i.test(id);
+    return /^(team|naruto|shadowclone|shadow-clone|kagebunshin|kage-bunshin|qaloop|qa-loop|ppt|imageuxreview|image-ux-review|research|autoresearch|db|database|madsks|mad-sks|gx)$/i.test(id);
 }
 export function looksLikeCodeChangingWork(prompt = '') {
     const text = String(prompt || '');
@@ -1012,7 +1016,7 @@ export function subagentExecutionPolicyText(route, prompt = '') {
     }
     return [
         'Native multi-session policy: REQUIRED for code-changing or execution work in this route.',
-        'The selected SKS route itself authorizes route-owned worker/reviewer native sessions; the user does not need to separately ask for helper sessions when the default Team pipeline is active.',
+        'The selected SKS route itself authorizes route-owned worker/reviewer native sessions; the user does not need to separately ask for helper sessions when the default Naruto pipeline is active.',
         'Before editing, the parent orchestrator must visibly state the SKS route, split independent write scopes, and run worker/reviewer native sessions whenever the route can be split safely.',
         'Run workers in parallel only with disjoint ownership. The parent owns integration, verification, and final evidence.',
         'If native sessions are unavailable or the work cannot be safely split, record explicit unavailable/unsplittable native-session evidence before editing.',
@@ -1027,7 +1031,7 @@ export function routeReasoning(route, prompt = '') {
         return reasoning('xhigh', 'from_chat_img_image_work_order_analysis');
     if (/(?:^|\s)sks\s+--mad\b|(?:^|\s)--mad\b|\$MAD-SKS\b|\bmad-sks\b|\bmadsks\b/i.test(text))
         return reasoning('xhigh', 'mad_sks_or_mad_launch_default');
-    if (route?.id === 'Team')
+    if (route?.id === 'Team' || route?.id === 'Naruto')
         return teamRouteReasoning(text);
     if (route?.id === 'Research' || route?.id === 'AutoResearch')
         return reasoning('xhigh', 'research_or_experiment_route');

package/dist/core/update/update-notice.js

@@ -0,0 +1,120 @@
+import https from 'node:https';
+import os from 'node:os';
+import path from 'node:path';
+import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+export const SKS_UPDATE_NOTICE_SCHEMA = 'sks.update-notice.v1';
+export async function checkSksUpdateNotice(input = {}) {
+    const env = input.env || process.env;
+    const packageName = input.packageName || env.SKS_UPDATE_NOTICE_PACKAGE || 'sneakoscope';
+    const currentVersion = input.currentVersion || env.SKS_PACKAGE_VERSION || '0.0.0';
+    const ttlMs = normalizePositiveInt(env.SKS_UPDATE_NOTICE_TTL_MS, 6 * 60 * 60 * 1000);
+    const cachePath = path.join(os.homedir(), '.sneakoscope', 'cache', 'update-notice.json');
+    if (env.SKS_DISABLE_UPDATE_NOTICE === '1' || env.SKS_UPDATE_NOTICE_DISABLE === '1' || env.SKS_UPDATE_NOTICE === '0') {
+        return persistNotice(input.missionDir, {
+            schema: SKS_UPDATE_NOTICE_SCHEMA,
+            checked_at: nowIso(),
+            package_name: packageName,
+            current_version: currentVersion,
+            latest_version: null,
+            update_available: false,
+            source: 'disabled',
+            cache_ttl_ms: ttlMs,
+            message: 'SKS update notice disabled by environment.'
+        });
+    }
+    const cached = await readJson(cachePath, null);
+    if (cached?.schema === SKS_UPDATE_NOTICE_SCHEMA && Date.now() - Date.parse(cached.checked_at || '') < ttlMs) {
+        return persistNotice(input.missionDir, { ...cached, source: 'cache', cache_ttl_ms: ttlMs });
+    }
+    try {
+        const latest = await npmLatest(packageName, input.timeoutMs || normalizePositiveInt(env.SKS_UPDATE_NOTICE_TIMEOUT_MS, 1500));
+        const updateAvailable = compareVersions(latest, currentVersion) > 0;
+        const notice = {
+            schema: SKS_UPDATE_NOTICE_SCHEMA,
+            checked_at: nowIso(),
+            package_name: packageName,
+            current_version: currentVersion,
+            latest_version: latest,
+            update_available: updateAvailable,
+            source: 'npm-registry',
+            cache_ttl_ms: ttlMs,
+            message: updateAvailable
+                ? `SKS ${latest} is available; current ${currentVersion}. This notice is informational and does not block launch or release gates.`
+                : `SKS ${currentVersion} is current enough; update notice is informational.`
+        };
+        await ensureDir(path.dirname(cachePath));
+        await writeJsonAtomic(cachePath, notice).catch(() => undefined);
+        return persistNotice(input.missionDir, notice);
+    }
+    catch (err) {
+        const notice = {
+            schema: SKS_UPDATE_NOTICE_SCHEMA,
+            checked_at: nowIso(),
+            package_name: packageName,
+            current_version: currentVersion,
+            latest_version: cached?.latest_version || null,
+            update_available: false,
+            source: 'error',
+            cache_ttl_ms: ttlMs,
+            message: 'SKS update notice could not reach npm; launch continues without blocking.',
+            error: err?.message || String(err)
+        };
+        return persistNotice(input.missionDir, notice);
+    }
+}
+async function persistNotice(missionDir, notice) {
+    if (missionDir)
+        await writeJsonAtomic(path.join(missionDir, 'update-notice.json'), notice).catch(() => undefined);
+    return notice;
+}
+function npmLatest(packageName, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: 'registry.npmjs.org',
+            path: `/${encodeURIComponent(packageName).replace(/^%40/, '@')}/latest`,
+            method: 'GET',
+            timeout: timeoutMs,
+            headers: { Accept: 'application/json' }
+        }, (res) => {
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+                try {
+                    if ((res.statusCode || 0) < 200 || (res.statusCode || 0) >= 300)
+                        throw new Error(`npm_status_${res.statusCode}`);
+                    const parsed = JSON.parse(body);
+                    if (!parsed?.version)
+                        throw new Error('npm_latest_version_missing');
+                    resolve(String(parsed.version));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.on('timeout', () => {
+            req.destroy(new Error('update_notice_timeout'));
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}
+function compareVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+        const delta = (a[i] || 0) - (b[i] || 0);
+        if (delta !== 0)
+            return delta;
+    }
+    return 0;
+}
+function parseVersion(value) {
+    return String(value || '').split(/[.-]/).map((part) => Number(part)).map((part) => Number.isFinite(part) ? part : 0);
+}
+function normalizePositiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+//# sourceMappingURL=update-notice.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.14';
+export const PACKAGE_VERSION = '2.0.16';
 //# sourceMappingURL=version.js.map