sneakoscope 6.0.3 → 6.1.2

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

@@ -1,203 +1,6 @@
 #!/usr/bin/env node
-// @ts-nocheck
-// $Naruto Shadow Clone Swarm gate.
-// Proves Naruto can queue a 100-clone roster while active work stays bounded by
-// the desktop-safe resource governor.
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root, exists } from './sks-1-18-gate-lib.js';
-const schema = await importDist('core/agents/agent-schema.js');
-const roster = await importDist('core/agents/agent-roster.js');
-const scheduler = await importDist('core/agents/agent-scheduler.js');
-const effortPolicy = await importDist('core/agents/agent-effort-policy.js');
-// 1) Naruto ceiling exists and is 100; standard ceiling untouched at 20.
-assertGate(schema.MAX_NARUTO_AGENT_COUNT === 100, 'MAX_NARUTO_AGENT_COUNT must be 100', { value: schema.MAX_NARUTO_AGENT_COUNT });
-assertGate(schema.MAX_AGENT_COUNT === 20, 'MAX_AGENT_COUNT must remain 20 (standard ceiling)', { value: schema.MAX_AGENT_COUNT });
-// 2) Roster size can reach 100, but every scheduler caller stays desktop-safe.
-const narutoSlots = scheduler.normalizeTargetActiveSlots(100, schema.MAX_NARUTO_AGENT_COUNT);
-const defaultSlots = scheduler.normalizeTargetActiveSlots(100);
-assertGate(narutoSlots === 4, 'normalizeTargetActiveSlots(100, naruto-max) must retain the desktop-safe cap', { narutoSlots });
-assertGate(defaultSlots === 4, 'normalizeTargetActiveSlots(100) must stay desktop-safe', { defaultSlots });
-// 3) A 100-clone roster builds 100 unique clones (no unique-persona ceiling).
-const fullRoster = roster.buildNarutoCloneRoster({ clones: 100, maxAgentCount: schema.MAX_NARUTO_AGENT_COUNT });
-const uniqueIds = new Set(fullRoster.roster.map((row) => row.id)).size;
-assertGate(fullRoster.agent_count === 100, 'clone roster must have 100 clones', { agent_count: fullRoster.agent_count });
-assertGate(uniqueIds === 100, 'clone roster ids must be unique', { uniqueIds });
-assertGate(fullRoster.max_agents === 100, 'clone roster max_agents must be 100', { max_agents: fullRoster.max_agents });
-// 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) 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((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) 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' });
-const lowFreeButCapable = roster.systemSafeNarutoConcurrency({
-    backend: 'codex-sdk',
-    cores: 10,
-    freeBytes: 512 * 1024 * 1024,
-    totalBytes: 16 * 1024 * 1024 * 1024
-});
-assertGate(fakeSafe.cap >= 1 && fakeSafe.cap <= 4, 'fake-backend active concurrency cap must stay in [1, 4]', { fakeSafe });
-assertGate(heavySafe.cap >= 1 && heavySafe.cap <= 4, 'heavy-backend active concurrency cap must stay in [1, 4]', { heavySafe });
-assertGate(heavySafe.cap <= fakeSafe.cap, 'heavy backend must throttle no looser than the light backend', { heavySafe, fakeSafe });
-assertGate(heavySafe.cores >= 1, 'must detect at least one core', { cores: heavySafe.cores });
-assertGate(lowFreeButCapable.cap === 1, 'low free memory must collapse active Codex concurrency to one worker', { lowFreeButCapable });
-const bigMemoryHost = roster.systemSafeNarutoConcurrency({ backend: 'codex-sdk', cores: 4, freeBytes: 48 * 1024 * 1024 * 1024, totalBytes: 64 * 1024 * 1024 * 1024 });
-assertGate(bigMemoryHost.cap >= 1 && bigMemoryHost.cap <= 4, 'large memory must not bypass the interactive CPU cap', { bigMemoryHost });
-// 6) A small end-to-end run proves the same queue/drain path. The direct roster
-//    assertions above cover the 100-clone ceiling without making this release
-//    gate create dozens of unnecessary worker processes.
-const proofClones = 6;
-const proofConcurrency = 4;
-const cli = path.join(root, 'dist', 'bin', 'sks.js');
-const isolatedWorktreeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-shadow-wt-'));
-const childEnv = { ...process.env, SKS_WORKTREE_ROOT: isolatedWorktreeRoot, SKS_DISABLE_GIT_WORKTREE: '1' };
-assertGate(exists('dist/bin/sks.js'), 'dist/bin/sks.js missing (build first)');
-const helpRun = spawnSync(process.execPath, [cli, 'naruto', '--help', '--json'], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 30000, maxBuffer: 1024 * 1024 });
-const helpParsed = parseJson(helpRun.stdout);
-assertGate(helpRun.status === 0 && helpParsed?.action === 'help', 'sks naruto --help must emit help instead of launching a run', { status: helpRun.status, stdout: tail(helpRun.stdout), stderr: tail(helpRun.stderr) });
-const run = spawnSync(process.execPath, [
-    cli, 'naruto', 'run', 'shadow clone swarm gate proof',
-    '--clones', String(proofClones),
-    '--backend', 'fake',
-    '--work-items', String(proofClones),
-    '--concurrency', String(proofConcurrency),
-    '--json',
-    '--no-open-zellij'
-], { cwd: root, env: childEnv, encoding: 'utf8', timeout: 780000, maxBuffer: 8 * 1024 * 1024 });
-const parsed = parseJson(run.stdout);
-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);
-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);
-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,
-    standard_ceiling: schema.MAX_AGENT_COUNT,
-    default_clamp: defaultSlots,
-    naruto_slots_at_100: narutoSlots,
-    proof_clones: proofClones,
-    proof_concurrency: proofConcurrency,
-    target_active_slots: parsed.target_active_slots,
-    fake_safe_cap: fakeSafe.cap,
-    heavy_safe_cap: heavySafe.cap,
-    low_free_capable_cap: lowFreeButCapable.cap,
-    cores: heavySafe.cores,
-    completed_count: state.completed_count,
-    standard_opt_out_service_tier: standardOptOutParsed?.fast_mode_policy?.service_tier,
-    mission_id: parsed.mission_id,
-    isolated_worktree_root: isolatedWorktreeRoot
-});
-function parseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return null;
-    }
-}
-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);
-    }
-}
+// Compatibility entrypoint retained for the historical packed blackbox name.
+// The 6.1.1 Naruto contract is the Codex official subagent workflow.
+await import('./official-subagent-workflow-check.js');
+export {};
 //# sourceMappingURL=naruto-shadow-clone-swarm-check.js.map

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

@@ -4,13 +4,14 @@ 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 { readCurrentNpmPackProof, writeNpmPackProof } from '../core/release/npm-pack-proof.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 || 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`
-    const argv = ['pack', '--dry-run', '--json', '--ignore-scripts'];
+    const argv = ['pack', '--dry-run', '--ignore-scripts', '--json'];
     const res = npmCli
         ? spawnSync(process.execPath, [npmCli, ...argv], { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 })
         : spawnSync('npm', argv, { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
@@ -21,17 +22,23 @@ function writeReport(report) {
     fs.mkdirSync(path.dirname(out), { recursive: true });
     fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
 }
-const t0 = Date.now();
-const res = runNpmPack();
-const packMs = Date.now() - t0;
-let info;
-if (res.status === 0) {
-    try {
-        const parsed = JSON.parse(res.stdout);
-        info = Array.isArray(parsed) ? parsed[0] : parsed;
-    }
-    catch {
-        info = undefined;
+const existingProof = readCurrentNpmPackProof(root);
+let packMs = existingProof.ok && existingProof.proof ? existingProof.proof.pack_ms : 0;
+let info = existingProof.ok && existingProof.proof ? existingProof.proof.info : undefined;
+if (!info) {
+    const t0 = Date.now();
+    const res = runNpmPack();
+    packMs = Date.now() - t0;
+    if (res.status === 0) {
+        try {
+            const parsed = JSON.parse(res.stdout);
+            info = Array.isArray(parsed) ? parsed[0] : parsed;
+            if (info)
+                writeNpmPackProof(root, info, packMs);
+        }
+        catch {
+            info = undefined;
+        }
     }
 }
 if (!info) {
@@ -45,6 +52,7 @@ const report = {
     schema: 'sks.npm-publish-performance.v1',
     ok: info.entryCount <= MAX_FILES && info.size <= MAX_PACKED,
     pack_ms: packMs,
+    reused_pack_proof: existingProof.ok,
     slowest_phase: 'pack',
     file_count: info.entryCount,
     packed_bytes: info.size,

package/dist/scripts/official-subagent-workflow-check.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+import { buildOfficialSubagentPrompt } from '../core/subagents/official-subagent-prompt.js';
+import { SUBAGENT_PARENT_SUMMARY_FILENAME, persistOrReuseTrustworthySubagentParentSummary, writeSubagentEvidence } from '../core/subagents/subagent-evidence.js';
+import { resolveSubagentThreadBudget } from '../core/subagents/thread-budget.js';
+import { runOfficialSubagentWorkflow } from '../core/subagents/official-subagent-runner.js';
+const counts = [4, 8, 12, 20, 100].map((requested) => resolveSubagentThreadBudget({
+    requested,
+    configuredMaxThreads: requested === 20 ? 12 : undefined
+}));
+const implicitCount = resolveSubagentThreadBudget();
+assertGate(implicitCount.requestedSubagents === 1, 'implicit Naruto must default to one safe child', implicitCount);
+assertGate(counts[0]?.requestedSubagents === 4, 'requested 4 must remain 4', counts);
+assertGate(counts[1]?.requestedSubagents === 8, 'requested 8 must remain 8', counts);
+assertGate(counts[2]?.requestedSubagents === 12, 'requested 12 must remain 12', counts);
+assertGate(counts[3]?.requestedSubagents === 20 && counts[3]?.firstWave === 12 && counts[3]?.waveCount === 2, 'requested 20/maxThreads 12 must plan two waves without a 4/5 cap', counts);
+assertGate(counts[4]?.requestedSubagents === 32, 'requested 100 must use the official hard safety cap 32', counts);
+const prompt = buildOfficialSubagentPrompt({
+    goal: 'Review independent packages and report one parent summary.',
+    slices: [],
+    requestedSubagents: 12,
+    maxThreads: 12,
+    decompositionStatus: 'parent_required'
+});
+assertGate(/worker/i.test(prompt) && /expert/i.test(prompt), 'official delegation prompt must include worker and expert policy', { prompt });
+assertGate(/wait|await/i.test(prompt) && /all/i.test(prompt), 'official delegation prompt must require waiting for every requested subagent', { prompt });
+assertGate(/max.depth|max_depth|depth\s*1/i.test(prompt), 'official delegation prompt must keep max depth at 1', { prompt });
+const fixture = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-official-subagent-gate-'));
+try {
+    const events = [
+        { event: 'SubagentStart', agent: 'worker', thread_id: 'a1' },
+        { event: 'SubagentStart', agent: 'worker', thread_id: 'a2' },
+        { event: 'SubagentStart', agent: 'expert', thread_id: 'a3' },
+        { event: 'SubagentStop', agent: 'worker', thread_id: 'a1' },
+        { event: 'SubagentStop', agent: 'worker', thread_id: 'a2' },
+        { event: 'SubagentStop', agent: 'expert', thread_id: 'a3' }
+    ];
+    const structuredParentSummary = {
+        schema: 'sks.subagent-parent-summary.v1',
+        status: 'completed',
+        summary: 'All three official subagents completed and the parent integrated their findings.',
+        thread_outcomes: ['a1', 'a2', 'a3'].map((thread_id) => ({ thread_id, status: 'completed', summary: `${thread_id} complete` })),
+        changed_files: [],
+        verification: [],
+        blockers: []
+    };
+    const persistedParentSummary = await persistOrReuseTrustworthySubagentParentSummary(fixture, structuredParentSummary);
+    const persistedParentSummaryFile = JSON.parse(fs.readFileSync(path.join(fixture, SUBAGENT_PARENT_SUMMARY_FILENAME), 'utf8'));
+    assertGate(persistedParentSummaryFile.schema === 'sks.subagent-parent-summary.v1' && persistedParentSummaryFile.thread_outcomes.length === 3, 'structured parent summary must persist under the canonical artifact name', persistedParentSummaryFile);
+    const reusedParentSummary = await persistOrReuseTrustworthySubagentParentSummary(fixture, 'prose retry must not replace durable structured evidence');
+    assertGate(JSON.stringify(reusedParentSummary) === JSON.stringify(structuredParentSummary), 'untrusted prose must not downgrade a persisted trustworthy parent summary', { reusedParentSummary });
+    const explicitFailure = 'The parent integration failed with an error and did not complete.';
+    const failedParentSummary = await persistOrReuseTrustworthySubagentParentSummary(fixture, explicitFailure);
+    assertGate(failedParentSummary === explicitFailure && !fs.existsSync(path.join(fixture, SUBAGENT_PARENT_SUMMARY_FILENAME)), 'explicit failure prose must invalidate persisted successful parent evidence', { failedParentSummary });
+    const contradictedParentSummary = await persistOrReuseTrustworthySubagentParentSummary(fixture, structuredParentSummary, { workflowStatus: 'parent_failed' });
+    assertGate(contradictedParentSummary === null && !fs.existsSync(path.join(fixture, SUBAGENT_PARENT_SUMMARY_FILENAME)), 'failed parent workflow must override and invalidate a contradictory completed summary', { contradictedParentSummary });
+    const restoredParentSummary = await persistOrReuseTrustworthySubagentParentSummary(fixture, structuredParentSummary);
+    const evidence = await writeSubagentEvidence(fixture, {
+        requestedSubagents: 3,
+        events,
+        parentSummary: restoredParentSummary,
+        workflowStatus: 'completed',
+        preparationOnly: false
+    });
+    assertGate(evidence.ok === true && evidence.parent_summary_trustworthy === true, 'matched official SubagentStart/SubagentStop events plus a structured parent summary must pass', evidence);
+    assertGate(evidence.started_threads === 3 && evidence.completed_threads === 3 && evidence.failed_threads === 0, 'official event counts must be normalized without PID evidence', evidence);
+    assertGate(Array.isArray(evidence.event_sources) && evidence.event_sources.includes('SubagentStart') && evidence.event_sources.includes('SubagentStop'), 'official hook event sources must be retained', evidence);
+    const proseOnly = await writeSubagentEvidence(fixture, {
+        requestedSubagents: 3,
+        events,
+        parentSummary: 'All subagents stopped successfully.',
+        workflowStatus: 'completed',
+        preparationOnly: false
+    });
+    assertGate(proseOnly.ok === false && proseOnly.parent_summary_trustworthy === false && proseOnly.ambiguous_stop_thread_ids.length === 3, 'prose-only parent output must fail closed', proseOnly);
+    const ambiguous = await writeSubagentEvidence(fixture, {
+        requestedSubagents: 3,
+        events,
+        parentSummary: { ...structuredParentSummary, status: 'success' },
+        workflowStatus: 'completed',
+        preparationOnly: false
+    });
+    assertGate(ambiguous.ok === false && ambiguous.blockers.includes('parent_summary_status_ambiguous'), 'ambiguous parent status must fail closed', ambiguous);
+    const blocked = await writeSubagentEvidence(fixture, {
+        requestedSubagents: 3,
+        events,
+        parentSummary: {
+            ...structuredParentSummary,
+            status: 'blocked',
+            summary: 'Integration is blocked on a required result.',
+            thread_outcomes: structuredParentSummary.thread_outcomes.map((row) => ({ ...row, status: 'blocked', summary: `${row.thread_id} blocked` })),
+            blockers: ['fixture_blocker']
+        },
+        workflowStatus: 'blocked',
+        preparationOnly: false
+    });
+    assertGate(blocked.ok === false && blocked.parent_summary_status === 'failed', 'blocked parent outcomes must fail closed', blocked);
+    const failedResultText = await writeSubagentEvidence(fixture, {
+        requestedSubagents: 3,
+        events: events.map((row) => row.event === 'SubagentStop' && row.thread_id === 'a2'
+            ? { ...row, last_assistant_message: 'The delegated slice failed with an error.' }
+            : row),
+        parentSummary: structuredParentSummary,
+        workflowStatus: 'completed',
+        preparationOnly: false
+    });
+    assertGate(failedResultText.ok === false && failedResultText.failed_thread_ids.includes('a2'), 'unambiguous failed result text must override a contradictory completed claim', failedResultText);
+    let nestedLaunch = false;
+    const appResult = await runOfficialSubagentWorkflow({
+        root,
+        prompt,
+        requestedSubagents: 3,
+        maxThreads: 12,
+        appSession: true,
+        runProcessImpl: async () => {
+            nestedLaunch = true;
+            throw new Error('nested launch forbidden');
+        }
+    });
+    assertGate(nestedLaunch === false && appResult.ok === false && appResult.status === 'delegation_context_ready' && appResult.completion_evidence === false, 'in-app preparation must not launch nested codex or count as completion', appResult);
+    const facade = fs.readFileSync(path.join(root, 'src', 'core', 'commands', 'naruto-command.ts'), 'utf8');
+    const preparationOwner = fs.readFileSync(path.join(root, 'src', 'core', 'subagents', 'official-subagent-preparation.ts'), 'utf8');
+    assertGate(!facade.includes('naruto-command-legacy') && !fs.existsSync(path.join(root, 'src', 'core', 'commands', 'naruto-command-legacy.ts')), 'legacy Naruto process swarm command must be removed and unreachable');
+    assertGate(!facade.includes("from '../agents/agent-orchestrator.js'") && !facade.includes("from '../agents/native-cli-session-swarm.js'"), 'default Naruto facade must not eager-import the process orchestrator');
+    assertGate(facade.includes('prepareOfficialSubagentMission'), 'Naruto facade must delegate preparation to the shared official-subagent owner');
+    assertGate(preparationOwner.includes('delegation_prompt: delegationPrompt'), 'canonical subagent plan must persist the official delegation prompt required by the stop gate');
+    emitGate('naruto:official-subagent-workflow', {
+        requested_counts: counts.map((row) => row.requestedSubagents),
+        max_threads: counts.map((row) => row.maxThreads),
+        event_evidence: {
+            started: evidence.started_threads,
+            completed: evidence.completed_threads,
+            failed: evidence.failed_threads
+        },
+        app_nested_launch: nestedLaunch,
+        native_process_proof_required: false
+    });
+}
+finally {
+    fs.rmSync(fixture, { recursive: true, force: true });
+}
+//# sourceMappingURL=official-subagent-workflow-check.js.map

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

@@ -1,27 +1,13 @@
 #!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
+import { readCurrentNpmPackProof } from '../core/release/npm-pack-proof.js';
 const pkg = readJson('package.json');
 const scripts = pkg.scripts || {};
-const cacheRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-package-published-contract-'));
-const dry = spawnSync('npm', ['pack', '--dry-run', '--json', '--ignore-scripts'], {
-    cwd: root,
-    encoding: 'utf8',
-    env: {
-        ...process.env,
-        npm_config_cache: path.join(cacheRoot, 'npm-cache')
-    },
-    maxBuffer: 16 * 1024 * 1024
-});
-assertGate(dry.status === 0, 'npm pack --dry-run must succeed for package contract check', {
-    status: dry.status,
-    stderr: dry.stderr
-});
-const parsed = JSON.parse(dry.stdout || '[]');
-const files = new Set((parsed[0]?.files || []).map((row) => String(row.path || '').replace(/\\/g, '/')));
+const packProof = readCurrentNpmPackProof(root);
+assertGate(packProof.ok && packProof.proof, 'current npm pack proof is required for package contract check', { blockers: packProof.blockers });
+const info = packProof.proof.info;
+const files = new Set((info.files || []).map((row) => String(row.path || '').replace(/\\/g, '/')));
 const missingTargets = [];
 for (const [name, command] of Object.entries(scripts)) {
     for (const target of scriptTargets(String(command))) {
@@ -38,7 +24,7 @@ emitGate('package:published-contract', {
     files: files.size,
     script_count: Object.keys(scripts).length,
     missing_targets: 0,
-    package: path.basename(parsed[0]?.filename || '')
+    package: path.basename(info.filename || '')
 });
 function scriptTargets(command) {
     const targets = [];

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

@@ -4,10 +4,11 @@ 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 { DEFAULT_MAX_PACK_BYTES, DEFAULT_MAX_UNPACKED_BYTES } from '../core/release/package-size-budget.js';
+import { writeNpmPackProof } from '../core/release/npm-pack-proof.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);
+const MAX_UNPACKED = Number(process.env.SKS_MAX_UNPACKED_BYTES || DEFAULT_MAX_UNPACKED_BYTES);
 // Raised from 2300 KiB after the 5.4.0 dollar-command hardening pass added
 // src/core/feature-fixture-executor.ts and expanded several command modules
 // (route-success-helpers.ts, seo-command.ts, ppt-command.ts, qa-loop-command.ts,
@@ -33,7 +34,7 @@ function runNpmPack() {
     const npmCli = process.env.npm_execpath; // set when invoked via `npm run`
     const npmCache = process.env.SKS_RELEASE_NPM_CACHE || path.join(os.tmpdir(), 'sneakoscope-npm-cache');
     fs.mkdirSync(npmCache, { recursive: true });
-    const argv = ['pack', '--dry-run', '--json', '--ignore-scripts'];
+    const argv = ['pack', '--dry-run', '--ignore-scripts', '--json'];
     const opts = {
         cwd: root,
         encoding: 'utf8',
@@ -49,7 +50,9 @@ function runNpmPack() {
         : spawnSync('npm', argv, opts);
     return res;
 }
+const packStarted = Date.now();
 const res = runNpmPack();
+const packMs = Date.now() - packStarted;
 assertGate(res.status === 0, 'npm_pack_failed', { stderr: res.stderr });
 let info;
 try {
@@ -60,6 +63,7 @@ catch (err) {
     assertGate(false, 'npm_pack_unparseable', { error: String(err && err.message ? err.message : err) });
 }
 const files = info.files.map((f) => f.path);
+const packProof = writeNpmPackProof(root, info, packMs);
 const runtimeManifest = JSON.parse(fs.readFileSync(path.join(root, 'runtime-required-scripts.json'), 'utf8'));
 assertGate(runtimeManifest.schema === 'sks.runtime-required-scripts.v1' && Array.isArray(runtimeManifest.scripts), 'runtime required scripts manifest invalid', runtimeManifest);
 assertGate(info.entryCount <= MAX_FILES, 'packlist_file_count_over_limit', { entryCount: info.entryCount, max_files: MAX_FILES });
@@ -72,6 +76,9 @@ for (const entry of runtimeManifest.scripts) {
 assertGate(files.includes('package.json'), 'packlist_missing_runtime_entry', { missing: 'package.json' });
 assertGate(files.includes('README.md'), 'packlist_missing_runtime_entry', { missing: 'README.md' });
 assertGate(files.includes('LICENSE'), 'packlist_missing_runtime_entry', { missing: 'LICENSE' });
+for (const manifest of ['release-gates.v2.json', 'infra-harness-gates.json', 'runtime-required-scripts.json']) {
+    assertGate(files.includes(manifest), 'packlist_missing_runtime_manifest', { missing: manifest });
+}
 assertGate(files.some((f) => f.startsWith('schemas/')), 'packlist_missing_runtime_entry', { missing: 'schemas/' });
 const forbidden = files.filter((f) => f.startsWith('test/') ||
     f.startsWith('src/') ||
@@ -93,6 +100,10 @@ const report = {
     entryCount: info.entryCount,
     size: info.size,
     unpackedSize: info.unpackedSize,
+    pack_ms: packMs,
+    pack_proof_id: packProof.proof_id,
+    pack_info_sha256: packProof.info_digest,
+    pack_file_list_sha256: packProof.file_list_digest,
     runtime_required_scripts: runtimeManifest.scripts.map((entry) => entry.path),
     runtime_required_missing: runtimeManifest.scripts.filter((entry) => !files.includes(entry.path)).map((entry) => entry.path),
     max_files: MAX_FILES,
@@ -112,6 +123,9 @@ const surfaceReport = {
     max_file_count: SURFACE_MAX_FILES,
     actual_tarball_bytes: info.size,
     actual_file_count: info.entryCount,
+    pack_proof_id: packProof.proof_id,
+    pack_info_sha256: packProof.info_digest,
+    pack_file_list_sha256: packProof.file_list_digest,
     forbidden_globs: [
         'dist/**/__tests__/**',
         'dist/**/*.test.js',

package/dist/scripts/parallel-verification-engine-check.js

@@ -19,9 +19,9 @@ for (const rel of [
 }
 await runFixture();
 const releaseSource = read('src/scripts/release-parallel-check.ts');
-for (const token of ['runVerificationDag', 'buildVerificationDag', 'writeParallelVerificationProof']) {
+for (const token of ['release-gate-dag-runner.js', "'--preset', 'release', '--full'", 'spawnSync(process.execPath']) {
     if (!releaseSource.includes(token))
-        issues.push(`release_parallel_runner_missing:${token}`);
+        issues.push(`release_parallel_redirect_missing:${token}`);
 }
 const result = { schema: 'sks.parallel-verification-engine-check.v1', ok: issues.length === 0, issues };
 console.log(JSON.stringify(result, null, 2));

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