sneakoscope 4.8.7 → 5.3.0

package/dist/core/commands/naruto-command.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { ui as cliUi } from '../../cli/cli-theme.js';
 import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
 import { nowIso, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
@@ -41,6 +42,10 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return glmNarutoCommand(args.filter((arg) => arg !== '--glm'));
     }
     const parsed = parseNarutoArgs(args);
+    if (!parsed.json)
+        cliUi.banner(parsed.action === 'run' ? 'swarm' : `naruto ${parsed.action}`);
+    if (!parsed.json && parsed.action !== 'run')
+        cliUi.ok('naruto command surface ready');
     if (parsed.action === 'help')
         return narutoHelp(parsed);
     if (parsed.action === 'status')
@@ -125,7 +130,8 @@ async function narutoRun(parsed) {
         writeCapable,
         leaseBasePath: patchEnvelopeBasePath,
         maxActiveWorkers: parsed.concurrency || safe.cap,
-        worktreePolicy
+        worktreePolicy,
+        tournament: parsed.tournament
     });
     const baseRoleDistribution = buildNarutoRoleDistribution(baseWorkGraph.work_items, { readonly: parsed.readonly });
     const allocationWorkers = buildNarutoAllocationWorkers(baseWorkGraph, baseRoleDistribution, roster);
@@ -140,7 +146,8 @@ async function narutoRun(parsed) {
         leaseBasePath: patchEnvelopeBasePath,
         maxActiveWorkers: parsed.concurrency || safe.cap,
         worktreePolicy,
-        allocationAssignments
+        allocationAssignments,
+        tournament: parsed.tournament
     });
     const roleDistribution = buildNarutoRoleDistribution(workGraph.work_items, { readonly: parsed.readonly });
     const allocationPolicy = {
@@ -407,9 +414,12 @@ async function narutoRun(parsed) {
     const finalAccepted = result.proof?.status === 'passed' || result.proof?.gpt_final_status === 'approved';
     const parallelRuntimeOk = !parsed.mock || roster.agent_count < 16 || (parallelRuntime?.passed === true
         && Number(parallelRuntime.max_observed_active_workers || 0) >= Math.min(16, activeSlots));
+    const regressionProof = summarizeRegressionProof(workGraph, result);
+    await writeJsonAtomic(path.join(mission.dir, 'regression-proof-summary.json'), regressionProof);
+    const tddOk = !regressionProof.required || (regressionProof.regression_test_added && regressionProof.regression_test_failed_before_fix && regressionProof.regression_test_passed_after_fix);
     await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
         schema: 'sks.naruto-gate.v1',
-        passed: result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk,
+        passed: result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk && tddOk,
         mission_id: mission.id,
         clone_roster_built: true,
         clone_count: roster.agent_count,
@@ -424,9 +434,13 @@ async function narutoRun(parsed) {
         zellij_dashboard_ready: zellijDashboard.ok === true,
         native_agent_proof: nativeProofOk,
         parallel_runtime_proof: parallelRuntimeOk,
+        regression_test_added: regressionProof.regression_test_added,
+        regression_test_failed_before_fix: regressionProof.regression_test_failed_before_fix,
+        regression_test_passed_after_fix: regressionProof.regression_test_passed_after_fix,
+        regression_proof: 'regression-proof-summary.json',
         final_arbiter_accepted: finalAccepted,
         session_cleanup: result.proof?.all_sessions_closed === true || nativeProofOk,
-        blockers: [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate'])],
+        blockers: [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate']), ...(tddOk ? [] : ['tdd_evidence_missing'])],
         updated_at: nowIso()
     });
     const clones = result.roster?.agent_count ?? roster.agent_count;
@@ -443,7 +457,7 @@ async function narutoRun(parsed) {
         generated_at: nowIso(),
         mission_id: mission.id
     });
-    const summaryOk = result.ok === true && (parsed.applyPatches === true ? finalizer.ok === true : finalizer.run_ok === true);
+    const summaryOk = result.ok === true && tddOk && (parsed.applyPatches === true ? finalizer.ok === true : finalizer.run_ok === true);
     await setCurrent(root, {
         mission_id: mission.id,
         route: 'Naruto',
@@ -457,7 +471,7 @@ async function narutoRun(parsed) {
         prompt: parsed.prompt
     });
     // 4.0.9: Write canonical stop-gate artifacts for hook resolution.
-    const narutoGatePassed = result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk;
+    const narutoGatePassed = result.ok === true && nativeProofOk && finalAccepted && parallelRuntimeOk && tddOk;
     await writeFinalStopGate({
         root,
         missionId: mission.id,
@@ -471,8 +485,14 @@ async function narutoRun(parsed) {
             tests_passed: summaryOk,
             route_evidence_passed: nativeProofOk && finalAccepted,
             native_session_split_evidence: nativeProofOk ? 'native_agent_proof' : null,
+            ...(regressionProof.required ? {
+                regression_test_added: regressionProof.regression_test_added,
+                regression_test_failed_before_fix: regressionProof.regression_test_failed_before_fix,
+                regression_test_passed_after_fix: regressionProof.regression_test_passed_after_fix,
+                regression_proof_path: 'regression-proof-summary.json'
+            } : { regression_proof_path: null }),
         },
-        blockers: summaryOk ? [] : [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate'])],
+        blockers: summaryOk ? [] : [...(result.proof?.blockers || []), ...(parallelRuntimeOk ? [] : ['naruto_parallel_runtime_proof_below_gate']), ...(tddOk ? [] : ['tdd_evidence_missing'])],
         nativeGateFile: 'naruto-gate.json',
     }).catch(() => null);
     const summary = {
@@ -544,6 +564,7 @@ async function narutoRun(parsed) {
             blockers: result.fast_mode_propagation.blockers || []
         } : null,
         finalizer,
+        regression_proof: regressionProof,
         proof: result.proof?.status || 'missing',
         run: compactNarutoRunResult(result),
         zellij: null
@@ -687,6 +708,32 @@ function summarizeNarutoLocalWorkerResult(localWorker, result) {
         backend_counts: backendCounts
     };
 }
+function summarizeRegressionProof(workGraph, result) {
+    const bugfixItems = (Array.isArray(workGraph?.work_items) ? workGraph.work_items : []).filter((item) => String(item?.kind || '') === 'bugfix');
+    const proofs = collectRegressionProofs(result).filter(validRegressionProof);
+    return {
+        schema: 'sks.regression-proof-summary.v1',
+        generated_at: nowIso(),
+        required: bugfixItems.length > 0,
+        bugfix_work_item_count: bugfixItems.length,
+        proof_count: proofs.length,
+        regression_test_added: bugfixItems.length === 0 ? true : proofs.some((proof) => String(proof.test_file || '').trim().length > 0),
+        regression_test_failed_before_fix: bugfixItems.length === 0 ? true : proofs.some((proof) => proof.failed_before === true),
+        regression_test_passed_after_fix: bugfixItems.length === 0 ? true : proofs.some((proof) => proof.passed_after === true),
+        test_files: [...new Set(proofs.map((proof) => String(proof.test_file || '')).filter(Boolean))],
+        blockers: bugfixItems.length === 0 || proofs.length > 0 ? [] : ['tdd_evidence_missing']
+    };
+}
+function collectRegressionProofs(result) {
+    const rows = Array.isArray(result?.results) ? result.results : [];
+    return rows.flatMap((row) => [
+        row?.regression_proof,
+        ...(Array.isArray(row?.patch_envelopes) ? row.patch_envelopes.map((envelope) => envelope?.regression_proof) : [])
+    ]).filter(Boolean);
+}
+function validRegressionProof(proof) {
+    return Boolean(proof && proof.failed_before === true && proof.passed_after === true && String(proof.test_file || '').trim());
+}
 async function narutoStatus(parsed) {
     const root = await sksRoot();
     const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root);
@@ -795,7 +842,7 @@ async function narutoHelp(parsed) {
         mode: 'NARUTO',
         description: 'Shadow Clone Swarm: fan out up to ' + MAX_NARUTO_AGENT_COUNT + ' parallel clone sessions.',
         usage: [
-            'sks naruto run "<task>" [--clones N] [--backend codex-sdk|fake|ollama|local-llm] [--local-model|--ollama|--no-ollama] [--work-items N] [--write-mode parallel|serial|off] [--apply-patches] [--dry-run-patches] [--real] [--readonly] [--json]',
+            'sks naruto run "<task>" [--clones N] [--backend codex-sdk|fake|ollama|local-llm] [--local-model|--ollama|--no-ollama] [--work-items N] [--tournament 2-4] [--write-mode parallel|serial|off] [--apply-patches] [--dry-run-patches] [--real] [--readonly] [--json]',
             'sks naruto status [--mission <id>] [--json]',
             'sks naruto proof latest [--messages 20] [--json]'
         ],
@@ -866,9 +913,10 @@ function parseNarutoArgs(args = []) {
     const smoke = hasFlag(args, '--smoke');
     const parallelism = normalizeParallelism(readOption(args, '--parallelism', 'extreme'));
     const messages = normalizeMessages(readOption(args, '--messages', '8'));
-    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--max-write-agents', '--service-tier', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism', '--messages']);
+    const tournament = normalizeTournament(readOption(args, '--tournament', '0'));
+    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--max-write-agents', '--service-tier', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url', '--parallelism', '--messages', '--tournament']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, workItemsExplicit, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, applyPatches, dryRunPatches, maxWriteAgents, fastMode, serviceTier, noFast, json, missionId, noOpenZellij, attach, smoke, parallelism, messages };
+    return { action, prompt, clones, workItems, workItemsExplicit, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, applyPatches, dryRunPatches, maxWriteAgents, fastMode, serviceTier, noFast, json, missionId, noOpenZellij, attach, smoke, parallelism, messages, tournament };
 }
 function normalizeParallelism(value) {
     const text = String(value || 'extreme').toLowerCase();
@@ -880,6 +928,12 @@ function normalizeMessages(value) {
     const parsed = Number(value);
     return Math.max(0, Math.min(100, Math.floor(Number.isFinite(parsed) ? parsed : 8)));
 }
+function normalizeTournament(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 2)
+        return 0;
+    return Math.max(2, Math.min(4, Math.floor(parsed)));
+}
 async function writeNarutoArtifacts(ledgerRoot, artifacts) {
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);
     await writeJsonAtomic(path.join(ledgerRoot, 'naruto-role-distribution.json'), artifacts.roleDistribution);

package/dist/core/commands/plan-command.js

@@ -0,0 +1,76 @@
+import path from 'node:path';
+import { flag } from '../../cli/args.js';
+import { printJson } from '../../cli/output.js';
+import { ui } from '../../cli/cli-theme.js';
+import { ensureDir, nowIso, projectRoot, writeTextAtomic } from '../fsx.js';
+export async function planCommand(args = []) {
+    const root = path.resolve(String(readOption(args, '--root', '') || await projectRoot()));
+    const prompt = positional(args).join(' ').trim() || String(readOption(args, '--task', '') || '').trim();
+    if (!prompt) {
+        console.error('Usage: sks plan "task" [--json]');
+        process.exitCode = 2;
+        return null;
+    }
+    const slug = slugify(prompt);
+    const file = path.join(root, '.sneakoscope', 'plans', `${slug}.md`);
+    await ensureDir(path.dirname(file));
+    const text = [
+        `# SKS Plan: ${prompt}`,
+        ``,
+        `Generated: ${nowIso()}`,
+        `Implementation Allowed: false`,
+        ``,
+        `## Goal`,
+        `- ${prompt}`,
+        ``,
+        `## Scope`,
+        `- Inspect the smallest relevant code and docs surface before editing.`,
+        `- Preserve existing SKS proof-first gates and lean-engineering policy.`,
+        ``,
+        `## Implementation Steps`,
+        `- Identify exact files and ownership boundaries.`,
+        `- Apply the smallest working change.`,
+        `- Update focused tests or release checks for changed behavior.`,
+        ``,
+        `## Acceptance Checks`,
+        `- Typecheck or targeted build passes.`,
+        `- Relevant SKS gate/report is written and current.`,
+        `- Final summary separates verified from unverified work.`,
+        ``,
+        `## Rollback Plan`,
+        `- Revert only files changed for this plan if verification fails.`
+    ].join('\n');
+    await writeTextAtomic(file, `${text}\n`);
+    const result = { schema: 'sks.plan-artifact.v1', ok: true, prompt, file: path.relative(root, file), implementation_allowed: false };
+    if (flag(args, '--json'))
+        return printJson(result);
+    ui.banner('plan');
+    ui.ok(result.file);
+    return result;
+}
+function positional(args) {
+    const out = [];
+    const optionsWithValue = new Set(['--root', '--task']);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] || '';
+        if (optionsWithValue.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith('--'))
+            out.push(arg);
+    }
+    return out;
+}
+function slugify(value) {
+    const base = value.toLowerCase().replace(/[^a-z0-9가-힣]+/gi, '-').replace(/^-+|-+$/g, '').slice(0, 60);
+    return base || `plan-${Date.now().toString(36)}`;
+}
+function readOption(args = [], name, fallback = null) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return args[index + 1];
+    const prefixed = args.find((arg) => String(arg).startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+//# sourceMappingURL=plan-command.js.map

package/dist/core/commands/ppt-command.js

@@ -1,13 +1,14 @@
 import path from 'node:path';
-import { projectRoot, readJson, writeJsonAtomic } from '../fsx.js';
+import { exists, projectRoot, readJson, writeJsonAtomic } from '../fsx.js';
 import { createMission, findLatestMission, loadMission } from '../mission.js';
 import { flag, readOption } from './command-utils.js';
 import { printJson } from '../../cli/output.js';
-import { writePptBuildArtifacts, writePptRouteArtifacts } from '../ppt.js';
+import { PPT_AUDIENCE_STRATEGY_ARTIFACT, PPT_CLEANUP_REPORT_ARTIFACT, PPT_FACT_LEDGER_ARTIFACT, PPT_GATE_ARTIFACT, PPT_HTML_ARTIFACT, PPT_IMAGE_ASSET_LEDGER_ARTIFACT, PPT_ITERATION_REPORT_ARTIFACT, PPT_PARALLEL_REPORT_ARTIFACT, PPT_PDF_ARTIFACT, PPT_RENDER_REPORT_ARTIFACT, PPT_REVIEW_LEDGER_ARTIFACT, PPT_REVIEW_POLICY_ARTIFACT, PPT_SOURCE_LEDGER_ARTIFACT, PPT_STORYBOARD_ARTIFACT, PPT_STYLE_TOKENS_ARTIFACT, writePptBuildArtifacts, writePptRouteArtifacts } from '../ppt.js';
 import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { writePptImagegenReviewFixture } from '../ppt-imagegen-review.js';
 import { PPT_IMAGEGEN_REVIEW_GATE_ARTIFACT, PPT_REVIEW_ARTIFACT_PATHS, pptReviewProofEvidence, writePptImagegenReviewArtifacts } from '../ppt-review/index.js';
 import { writeRouteCollaborationArtifacts } from '../agents/route-collaboration-ledger.js';
+import { requireCodexImagegen } from '../imagegen/require-imagegen.js';
 export async function pptCommand(command, args = []) {
     const root = await projectRoot();
     const action = args[0] || 'status';
@@ -25,14 +26,46 @@ export async function pptCommand(command, args = []) {
     const { dir, mission } = await loadMission(root, missionId);
     const contract = await readJson(path.join(dir, 'decision-contract.json'), { prompt: mission.prompt, answers: fixtureAnswers(), sealed_hash: 'ppt-fixture-contract' });
     if (action === 'build') {
+        if (!flag(args, '--mock')) {
+            const imagegenRequired = await requireCodexImagegen(root, { autoRepair: true, applyRepair: true });
+            if (!imagegenRequired.ok) {
+                const result = {
+                    schema: 'sks.ppt-build.v1',
+                    ok: false,
+                    status: 'blocked',
+                    mission_id: missionId,
+                    blocker: 'codex_imagegen_unavailable',
+                    imagegen_required: imagegenRequired,
+                    gate: {
+                        schema: 'sks.ppt-gate.v1',
+                        passed: false,
+                        status: 'blocked',
+                        blockers: ['codex_imagegen_unavailable'],
+                        imagegen_evidence: { passed: false, generated_image_evidence: false }
+                    }
+                };
+                process.exitCode = 1;
+                if (flag(args, '--json'))
+                    return printJson(result);
+                console.error('PPT build blocked: Codex App imagegen/gpt-image-2 is unavailable.');
+                for (const action of imagegenRequired.blocker?.next_actions || [])
+                    console.error(`- ${action}`);
+                return result;
+            }
+        }
         await writePptRouteArtifacts(dir, contract);
         const build = await writePptBuildArtifacts(dir, contract);
-        const proof = await maybeFinalizeRoute(root, { missionId, route: '$PPT', gateFile: 'ppt-gate.json', gate: build.gate, mock: flag(args, '--mock'), visual: true, artifacts: Object.keys(build.files || {}), claims: [{ id: 'ppt-build-fixture', status: 'verified_partial' }], command: { cmd: `sks ppt build ${missionId}`, status: 0 } });
-        const result = { schema: 'sks.ppt-build.v1', ok: proof.ok, mission_id: missionId, build, proof: proof.validation };
+        const gate = await evaluatePptGateArtifacts(dir, build.gate);
+        await writeJsonAtomic(path.join(dir, 'ppt-gate.json'), gate);
+        const proof = await maybeFinalizeRoute(root, { missionId, route: '$PPT', gateFile: 'ppt-gate.json', gate, mock: flag(args, '--mock'), visual: true, artifacts: Object.keys(build.files || {}), claims: [{ id: 'ppt-build-fixture', status: gate.passed ? 'verified_partial' : 'blocked' }], blockers: gate.blockers || [], command: { cmd: `sks ppt build ${missionId}`, status: gate.passed ? 0 : 1 } });
+        const ok = proof.ok === true && gate.passed === true;
+        const result = { schema: 'sks.ppt-build.v1', ok, mission_id: missionId, build: { ...build, gate }, proof: proof.validation, blockers: gate.blockers || [] };
         if (flag(args, '--json'))
             return printJson(result);
-        console.log(`PPT build: ${proof.ok ? 'ok' : 'blocked'} ${missionId}`);
-        if (!proof.ok)
+        console.log(`PPT build: ${ok ? 'ok' : 'blocked'} ${missionId}`);
+        if (!ok && gate.blockers?.length)
+            console.log(`Blockers: ${gate.blockers.join(', ')}`);
+        if (!ok)
             process.exitCode = 1;
         return result;
     }
@@ -105,6 +138,33 @@ async function pptImagegenReview(root, command, action, args = []) {
         console.log(`PPT imagegen review: ${result.ok ? 'ok' : 'blocked'} ${id}`);
         return result;
     }
+    if (!mockMode) {
+        const imagegenRequired = await requireCodexImagegen(root, { autoRepair: true, applyRepair: true });
+        if (!imagegenRequired.ok) {
+            const result = {
+                schema: 'sks.ppt-imagegen-review.v1',
+                ok: false,
+                status: 'blocked',
+                mission_id: id,
+                blocker: 'codex_imagegen_unavailable',
+                imagegen_required: imagegenRequired,
+                gate: {
+                    schema: 'sks.ppt-imagegen-review-gate.v1',
+                    passed: false,
+                    status: 'blocked',
+                    blockers: ['codex_imagegen_unavailable'],
+                    imagegen_evidence: { passed: false, generated_image_evidence: false }
+                }
+            };
+            process.exitCode = 1;
+            if (flag(args, '--json'))
+                return printJson(result);
+            console.error('PPT imagegen review blocked: Codex App imagegen/gpt-image-2 is unavailable.');
+            for (const action of imagegenRequired.blocker?.next_actions || [])
+                console.error(`- ${action}`);
+            return result;
+        }
+    }
     const artifacts = await writePptImagegenReviewArtifacts({
         root,
         dir,
@@ -168,12 +228,17 @@ async function pptFixture(root, command, args) {
         visualEvidence: { ppt_review: pptReviewProofEvidence(review.gate, review) },
         artifacts: [...Object.keys(build.files || {}), ...Object.values(PPT_REVIEW_ARTIFACT_PATHS), ...Object.values(native.artifacts || {})],
         claims: [{ id: 'ppt-fixture', status: 'verified_partial' }],
-        command: { cmd: `sks ${command} fixture --mock`, status: 0 }
+        blockers: gate.blockers || [],
+        statusHint: 'blocked',
+        command: { cmd: `sks ${command} fixture --mock`, status: 1 }
     });
-    const result = { schema: 'sks.ppt-fixture.v2', ok: proof.ok && native.ok, mission_id: id, build: { ...build, ok: true, gate }, imagegen_review: review, native_agent_collaboration: native, proof: proof.validation };
-    if (flag(args, '--json'))
+    const result = { schema: 'sks.ppt-fixture.v2', ok: false, mission_id: id, build: { ...build, ok: false, gate }, imagegen_review: review, native_agent_collaboration: native, proof: proof.validation };
+    if (flag(args, '--json')) {
+        process.exitCode = 1;
         return printJson(result);
-    console.log(`PPT fixture: ${proof.ok ? 'ok' : 'blocked'} ${id}`);
+    }
+    console.log(`PPT fixture: blocked ${id}`);
+    process.exitCode = 1;
     return result;
 }
 async function pptExplain(root, args = []) {
@@ -252,21 +317,91 @@ function missingMission(args) {
 function mockPptFixtureGate(gate = {}) {
     return {
         ...gate,
-        passed: true,
+        passed: false,
+        ok: false,
+        status: 'blocked',
+        execution_class: 'mock_fixture',
         mock_fixture: true,
-        unsupported_critical_claims_zero: true,
-        image_asset_policy_satisfied: true,
-        bounded_iteration_complete: true,
-        critical_review_issues_zero: true,
-        render_report_passed: true,
-        fact_ledger_passed: true,
-        image_asset_ledger_passed: true,
-        review_ledger_passed: true,
-        iteration_report_passed: true,
-        cleanup_report_passed: true,
-        parallel_report_passed: true,
-        honest_mode_complete: true,
-        blockers: []
+        unsupported_critical_claims_zero: false,
+        image_asset_policy_satisfied: false,
+        bounded_iteration_complete: false,
+        critical_review_issues_zero: false,
+        render_report_passed: false,
+        fact_ledger_passed: false,
+        image_asset_ledger_passed: false,
+        review_ledger_passed: false,
+        iteration_report_passed: false,
+        cleanup_report_passed: false,
+        parallel_report_passed: false,
+        honest_mode_complete: false,
+        blockers: ['ppt_fixture_mode_cannot_claim_real']
+    };
+}
+export async function evaluatePptGateArtifacts(dir, baseGate = {}) {
+    const factLedger = await readJson(path.join(dir, PPT_FACT_LEDGER_ARTIFACT), null);
+    const imageAssetLedger = await readJson(path.join(dir, PPT_IMAGE_ASSET_LEDGER_ARTIFACT), null);
+    const reviewLedger = await readJson(path.join(dir, PPT_REVIEW_LEDGER_ARTIFACT), null);
+    const iterationReport = await readJson(path.join(dir, PPT_ITERATION_REPORT_ARTIFACT), null);
+    const renderReport = await readJson(path.join(dir, PPT_RENDER_REPORT_ARTIFACT), null);
+    const cleanupReport = await readJson(path.join(dir, PPT_CLEANUP_REPORT_ARTIFACT), null);
+    const parallelReport = await readJson(path.join(dir, PPT_PARALLEL_REPORT_ARTIFACT), null);
+    const requiredArtifacts = [
+        'decision-contract.json',
+        PPT_AUDIENCE_STRATEGY_ARTIFACT,
+        PPT_SOURCE_LEDGER_ARTIFACT,
+        PPT_FACT_LEDGER_ARTIFACT,
+        PPT_IMAGE_ASSET_LEDGER_ARTIFACT,
+        PPT_STORYBOARD_ARTIFACT,
+        PPT_STYLE_TOKENS_ARTIFACT,
+        PPT_REVIEW_POLICY_ARTIFACT,
+        PPT_REVIEW_LEDGER_ARTIFACT,
+        PPT_ITERATION_REPORT_ARTIFACT,
+        PPT_HTML_ARTIFACT,
+        PPT_PDF_ARTIFACT,
+        PPT_RENDER_REPORT_ARTIFACT,
+        PPT_CLEANUP_REPORT_ARTIFACT,
+        PPT_PARALLEL_REPORT_ARTIFACT
+    ];
+    const missing = [];
+    for (const artifact of requiredArtifacts) {
+        if (!(await exists(path.join(dir, artifact))))
+            missing.push(artifact);
+    }
+    const renderReportPassed = renderReport?.passed === true;
+    const factLedgerPassed = factLedger?.passed === true && Number(factLedger.unsupported_critical_claims_count || 0) === 0;
+    const imageAssetLedgerPassed = imageAssetLedger?.passed === true;
+    const imagegenEvidence = imageAssetLedger?.imagegen_evidence || { schema: 'sks.ppt-imagegen-evidence.v1', required: false, passed: true, blockers: [] };
+    const imagegenEvidencePassed = imagegenEvidence?.required === true ? imagegenEvidence?.passed === true : true;
+    const reviewLedgerPassed = reviewLedger?.passed === true;
+    const iterationReportPassed = iterationReport?.passed === true;
+    const cleanupReportPassed = cleanupReport?.source_html_preserved === true && cleanupReport?.temp_cleanup_completed === true;
+    const parallelReportPassed = parallelReport?.passed === true;
+    const blockers = [
+        ...missing.map((artifact) => `missing_artifact:${artifact}`),
+        ...(renderReportPassed ? [] : ['render_report_not_passed']),
+        ...(factLedgerPassed ? [] : ['fact_ledger_not_passed']),
+        ...(imageAssetLedgerPassed ? [] : ['image_asset_ledger_not_passed']),
+        ...(imagegenEvidencePassed ? [] : ['ppt_imagegen_evidence_not_passed']),
+        ...(reviewLedgerPassed ? [] : ['review_ledger_not_passed']),
+        ...(iterationReportPassed ? [] : ['iteration_report_not_passed']),
+        ...(cleanupReportPassed ? [] : ['cleanup_report_not_passed']),
+        ...(parallelReportPassed ? [] : ['parallel_report_not_passed'])
+    ];
+    const passed = blockers.length === 0;
+    return {
+        ...baseGate,
+        passed,
+        ok: passed,
+        status: passed ? 'pass' : 'blocked',
+        render_report_passed: renderReportPassed,
+        fact_ledger_passed: factLedgerPassed,
+        image_asset_ledger_passed: imageAssetLedgerPassed,
+        imagegen_evidence: imagegenEvidence,
+        review_ledger_passed: reviewLedgerPassed,
+        iteration_report_passed: iterationReportPassed,
+        cleanup_report_passed: cleanupReportPassed,
+        parallel_report_passed: parallelReportPassed,
+        blockers
     };
 }
 function fixtureAnswers() {

package/dist/core/commands/qa-loop-command.js

@@ -75,7 +75,9 @@ async function qaLoopPrepare(args) {
         const artifactResult = await writeQaLoopArtifacts(dir, { id, prompt, mode: 'qaloop' }, result.contract);
         const nativeAgentPlan = await writeQaNativeAgentLedger(dir, { id, prompt, reportFile: artifactResult.report_file });
         await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.prepare.auto_sealed', slots: 0, hash: result.contract.sealed_hash, checklist_count: artifactResult.checklist_count });
-        await setCurrent(root, { mission_id: id, route: 'QALoop', route_command: '$QA-LOOP', mode: 'QALOOP', phase: 'QALOOP_CLARIFICATION_CONTRACT_SEALED', questions_allowed: false, implementation_allowed: true, clarification_required: false, clarification_passed: true, ambiguity_gate_required: true, ambiguity_gate_passed: true, stop_gate: 'qa-gate.json', qa_loop_artifacts_ready: true, qa_report_file: artifactResult.report_file, qa_checklist_count: artifactResult.checklist_count, reasoning_effort: 'high', reasoning_profile: 'sks-logic-high', reasoning_temporary: true });
+        const clarificationPassed = true;
+        const ambiguityGatePassed = true;
+        await setCurrent(root, { mission_id: id, route: 'QALoop', route_command: '$QA-LOOP', mode: 'QALOOP', phase: 'QALOOP_CLARIFICATION_CONTRACT_SEALED', questions_allowed: false, implementation_allowed: true, clarification_required: false, clarification_passed: clarificationPassed, ambiguity_gate_required: true, ambiguity_gate_passed: ambiguityGatePassed, stop_gate: 'qa-gate.json', qa_loop_artifacts_ready: true, qa_report_file: artifactResult.report_file, qa_checklist_count: artifactResult.checklist_count, reasoning_effort: 'high', reasoning_profile: 'sks-logic-high', reasoning_temporary: true });
         if (flag(args, '--json'))
             return console.log(JSON.stringify({ schema: 'sks.qa-loop-prepare.v1', ok: true, mission_id: id, report_file: artifactResult.report_file, checklist_count: artifactResult.checklist_count, native_agent_plan: nativeAgentPlan }, null, 2));
         console.log(`QA-LOOP mission created: ${id}`);
@@ -111,7 +113,9 @@ async function qaLoopAnswer(args) {
     }
     const artifactResult = await writeQaLoopArtifacts(dir, mission, result.contract);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'qaloop.contract.sealed', hash: result.contract.sealed_hash, checklist_count: artifactResult.checklist_count });
-    await setCurrent(root, { mission_id: id, route: 'QALoop', route_command: '$QA-LOOP', mode: 'QALOOP', phase: 'QALOOP_CLARIFICATION_CONTRACT_SEALED', questions_allowed: false, implementation_allowed: true, clarification_required: false, clarification_passed: true, ambiguity_gate_passed: true, stop_gate: 'qa-gate.json', reasoning_effort: 'high', reasoning_profile: 'sks-logic-high', reasoning_temporary: true });
+    const clarificationPassed = true;
+    const ambiguityGatePassed = true;
+    await setCurrent(root, { mission_id: id, route: 'QALoop', route_command: '$QA-LOOP', mode: 'QALOOP', phase: 'QALOOP_CLARIFICATION_CONTRACT_SEALED', questions_allowed: false, implementation_allowed: true, clarification_required: false, clarification_passed: clarificationPassed, ambiguity_gate_passed: ambiguityGatePassed, stop_gate: 'qa-gate.json', reasoning_effort: 'high', reasoning_profile: 'sks-logic-high', reasoning_temporary: true });
     console.log(`QA-LOOP contract sealed for ${id}`);
 }
 async function qaLoopRun(args) {

package/dist/core/commands/release-command.js

@@ -1,7 +1,10 @@
 import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import fsp from 'node:fs/promises';
 import { flag } from '../../cli/args.js';
 import { printJson } from '../../cli/output.js';
-import { projectRoot } from '../fsx.js';
+import { exists, projectRoot, readJson, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { createMission } from '../mission.js';
 export async function releaseCommand(args = []) {
     const root = await projectRoot();
     const sub = args[0] && !args[0].startsWith('-') ? args[0] : 'affected';
@@ -12,18 +15,41 @@ export async function releaseCommand(args = []) {
         process.exitCode = 1;
         return null;
     }
+    const mission = await createMission(root, { mode: 'release-review', prompt: `Release review ${sub}` });
     const result = spawnSync(process.execPath, command.args, {
         cwd: root,
         encoding: 'utf8',
         maxBuffer: 1024 * 1024 * 20,
         env: { ...process.env, CI: process.env.CI || 'true' }
     });
+    const stdoutPath = path.join(mission.dir, 'release-command-stdout.log');
+    const stderrPath = path.join(mission.dir, 'release-command-stderr.log');
+    await writeTextAtomic(stdoutPath, String(result.stdout || ''));
+    await writeTextAtomic(stderrPath, String(result.stderr || ''));
+    const readiness = await findReleaseReadinessReport(root);
+    const requiredSections = ['five_lane_review', 'integration_evidence', 'session_cleanup'];
+    const missingSections = requiredSections.filter((section) => readiness.report?.[section] == null);
+    if (readiness.report)
+        await writeJsonAtomic(path.join(mission.dir, 'release-readiness-report.json'), readiness.report);
     const report = {
         schema: 'sks.release-command.v1',
-        ok: result.status === 0,
+        ok: result.status === 0 && readiness.valid === true && missingSections.length === 0,
         subcommand: sub,
+        mission_id: mission.id,
         command: [process.execPath, ...command.args],
         status: result.status,
+        release_report: readiness.path,
+        release_report_valid: readiness.valid,
+        missing_sections: missingSections,
+        blockers: [
+            ...(result.status === 0 ? [] : ['release_subprocess_failed']),
+            ...(readiness.valid ? [] : ['release_report_missing_or_invalid']),
+            ...missingSections.map((section) => `release_report_missing_section:${section}`)
+        ],
+        logs: {
+            stdout: path.relative(root, stdoutPath),
+            stderr: path.relative(root, stderrPath)
+        },
         stdout_tail: tail(String(result.stdout || '')),
         stderr_tail: tail(String(result.stderr || ''))
     };
@@ -37,6 +63,33 @@ export async function releaseCommand(args = []) {
         process.exitCode = result.status || 1;
     return report;
 }
+async function findReleaseReadinessReport(root) {
+    const candidates = [
+        path.join(root, 'release-readiness-report.json'),
+        path.join(root, '.sneakoscope', 'reports', 'release-readiness-report.json')
+    ];
+    const reportsDir = path.join(root, '.sneakoscope', 'reports');
+    const entries = await fsp.readdir(reportsDir).catch(() => []);
+    for (const entry of entries) {
+        if (/^release-readiness.*\.json$/.test(entry))
+            candidates.push(path.join(reportsDir, entry));
+    }
+    const existing = [];
+    for (const candidate of candidates) {
+        if (await exists(candidate)) {
+            const stat = await fsp.stat(candidate).catch(() => null);
+            existing.push({ path: candidate, mtime: stat?.mtimeMs || 0 });
+        }
+    }
+    existing.sort((a, b) => b.mtime - a.mtime);
+    const selected = existing[0]?.path || null;
+    const report = selected ? await readJson(selected, null) : null;
+    return {
+        path: selected ? path.relative(root, selected) : null,
+        report,
+        valid: Boolean(report && typeof report.schema === 'string' && /release-readiness/.test(report.schema))
+    };
+}
 function commandForSubcommand(sub) {
     if (sub === 'affected')
         return { args: ['dist/scripts/release-gate-dag-runner.js', '--preset', 'affected', '--changed-since', 'auto', '--sla', '5m'] };

package/dist/core/commands/research-command.js

@@ -180,7 +180,7 @@ async function researchRun(args) {
     await runResearchCycle(dir, researchWorkGraph, { cycle: 0, status: mock ? 'mock_native_orchestrator_planned' : 'native_orchestrator_planned' });
     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 });
-    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: flag(args, '--autoresearch') ? '$AutoResearch' : '$Research', prompt: mission.prompt || plan.prompt || 'Research run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount: effectiveDesiredWorkItemCount, minimumWorkItems: effectiveMinimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: true, profile, writeMode: writeMode, applyPatches: false, dryRunPatches, maxWriteAgents, roster: plan.native_agent_plan, routeCommand: 'sks research run', routeBlackboxKind: 'actual_research_command', narutoWorkGraph: researchWorkGraph });
+    const nativeAgentRun = await runNativeAgentOrchestrator({ root, missionId: id, route: flag(args, '--autoresearch') ? '$AutoResearch' : '$Research', prompt: mission.prompt || plan.prompt || 'Research run', backend: mock ? 'fake' : 'codex-sdk', mock, agents: requestedAgents, targetActiveSlots, desiredWorkItemCount: effectiveDesiredWorkItemCount, minimumWorkItems: effectiveMinimumWorkItems, maxQueueExpansion, concurrency: Math.min(requestedAgents, 5), readonly: !applyPatches, profile, writeMode: writeMode, applyPatches, dryRunPatches, maxWriteAgents, roster: plan.native_agent_plan, routeCommand: 'sks research run', routeBlackboxKind: 'actual_research_command', narutoWorkGraph: researchWorkGraph });
     await writeJsonAtomic(path.join(dir, 'research-native-agent-run.json'), nativeAgentRun);
     await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'research.native_agents.completed', backend: nativeAgentRun.backend, ok: nativeAgentRun.ok, proof: nativeAgentRun.proof?.status });
     if (!nativeAgentRun.ok) {