sneakoscope 6.0.3 → 6.1.2

package/dist/core/pipeline-internals/runtime-gates.js

@@ -119,6 +119,9 @@ function reflectionStopReason(state = {}, status = {}) {
 export async function projectGateStatus(root, state = {}) {
     const gates = [];
     const id = state?.mission_id || null;
+    const hasActiveGate = Boolean(id && state?.stop_gate && !['none', 'honest_mode', 'clarification-gate'].includes(state.stop_gate));
+    const activeGate = hasActiveGate ? await passedActiveGate(root, state) : null;
+    const activeGateNotApplicable = activeGate?.not_applicable === true;
     if (clarificationGatePending(state)) {
         gates.push({
             id: 'clarification-gate',
@@ -136,16 +139,16 @@ export async function projectGateStatus(root, state = {}) {
             source: id ? `.sneakoscope/missions/${id}/context7-evidence.jsonl` : '.sneakoscope/state/context7-evidence.jsonl'
         });
     }
-    if (state?.subagents_required) {
+    if (state?.subagents_required && !activeGateNotApplicable) {
         const evidence = await subagentEvidence(root, state);
         gates.push({
-            id: 'native-session-evidence',
+            id: 'official-subagent-evidence',
             ok: evidence.ok,
-            missing: evidence.ok ? [] : ['native_session_or_exception_evidence'],
-            source: id ? `.sneakoscope/missions/${id}/subagent-evidence.jsonl` : '.sneakoscope/state/subagent-evidence.jsonl'
+            missing: evidence.ok ? [] : (evidence.blockers || ['official_subagent_events_and_parent_summary']),
+            source: id ? `.sneakoscope/missions/${id}/subagent-evidence.json` : '.sneakoscope/state/subagents/subagent-evidence.json'
         });
     }
-    if (id && routeRequiresAgentIntake(routeFromState(state), { task: state.prompt, force: state.forceAgents === true, noAgents: state.agents_required === false })) {
+    if (id && !stateUsesOfficialSubagentWorkflow(state) && routeRequiresAgentIntake(routeFromState(state), { task: state.prompt, force: state.forceAgents === true, noAgents: state.agents_required === false })) {
         const agentGate = await readAgentGateStatus(root, id);
         gates.push({
             id: AGENT_INTAKE_STAGE_ID,
@@ -154,8 +157,8 @@ export async function projectGateStatus(root, state = {}) {
             source: `.sneakoscope/missions/${id}/agents/agent-proof-evidence.json`
         });
     }
-    if (id && state?.stop_gate && !['none', 'honest_mode', 'clarification-gate'].includes(state.stop_gate)) {
-        const active = await passedActiveGate(root, state);
+    if (hasActiveGate) {
+        const active = activeGate;
         gates.push({
             id: active.file || state.stop_gate,
             ok: active.ok,
@@ -194,6 +197,17 @@ export async function projectGateStatus(root, state = {}) {
     };
 }
 export async function evaluateStop(root, state, payload, opts = {}) {
+    // `sks route close` is the explicit terminal control for abandoning or
+    // superseding a route. Once it has closed the route, stale requirements
+    // from that route must not re-open native-agent, reflection, or proof gates
+    // on the next Stop hook invocation.
+    if (state?.route_closed === true) {
+        return {
+            continue: true,
+            action: 'route_closed',
+            systemMessage: `SKS: explicitly closed route accepted${state?.mission_id ? ` (${state.mission_id})` : ''}.`
+        };
+    }
     const last = extractLastMessage(payload);
     const jsonCache = new Map();
     if (clarificationGatePending(state)) {
@@ -213,9 +227,13 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     if (!opts.noQuestion && (stopGate === 'none' || stopGate === 'honest_mode') && !state?.context7_required && !state?.subagents_required && !completionProofRequired && !reflectionRequired) {
         return null;
     }
-    const agentIntakeRequired = state?.mission_id && routeRequiresAgentIntake(route, { task: state.prompt, force: state.forceAgents === true, noAgents: state.agents_required === false });
+    const activeGatePreview = state?.subagents_required
+        ? await passedActiveGate(root, state, jsonCache)
+        : null;
+    const activeGateNotApplicable = activeGatePreview?.not_applicable === true;
+    const agentIntakeRequired = state?.mission_id && !stateUsesOfficialSubagentWorkflow(state) && routeRequiresAgentIntake(route, { task: state.prompt, force: state.forceAgents === true, noAgents: state.agents_required === false });
     const context7Promise = state?.context7_required ? hasContext7DocsEvidence(root, state) : Promise.resolve(true);
-    const subagentPromise = state?.subagents_required ? hasSubagentEvidence(root, state) : Promise.resolve(true);
+    const subagentPromise = state?.subagents_required && !activeGateNotApplicable ? hasSubagentEvidence(root, state) : Promise.resolve(true);
     const completionProofPromise = agentIntakeRequired
         ? exists(path.join(missionDir(root, state.mission_id), 'completion-proof.json'))
         : Promise.resolve(true);
@@ -231,12 +249,15 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     if (state?.context7_required && !context7Ok) {
         return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} requires Context7 evidence before completion. Use Context7 resolve-library-id, then query-docs (or legacy get-library-docs), so SKS can record context7-evidence.jsonl.`, { gate: 'context7-evidence' });
     }
-    if (state?.subagents_required && !subagentOk) {
-        return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} requires native multi-session evidence before completion. Run worker/reviewer native sessions for disjoint code-changing work, or record explicit evidence that native sessions were unavailable or unsafe to split.`, { gate: 'native-session-evidence' });
+    if (state?.subagents_required && !activeGateNotApplicable && !subagentOk) {
+        const evidence = await subagentEvidence(root, state);
+        return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} requires official Codex subagent evidence before completion. Record matched SubagentStart/SubagentStop events for every requested agent thread, wait for all threads, and provide the parent integration summary. Missing: ${(evidence.blockers || ['official_subagent_events_and_parent_summary']).join(', ')}.`, { gate: 'official-subagent-evidence', missing: evidence.blockers });
     }
     if (agentIntakeRequired && !completionProofExists) {
         if (!agentGate.ok) {
-            return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route cannot continue to implementation/finalization: native agent intake gate is missing or blocked. Run: sks agent run latest --mock --json`, { gate: AGENT_INTAKE_STAGE_ID, missing: agentGate.missing || ['agents/agent-proof-evidence.json'] });
+            const missionArg = String(state.mission_id || '').trim() || '<mission-id>';
+            const routeArg = String(state.route_command || state.route || state.mode || '$Agent');
+            return complianceBlock(root, state, `SKS ${routeArg} route cannot continue to implementation/finalization: native agent intake gate is missing or blocked. Run: sks agent run --mission ${shellQuote(missionArg)} --route ${shellQuote(routeArg)} --agents 5 --json`, { gate: AGENT_INTAKE_STAGE_ID, missing: agentGate.missing || ['agents/agent-proof-evidence.json'] });
         }
     }
     if (!mistakeRecall.ok) {
@@ -255,15 +276,16 @@ export async function evaluateStop(root, state, payload, opts = {}) {
             };
         }
         if (gate.ok) {
+            const proofGate = await routeProofGateStatus(root, state);
+            if (!proofGate.ok) {
+                return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route cannot finalize without a valid Completion Proof. Missing or invalid proof issues: ${proofGate.issues.join(', ')}.`, { gate: 'completion-proof', missing: proofGate.issues });
+            }
             const coverage = await workOrderCoverageGateStatus(root, state);
             if (!coverage.ok)
                 return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route has unresolved work-order-ledger items (neither verified nor honestly blocked): ${coverage.blockers.join(', ')}.`, { gate: 'work-order-ledger', missing: coverage.blockers });
             const reflection = await reflectionGateStatus(root, state, jsonCache);
             if (!reflection.ok) {
-                const coverageRequiredRoute = routeById(routeFromState(state))?.coverage_required === true;
-                if (coverageRequiredRoute)
-                    return complianceBlock(root, state, reflectionStopReason(state, reflection), { gate: 'reflection', missing: reflection.missing });
-                await appendHonestModeNote(root, state, `reflection stale: ${(reflection.missing || []).join(', ')}`);
+                return complianceBlock(root, state, reflectionStopReason(state, reflection), { gate: 'reflection', missing: reflection.missing });
             }
             return { continue: true };
         }
@@ -285,10 +307,30 @@ export async function evaluateStop(root, state, payload, opts = {}) {
             });
             if (stopCheck.action === 'allow_stop') {
                 if (narutoFamily) {
+                    const activeGateNotApplicable = stopCheck.diagnostics.reason === 'gate_not_applicable';
+                    if (!activeGateNotApplicable) {
+                        const nativeGate = await readJson(path.join(missionDir(root, state.mission_id), 'naruto-gate.json'), null);
+                        const officialMissing = nativeGate
+                            ? [
+                                ...missingRequiredGateFields('naruto-gate.json', state, nativeGate),
+                                ...await missingNarutoArtifacts(root, state, nativeGate)
+                            ]
+                            : ['naruto-gate.json'];
+                        if (officialMissing.length) {
+                            return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route cannot stop yet. Official subagent evidence and the parent integration summary are incomplete. Missing: ${officialMissing.join(', ')}. Historical legacy artifacts are read only when the mission itself already carries an explicit legacy workflow marker; no environment switch can reactivate that runtime.`, { gate: 'official-subagent-evidence', missing: officialMissing });
+                        }
+                    }
                     const coverage = await workOrderCoverageGateStatus(root, state);
                     if (!coverage.ok)
                         return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route has unresolved work-order-ledger items (neither verified nor honestly blocked): ${coverage.blockers.join(', ')}.`, { gate: 'work-order-ledger', missing: coverage.blockers });
-                    return { continue: true, systemMessage: `SKS: canonical stop-gate passed at ${stopCheck.gate_path}` };
+                    const proofGate = await routeProofGateStatus(root, state);
+                    if (!proofGate.ok) {
+                        return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route cannot finalize without a valid Completion Proof. Missing or invalid proof issues: ${proofGate.issues.join(', ')}.`, { gate: 'completion-proof', missing: proofGate.issues });
+                    }
+                    const reflection = await reflectionGateStatus(root, state, jsonCache);
+                    if (!reflection.ok)
+                        return complianceBlock(root, state, reflectionStopReason(state, reflection), { gate: 'reflection', missing: reflection.missing });
+                    return { continue: true, systemMessage: `SKS: canonical stop-gate ${activeGateNotApplicable ? 'was not applicable and independent gates passed' : 'passed'} at ${stopCheck.gate_path}` };
                 }
             }
             else if (stopCheck.action === 'hard_blocked') {
@@ -329,6 +371,9 @@ export async function evaluateStop(root, state, payload, opts = {}) {
     fireAndForgetProjectMemory(root, state);
     return null;
 }
+function shellQuote(value) {
+    return `'${String(value ?? '').replace(/'/g, `'"'"'`)}'`;
+}
 function fireAndForgetProjectMemory(root, state = {}) {
     if (!state?.mission_id)
         return;
@@ -425,7 +470,7 @@ async function markReflectionInvalidatedForGateFailure(root, state = {}, detail
     const gate = String(detail.gate || state.stop_gate || '');
     if (!reflectionRequiredForState(state))
         return;
-    if (!gate || /^(reflection|context7-evidence|native-session-evidence|no-question|clarification)$/i.test(gate))
+    if (!gate || /^(reflection|context7-evidence|official-subagent-evidence|native-session-evidence|no-question|clarification)$/i.test(gate))
         return;
     await setCurrent(root, {
         mission_id: state.mission_id,
@@ -469,6 +514,23 @@ async function passedActiveGate(root, state, jsonCache) {
         const p = path.join(missionDir(root, id), file);
         const gate = await readJsonCached(jsonCache, p, null);
         if (gate) {
+            if (String(gate.status || '').trim().toLowerCase() === 'not_applicable') {
+                const reason = String(gate.reason || '').trim();
+                const missing = [];
+                if (!reason)
+                    missing.push('reason');
+                if (gate.blockers !== undefined && !Array.isArray(gate.blockers))
+                    missing.push('blockers_invalid');
+                else if (Array.isArray(gate.blockers) && gate.blockers.length > 0)
+                    missing.push('blockers');
+                if (gate.missing_fields !== undefined && !Array.isArray(gate.missing_fields))
+                    missing.push('missing_fields_invalid');
+                else if (Array.isArray(gate.missing_fields) && gate.missing_fields.length > 0)
+                    missing.push('missing_fields');
+                return missing.length
+                    ? { ok: false, file, missing }
+                    : { ok: true, file, not_applicable: true, reason };
+            }
             const missing = [
                 ...missingRequiredGateFields(file, state, gate),
                 ...await missingRequiredGateArtifacts(root, file, state, gate)
@@ -505,17 +567,6 @@ async function passedHardBlocker(root, state, jsonCache) {
     }
     return { ok: blocker.passed === true && hasReason && hasEvidence, file };
 }
-async function appendHonestModeNote(root, state = {}, message) {
-    if (!state?.mission_id)
-        return;
-    const dir = missionDir(root, state.mission_id);
-    await appendJsonl(path.join(dir, 'honest-mode-notes.jsonl'), {
-        ts: nowIso(),
-        type: 'honest_mode_note',
-        route: state.route_command || state.route || state.mode || null,
-        message
-    });
-}
 function missingRequiredGateFields(file, state, gate = {}) {
     const mode = String(state?.mode || '').toUpperCase();
     if (file === 'team-gate.json' || mode === 'TEAM') {
@@ -528,24 +579,32 @@ function missingRequiredGateFields(file, state, gate = {}) {
             .filter((key) => gate[key] !== true);
     }
     if (file === 'naruto-gate.json' || mode === 'NARUTO') {
-        const required = [
-            'clone_roster_built',
-            'work_graph_ready',
-            'role_distribution_ready',
-            'allocation_ready',
-            'rebalance_ready',
-            'concurrency_governor_ready',
-            'active_pool_ready',
-            'verification_dag_ready',
-            'gpt_final_pack_ready',
-            'zellij_dashboard_ready',
-            'native_agent_proof',
-            'final_arbiter_accepted',
-            'session_cleanup'
-        ];
+        const required = legacyNarutoWorkflowEnabled(state, gate)
+            ? [
+                'clone_roster_built',
+                'work_graph_ready',
+                'role_distribution_ready',
+                'allocation_ready',
+                'rebalance_ready',
+                'concurrency_governor_ready',
+                'active_pool_ready',
+                'verification_dag_ready',
+                'gpt_final_pack_ready',
+                'zellij_dashboard_ready',
+                'native_agent_proof',
+                'final_arbiter_accepted',
+                'session_cleanup'
+            ]
+            : ['subagent_plan_ready', 'official_subagent_evidence', 'parent_summary_present', 'session_cleanup'];
+        if (!legacyNarutoWorkflowEnabled(state, gate) && gate.workflow !== 'official_codex_subagent')
+            required.push('workflow');
+        if (!legacyNarutoWorkflowEnabled(state, gate) && gate.parent_model_match === false)
+            required.push('parent_model_match');
+        if (!legacyNarutoWorkflowEnabled(state, gate) && Array.isArray(gate.config_blockers) && gate.config_blockers.length)
+            required.push(...gate.config_blockers.map((item) => `config:${String(item)}`));
         if (fromChatImgCoverageRequired(state, gate))
             required.push('from_chat_img_request_coverage');
-        return required.filter((key) => gate[key] !== true);
+        return required.filter((key) => key.includes(':') || gate[key] !== true);
     }
     if (file === 'qa-gate.json' || mode === 'QALOOP') {
         const required = ['clarification_contract_sealed', 'qa_report_written', 'qa_ledger_complete', 'checklist_completed', 'safety_reviewed', 'deployed_destructive_tests_blocked', 'credentials_not_persisted', 'honest_mode_complete'];
@@ -816,6 +875,79 @@ function gateFilesForState(state) {
     return ['done-gate.json'];
 }
 async function missingNarutoArtifacts(root, state = {}, gate = {}) {
+    const id = state?.mission_id;
+    if (!id)
+        return ['mission_id'];
+    const dir = missionDir(root, id);
+    if (legacyNarutoWorkflowEnabled(state, gate))
+        return missingLegacyNarutoArtifacts(root, state, gate);
+    const required = [
+        'naruto-gate.json',
+        'subagent-plan.json',
+        'subagent-events.jsonl',
+        'subagent-parent-summary.json',
+        'subagent-evidence.json',
+        'naruto-summary.json'
+    ];
+    const missing = [];
+    for (const file of required) {
+        if (!(await exists(path.join(dir, file))))
+            missing.push(file);
+    }
+    const [plan, evidenceFile, summary, recomputedEvidence] = await Promise.all([
+        readJson(path.join(dir, 'subagent-plan.json'), null),
+        readJson(path.join(dir, 'subagent-evidence.json'), null),
+        readJson(path.join(dir, 'naruto-summary.json'), null),
+        subagentEvidence(root, state)
+    ]);
+    if (plan?.schema !== 'sks.subagent-plan.v1')
+        missing.push('subagent-plan.json:schema');
+    if (plan?.workflow !== 'official_codex_subagent')
+        missing.push('subagent-plan.json:workflow');
+    if (Number(plan?.requested_subagents || 0) < 1)
+        missing.push('subagent-plan.json:requested_subagents');
+    if (Number(plan?.max_threads || 0) < 1)
+        missing.push('subagent-plan.json:max_threads');
+    if (Number(plan?.max_depth || 0) !== 1)
+        missing.push('subagent-plan.json:max_depth');
+    if (!String(plan?.delegation_prompt || '').trim())
+        missing.push('subagent-plan.json:delegation_prompt');
+    if (plan?.parent_model_match === false)
+        missing.push('subagent-plan.json:parent_model_match');
+    if (evidenceFile?.schema !== 'sks.subagent-evidence.v1')
+        missing.push('subagent-evidence.json:schema');
+    if (evidenceFile?.workflow !== 'official_codex_subagent')
+        missing.push('subagent-evidence.json:workflow');
+    if (recomputedEvidence?.ok !== true)
+        missing.push(...(Array.isArray(recomputedEvidence?.blockers) && recomputedEvidence.blockers.length ? recomputedEvidence.blockers.map((item) => `subagent-evidence.json:${String(item)}`) : ['subagent-evidence.json:ok']));
+    if (recomputedEvidence?.parent_summary_present !== true || recomputedEvidence?.parent_summary_trustworthy !== true)
+        missing.push('subagent-evidence.json:parent_summary_trustworthy');
+    if (Number(recomputedEvidence?.requested_subagents || 0) !== Number(plan?.requested_subagents || 0))
+        missing.push('subagent-evidence.json:requested_subagents');
+    if (Number(recomputedEvidence?.failed_threads || 0) !== 0)
+        missing.push('subagent-evidence.json:failed_threads');
+    if (Number(recomputedEvidence?.completed_threads || 0) < Number(plan?.requested_subagents || 0))
+        missing.push('subagent-evidence.json:completed_threads');
+    if (summary?.schema !== 'sks.naruto-subagent-workflow.v1')
+        missing.push('naruto-summary.json:schema');
+    if (summary?.workflow !== 'official_codex_subagent')
+        missing.push('naruto-summary.json:workflow');
+    if (summary?.ok !== true || summary?.status !== 'completed')
+        missing.push('naruto-summary.json:completed');
+    if (summary?.parent_summary_present !== true || !String(summary?.parent_summary || '').trim())
+        missing.push('naruto-summary.json:parent_summary');
+    if (!String(summary?.verification?.budget || '').trim())
+        missing.push('naruto-summary.json:verification.budget');
+    if (summary?.legacy_process_swarm_used !== false)
+        missing.push('naruto-summary.json:legacy_process_swarm_used');
+    if (summary?.parent?.observed_model_match === false)
+        missing.push('naruto-summary.json:parent.observed_model_match');
+    if (fromChatImgCoverageRequired(state, gate) && gate.from_chat_img_request_coverage === true) {
+        missing.push(...await missingFromChatImgCoverageArtifacts(root, state));
+    }
+    return missing;
+}
+async function missingLegacyNarutoArtifacts(root, state = {}, gate = {}) {
     const id = state?.mission_id;
     if (!id)
         return ['mission_id'];
@@ -829,17 +961,27 @@ async function missingNarutoArtifacts(root, state = {}, gate = {}) {
         'agents/naruto-gpt-final-pack.json'
     ];
     const missing = [];
-    for (const file of required) {
+    for (const file of required)
         if (!(await exists(path.join(dir, file))))
             missing.push(file);
-    }
     if (gate.native_agent_proof === true && !(await exists(path.join(dir, 'agents', 'agent-proof-evidence.json'))))
         missing.push('agents/agent-proof-evidence.json');
-    if (fromChatImgCoverageRequired(state, gate) && gate.from_chat_img_request_coverage === true) {
+    if (fromChatImgCoverageRequired(state, gate) && gate.from_chat_img_request_coverage === true)
         missing.push(...await missingFromChatImgCoverageArtifacts(root, state));
-    }
     return missing;
 }
+function legacyNarutoWorkflowEnabled(state = {}, gate = {}) {
+    return state?.legacy_subagent_workflow === true
+        || state?.workflow === 'legacy_process_swarm'
+        || gate?.legacy_workflow === true
+        || gate?.workflow === 'legacy_process_swarm';
+}
+function stateUsesOfficialSubagentWorkflow(state = {}) {
+    return state?.subagents_required === true
+        && state?.native_sessions_required === false
+        && state?.legacy_subagent_workflow !== true
+        && state?.workflow !== 'legacy_process_swarm';
+}
 function extractLastMessage(payload) {
     return payload.last_assistant_message || payload.assistant_message || payload.message || payload.response || payload.raw || '';
 }

package/dist/core/ppt/style-tokens.js

@@ -199,7 +199,7 @@ export function buildPptStyleTokens(contract = {}) {
             avoid: ['over-designed decoration', 'ornamental gradients', 'nested cards', 'low-contrast gray body text', 'excessive motion or effects'],
             detail_strategy: ['precise spacing', 'clear hierarchy', 'thin rules', 'disciplined alignment', 'visible source rails', 'subtle accent color only when it clarifies meaning'],
             anti_generic_ai_style: 'prevent AI-like design: select and apply a concrete awesome-design-md reference profile before styling; do not default to generic cards, gradients, vague SaaS visuals, oversized decoration, or unsupported image-like flourishes',
-            image_policy: 'use images only when they improve comprehension; prefer Codex App built-in image generation via https://developers.openai.com/codex/app/features#image-generation when generated assets are needed'
+            image_policy: 'use images only when they improve comprehension; prefer Codex App built-in image generation via https://learn.chatgpt.com/docs/image-generation when generated assets are needed'
         }
     };
 }

package/dist/core/ppt-review/index.js

@@ -136,7 +136,7 @@ function buildPptImagegenReviewGate(parts = {}) {
         wrongness_checked: true,
         honest_mode_complete: true,
         mock_fixture: parts.mock === true,
-        verified_level: parts.mock === true ? 'verified_partial' : 'blocked_until_real_generation_extraction_recheck',
+        verified_level: parts.mock === true ? 'mock_only' : 'blocked_until_real_generation_extraction_recheck',
         blockers: [...new Set(blockers.filter(Boolean))],
         passed: false
     };

package/dist/core/ppt-review/slide-exporter.js

@@ -4,6 +4,7 @@ import { exists, nowIso, runProcess, which } from '../fsx.js';
 import { sha256File, imageDimensions } from '../wiki-image/image-hash.js';
 export const PPT_DECK_INVENTORY_ARTIFACT = 'ppt-deck-inventory.json';
 export const PPT_SLIDE_EXPORT_LEDGER_ARTIFACT = 'ppt-slide-export-ledger.json';
+const MAX_MOCK_SLIDE_EXPORTS = 256;
 export function splitList(value = '') {
     if (Array.isArray(value))
         return value.map((item) => String(item || '').trim()).filter(Boolean);
@@ -77,20 +78,27 @@ export async function exportSlidesToImages({ root, dir, deckPath = null, deckInv
         });
     }
     if (mock && exportedSlides.length === 0) {
-        const fixture = await writeFixturePng(dir, 'slide-1.png');
-        const rel = path.relative(root, fixture).split(path.sep).join('/');
-        exportedSlides.push({
-            slide_id: 'slide-1',
-            slide_index: 1,
-            image_path: rel,
-            sha256: await sha256File(fixture),
-            width: 1,
-            height: 1,
-            format: 'png',
-            fidelity: 'mock_fixture_one_by_one_png',
-            source: deckPath ? 'fake_export' : 'mock_fixture',
-            local_only: true
-        });
+        const inventorySlideCount = Number(inventory?.slide_count);
+        const requestedMockSlides = Number.isInteger(inventorySlideCount) && inventorySlideCount > 0 ? inventorySlideCount : 1;
+        const mockSlideCount = Math.min(MAX_MOCK_SLIDE_EXPORTS, requestedMockSlides);
+        if (requestedMockSlides > MAX_MOCK_SLIDE_EXPORTS)
+            blockers.push('mock_slide_export_limit_exceeded');
+        for (let index = 0; index < mockSlideCount; index += 1) {
+            const fixture = await writeFixturePng(dir, `slide-${index + 1}.png`);
+            const rel = path.relative(root, fixture).split(path.sep).join('/');
+            exportedSlides.push({
+                slide_id: `slide-${index + 1}`,
+                slide_index: index + 1,
+                image_path: rel,
+                sha256: await sha256File(fixture),
+                width: 1,
+                height: 1,
+                format: 'png',
+                fidelity: 'mock_fixture_one_by_one_png',
+                source: deckPath ? 'fake_export' : 'mock_fixture',
+                local_only: true
+            });
+        }
     }
     const exportAdapter = manualImages.length ? 'manual_slide_image_attach' : mock ? (deckPath ? 'fake_export' : 'mock_fixture') : await detectSlideExportAdapter();
     if (!manualImages.length && !mock && inventory?.passed === true) {
@@ -101,9 +109,7 @@ export async function exportSlidesToImages({ root, dir, deckPath = null, deckInv
     const deckSlideCount = Number(inventory?.slide_count || 0);
     if (manualImages.length === 0 && !mock && exportedSlides.length === 0)
         blockers.push('slide_export_unavailable');
-    if (manualImages.length > 0 && deckSlideCount > 0 && exportedSlides.length < deckSlideCount)
-        blockers.push('partial_export');
-    if (manualImages.length === 0 && !mock && deckSlideCount > 0 && exportedSlides.length > 0 && exportedSlides.length < deckSlideCount)
+    if (deckSlideCount > 0 && exportedSlides.length < deckSlideCount)
         blockers.push('partial_export');
     if (inventory?.passed !== true)
         blockers.push(...(inventory?.blockers || []));

package/dist/core/ppt-review/slide-imagegen-review.js

@@ -158,7 +158,7 @@ export async function generateSlideCalloutReviews({ root, dir, slideExportLedger
         extraction_pending_count: generatedReviewImages.filter((image) => image.callout_extraction_status === 'pending').length,
         blockers: [...new Set(blockers)],
         passed: slides.length > 0 && generatedReviewImages.length === slides.length && blockers.length === 0 && generatedReviewImages.every((image) => image.callout_extraction_status === 'succeeded'),
-        verified_level: mock ? 'verified_partial' : generatedReviewImages.length ? 'verified_partial' : 'blocked',
+        verified_level: mock ? 'mock_only' : generatedReviewImages.length ? 'verified_partial' : 'blocked',
         next_action: blockers.includes('imagegen_capability_missing')
             ? 'Generate slide callout review images with Codex App $imagegen/gpt-image-2, then attach them or rerun extraction.'
             : null

package/dist/core/ppt-review/slide-issue-extraction.js

@@ -60,9 +60,11 @@ export async function extractSlideIssues(input = {}) {
         validation: { ok: true, issues: [] },
         passed: blockers.length === 0
     };
+    const validation = validateJsonSchemaRecursive(ledgerBase, jsonSchema);
     const ledger = {
         ...ledgerBase,
-        validation: validateJsonSchemaRecursive(ledgerBase, jsonSchema)
+        validation,
+        passed: ledgerBase.passed && validation.ok
     };
     await writeJsonAtomic(path.join(dir, PPT_SLIDE_ISSUE_LEDGER_ARTIFACT), ledger);
     const extractionReport = {
@@ -76,7 +78,7 @@ export async function extractSlideIssues(input = {}) {
         blockers: [...new Set(blockers)],
         fallback_used: !mock && !input.sessionId,
         validation_status: ledger.validation.ok ? 'valid' : 'blocked',
-        passed: blockers.length === 0 && reports.every((report) => report.passed !== false)
+        passed: ledger.passed && reports.every((report) => report.passed !== false)
     };
     await writeJsonAtomic(path.join(dir, PPT_SLIDE_EXTRACTION_REPORT_ARTIFACT), extractionReport);
     const deckLedger = buildDeckIssueLedger(ledger, calloutLedger);

package/dist/core/preflight/parallel-preflight-engine.js

@@ -5,6 +5,8 @@ import { inspectCodexConfigReadability } from '../codex/codex-config-readability
 import { repairCodexConfigEperm } from '../codex/codex-config-eperm-repair.js';
 import { splitCodexProjectConfigPolicy } from '../codex/codex-project-config-policy.js';
 import { checkZellijCapability } from '../zellij/zellij-capability.js';
+import { codexLbStatus } from '../../cli/install-helpers.js';
+import { codexLbToolOutputRecoveryOverrideAcknowledged } from '../codex-lb/codex-lb-tool-output-recovery.js';
 export const PARALLEL_PREFLIGHT_SCHEMA = 'sks.parallel-preflight.v1';
 export async function runParallelPreflight(checks) {
     const startedAt = nowIso();
@@ -38,7 +40,8 @@ export async function runCodexLaunchPreflight(rootInput = process.cwd(), opts =
     const probeCodex = opts.launchFast === true ? false : opts.actualCodex !== false;
     const readonly = await runParallelPreflight([
         { id: 'codex_config_readability', run: () => inspectCodexConfigReadability(root, { ...opts, codexProbe: probeCodex, actualCodex: probeCodex, writeReport: false }) },
-        { id: 'codex_project_config_policy', run: () => splitCodexProjectConfigPolicy(root, { ...opts, writeReport: false }) }
+        { id: 'codex_project_config_policy', run: () => splitCodexProjectConfigPolicy(root, { ...opts, writeReport: false }) },
+        { id: 'codex_lb_tool_output_recovery', run: () => inspectCodexLbToolOutputRecoveryForLaunch(opts) }
     ]);
     const repair = opts.fix === true || readonly.ok === false
         ? await repairCodexConfigEperm(root, { ...opts, codexProbe: probeCodex, actualCodex: probeCodex, fix: opts.fix !== false, writeReport: false })
@@ -66,6 +69,7 @@ export async function runCodexLaunchPreflight(rootInput = process.cwd(), opts =
     };
     const blockers = [...new Set([...(readonly.blockers || []), ...(repair?.blockers || []), ...(zellijCapability?.blockers || []), ...(fastTierProof.ok ? [] : ['service_tier_not_passed_to_codex'])])];
     const operatorActions = [...new Set([...(readonly.operator_actions || []), ...(repair?.operator_actions || []), ...(zellijCapability?.operator_actions || [])])];
+    const codexLbToolOutputRecovery = readonly.results.find((result) => result.id === 'codex_lb_tool_output_recovery')?.value || null;
     const report = {
         schema: 'sks.mad-launch-preflight.v1',
         generated_at: nowIso(),
@@ -74,6 +78,7 @@ export async function runCodexLaunchPreflight(rootInput = process.cwd(), opts =
         readonly,
         repair,
         zellij_capability: zellijCapability,
+        codex_lb_tool_output_recovery: codexLbToolOutputRecovery,
         fast_tier_proof: fastTierProof,
         blockers,
         operator_actions: operatorActions
@@ -82,4 +87,48 @@ export async function runCodexLaunchPreflight(rootInput = process.cwd(), opts =
         await writeJsonAtomic(reportPath, { ...report, report_path: reportPath });
     return report;
 }
+export async function inspectCodexLbToolOutputRecoveryForLaunch(opts = {}) {
+    if (opts.skipCodexLbToolOutputRecovery === true) {
+        return {
+            schema: 'sks.codex-lb-launch-recovery-preflight.v1',
+            ok: true,
+            status: 'not_applicable',
+            selected: false,
+            blockers: [],
+            operator_actions: []
+        };
+    }
+    const allowUnverifiedToolOutputRecovery = opts.allowUnverifiedToolOutputRecovery === true
+        || codexLbToolOutputRecoveryOverrideAcknowledged({ env: opts.env || process.env });
+    const status = await codexLbStatus({
+        ...opts,
+        ...(opts.home ? { home: opts.home } : {}),
+        ...(opts.codexLbConfigPath ? { configPath: opts.codexLbConfigPath } : {}),
+        ...(opts.codexLbEnvPath ? { envPath: opts.codexLbEnvPath } : {}),
+        ...(typeof opts.codexLbToolOutputRecoveryFetch === 'function'
+            ? { toolOutputRecoveryFetch: opts.codexLbToolOutputRecoveryFetch }
+            : {}),
+        ...(opts.codexLbToolOutputRecoveryTimeoutMs
+            ? { toolOutputRecoveryTimeoutMs: opts.codexLbToolOutputRecoveryTimeoutMs }
+            : {}),
+        probeToolOutputRecovery: true,
+        allowUnverifiedToolOutputRecovery
+    });
+    const recovery = status.tool_output_recovery;
+    const required = status.selected === true;
+    const ok = !required || recovery?.ok === true;
+    return {
+        schema: 'sks.codex-lb-launch-recovery-preflight.v1',
+        ok,
+        status: !required ? 'not_selected' : recovery?.status || 'version_unverified',
+        selected: required,
+        provider_ready: status.provider_ready === true,
+        base_url: status.base_url || null,
+        tool_output_recovery: recovery || null,
+        blockers: ok ? [] : recovery?.blockers || ['codex_lb_tool_output_recovery_version_unverified'],
+        operator_actions: ok ? [] : recovery?.operator_actions || [
+            'Upgrade codex-lb, or run `sks codex-lb use-oauth`; SKS will not switch providers silently.'
+        ]
+    };
+}
 //# sourceMappingURL=parallel-preflight-engine.js.map

package/dist/core/product-design-plugin.js

@@ -4,7 +4,7 @@ export const PRODUCT_DESIGN_REQUIRED_SKILLS = Object.freeze([
     'get-context',
     'ideate',
     'image-to-code',
-    'prototype',
+    'index',
     'research',
     'share',
     'url-to-code',
@@ -56,7 +56,7 @@ export const PRODUCT_DESIGN_PIPELINE_STAGES = Object.freeze([
     },
     {
         stage: 'artifact_generation',
-        skills: ['prototype', 'image-to-code', 'url-to-code'],
+        skills: ['index', 'image-to-code', 'url-to-code'],
         routes: ['Team', 'PPT'],
         purpose: 'turn sealed context, screenshots, images, or URLs into prototype/source direction'
     },

package/dist/core/proof/route-finalizer.js

@@ -214,7 +214,7 @@ function inferRouteFailureAnalysis({ missionId, route, status, blockers, unverif
         return {
             status: 'complete',
             root_cause: 'Visual evidence was produced from a mock fixture, which cannot support a real fully verified visual route claim.',
-            corrective_action: 'Kept the Completion Proof at verified_partial and recorded the mock-evidence caveat in unverified evidence.',
+            corrective_action: `Kept the Completion Proof at ${status || 'mock_only'} and recorded the mock-evidence caveat instead of upgrading fixture evidence to a real verification claim.`,
             evidence
         };
     }

package/dist/core/proof/route-proof-gate.js

@@ -28,14 +28,19 @@ export async function validateRouteCompletionProof(root, { missionId = null, rou
         if (Number(anchors) <= 0)
             issues.push('image_voxel_anchors_missing');
     }
-    if (routeRequiresAgentIntake(route || proof.route, { task: state.prompt, noAgents: state.agents_required === false })) {
+    const normalizedRoute = normalizeProofRoute(route || proof.route);
+    const officialSubagentWorkflow = normalizedRoute === '$Naruto' && (state.subagents_required === true
+        || state.native_sessions_required === false
+        || proof.evidence?.route_gate?.workflow === 'official_codex_subagent');
+    const legacyAgentProofRequired = normalizedRoute === '$Release-Review'
+        || (!officialSubagentWorkflow && routeRequiresAgentIntake(route || proof.route, { task: state.prompt, noAgents: state.agents_required === false }));
+    if (legacyAgentProofRequired) {
         const agents = proof.evidence?.agents;
         if (!agents)
             issues.push('agent_proof_evidence_missing');
         else {
             if (agents.status !== 'passed' || agents.ok !== true)
                 issues.push('agent_gate_not_passed');
-            const normalizedRoute = normalizeProofRoute(route || proof.route);
             const maxAgentCount = normalizedRoute === '$Naruto' ? 100 : 20;
             const agentCount = Number(agents.agent_count || 0);
             if (agentCount < 5)