sneakoscope 6.0.2 → 6.1.0

package/dist/scripts/naruto-shadow-clone-swarm-check.js

@@ -29,31 +29,30 @@ assertGate(fullRoster.max_agents === 100, 'clone roster max_agents must be 100',
 // 4) Over-cap is clamped, not crashed.
 const overCap = roster.buildNarutoCloneRoster({ clones: 500, maxAgentCount: schema.MAX_NARUTO_AGENT_COUNT });
 assertGate(overCap.agent_count === 100, 'clones above the ceiling clamp to 100', { agent_count: overCap.agent_count });
-// 4b) Dynamic per-clone effort policy (like team mode), capped + always fast.
-//     A neutral/no-tool prompt yields a low/medium MIX: read-only personas -> low, writers -> medium.
+// 4b) Naruto-only GPT-5.6 family policy. The old low/medium cap is gone.
 const effortRoster = roster.buildNarutoCloneRoster({ clones: 24, prompt: 'review and summarize the current findings', maxAgentCount: schema.MAX_NARUTO_AGENT_COUNT });
 const efforts = new Set(effortRoster.roster.map((row) => row.reasoning_effort));
 const modelTiers = new Set(effortRoster.roster.map((row) => row.model_tier));
 const modelEfforts = new Set(effortRoster.roster.map((row) => row.model_reasoning_effort));
 const tiers = new Set(effortRoster.roster.map((row) => row.service_tier));
 const fastFlags = new Set(effortRoster.roster.map((row) => row.fast_mode));
-assertGate([...efforts].every((e) => e === 'low' || e === 'medium'), 'naruto clone efforts must be only low/medium (never high/xhigh)', { efforts: [...efforts] });
-assertGate(efforts.has('low') && efforts.has('medium'), 'naruto effort must be dynamic: a no-tool prompt must yield both low and medium clones', { efforts: [...efforts] });
-assertGate([...modelTiers].every((tier) => tier === 'codex-selected-low' || tier === 'codex-selected-medium'), 'Naruto must inherit the Codex-selected model and vary only reasoning effort', { modelTiers: [...modelTiers] });
-assertGate(modelTiers.has('codex-selected-low') && modelTiers.has('codex-selected-medium'), 'Naruto effort allocation must dynamically mix low and medium without changing model IDs', { modelTiers: [...modelTiers] });
-assertGate([...modelEfforts].every((effort) => effort === 'low' || effort === 'medium'), 'ordinary Naruto clone model reasoning must stay low/medium', { modelEfforts: [...modelEfforts] });
+assertGate([...efforts].every((effort) => effort === 'xhigh' || effort === 'max'), 'Naruto clone efforts must use only xhigh/max', { efforts: [...efforts] });
+assertGate([...effortRoster.roster].every((row) => ['gpt-5.6-luna', 'gpt-5.6-terra', 'gpt-5.6-sol'].includes(row.model)), 'Naruto workers must use only the GPT-5.6 trio', { models: [...new Set(effortRoster.roster.map((row) => row.model))] });
+assertGate([...modelTiers].every((tier) => /gpt-5\.6-(?:luna|terra|sol)-(?:xhigh|max)/.test(tier)), 'Naruto model tiers must record exact GPT-5.6 model and effort', { modelTiers: [...modelTiers] });
+assertGate([...modelEfforts].every((effort) => effort === 'xhigh' || effort === 'max'), 'Naruto model reasoning must use xhigh/max', { modelEfforts: [...modelEfforts] });
 assertGate([...tiers].length === 1 && tiers.has('fast'), 'every naruto clone must be fast service tier', { tiers: [...tiers] });
 assertGate([...fastFlags].length === 1 && fastFlags.has(true), 'every naruto clone must have fast_mode=true', { fastFlags: [...fastFlags] });
-// 4c) Unit rule: no tool use -> low; any tool use -> medium; always fast.
-const simple = effortPolicy.decideNarutoCloneEffort({ readonly: true, prompt: 'simple docs overview' });
-const toolWrite = effortPolicy.decideNarutoCloneEffort({ readonly: false, prompt: 'add a feature' });
-const toolReadCmd = effortPolicy.decideNarutoCloneEffort({ readonly: true, prompt: 'run the build and apply the migration' });
-const simpleWrite = effortPolicy.decideNarutoCloneEffort({ readonly: false, prompt: 'simple one-line typo fix' });
-assertGate(simple.reasoning_effort === 'low' && simple.service_tier === 'fast', 'no-tool read-only work must be low + fast', { simple });
-assertGate(simple.model === '' && simple.model_reasoning_effort === 'low', 'no-tool read-only work must inherit the Codex model at low effort', { simple });
-assertGate(toolWrite.reasoning_effort === 'medium' && toolWrite.service_tier === 'fast' && toolWrite.model === '' && toolWrite.model_reasoning_effort === 'medium', 'writing clone must inherit the Codex model at medium effort', { toolWrite });
-assertGate(simpleWrite.model === '' && simpleWrite.model_reasoning_effort === 'low', 'simple write work must inherit the Codex model at low effort', { simpleWrite });
-assertGate(toolReadCmd.reasoning_effort === 'medium' && toolReadCmd.service_tier === 'fast' && toolReadCmd.model_reasoning_effort === 'high', 'risky read-only command/migration work must escalate model reasoning to high', { toolReadCmd });
+// 4c) Deterministic work-kind matrix.
+const coding = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'implementer', naruto_role: 'implementer' }, prompt: 'implement a normal coding feature' });
+const criticalCoding = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'implementer', naruto_role: 'implementer' }, prompt: 'implement a critical security migration' });
+const refactor = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'integrator', naruto_role: 'integrator' }, prompt: 'refactor the architecture and integration plan' });
+const e2e = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'browser e2e verifier', naruto_role: 'verifier' }, prompt: 'run browser e2e tests' });
+const forensicGui = effortPolicy.decideNarutoCloneEffort({ persona: { role: 'Computer Use GUI verifier', naruto_role: 'verifier' }, prompt: 'forensic cross-app failure verification' });
+assertGate(coding.model === 'gpt-5.6-terra' && coding.model_reasoning_effort === 'xhigh', 'ordinary coding must use Terra xhigh', { coding });
+assertGate(criticalCoding.model === 'gpt-5.6-terra' && criticalCoding.model_reasoning_effort === 'max', 'critical coding must use Terra max', { criticalCoding });
+assertGate(refactor.model === 'gpt-5.6-sol' && refactor.model_reasoning_effort === 'max', 'refactor/architecture/integration must use Sol max', { refactor });
+assertGate(e2e.model === 'gpt-5.6-luna' && e2e.model_reasoning_effort === 'xhigh', 'browser E2E must use Luna xhigh', { e2e });
+assertGate(forensicGui.model === 'gpt-5.6-luna' && forensicGui.model_reasoning_effort === 'max', 'forensic Computer Use GUI verification must use Luna max', { forensicGui });
 // 5) System-safe concurrency: never spawn the whole count at once; throttle to host capacity.
 const fakeSafe = roster.systemSafeNarutoConcurrency({ backend: 'fake' });
 const heavySafe = roster.systemSafeNarutoConcurrency({ backend: 'codex-sdk' });
@@ -91,47 +90,60 @@ const run = spawnSync(process.execPath, [
     '--json',
     '--no-open-zellij'
 ], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 780000, maxBuffer: 8 * 1024 * 1024 });
-assertGate(run.status === 0, 'sks naruto run must exit 0', { status: run.status, stderr: tail(run.stderr) });
 const parsed = parseJson(run.stdout);
-assertGate(parsed !== null, 'sks naruto run must emit JSON', { stdout: tail(run.stdout) });
-assertGate(parsed.ok === true, 'naruto run must be ok', { ok: parsed.ok });
-assertGate(parsed.mode === 'NARUTO' && parsed.jutsu === 'kage_bunshin_no_jutsu', 'naruto run must report NARUTO mode', { mode: parsed.mode, jutsu: parsed.jutsu });
-assertGate(parsed.clones === proofClones, 'clone fan-out must use the requested queued count', { clones: parsed.clones });
-assertGate(parsed.max_clones === 100, 'naruto run must advertise the 100 ceiling', { max_clones: parsed.max_clones });
-assertGate(parsed.proof === 'passed', 'naruto run proof must pass', { proof: parsed.proof });
-// Throttle invariant: active concurrency never exceeds the requested count nor the host cap.
-assertGate(parsed.target_active_slots >= 1 && parsed.target_active_slots <= proofClones, 'active slots must be in [1, clones]', { target_active_slots: parsed.target_active_slots });
-assertGate(parsed.target_active_slots <= fakeSafe.cap, 'active slots must be throttled to the system-safe cap', { target_active_slots: parsed.target_active_slots, cap: fakeSafe.cap });
-assertGate(parsed.target_active_slots <= proofConcurrency && parsed.target_active_slots <= 4, 'release proof must keep Naruto live slots desktop-safe while queued fan-out remains larger', { target_active_slots: parsed.target_active_slots, proofConcurrency });
-// Task 9.1: fan-out (clones) and live concurrency (target_active_slots) are reported
-// distinctly, and concurrency_capped truthfully reflects "N clones, running M at a time".
-assertGate(typeof parsed.concurrency_capped === 'boolean', 'naruto run must report concurrency_capped', { concurrency_capped: parsed.concurrency_capped });
-assertGate(parsed.concurrency_capped === (parsed.clones > parsed.target_active_slots), 'concurrency_capped must reflect clones > live slots', { clones: parsed.clones, target_active_slots: parsed.target_active_slots, concurrency_capped: parsed.concurrency_capped });
-assertGate(parsed.system && Number(parsed.system.safe_concurrency) >= 1, 'naruto run must report system safe_concurrency (host-derived cap)', { system: parsed.system });
-assertGate(parsed.work_graph?.write_allowed_count > 0 && parsed.work_graph?.mixed_work_kinds?.length > 1, 'naruto run must report a mixed work graph with write-capable items', { work_graph: parsed.work_graph });
-assertGate(Number(parsed.work_graph?.parallel_write_wave_count || 0) > 0, 'naruto run must expose at least one parallel write-capable wave with non-overlapping leases', { work_graph: parsed.work_graph });
-assertGate(parsed.role_distribution?.verifier_only === false, 'naruto run proof/status must distinguish active worker roles beyond verifier-only', { role_distribution: parsed.role_distribution });
-assertGate(Number(parsed.role_distribution?.implementation_like_ratio || 0) >= 0.4, 'naruto run must include implementation-like role distribution', { role_distribution: parsed.role_distribution });
-const commandGraphPath = path.join(root, '.sneakoscope', 'missions', parsed.mission_id, 'agents', 'naruto-work-graph.json');
-const commandGraph = JSON.parse(fs.readFileSync(commandGraphPath, 'utf8'));
-const writePaths = commandGraph.work_items.filter((row) => row.write_allowed).flatMap((row) => row.write_paths);
-assertGate(new Set(writePaths).size > 1, 'naruto command default patch-envelope leases must be per work item, not one shared write path', { sample: writePaths.slice(0, 8), unique: new Set(writePaths).size });
-assertGate(commandGraph.active_waves.some((wave) => wave.write_paths.length > 1), 'naruto command graph must contain a parallel write wave when route-local patch envelopes do not overlap', { waves: commandGraph.active_waves.slice(0, 3) });
-const state = parsed.run?.scheduler?.state || parsed.run?.scheduler || {};
-assertGate(Number(state.completed_count) === Number(parsed.work_graph?.total_work_items || 0) && Number(state.completed_count) >= proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count, total_work_items: parsed.work_graph?.total_work_items, proofClones });
-assertGate(parsed.target_active_slots <= 4, 'explicit --concurrency cannot bypass the desktop-safe cap', { target_active_slots: parsed.target_active_slots });
+assertGate(parsed !== null, 'sks naruto run must emit JSON', { stdout: tail(run.stdout), stderr: tail(run.stderr) });
+let state = {};
+withMissionRouteClose(parsed, childEnv, () => {
+    assertGate(run.status === 0, 'sks naruto run must exit 0', { status: run.status, stderr: tail(run.stderr) });
+    assertGate(parsed.ok === true, 'naruto run must be ok', { ok: parsed.ok });
+    assertGate(parsed.mode === 'NARUTO' && parsed.jutsu === 'kage_bunshin_no_jutsu', 'naruto run must report NARUTO mode', { mode: parsed.mode, jutsu: parsed.jutsu });
+    assertGate(parsed.clones === proofClones, 'clone fan-out must use the requested queued count', { clones: parsed.clones });
+    assertGate(parsed.max_clones === 100, 'naruto run must advertise the 100 ceiling', { max_clones: parsed.max_clones });
+    assertGate(parsed.proof === 'passed', 'naruto run proof must pass', { proof: parsed.proof });
+    // Throttle invariant: active concurrency never exceeds the requested count nor the host cap.
+    assertGate(parsed.target_active_slots >= 1 && parsed.target_active_slots <= proofClones, 'active slots must be in [1, clones]', { target_active_slots: parsed.target_active_slots });
+    assertGate(parsed.target_active_slots <= fakeSafe.cap, 'active slots must be throttled to the system-safe cap', { target_active_slots: parsed.target_active_slots, cap: fakeSafe.cap });
+    assertGate(parsed.target_active_slots <= proofConcurrency && parsed.target_active_slots <= 4, 'release proof must keep Naruto live slots desktop-safe while queued fan-out remains larger', { target_active_slots: parsed.target_active_slots, proofConcurrency });
+    // Task 9.1: fan-out (clones) and live concurrency (target_active_slots) are reported
+    // distinctly, and concurrency_capped truthfully reflects "N clones, running M at a time".
+    assertGate(typeof parsed.concurrency_capped === 'boolean', 'naruto run must report concurrency_capped', { concurrency_capped: parsed.concurrency_capped });
+    assertGate(parsed.concurrency_capped === (parsed.clones > parsed.target_active_slots), 'concurrency_capped must reflect clones > live slots', { clones: parsed.clones, target_active_slots: parsed.target_active_slots, concurrency_capped: parsed.concurrency_capped });
+    assertGate(parsed.system && Number(parsed.system.safe_concurrency) >= 1, 'naruto run must report system safe_concurrency (host-derived cap)', { system: parsed.system });
+    assertGate(parsed.work_graph?.write_allowed_count > 0 && parsed.work_graph?.mixed_work_kinds?.length > 1, 'naruto run must report a mixed work graph with write-capable items', { work_graph: parsed.work_graph });
+    assertGate(Number(parsed.work_graph?.parallel_write_wave_count || 0) > 0, 'naruto run must expose at least one parallel write-capable wave with non-overlapping leases', { work_graph: parsed.work_graph });
+    assertGate(parsed.role_distribution?.verifier_only === false, 'naruto run proof/status must distinguish active worker roles beyond verifier-only', { role_distribution: parsed.role_distribution });
+    assertGate(Number(parsed.role_distribution?.implementation_like_ratio || 0) >= 0.4, 'naruto run must include implementation-like role distribution', { role_distribution: parsed.role_distribution });
+    assertGate(parsed.local_worker?.auto_select_eligible === false, 'normal Naruto must never auto-select a local/Ollama backend', { local_worker: parsed.local_worker });
+    const commandGraphPath = path.join(root, '.sneakoscope', 'missions', parsed.mission_id, 'agents', 'naruto-work-graph.json');
+    const commandGraph = JSON.parse(fs.readFileSync(commandGraphPath, 'utf8'));
+    const writePaths = commandGraph.work_items.filter((row) => row.write_allowed).flatMap((row) => row.write_paths);
+    assertGate(new Set(writePaths).size > 1, 'naruto command default patch-envelope leases must be per work item, not one shared write path', { sample: writePaths.slice(0, 8), unique: new Set(writePaths).size });
+    assertGate(commandGraph.active_waves.some((wave) => wave.write_paths.length > 1), 'naruto command graph must contain a parallel write wave when route-local patch envelopes do not overlap', { waves: commandGraph.active_waves.slice(0, 3) });
+    state = parsed.run?.scheduler?.state || parsed.run?.scheduler || {};
+    assertGate(Number(state.completed_count) === Number(parsed.work_graph?.total_work_items || 0) && Number(state.completed_count) >= proofClones, 'all clone work items must complete despite throttling', { completed_count: state.completed_count, total_work_items: parsed.work_graph?.total_work_items, proofClones });
+    assertGate(parsed.target_active_slots <= 4, 'explicit --concurrency cannot bypass the desktop-safe cap', { target_active_slots: parsed.target_active_slots });
+});
 // 7) A small request is never inflated; live pressure may still reduce it.
 const small = spawnSync(process.execPath, [cli, 'naruto', 'run', 'tiny', '--clones', '2', '--backend', 'fake', '--work-items', '2', '--json', '--no-open-zellij'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 600000, maxBuffer: 4 * 1024 * 1024 });
 const smallParsed = parseJson(small.stdout);
-assertGate(small.status === 0 && smallParsed?.target_active_slots >= 1 && smallParsed?.target_active_slots <= 2, 'a 2-clone run must stay within [1, 2] active workers', { status: small.status, target_active_slots: smallParsed?.target_active_slots });
+withMissionRouteClose(smallParsed, childEnv, () => {
+    assertGate(small.status === 0 && smallParsed?.target_active_slots >= 1 && smallParsed?.target_active_slots <= 2, 'a 2-clone run must stay within [1, 2] active workers', {
+        status: small.status,
+        target_active_slots: smallParsed?.target_active_slots,
+        stdout: tail(small.stdout),
+        stderr: tail(small.stderr)
+    });
+});
 // 8) Naruto clones always run fast. Per-route --no-fast / standard-tier requests
 //    are intentionally not honored for shadow clones.
 const standardOptOut = spawnSync(process.execPath, [cli, 'naruto', 'run', 'fast opt-out ignored', '--clones', '2', '--backend', 'fake', '--work-items', '2', '--no-fast', '--service-tier', 'standard', '--json', '--no-open-zellij'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 600000, maxBuffer: 4 * 1024 * 1024 });
 const standardOptOutParsed = parseJson(standardOptOut.stdout);
-assertGate(standardOptOut.status === 0 && standardOptOutParsed?.fast_mode_policy?.fast_mode === true && standardOptOutParsed?.fast_mode_policy?.service_tier === 'fast', 'naruto --no-fast / --service-tier standard must still run clones in fast mode', {
-    status: standardOptOut.status,
-    fast_mode_policy: standardOptOutParsed?.fast_mode_policy,
-    stderr: tail(standardOptOut.stderr)
+withMissionRouteClose(standardOptOutParsed, childEnv, () => {
+    assertGate(standardOptOut.status === 0 && standardOptOutParsed?.fast_mode_policy?.fast_mode === true && standardOptOutParsed?.fast_mode_policy?.service_tier === 'fast', 'naruto --no-fast / --service-tier standard must still run clones in fast mode', {
+        status: standardOptOut.status,
+        fast_mode_policy: standardOptOutParsed?.fast_mode_policy,
+        stderr: tail(standardOptOut.stderr)
+    });
 });
 emitGate('naruto:shadow-clone-swarm', {
     max_naruto_agent_count: schema.MAX_NARUTO_AGENT_COUNT,
@@ -162,4 +174,30 @@ function tail(value, limit = 2000) {
     const text = String(value || '');
     return text.length <= limit ? text : text.slice(-limit);
 }
+function closeMission(missionId, env) {
+    assertGate(Boolean(missionId), 'naruto proof mission id missing before route close', { missionId });
+    const closed = spawnSync(process.execPath, [cli, 'route', 'close', '--mission', String(missionId), '--json'], {
+        cwd: root,
+        env,
+        encoding: 'utf8',
+        timeout: 30000,
+        maxBuffer: 1024 * 1024
+    });
+    const parsedClose = parseJson(closed.stdout);
+    assertGate(closed.status === 0 && parsedClose?.ok === true, 'naruto proof mission route close must succeed', {
+        missionId,
+        status: closed.status,
+        stdout: tail(closed.stdout),
+        stderr: tail(closed.stderr)
+    });
+}
+function withMissionRouteClose(parsedResult, env, verify) {
+    try {
+        return verify();
+    }
+    finally {
+        if (parsedResult?.mission_id)
+            closeMission(parsedResult.mission_id, env);
+    }
+}
 //# sourceMappingURL=naruto-shadow-clone-swarm-check.js.map

package/dist/scripts/npm-publish-performance-check.js

@@ -3,9 +3,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { DEFAULT_MAX_PACK_BYTES } from '../core/release/package-size-budget.js';
 import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
 const MAX_FILES = Number(process.env.SKS_MAX_PACK_FILES || 2100);
-const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 2410 * 1024);
+const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || DEFAULT_MAX_PACK_BYTES);
 const BUDGET_MS = Number(process.env.SKS_PACK_BUDGET_MS || 30000);
 function runNpmPack() {
     const npmCli = process.env.npm_execpath; // set when invoked via `npm run`

package/dist/scripts/package-published-contract-check.js

@@ -7,6 +7,14 @@ import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
 const pkg = readJson('package.json');
 const scripts = pkg.scripts || {};
 const cacheRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-package-published-contract-'));
+let cacheCleaned = false;
+const cleanupCacheRoot = () => {
+    if (cacheCleaned)
+        return;
+    cacheCleaned = true;
+    fs.rmSync(cacheRoot, { recursive: true, force: true });
+};
+process.once('exit', cleanupCacheRoot);
 const dry = spawnSync('npm', ['pack', '--dry-run', '--json', '--ignore-scripts'], {
     cwd: root,
     encoding: 'utf8',
@@ -34,6 +42,7 @@ assertGate(missingTargets.length === 0, 'published package scripts must not refe
     missingTargets: missingTargets.slice(0, 50),
     missing_count: missingTargets.length
 });
+cleanupCacheRoot();
 emitGate('package:published-contract', {
     files: files.size,
     script_count: Object.keys(scripts).length,

package/dist/scripts/packlist-performance-check.js

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { DEFAULT_MAX_PACK_BYTES } from '../core/release/package-size-budget.js';
 import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
 const MAX_FILES = Number(process.env.SKS_MAX_PACK_FILES || 2100);
 const MAX_UNPACKED = Number(process.env.SKS_MAX_UNPACKED_BYTES || 10 * 1024 * 1024);
@@ -22,8 +23,10 @@ const MAX_UNPACKED = Number(process.env.SKS_MAX_UNPACKED_BYTES || 10 * 1024 * 10
 // checks; keep those scripts publishable because package contract validation
 // rejects scripts that point at files absent from the tarball. 5.12.0 adds ops
 // maturity diagnostics, migration/recovery smokes, and their package-referenced
-// gates, pushing the packed tarball to ~2400 KiB.
-const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 2410 * 1024);
+// gates, pushing the packed tarball to ~2400 KiB. 6.0.3 adds the menu restart
+// lifecycle and Naruto GPT-5.6 routing enforcement, bringing the measured
+// packed size to ~2411 KiB; keep the next 1 KiB boundary as the narrow cap.
+const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || DEFAULT_MAX_PACK_BYTES);
 const SURFACE_MAX_PACKED = Number(process.env.SKS_PACKAGE_SURFACE_MAX_PACK_BYTES || 25_000_000);
 const SURFACE_MAX_FILES = Number(process.env.SKS_PACKAGE_SURFACE_MAX_FILES || 2500);
 function runNpmPack() {

package/dist/scripts/postinstall-safe-side-effects-check.js

@@ -7,6 +7,8 @@ import { root, assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
 // side-effects by default. This is STATIC source analysis only — we never execute
 // `postinstall`, because doing so would mutate the global Codex App / shell environment.
 const helpers = readText('src/cli/install-helpers.ts');
+const desktopConfigPolicy = readText('src/core/codex-runtime/codex-desktop-config-policy.ts');
+const codexConfigGuard = readText('src/core/codex/codex-config-guard.ts');
 // Heavy CLI tool installs (brew / npm globals) are opt-in only.
 assertGate(helpers.includes('SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS'), 'postinstall cli tool install must be gated behind SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS');
 // Killing a third-party app's processes is opt-in only.
@@ -15,9 +17,12 @@ assertGate(helpers.includes('runPostinstallProjectRetentionCleanup') && helpers.
 // Config writes are gated (unparseable preserved / unsafe rewrite skipped) and backed up.
 assertGate(helpers.includes('unparseable_config_preserved'), 'postinstall must preserve unparseable config');
 assertGate(helpers.includes('skipped_unsafe_rewrite'), 'postinstall must skip unsafe config rewrites');
-assertGate(helpers.includes('backupCodexConfig'), 'postinstall config writes must back up the existing config');
-// User model / service_tier are set-if-absent, never overwritten.
-assertGate(helpers.includes('upsertTopLevelTomlStringIfAbsent'), 'postinstall must set user model/service_tier only when absent');
+assertGate(desktopConfigPolicy.includes('backupCodexConfig'), 'postinstall config writes must back up the existing config');
+// Host-owned feature choices are set-if-absent, and model/reasoning keys are
+// changed only when bounded SKS provenance proves SKS created them.
+assertGate(desktopConfigPolicy.includes('upsertTomlTableKeyIfAbsent')
+    && desktopConfigPolicy.includes('removeLegacyTopLevelCodexModeLocks')
+    && codexConfigGuard.includes('hasSksModeLockProvenance'), 'postinstall must preserve host-owned feature/model choices');
 // The postinstall() body must be wrapped in try/catch/finally so it never fails `npm install`.
 const postinstallStart = helpers.indexOf('export async function postinstall');
 assertGate(postinstallStart !== -1, 'postinstall function not found in install-helpers.ts');

package/dist/scripts/ppt-no-mock-as-real-check.js

@@ -3,6 +3,8 @@
 import { assertGate, emitGate, readMissionJson, runPptReview } from './sks-1-11-gate-lib.js';
 const result = runPptReview('review');
 const proof = readMissionJson(result.mission_id, 'completion-proof.json');
-assertGate(proof.status !== 'verified' && result.proof_evidence.status === 'verified_partial', 'ppt mock fixture was allowed to claim fully real evidence', { proof_status: proof.status, evidence_status: result.proof_evidence.status });
+assertGate(proof.status === 'mock_only'
+    && result.proof_evidence.status === 'blocked'
+    && (result.proof_evidence.blockers || []).some((blocker) => String(blocker).includes('mock_fixture')), 'ppt mock fixture was allowed to claim fully real evidence', { proof_status: proof.status, evidence_status: result.proof_evidence.status, blockers: result.proof_evidence.blockers || [] });
 emitGate('ppt:no-mock-as-real', { mission_id: result.mission_id, proof_status: proof.status });
 //# sourceMappingURL=ppt-no-mock-as-real-check.js.map

package/dist/scripts/product-design-plugin-routing-check.js

@@ -25,7 +25,7 @@ assertGate(PRODUCT_DESIGN_PLUGIN.app_server.install_params.remoteMarketplaceName
 assertGate(PRODUCT_DESIGN_PLUGIN.app_server.read_params.pluginName === PRODUCT_DESIGN_PLUGIN.remote_plugin_id, 'plugin/read must use Product Design remote plugin id');
 assertGate(PRODUCT_DESIGN_PLUGIN.app_server.install_params.pluginName === PRODUCT_DESIGN_PLUGIN.remote_plugin_id, 'plugin/install must use Product Design remote plugin id');
 assertGate(PRODUCT_DESIGN_PLUGIN.app_server.list_params.marketplaceKinds.includes('vertical'), 'plugin/list must query vertical marketplaces');
-for (const skill of ['audit', 'design-qa', 'get-context', 'ideate', 'image-to-code', 'prototype', 'research', 'share', 'url-to-code', 'user-context']) {
+for (const skill of ['audit', 'design-qa', 'get-context', 'ideate', 'image-to-code', 'index', 'research', 'share', 'url-to-code', 'user-context']) {
     assertGate(PRODUCT_DESIGN_REQUIRED_SKILLS.includes(skill), `Product Design required skill missing: ${skill}`);
 }
 assertGate(PRODUCT_DESIGN_PIPELINE_STAGES.length >= 5, 'Product Design pipeline stage map too small');

package/dist/scripts/release-check-stamp.js

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 const stampPath = process.env.SKS_RELEASE_STAMP_PATH || path.join(root, '.sneakoscope', 'reports', 'release-check-stamp.json');
 const command = process.argv[2] || 'verify';
+const commandArgs = process.argv.slice(3);
 const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 function fail(message, detail = '') {
     console.error(`Release check stamp failed: ${message}`);
@@ -270,7 +271,7 @@ function currentStampPayload() {
         include: (rel) => packageFileIncluded(`dist/${rel}`, packageEntries)
     });
     return {
-        schema: 'sks.release-check-stamp.v1',
+        schema: 'sks.release-check-stamp.v2',
         package_name: pkg.name,
         package_version: pkg.version,
         git_commit: gitCommit(),
@@ -285,8 +286,10 @@ function currentStampPayload() {
     };
 }
 function writeStamp() {
+    const releaseGateProof = fullReleaseGateProofForWrite();
     const payload = {
         ...currentStampPayload(),
+        release_gate_proof: releaseGateProof,
         generated_at: new Date().toISOString()
     };
     fs.mkdirSync(path.dirname(stampPath), { recursive: true });
@@ -318,6 +321,9 @@ function inspectStamp() {
         if (stamp[key] !== current[key])
             mismatches.push(`${key}: stamp=${stamp[key] || 'missing'} current=${current[key] || 'missing'}`);
     }
+    const proofInspection = inspectFullReleaseGateProof(stamp.release_gate_proof);
+    if (!proofInspection.ok)
+        mismatches.push(...proofInspection.blockers.map((blocker) => `release_gate_proof:${blocker}`));
     if (mismatches.length) {
         return {
             ok: false,
@@ -328,6 +334,180 @@ function inspectStamp() {
     }
     return { ok: true, current };
 }
+function fullReleaseGateProofForWrite() {
+    const preset = argValue('--preset');
+    const full = commandArgs.includes('--full');
+    if (preset !== 'release' || !full) {
+        fail('full release proof required to write publish stamp', 'Use `npm run release:check:full`; affected/fast/confidence checks cannot authorize publish.');
+    }
+    const explicit = argValue('--summary');
+    const summaryPath = explicit ? path.resolve(root, explicit) : latestFullReleaseSummaryPath();
+    if (!summaryPath)
+        fail('full release DAG summary missing', 'Run `npm run release:check:full` before writing the publish stamp.');
+    const reportRoot = path.resolve(root, '.sneakoscope', 'reports', 'release-gates');
+    const relative = path.relative(reportRoot, summaryPath);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        fail('release DAG summary is outside the managed report root');
+    let summary;
+    try {
+        summary = JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
+    }
+    catch (error) {
+        fail('unable to read full release DAG summary', error?.message || String(error));
+    }
+    const validation = validateFullReleaseSummary(summary);
+    if (validation.length)
+        fail('release DAG summary is not full publish proof', validation.join('\n'));
+    const explicitRealSummary = argValue('--real-summary');
+    const realSummaryPath = explicitRealSummary
+        ? path.resolve(root, explicitRealSummary)
+        : path.join(root, '.sneakoscope', 'reports', 'release-real-check.json');
+    const managedReports = path.resolve(root, '.sneakoscope', 'reports');
+    const realRelative = path.relative(managedReports, realSummaryPath);
+    if (realRelative.startsWith('..') || path.isAbsolute(realRelative))
+        fail('release real-check summary is outside the managed report root');
+    let realSummary;
+    try {
+        realSummary = JSON.parse(fs.readFileSync(realSummaryPath, 'utf8'));
+    }
+    catch (error) {
+        fail('unable to read release real-check summary', error?.message || String(error));
+    }
+    const realValidation = validateReleaseRealSummary(realSummary);
+    if (realValidation.length)
+        fail('release real-check summary is not publish proof', realValidation.join('\n'));
+    if (fs.statSync(realSummaryPath).mtimeMs < fs.statSync(summaryPath).mtimeMs)
+        fail('release real-check predates the full release DAG summary');
+    return {
+        schema: 'sks.release-check-full-proof.v1',
+        preset: 'release',
+        full: true,
+        run_id: summary.run_id,
+        summary_path: path.relative(root, summaryPath).split(path.sep).join('/'),
+        summary_sha256: sha256(fs.readFileSync(summaryPath)),
+        selected_gates: summary.selected_gates,
+        completed: summary.completed,
+        failed: summary.failed,
+        affected_mode: summary.affected_selection?.mode,
+        confidence: summary.completion_certificate?.confidence || null,
+        real_check_path: path.relative(root, realSummaryPath).split(path.sep).join('/'),
+        real_check_sha256: sha256(fs.readFileSync(realSummaryPath)),
+        real_check_count: realSummary.all_checks.length
+    };
+}
+function latestFullReleaseSummaryPath() {
+    const reportRoot = path.join(root, '.sneakoscope', 'reports', 'release-gates');
+    if (!fs.existsSync(reportRoot))
+        return null;
+    return fs.readdirSync(reportRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(reportRoot, entry.name, 'summary.json'))
+        .filter((file) => fs.existsSync(file))
+        .map((file) => ({ file, stat: fs.statSync(file) }))
+        .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)
+        .map((row) => row.file)
+        .find((file) => {
+        try {
+            return validateFullReleaseSummary(JSON.parse(fs.readFileSync(file, 'utf8'))).length === 0;
+        }
+        catch {
+            return false;
+        }
+    }) || null;
+}
+function validateFullReleaseSummary(summary) {
+    const blockers = [];
+    if (summary?.schema !== 'sks.release-gate-dag-run.v1')
+        blockers.push('summary_schema_invalid');
+    if (summary?.ok !== true)
+        blockers.push('summary_not_ok');
+    if (summary?.selected_preset !== 'release')
+        blockers.push('preset_not_release');
+    if (summary?.affected_selection?.mode !== 'full')
+        blockers.push('affected_mode_not_full');
+    if (!Number.isInteger(summary?.selected_gates) || summary.selected_gates <= 0)
+        blockers.push('selected_gates_empty');
+    if (summary?.failed !== 0)
+        blockers.push('failed_gates_present');
+    if (summary?.completed !== summary?.selected_gates)
+        blockers.push('not_all_selected_gates_completed');
+    if (!Array.isArray(summary?.selected_gate_ids) || summary.selected_gate_ids.length !== summary.selected_gates)
+        blockers.push('selected_gate_ids_incomplete');
+    if (summary?.completion_certificate?.confidence !== 'full-release-proof')
+        blockers.push('completion_confidence_not_full');
+    if (summary?.completion_certificate?.full_release_proof !== 'current_run')
+        blockers.push('full_release_proof_not_current_run');
+    return blockers;
+}
+function validateReleaseRealSummary(summary) {
+    const blockers = [];
+    if (summary?.schema !== 'sks.release-real-check.v1')
+        blockers.push('real_check_schema_invalid');
+    if (summary?.ok !== true)
+        blockers.push('real_check_not_ok');
+    if (!Array.isArray(summary?.all_checks) || summary.all_checks.length === 0)
+        blockers.push('real_check_empty');
+    else if (summary.all_checks.some((row) => row?.ok !== true))
+        blockers.push('real_check_failures_present');
+    return blockers;
+}
+function inspectFullReleaseGateProof(proof) {
+    const blockers = [];
+    if (proof?.schema !== 'sks.release-check-full-proof.v1')
+        blockers.push('proof_schema_invalid');
+    if (proof?.preset !== 'release' || proof?.full !== true)
+        blockers.push('proof_not_full_release');
+    const summaryPath = proof?.summary_path ? path.resolve(root, proof.summary_path) : null;
+    const reportRoot = path.resolve(root, '.sneakoscope', 'reports', 'release-gates');
+    if (!summaryPath || !fs.existsSync(summaryPath))
+        blockers.push('summary_missing');
+    else {
+        const relative = path.relative(reportRoot, summaryPath);
+        if (relative.startsWith('..') || path.isAbsolute(relative))
+            blockers.push('summary_outside_managed_reports');
+        else {
+            const bytes = fs.readFileSync(summaryPath);
+            if (sha256(bytes) !== proof.summary_sha256)
+                blockers.push('summary_hash_mismatch');
+            try {
+                const summary = JSON.parse(bytes);
+                blockers.push(...validateFullReleaseSummary(summary));
+                if (summary.run_id !== proof.run_id || summary.selected_gates !== proof.selected_gates || summary.completed !== proof.completed || summary.failed !== proof.failed)
+                    blockers.push('summary_identity_mismatch');
+            }
+            catch {
+                blockers.push('summary_parse_failed');
+            }
+        }
+    }
+    const realCheckPath = proof?.real_check_path ? path.resolve(root, proof.real_check_path) : null;
+    if (!realCheckPath || !fs.existsSync(realCheckPath))
+        blockers.push('real_check_summary_missing');
+    else {
+        const relative = path.relative(path.resolve(root, '.sneakoscope', 'reports'), realCheckPath);
+        if (relative.startsWith('..') || path.isAbsolute(relative))
+            blockers.push('real_check_summary_outside_managed_reports');
+        else {
+            const bytes = fs.readFileSync(realCheckPath);
+            if (sha256(bytes) !== proof.real_check_sha256)
+                blockers.push('real_check_summary_hash_mismatch');
+            try {
+                const realSummary = JSON.parse(bytes);
+                blockers.push(...validateReleaseRealSummary(realSummary));
+                if (realSummary.all_checks?.length !== proof.real_check_count)
+                    blockers.push('real_check_identity_mismatch');
+            }
+            catch {
+                blockers.push('real_check_summary_parse_failed');
+            }
+        }
+    }
+    return { ok: blockers.length === 0, blockers: [...new Set(blockers)] };
+}
+function argValue(name) {
+    const index = commandArgs.indexOf(name);
+    return index >= 0 ? commandArgs[index + 1] || null : null;
+}
 function verifyStamp() {
     const result = inspectStamp();
     if (!result.ok)
@@ -359,5 +539,5 @@ else if (command === 'verify')
 else if (command === 'ensure')
     ensureStamp();
 else
-    fail(`unknown command ${command}`, 'Usage: node ./dist/scripts/release-check-stamp.js <write|verify|ensure>');
+    fail(`unknown command ${command}`, 'Usage: node ./dist/scripts/release-check-stamp.js <write --preset release --full [--summary path]|verify|ensure>');
 //# sourceMappingURL=release-check-stamp.js.map

package/dist/scripts/release-dag-full-coverage-check.js

@@ -14,14 +14,14 @@ const requiredReleasePresetIds = [
     'qa-loop:comprehensive-verification',
     'loop-integration-finalizer-check',
     'naruto:canonical-stop-gate',
-    'agent:native-cli-session-swarm',
-    'agent:native-cli-session-proof',
-    'agent:fast-mode-worker-propagation',
-    'release:dag-full-coverage',
+    'agent:native-cli-session-swarm-scaling',
+    'agent:fast-mode-policy',
+    'codex-control:event-stream-ledger',
+    'release:dag-runner',
     'release:gate-budget',
-    'release:gate-planner',
+    'release:gate-selection-comprehensive',
     'policy:gate-audit',
-    'runtime:no-tmux',
+    'runtime:proof-summary',
     'typecheck'
 ];
 const requiredHarnessPresetIds = [
@@ -42,7 +42,7 @@ const schemaComplete = [...releaseManifest.gates, ...harnessManifest.gates].ever
 const report = {
     schema: 'sks.release-dag-full-coverage-check.v2',
     ok: schemaComplete
-        && releasePreset.length <= 220
+        && releasePreset.length <= 200
         && missingRequiredReleasePreset.length === 0
         && missingRequiredHarnessPreset.length === 0
         && duplicateAcrossManifests.length === 0

package/dist/scripts/release-dynamic-presets-check.js

@@ -15,6 +15,14 @@ assertGate(String(scripts['release:check:affected']).includes('build:incremental
 assertGate(dag.includes('selectAffectedReleaseGates'), 'release DAG must use affected selector');
 assertGate(dagMod.selectReleaseGatePreset(manifest, 'affected').length === releaseCount, 'affected preset must select the release gate universe before affected filtering');
 assertGate(dagMod.selectReleaseGatePreset(manifest, 'fast').length === releaseCount, 'fast preset must select the release gate universe before affected filtering');
+let unknownPresetBlocked = false;
+try {
+    dagMod.selectReleaseGatePreset(manifest, 'unknown-preset');
+}
+catch (error) {
+    unknownPresetBlocked = /release_gate_preset_empty_or_unknown/.test(String(error?.message || error));
+}
+assertGate(unknownPresetBlocked, 'unknown or empty release presets must fail closed');
 assertGate(runner.includes('--changed-since') && runner.includes('--full') && runner.includes('--sla'), 'release DAG runner must parse changed-since/full/sla');
 emitGate('release:dynamic-presets', { presets: 4 });
 //# sourceMappingURL=release-dynamic-presets-check.js.map

package/dist/scripts/release-gate-dag-runner-check.js

@@ -17,7 +17,8 @@ const effectiveReleaseCheck = delegatedReleaseCheck ? String(pkg.scripts[delegat
 assertGate(effectiveReleaseCheck.includes('release-gate-dag-runner.js'), 'release:check must execute DAG runner', { release_check: releaseCheck, delegated_release_check: delegatedReleaseCheck || null, effective_release_check: effectiveReleaseCheck });
 assertGate(!/&&\s*npm run\s+\w/.test(releaseCheck.replace('npm run build --silent &&', '')), 'release:check must not be a giant npm-run chain', releaseCheck);
 assertGate(!/&&\s*npm run\s+\w/.test(effectiveReleaseCheck.replace('npm run build:incremental --silent &&', '').replace('npm run build --silent &&', '')), 'effective release:check must not be a giant npm-run chain', effectiveReleaseCheck);
-assertGate(pkg.scripts['release:check:legacy'], 'release:check:legacy must exist for explicit debugging');
+assertGate(!pkg.scripts['release:check:legacy'], 'retired release:check:legacy alias must stay removed');
+assertGate(pkg.scripts['release:real-check'] === 'node ./dist/scripts/release-real-check.js', 'release:real-check must expose the canonical environment-dependent proof runner');
 assertGate(manifest.schema === 'sks.release-gates.v2' && manifest.gates.length >= 10, 'release-gates.v2 manifest must exist with nodes', manifest);
 for (const gateId of [
     'scheduler:comprehensive',
@@ -37,7 +38,7 @@ assertGate(runner.includes('detached: process.platform') && runner.includes('kil
 assertGate(runner.includes('pruneOldReleaseGateRunDirs') && runner.includes('SKS_RELEASE_GATE_RUN_RETENTION'), 'DAG runner must prune stale release-gate run reports before they exhaust local disk');
 assertGate(runnerCli.includes('ensureCurrentMigrationBeforeCommand') && runnerCli.includes('release-gate-runner-preflight'), 'DAG runner CLI must self-heal project migration before hermetic gates run');
 assertGate(hermeticEnv.includes('SKS_UPDATE_MIGRATION_GATE_DISABLED'), 'hermetic release gates must not rewrite project migration receipts from temporary HOME roots');
-assertGate(hermeticEnv.includes('legacy:update-e2e') && hermeticEnv.includes('migrationGateDisabled'), 'legacy:update-e2e must keep migration gate enabled while testing migration retry/repair behavior');
+assertGate(hermeticEnv.includes("input.gate.id === 'legacy:update-e2e'") && hermeticEnv.includes('delete gateEnv.SKS_UPDATE_MIGRATION_GATE_DISABLED'), 'legacy:update-e2e must explicitly remove an inherited disable flag while testing migration retry/repair behavior');
 const dag = await importDist('core/release/release-gate-dag.js');
 const fsx = await importDist('core/fsx.js');
 const fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-release-dag-timeout-'));