sneakoscope 3.1.8 → 3.1.9

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

@@ -1,8 +1,9 @@
 import path from 'node:path';
-import { nowIso, sksRoot, writeJsonAtomic } from '../fsx.js';
+import { nowIso, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { findLatestMission } from '../mission.js';
 import { narutoCommand } from './naruto-command.js';
 import { teamLegacyObserveCommand, teamLegacySubcommands } from './team-legacy-observe-command.js';
+import { SSOT_GUARD_ARTIFACT } from '../safety/ssot-guard.js';
 export async function team(args = []) {
     if (teamLegacySubcommands.has(String(args[0] || ''))) {
         return teamLegacyObserveCommand(String(args[0]), args.slice(1));
@@ -13,9 +14,13 @@ async function redirectTeamCreateToNaruto(args = []) {
     const root = await sksRoot();
     const list = (args || []).map((arg) => String(arg));
     const narutoArgs = list[0] === 'run' ? list : ['run', ...list];
+    const jsonRequested = list.includes('--json');
     console.warn('SKS Team is deprecated for new execution missions; redirecting to $Naruto.');
-    const result = await narutoCommand(narutoArgs);
+    const result = jsonRequested
+        ? await withSuppressedConsoleLog(() => narutoCommand(narutoArgs))
+        : await narutoCommand(narutoArgs);
     const missionId = result?.mission_id || await findLatestMission(root);
+    const nativeAgentRun = missionId ? await buildTeamNativeAgentCompatibility(root, missionId, result) : null;
     if (missionId) {
         await writeJsonAtomic(path.join(root, '.sneakoscope', 'missions', missionId, 'team-alias-to-naruto.json'), {
             schema: 'sks.team-alias-to-naruto.v1',
@@ -26,10 +31,65 @@ async function redirectTeamCreateToNaruto(args = []) {
             route_command: '$Naruto',
             deprecated_route: '$Team',
             parallel_write_policy: result?.parallel_write_policy || result?.run?.parallel_write_policy || null,
+            ssot_guard_artifact: SSOT_GUARD_ARTIFACT,
             created_at: nowIso(),
             args: list
         });
     }
-    return result;
+    const finalResult = {
+        ...result,
+        mock: result?.mock === true || result?.backend === 'fake',
+        ...(nativeAgentRun ? { native_agent_run: nativeAgentRun } : {})
+    };
+    if (jsonRequested)
+        console.log(JSON.stringify(finalResult, null, 2));
+    return finalResult;
+}
+async function withSuppressedConsoleLog(fn) {
+    const originalLog = console.log;
+    console.log = () => undefined;
+    try {
+        return await fn();
+    }
+    finally {
+        console.log = originalLog;
+    }
+}
+async function buildTeamNativeAgentCompatibility(root, missionId, result) {
+    const ledgerRoot = path.join(root, '.sneakoscope', 'missions', missionId, 'agents');
+    const [schedulerState, proof, parallelWritePolicy] = await Promise.all([
+        readJson(path.join(ledgerRoot, 'agent-scheduler-state.json'), null),
+        readJson(path.join(ledgerRoot, 'agent-proof-evidence.json'), null),
+        readJson(path.join(ledgerRoot, 'agent-parallel-write-policy.json'), null)
+    ]);
+    if (!schedulerState || !proof)
+        return null;
+    return {
+        schema: result?.run?.schema || 'sks.agent-run.v1',
+        ok: result?.run?.ok === true || result?.ok === true,
+        mission_id: missionId,
+        route: '$Team',
+        backend: result?.backend || result?.run?.backend || proof.backend || null,
+        ledger_root: path.relative(root, ledgerRoot),
+        target_active_slots: schedulerState.target_active_slots ?? result?.target_active_slots ?? null,
+        scheduler: {
+            state: schedulerState
+        },
+        proof: {
+            ...proof,
+            route: '$Team',
+            route_command: 'sks team',
+            route_blackbox_kind: 'actual_team_command',
+            real_route_command_used: true
+        },
+        parallel_write_policy: parallelWritePolicy || result?.parallel_write_policy || result?.run?.parallel_write_policy || null,
+        redirected_to: '$Naruto',
+        compatibility: {
+            schema: 'sks.team-native-agent-compatibility.v1',
+            ok: true,
+            source: 'team-alias-to-naruto',
+            ledger_root: path.relative(root, ledgerRoot)
+        }
+    };
 }
 //# sourceMappingURL=team-command.js.map

package/dist/core/decision-contract.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { readJson, writeJsonAtomic, nowIso, sha256 } from './fsx.js';
 import { validateQaLoopAnswers } from './qa-loop.js';
-import { inferAnswersForPrompt } from './questions.js';
+import { buildRequestIntake, inferAnswersForPrompt, REQUEST_INTAKE_ARTIFACT } from './questions.js';
 import { bindMistakeRecallToAnswers, buildMistakeRecallLedger, mistakeRecallContractSummary, writeMistakeRecallArtifacts } from './mistake-recall.js';
 function isEmptyAnswer(v, slot = {}) {
     if (v === undefined || v === null)
@@ -41,7 +41,7 @@ export function validateAnswers(schema, answers) {
     errors.push(...validateQaLoopAnswers(schema, answers));
     return { ok: errors.length === 0, errors, resolved, totalRequired: schema.slots.filter((s) => s.required).length };
 }
-export function buildDecisionContract({ mission, schema, answers, mistakeRecall = null }) {
+export function buildDecisionContract({ mission, schema, answers, mistakeRecall = null, requestIntake = null }) {
     const madSks = answers.MAD_SKS_MODE === 'explicit_invocation_only';
     const defaults = {
         if_multiple_valid_implementations: 'choose_smallest_reversible_change',
@@ -115,6 +115,14 @@ export function buildDecisionContract({ mission, schema, answers, mistakeRecall
         acceptance_criteria: Array.isArray(answers.ACCEPTANCE_CRITERIA) ? answers.ACCEPTANCE_CRITERIA : String(answers.ACCEPTANCE_CRITERIA || '').split('\n').map((x) => x.trim()).filter(Boolean),
         non_goals: Array.isArray(answers.NON_GOALS) ? answers.NON_GOALS : String(answers.NON_GOALS || '').split('\n').map((x) => x.trim()).filter(Boolean),
         test_scope: answers.TEST_SCOPE,
+        request_intake: requestIntake ? {
+            artifact: REQUEST_INTAKE_ARTIFACT,
+            prompt_hash: requestIntake.prompt_hash || null,
+            interpreted_intent: requestIntake.interpreted_intent || null,
+            requirements: requestIntake.requirements || [],
+            transformed_prompt: requestIntake.transformed_prompt || null,
+            wiki_context_used: requestIntake.wiki_context_used || null
+        } : null,
         triwiki_mistake_recall: mistakeRecallContractSummary(mistakeRecall),
         approved_defaults: defaults,
         decision_ladder: [
@@ -135,6 +143,7 @@ export function buildDecisionContract({ mission, schema, answers, mistakeRecall
     return contract;
 }
 export async function sealContract(missionDir, mission) {
+    const root = rootFromMissionDir(missionDir);
     const schema = await readJson(path.join(missionDir, 'required-answers.schema.json'), {});
     const explicitAnswers = await readJson(path.join(missionDir, 'answers.json'), {});
     const inferred = inferAnswersForPrompt(mission?.prompt || schema?.prompt || '', explicitAnswers);
@@ -143,7 +152,7 @@ export async function sealContract(missionDir, mission) {
         ...inferred.answers,
         ...explicitAnswers
     };
-    const root = rootFromMissionDir(missionDir);
+    const requestIntake = await readOrBuildRequestIntake(missionDir, root, mission?.prompt || schema?.prompt || '', baseAnswers);
     const mistakeRecall = await buildMistakeRecallLedger(root, {
         prompt: mission?.prompt || schema?.prompt || '',
         answers: baseAnswers
@@ -152,7 +161,7 @@ export async function sealContract(missionDir, mission) {
     const validation = validateAnswers(schema, answers);
     if (!validation.ok)
         return { ok: false, validation };
-    const contract = buildDecisionContract({ mission, schema, answers, mistakeRecall });
+    const contract = buildDecisionContract({ mission, schema, answers, mistakeRecall, requestIntake });
     const mistakeRecallConsumption = await writeMistakeRecallArtifacts(missionDir, mistakeRecall, contract);
     await writeJsonAtomic(path.join(missionDir, 'resolved-answers.json'), {
         explicit_answers: explicitAnswers,
@@ -163,12 +172,27 @@ export async function sealContract(missionDir, mission) {
             artifact: 'mistake-recall-ledger.json',
             consumed: mistakeRecallConsumption.ok,
             required: mistakeRecall.required
+        },
+        request_intake: {
+            artifact: REQUEST_INTAKE_ARTIFACT,
+            prompt_hash: requestIntake?.prompt_hash || null,
+            transformed_prompt_available: Boolean(requestIntake?.transformed_prompt)
         }
     });
     await writeJsonAtomic(path.join(missionDir, 'decision-contract.json'), contract);
     await writeJsonAtomic(path.join(missionDir, 'answer-validation.json'), validation);
     return { ok: true, validation, contract };
 }
+async function readOrBuildRequestIntake(missionDir, root, prompt, answers = {}) {
+    const file = path.join(missionDir, REQUEST_INTAKE_ARTIFACT);
+    const existing = await readJson(file, null);
+    if (existing)
+        return existing;
+    const wikiContext = await readJson(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json'), null);
+    const intake = buildRequestIntake(prompt, answers, { wikiContext });
+    await writeJsonAtomic(file, intake);
+    return intake;
+}
 function rootFromMissionDir(missionDir) {
     const resolved = path.resolve(missionDir);
     const parts = resolved.split(path.sep);

package/dist/core/doctor/command-alias-cleanup.js

@@ -0,0 +1,64 @@
+import path from 'node:path';
+import { COMMAND_CATALOG } from '../routes.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { COMMANDS, LEGACY_COMMAND_ALIASES, commandNames } from '../../cli/command-registry.js';
+export const COMMAND_ALIAS_CLEANUP_SCHEMA = 'sks.command-alias-cleanup.v1';
+export async function runDoctorCommandAliasCleanup(opts) {
+    const report = commandAliasCleanupReport(opts);
+    if (opts.fix)
+        await writeJsonAtomic(report.report_path, report);
+    return report;
+}
+export function commandAliasCleanupReport(opts) {
+    const root = opts.root;
+    const legacyAliases = Object.entries(LEGACY_COMMAND_ALIASES).map(([alias, canonical]) => ({
+        alias,
+        canonical
+    }));
+    const registeredAliasCommands = legacyAliases
+        .filter((entry) => Object.prototype.hasOwnProperty.call(COMMANDS, entry.alias))
+        .map((entry) => entry.alias);
+    const catalogAliasRows = legacyAliases
+        .filter((entry) => COMMAND_CATALOG.some((row) => row.name === entry.alias))
+        .map((entry) => entry.alias);
+    const canonical = commandNames();
+    const missingCanonicalTargets = legacyAliases
+        .filter((entry) => !canonical.includes(entry.canonical))
+        .map((entry) => `${entry.alias}->${entry.canonical}`);
+    const blockers = [
+        ...registeredAliasCommands.map((alias) => `legacy_alias_registered_as_command:${alias}`),
+        ...catalogAliasRows.map((alias) => `legacy_alias_visible_in_command_catalog:${alias}`),
+        ...missingCanonicalTargets.map((entry) => `legacy_alias_missing_target:${entry}`)
+    ];
+    const ok = blockers.length === 0;
+    return {
+        schema: COMMAND_ALIAS_CLEANUP_SCHEMA,
+        ok,
+        status: ok ? 'clean' : 'blocked',
+        generated_at: nowIso(),
+        root,
+        fix: Boolean(opts.fix),
+        report_path: path.join(root, '.sneakoscope', 'reports', 'command-alias-cleanup.json'),
+        canonical_command_count: canonical.length,
+        legacy_alias_count: legacyAliases.length,
+        aliases: legacyAliases,
+        detected: {
+            registered_alias_commands: registeredAliasCommands,
+            catalog_alias_rows: catalogAliasRows,
+            missing_canonical_targets: missingCanonicalTargets
+        },
+        actions: ok
+            ? [{
+                    action: opts.fix ? 'doctor_fix_verified_aliases_consolidated' : 'verify_aliases_consolidated',
+                    ok: true,
+                    detail: 'Legacy command names dispatch through COMMAND_ALIASES and are not registered as duplicate command rows.'
+                }]
+            : [{
+                    action: 'source_registry_cleanup_required',
+                    ok: false,
+                    detail: 'Remove duplicate alias rows from COMMANDS and COMMAND_CATALOG, then map them through LEGACY_COMMAND_ALIASES.'
+                }],
+        blockers
+    };
+}
+//# sourceMappingURL=command-alias-cleanup.js.map

package/dist/core/feature-fixtures.js

@@ -39,6 +39,7 @@ const FIXTURES = Object.freeze({
     'cli-qa-loop': fixture('mock', 'sks qa-loop status latest --json', ['qa-loop-proof.json', 'completion-proof.json'], 'pass'),
     'cli-ppt': fixture('mock', 'sks ppt fixture --mock --json', ['ppt-imagegen-review-gate.json', 'completion-proof.json'], 'pass'),
     'cli-image-ux-review': fixture('mock', 'sks image-ux-review status latest --json', ['image-ux-generated-review-ledger.json', 'image-voxel-ledger.json'], 'pass'),
+    'cli-computer-use': fixture('real_optional', 'sks computer-use status --json', [], 'pass'),
     'cli-pipeline': fixture('mock', 'sks pipeline status latest --json', ['pipeline-plan.json'], 'pass'),
     'cli-validate-artifacts': fixture('mock', 'sks validate-artifacts latest --json', ['validation-report.json'], 'pass'),
     'cli-hproof': fixture('mock', 'sks hproof check latest', ['completion-proof.json'], 'pass'),
@@ -68,6 +69,7 @@ const FIXTURES = Object.freeze({
     'cli-zellij': fixture('mock', 'npm run zellij:capability --silent', [], 'pass'),
     'cli-tmux': fixture('mock', 'removed runtime migration notice: sks tmux --json', [], 'pass'),
     'cli-mad': fixture('mock', 'sks mad --help', [], 'pass'),
+    'cli-mad-sks': fixture('static', 'sks mad-sks status --json', [], 'pass'),
     'cli-auto-review': fixture('mock', 'sks auto-review status --json', [], 'pass'),
     'cli-commit': fixture('mock', 'sks commit --dry-run', [], 'pass'),
     'cli-commit-and-push': fixture('mock', 'sks commit-and-push --dry-run', [], 'pass'),

package/dist/core/feature-registry.js

@@ -813,7 +813,7 @@ function commandCategory(name) {
         return 'proof-route';
     if (['qa-loop', 'research', 'recallpulse', 'skill-dream', 'eval', 'perf'].includes(name))
         return 'loop';
-    if (['codex', 'codex-app', 'codex-native', 'codex-lb', 'auth', 'hooks', 'context7'].includes(name))
+    if (['codex', 'codex-app', 'codex-native', 'codex-lb', 'hooks', 'context7', 'computer-use'].includes(name))
         return 'integration';
     if (['db', 'guard', 'conflicts', 'harness', 'versioning'].includes(name))
         return 'safety';
@@ -826,7 +826,7 @@ function commandCategory(name) {
 function commandMaturity(name) {
     if (['help', 'version', 'commands', 'usage', 'root', 'quickstart', 'setup', 'doctor', 'selftest', 'update-check', 'fast-mode'].includes(name))
         return 'stable';
-    if (['codex', 'codex-app', 'codex-lb', 'hooks', 'features', 'all-features', 'wiki', 'wrongness', 'team', 'pipeline', 'goal', 'db', 'guard'].includes(name))
+    if (['codex', 'codex-app', 'codex-native', 'codex-lb', 'hooks', 'features', 'all-features', 'wiki', 'wrongness', 'team', 'pipeline', 'goal', 'db', 'guard', 'computer-use', 'mad-sks'].includes(name))
         return 'beta';
     return 'labs';
 }

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '3.1.8';
+export const PACKAGE_VERSION = '3.1.9';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/naruto/naruto-work-graph.js

@@ -29,7 +29,10 @@ export function buildNarutoWorkGraph(input = {}) {
     const readonly = input.readonly === true;
     const writeCapable = input.writeCapable !== false && !readonly;
     const minimumFanout = writeCapable ? requestedClones * 2 : requestedClones;
-    const totalWorkItems = Math.max(minimumFanout, normalizePositiveInt(input.totalWorkItems, minimumFanout));
+    const requestedWorkItems = normalizePositiveInt(input.totalWorkItems, minimumFanout);
+    const totalWorkItems = input.honorExplicitTotalWorkItems === true
+        ? Math.max(requestedClones, requestedWorkItems)
+        : Math.max(minimumFanout, requestedWorkItems);
     const kindCycle = writeCapable ? WRITE_CAPABLE_KIND_CYCLE : READONLY_KIND_CYCLE;
     const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
     const targetPaths = normalizePaths(input.targetPaths || []);

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

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { appendJsonl, exists, nowIso, readJson, readText, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { containsUserQuestion, noQuestionContinuationReason } from '../no-question-guard.js';
 import { createMission, missionDir, setCurrent } from '../mission.js';
-import { buildQuestionSchemaForRoute, writeQuestions } from '../questions.js';
+import { buildQuestionSchemaForRoute, buildRequestIntake, REQUEST_INTAKE_ARTIFACT, writeQuestions } from '../questions.js';
 import { sealContract } from '../decision-contract.js';
 import { scanDbSafety } from '../db-safety.js';
 import { GOAL_WORKFLOW_ARTIFACT, writeGoalWorkflow } from '../goal-workflow.js';
@@ -81,6 +81,8 @@ function reflectionInstructionText(commandPrefix = 'sks') {
 export function buildPipelinePlan(input = {}) {
     const route = input.route || routePrompt(input.task || '$SKS');
     const task = String(input.task || '').trim();
+    const requestIntake = input.requestIntake || null;
+    const executionPrompt = String(requestIntake?.transformed_prompt || task || '').trim();
     const ambiguity = normalizeAmbiguity(input.ambiguity, route);
     const proof = normalizeProofField(input.proofField);
     const lane = selectPipelineLane(route, task, proof);
@@ -106,6 +108,18 @@ export function buildPipelinePlan(input = {}) {
             reflection_required: reflectionRequiredForRoute(route)
         },
         task,
+        request_intake: requestIntake ? {
+            artifact: REQUEST_INTAKE_ARTIFACT,
+            prompt_hash: requestIntake.prompt_hash || null,
+            interpreted_goal: requestIntake.interpreted_intent?.goal || null,
+            requirement_count: Array.isArray(requestIntake.requirements) ? requestIntake.requirements.length : 0,
+            transformed_prompt_available: Boolean(requestIntake.transformed_prompt),
+            wiki_context_used: requestIntake.wiki_context_used?.source || null
+        } : {
+            artifact: REQUEST_INTAKE_ARTIFACT,
+            status: 'not_attached'
+        },
+        execution_prompt: executionPrompt,
         ambiguity_gate: ambiguity,
         runtime_lane: lane,
         stages,
@@ -130,10 +144,37 @@ export function buildPipelinePlan(input = {}) {
     };
 }
 export async function writePipelinePlan(dir, input = {}) {
-    const plan = buildPipelinePlan(input);
+    const requestIntake = input.requestIntake || await writeRequestIntakeArtifact(dir, input);
+    const plan = buildPipelinePlan({ ...input, requestIntake });
     await writeJsonAtomic(path.join(dir, PIPELINE_PLAN_ARTIFACT), plan);
     return plan;
 }
+export async function writeRequestIntakeArtifact(dir, input = {}) {
+    const file = path.join(dir, REQUEST_INTAKE_ARTIFACT);
+    if (!input.requestIntake && !input.forceRequestIntakeRewrite) {
+        const existing = await readJson(file, null);
+        if (existing)
+            return existing;
+    }
+    const root = input.root || rootFromMissionDir(dir);
+    const wikiContext = input.wikiContext !== undefined
+        ? input.wikiContext
+        : await readJson(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json'), null);
+    const intake = input.requestIntake || buildRequestIntake(input.task || '', {}, {
+        wikiContext,
+        route: input.route || null
+    });
+    await writeJsonAtomic(file, intake);
+    return intake;
+}
+function rootFromMissionDir(dir) {
+    const resolved = path.resolve(dir);
+    const parts = resolved.split(path.sep);
+    const idx = parts.lastIndexOf('.sneakoscope');
+    if (idx > 0)
+        return parts.slice(0, idx).join(path.sep) || path.sep;
+    return path.resolve(resolved, '..', '..', '..');
+}
 export function validatePipelinePlan(plan = {}) {
     const issues = [];
     if (plan.schema_version !== PIPELINE_PLAN_SCHEMA_VERSION)
@@ -336,12 +377,13 @@ function planVerification(route, proof) {
 function planNextActions(route, task, ambiguity, lane, agentPolicy = normalizeAgentPolicy(route, task, {})) {
     if (ambiguity.required && !ambiguity.passed) {
         return [
+            `read ${REQUEST_INTAKE_ARTIFACT} and preserve its source-order requirements`,
             'auto-seal execution contract from inferred answers',
             ...(looksLikeProblemSolvingRequest(task) ? ['run Solution Scout web search for similar fixes before editing'] : []),
             'continue with decision-contract.json'
         ];
     }
-    const actions = ['read pipeline-plan.json before work', 'execute kept stages only', 'run listed verification'];
+    const actions = [`read ${REQUEST_INTAKE_ARTIFACT} and use its transformed_prompt`, 'read pipeline-plan.json before work', 'execute kept stages only', 'run listed verification'];
     if (agentPolicy.required)
         actions.splice(1, 0, 'run sks agents run latest --json before implementation');
     if (!lane.fast_lane_allowed && routeRequiresSubagents(route, task)) {
@@ -375,6 +417,7 @@ export function promptPipelineContext(prompt, route = null) {
         'Hook visibility limit: hooks can inject context/status or block/continue a turn, but they cannot create arbitrary live chat bubbles; use team events, mission files, or normal assistant updates for live transcript details.',
         'Ambient Goal continuation: even without an explicit $Goal keyword, use Codex native /goal persistence when it helps keep long work resumable and complete; do not let it replace or skip the selected SKS route gates.',
         'Route contract: execution routes infer contract answers from the prompt, TriWiki/current-code defaults, and conservative SKS policy. DFix and Answer bypass stateful execution because they do not start implementation.',
+        `Wiki-informed request intake: when a mission exists, read ${REQUEST_INTAKE_ARTIFACT} before execution; preserve every source-order requirement, apply TriWiki attention/use_first and hydrate_first context, and execute request_intake.transformed_prompt through the selected route instead of relying on the vague original wording alone.`,
         'Plan-first interaction: when ambiguity questions are truly required, show the user only the missing human decision(s), then seal the decision contract internally and execute/verify.',
         'Question-shaped directive policy: before using Answer, decide whether a question is a real information request or an implicit instruction/complaint about broken behavior. Rhetorical bug reports, mandatory-policy statements, and "why is this not happening?" execution complaints must route to Naruto, not Answer.',
         'Best-practice prompt shape: extract Goal, Context, Constraints, and Done-when before implementation; keep questions compact and only ask for answers that can change scope, safety, user-facing behavior, or acceptance criteria.',
@@ -658,7 +701,8 @@ async function activePipelinePlanNote(root, state = {}) {
     const kept = plan.stage_summary?.kept ?? plan.kept_stages?.length ?? 0;
     const skipped = plan.stage_summary?.skipped ?? plan.skipped_stages?.length ?? 0;
     const next = Array.isArray(plan.next_actions) && plan.next_actions.length ? ` Next planned action: ${plan.next_actions[0]}.` : '';
-    return ` Pipeline plan: .sneakoscope/missions/${state.mission_id}/${PIPELINE_PLAN_ARTIFACT} (${lane}; kept=${kept}, skipped=${skipped}).${next}`;
+    const intake = plan.request_intake?.artifact ? ` Request intake: .sneakoscope/missions/${state.mission_id}/${plan.request_intake.artifact}; execution prompt=${plan.request_intake.transformed_prompt_available ? 'available' : 'missing'}.` : '';
+    return ` Pipeline plan: .sneakoscope/missions/${state.mission_id}/${PIPELINE_PLAN_ARTIFACT} (${lane}; kept=${kept}, skipped=${skipped}).${intake}${next}`;
 }
 async function prepareGoal(root, route, task, required) {
     const { id, dir, mission } = await createMission(root, { mode: 'goal', prompt: task });
@@ -1150,6 +1194,8 @@ function routeContext(route, id, task, required, next) {
 ${route.command} route prepared.
 Mission: ${id}
 Task: ${visibleTask}
+Request intake: .sneakoscope/missions/${id}/${REQUEST_INTAKE_ARTIFACT}
+Execution prompt: request-intake.transformed_prompt
 Pipeline plan: .sneakoscope/missions/${id}/${PIPELINE_PLAN_ARTIFACT}
 Required skills: ${route.requiredSkills.join(', ')}
 Stop gate: ${route.stopGate}

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

@@ -4,6 +4,7 @@ import { appendJsonl, exists, nowIso, readJson, readText, writeJsonAtomic } from
 import { containsUserQuestion, noQuestionContinuationReason } from '../no-question-guard.js';
 import { missionDir } from '../mission.js';
 import { evaluateResearchGate } from '../research.js';
+import { evaluateQaGate } from '../qa-loop.js';
 import { PPT_REQUIRED_GATE_FIELDS } from '../ppt.js';
 import { validateFinalHonestModeReport } from '../artifact-schemas.js';
 import { IMAGE_UX_REVIEW_GATE_ARTIFACT, IMAGE_UX_REVIEW_POLICY_ARTIFACT, IMAGE_UX_REVIEW_SCREEN_INVENTORY_ARTIFACT, IMAGE_UX_REVIEW_GENERATED_REVIEW_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ISSUE_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ITERATION_REPORT_ARTIFACT, IMAGE_UX_REVIEW_REQUIRED_GATE_FIELDS, IMAGE_UX_REVIEW_REFERENCE_GATE_FIELDS, IMAGE_UX_REVIEW_HONEST_MODE_ARTIFACT, imageUxReviewGateAllowsReferenceCloseout } from '../image-ux-review.js';
@@ -392,7 +393,9 @@ function missingRequiredGateFields(file, state, gate = {}) {
     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'];
         if (gate.ui_e2e_required === true)
-            required.push('chrome_extension_preflight_passed', 'ui_chrome_extension_evidence');
+            required.push('chrome_extension_preflight_passed', 'ui_chrome_extension_evidence', 'ui_chrome_extension_screenshot_captured');
+        if (gate.gpt_image_2_annotated_review_required === true)
+            required.push('gpt_image_2_annotated_review_generated');
         return required.filter((key) => gate[key] !== true);
     }
     if (file === 'ppt-gate.json' || mode === 'PPT') {
@@ -421,6 +424,12 @@ async function missingRequiredGateArtifacts(root, file, state, gate = {}) {
             return [];
         return (evaluated.reasons || ['research_gate_blocked']).map((reason) => `research-gate:${reason}`);
     }
+    if (file === 'qa-gate.json' || mode === 'QALOOP') {
+        const evaluated = await evaluateQaGate(missionDir(root, state.mission_id));
+        if (evaluated.passed === true)
+            return [];
+        return (evaluated.reasons || ['qa_gate_blocked']).map((reason) => `qa-gate:${reason}`);
+    }
     if (file === IMAGE_UX_REVIEW_GATE_ARTIFACT || mode === 'IMAGE_UX_REVIEW')
         return missingImageUxReviewArtifacts(root, state, gate);
     if (file === 'naruto-gate.json' || mode === 'NARUTO')

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

@@ -41,7 +41,7 @@ export async function validateRouteCompletionProof(root, { missionId = null, rou
             if (agentCount < 5)
                 issues.push('agent_count_below_5');
             if (agentCount > maxAgentCount)
-                issues.push(`agent_count_above_${maxAgentCount}`);
+                issues.push(normalizedRoute === '$Naruto' ? 'agent_count_above_100' : 'agent_count_above_20');
             if (agents.all_sessions_closed !== true)
                 issues.push('agent_sessions_not_closed');
             if (agents.no_overlap_ok !== true)