sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/mad-sks-zellij-launch-check.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-launcher.js')).href);
+const report = await mod.launchMadZellijUi(['--workspace', 'sks-mad-check'], {
+    root,
+    missionId: 'M-zellij-launch-check',
+    ledgerRoot: path.join(root, '.sneakoscope', 'missions', 'M-zellij-launch-check', 'agents'),
+    dryRun: true,
+    codexArgs: ['--profile', 'sks-mad-high', '--sandbox', 'danger-full-access', '--ask-for-approval', 'never', '-c', 'service_tier=fast', '-c', 'model_provider="codex-lb"'],
+    launchEnv: { SKS_MAD_SKS_TARGET_ROOT: root, SKS_PROTECTED_CORE_POLICY: path.join(root, '.sneakoscope', 'missions', 'M-zellij-launch-check', 'mad-sks-protected-core-policy.json') }
+});
+const paneProofExists = await fs.access(path.join(root, '.sneakoscope', 'missions', 'M-zellij-launch-check', 'zellij-pane-proof.json')).then(() => true).catch(() => false);
+const layoutText = await fs.readFile(report.layout_path, 'utf8');
+const installHelpers = await fs.readFile(path.join(root, 'src', 'cli', 'install-helpers.ts'), 'utf8');
+const madCommand = await fs.readFile(path.join(root, 'src', 'core', 'commands', 'mad-sks-command.ts'), 'utf8');
+const installSafetyOk = !installHelpers.includes("--from-postinstall', '--install-scope', 'global', '--force', '--yes")
+    && installHelpers.includes('SKS_POSTINSTALL_AUTO_INSTALL_CLI_TOOLS')
+    && installHelpers.includes('(zellijRepair as any).error || zellij.blockers[0]')
+    && installHelpers.includes('Codex CLI is missing. Install latest Codex CLI');
+const consoleDetailOk = madCommand.includes("['stderr_tail'")
+    && madCommand.includes("['stdout_tail'")
+    && madCommand.includes('report: ${launch.report_path}');
+const autoAttachOk = madCommand.includes('shouldAutoAttachZellij(args)')
+    && madCommand.includes('attachZellijSessionInteractive(launch.session_name')
+    && madCommand.includes("list.includes('--no-attach')")
+    && madCommand.includes("list.includes('--json')")
+    && madCommand.includes('process.env.ZELLIJ')
+    && madCommand.includes("list.includes('--attach')")
+    && madCommand.includes('process.stdout.isTTY && process.stdin.isTTY');
+const nativeSwarmOk = madCommand.includes('startMadNativeSwarm(')
+    && madCommand.includes('stripMadLaunchOnlyArgs(args, { includeGlmFlags: glmMadLaunch })')
+    && madCommand.includes('function madLaunchValueFlags(includeGlmFlags = false)')
+    && madCommand.includes("route: '$MAD-SKS'")
+    && madCommand.includes("route_command: 'sks --mad native swarm'")
+    && madCommand.includes("same_mission_ledger: true")
+    && madCommand.includes('slotCount: 0')
+    && madCommand.includes('zellijSessionName: launch.session_name')
+    && madCommand.includes('mad_sks.native_swarm_started');
+const codexPaneChecks = {
+    main_pane_kind: report.main_pane_kind === 'codex_interactive',
+    report_enabled: report.codex_pane?.enabled === true,
+    report_no_alt_screen_arg: report.codex_pane.args.includes('--no-alt-screen'),
+    report_profile_arg: report.codex_pane.args.includes('--profile') && report.codex_pane.args.includes('sks-mad-high'),
+    report_sandbox_arg: report.codex_pane.args.includes('--sandbox') && report.codex_pane.args.includes('danger-full-access'),
+    report_approval_arg: report.codex_pane.args.includes('--ask-for-approval') && report.codex_pane.args.includes('never'),
+    report_service_tier_arg: report.codex_pane.args.includes('service_tier=fast'),
+    report_provider_arg: report.codex_pane.args.some((arg) => /model_provider=.*codex-lb/.test(arg)),
+    report_target_env: report.codex_pane.launch_env_keys.includes('SKS_MAD_SKS_TARGET_ROOT'),
+    report_policy_env: report.codex_pane.launch_env_keys.includes('SKS_PROTECTED_CORE_POLICY'),
+    layout_orchestrator_pane: layoutText.includes('pane name="orchestrator" command="sh"'),
+    layout_codex_exec: /exec\s+'?codex'?/.test(layoutText),
+    layout_no_alt_screen_arg: layoutText.includes('--no-alt-screen'),
+    layout_profile_arg: layoutText.includes('--profile') && layoutText.includes('sks-mad-high'),
+    layout_sandbox_arg: layoutText.includes('--sandbox') && layoutText.includes('danger-full-access'),
+    layout_approval_arg: layoutText.includes('--ask-for-approval') && layoutText.includes('never'),
+    layout_service_tier_arg: layoutText.includes('service_tier=fast'),
+    layout_provider_arg: /model_provider=.*codex-lb/.test(layoutText),
+    layout_not_status_shell: !layoutText.includes('sks status --json || true; exec')
+};
+const codexPaneOk = Object.values(codexPaneChecks).every(Boolean);
+const clipboardCliOk = report.launch_command.includes('--copy-command')
+    && report.launch_command.includes('pbcopy')
+    && report.launch_command.includes('--copy-on-select')
+    && report.launch_command.includes('true')
+    && report.launch_command.includes('--mouse-mode')
+    && report.launch_command[report.launch_command.indexOf('--mouse-mode') + 1] === 'true'
+    && report.clipboard_mouse_mode === true
+    && !report.launch_command.includes('--copy-clipboard');
+const ok = report.kind === 'mad'
+    && report.layout_artifact
+    && report.layout_path
+    && report.pane_proof_path
+    && paneProofExists
+    && Array.isArray(report.launch_command)
+    && report.launch_command.join(' ').includes('attach --create-background')
+    && report.launch_command.includes('--default-layout')
+    && !report.launch_command.includes('--layout')
+    && !JSON.stringify(report).includes('tmux attach')
+    && installSafetyOk
+    && consoleDetailOk
+    && autoAttachOk
+    && nativeSwarmOk
+    && clipboardCliOk
+    && codexPaneOk;
+const gate = { schema: 'sks.mad-sks-zellij-launch-check.v1', ok, install_safety_ok: installSafetyOk, console_detail_ok: consoleDetailOk, auto_attach_ok: autoAttachOk, native_swarm_ok: nativeSwarmOk, clipboard_cli_ok: clipboardCliOk, codex_pane_ok: codexPaneOk, codex_pane_checks: codexPaneChecks, report };
+await writeMadZellijLaunchGate(gate);
+emit(gate);
+async function writeMadZellijLaunchGate(gate) {
+    await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+    await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'mad-sks-zellij-launch.json'), `${JSON.stringify(gate, null, 2)}\n`);
+}
+function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
+    process.exitCode = 1; }
+function fail(blocker, detail) { emit({ schema: 'sks.mad-sks-zellij-launch-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+//# sourceMappingURL=mad-sks-zellij-launch-check.js.map

package/dist/scripts/mad-zellij-headless-fallback-blackbox.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('mad:zellij-headless-fallback-blackbox');
+//# sourceMappingURL=mad-zellij-headless-fallback-blackbox.js.map

package/dist/scripts/mad-zellij-no-contradictory-output-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('mad:zellij-no-contradictory-output');
+//# sourceMappingURL=mad-zellij-no-contradictory-output-check.js.map

package/dist/scripts/mad-zellij-self-heal-blackbox.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('mad:zellij-self-heal-blackbox');
+//# sourceMappingURL=mad-zellij-self-heal-blackbox.js.map

package/dist/scripts/mad-zellij-self-heal-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
+await runDirective314Gate('mad:zellij-self-heal');
+//# sourceMappingURL=mad-zellij-self-heal-check.js.map

package/dist/scripts/managed-config-merge-check.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { assertGate, emitGate, makeTempRoot, writeText } from './sks-3-1-8-check-lib.js';
+import { writeManagedEnvConfig, writeManagedJsonConfig, writeManagedTomlConfig } from '../core/config/managed-config-merge.js';
+const root = await makeTempRoot('sks-managed-merge-');
+const envFile = path.join(root, '.env.local');
+await writeText(envFile, 'NEXT_PUBLIC_SUPABASE_ANON_KEY=keep-me\n');
+await writeManagedEnvConfig(envFile, await fs.readFile(envFile, 'utf8'), ['SKS_MANAGED=1', 'NEXT_PUBLIC_SUPABASE_ANON_KEY=replace-me']);
+const envText = await fs.readFile(envFile, 'utf8');
+const tomlFile = path.join(root, '.codex', 'config.toml');
+const toml = await writeManagedTomlConfig(tomlFile, '[mcp.supabase]\n# keep this comment\ntoken = "keep-token"\nunknown = "keep-unknown"\n', ['[mcp.supabase]\nurl = "https://example.supabase.co"']);
+const tomlAgain = await writeManagedTomlConfig(tomlFile, await fs.readFile(tomlFile, 'utf8'), ['[mcp.supabase]\nurl = "https://example.supabase.co"']);
+const jsonFile = path.join(root, '.sneakoscope', 'config.json');
+const json = await writeManagedJsonConfig(jsonFile, { supabase: { anon_key: 'keep-json', service_role_key: 'keep-service' }, mcp: { supabase: { token: 'keep-token-json' } } }, { supabase: { anon_key: 'replace-json', service_role_key: 'replace-service', url: 'x' }, mcp: { supabase: { token: 'replace-token-json', url: 'y' } } });
+const jsonText = await fs.readFile(jsonFile, 'utf8');
+const tomlText = await fs.readFile(tomlFile, 'utf8');
+assertGate(envText.includes('keep-me') && !envText.includes('replace-me'), 'env merge must preserve protected secret line', envText);
+assertGate(tomlText.includes('# keep this comment') && tomlText.includes('unknown = "keep-unknown"') && tomlText.includes('token = "keep-token"'), 'toml merge must preserve comments, unknown keys, and secret-bearing lines', tomlText);
+assertGate(jsonText.includes('keep-json') && jsonText.includes('keep-service') && jsonText.includes('keep-token-json') && !jsonText.includes('replace-json') && !jsonText.includes('replace-service') && !jsonText.includes('replace-token-json'), 'json merge must preserve nested protected secret values', jsonText);
+assertGate(toml.preserved_secret_lines_sha256.length > 0 && tomlAgain.changed === false, 'toml merge must report secret line hashes and be idempotent', { toml, tomlAgain });
+assertGate(toml.ok && json.ok, 'managed config merge results must be ok', { toml, json });
+emitGate('config:managed-merge');
+//# sourceMappingURL=managed-config-merge-check.js.map

package/dist/scripts/mcp-0-134-modernization-check.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/mcp/mcp-0-134-policy.js');
+const policy = mod.detectMcp0134PolicyFromConfig([
+    {
+        path: 'fixture.json',
+        text: JSON.stringify({
+            mcp_servers: {
+                docs: {
+                    transport: 'streamable_http',
+                    env: { DOCS_TOKEN: 'x' },
+                    oauth: { client_id: 'fixture' }
+                }
+            }
+        })
+    },
+    {
+        path: 'fixture.toml',
+        text: '[mcp_servers.docs_toml]\ntransport = "streamable_http"\n[mcp_servers.docs_toml.env]\nDOCS_TOKEN = "x"\n[mcp_servers.docs_toml.oauth]\nclient_id = "fixture"\n'
+    }
+]);
+const readOnly = mod.classifyMcpToolForConcurrency({ name: 'docs_search', annotations: { readOnlyHint: true }, inputSchema: { type: 'object' } });
+const destructive = mod.classifyMcpToolForConcurrency({ name: 'docs_delete', annotations: { readOnlyHint: true }, inputSchema: { type: 'object' } });
+const camelCaseDestructive = mod.classifyMcpToolForConcurrency({ name: 'writeFile', annotations: { readOnlyHint: true }, inputSchema: { type: 'object' } });
+const namespacedDestructive = mod.classifyMcpToolForConcurrency({ name: 'filesystem.writeFile', annotations: { readOnlyHint: true }, inputSchema: { type: 'object' } });
+const compacted = mod.compactMcpToolSchema({ type: 'object', properties: { item: { $ref: '#/$defs/Item' } }, $defs: { Item: { type: 'string' } }, description: 'x'.repeat(10000) }, 512);
+const compactedDefinitions = mod.compactMcpToolSchema({ type: 'object', properties: { item: { $ref: '#/definitions/Item' } }, definitions: { Item: { type: 'string' } }, description: 'x'.repeat(10000) }, 512);
+const report = {
+    schema: 'sks.mcp-0.134-modernization-check.v1',
+    ok: true,
+    policy,
+    readOnly,
+    destructive,
+    camelCaseDestructive,
+    namespacedDestructive,
+    compacted,
+    compactedDefinitions
+};
+assertGate(policy.per_server_environment_supported === true, 'MCP 0.134 policy must detect per-server env targeting', report);
+assertGate(policy.streamable_http_oauth_supported === true, 'MCP 0.134 policy must detect streamable HTTP OAuth', report);
+assertGate(policy.servers.some((server) => server.name === 'docs_toml' && server.environment_keys.includes('DOCS_TOKEN')), 'MCP 0.134 policy must detect nested TOML per-server env tables', report);
+assertGate(readOnly.concurrency === 'candidate_parallel_readonly', 'readOnlyHint safe tool should be candidate parallel readonly', report);
+assertGate(destructive.concurrency === 'serial_required', 'destructive readOnlyHint tool must remain serial', report);
+assertGate(camelCaseDestructive.concurrency === 'serial_required', 'camelCase destructive readOnlyHint tool must remain serial', report);
+assertGate(namespacedDestructive.concurrency === 'serial_required', 'namespaced destructive readOnlyHint tool must remain serial', report);
+assertGate(compacted.preserved_ref_defs === true, 'schema compaction must preserve $ref/$defs evidence', report);
+assertGate(compactedDefinitions.schema.definitions?.Item?.type === 'string', 'schema compaction must preserve definitions refs without moving them to $defs', report);
+const out = path.join(root, '.sneakoscope', 'reports', 'mcp-0-134-modernization.json');
+fs.mkdirSync(path.dirname(out), { recursive: true });
+fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+emitGate('mcp:0.134-modernization', { servers: policy.servers.length });
+//# sourceMappingURL=mcp-0-134-modernization-check.js.map

package/dist/scripts/mcp-plugin-inventory-check.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+process.env.SKS_CODEX_0138_FAKE = '1';
+process.env.SKS_CODEX_PLUGIN_JSON_FAKE = '1';
+const pluginMod = await importDist('core/codex-plugins/codex-plugin-json.js');
+const mcpMod = await importDist('core/mcp/mcp-plugin-inventory.js');
+const inventory = await pluginMod.buildCodexPluginInventory();
+const candidates = mcpMod.buildMcpPluginServerCandidates(inventory);
+assertGate(candidates.candidate_only === true && candidates.candidates.every((candidate) => candidate.auto_enable === false && candidate.destructive_tools_auto_enabled === false), 'remote MCP plugin inventory must be candidate-only and non-destructive by default', candidates);
+emitGate('mcp:plugin-inventory', { candidates: candidates.candidates.length });
+//# sourceMappingURL=mcp-plugin-inventory-check.js.map

package/dist/scripts/mcp-readonly-concurrency-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/mcp/mcp-0-134-policy.js');
+const readOnly = mod.classifyMcpToolForConcurrency({ name: 'search_docs', annotations: { readOnlyHint: true }, inputSchema: { type: 'object' } });
+const destructive = mod.classifyMcpToolForConcurrency({ name: 'delete_docs', annotations: { readOnlyHint: true }, inputSchema: { type: 'object' } });
+const report = { schema: 'sks.mcp-readonly-concurrency-check.v1', ok: readOnly.concurrency === 'candidate_parallel_readonly' && destructive.concurrency === 'serial_required', readOnly, destructive };
+const out = path.join(root, '.sneakoscope', 'reports', 'mcp-readonly-concurrency.json');
+fs.mkdirSync(path.dirname(out), { recursive: true });
+fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+assertGate(readOnly.concurrency === 'candidate_parallel_readonly', 'readOnlyHint non-destructive tools may be parallel candidates', report);
+assertGate(destructive.concurrency === 'serial_required', 'destructive tools remain serial even with readOnlyHint', report);
+assertGate(readOnly.advisory_only === true, 'readOnlyHint must remain advisory only', report);
+emitGate('mcp:readonly-concurrency', { read_only: readOnly.concurrency, destructive: destructive.concurrency });
+//# sourceMappingURL=mcp-readonly-concurrency-check.js.map

package/dist/scripts/mcp-readonly-runtime-scheduler-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/mcp/mcp-0-134-policy.js');
+const proof = await mod.proveMcpReadOnlyRuntimeScheduler();
+const report = { schema: 'sks.mcp-readonly-runtime-scheduler-check.v1', ok: proof.ok, proof };
+const out = path.join(root, '.sneakoscope', 'reports', 'mcp-readonly-runtime-scheduler.json');
+fs.mkdirSync(path.dirname(out), { recursive: true });
+fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+assertGate(proof.read_only_parallel === true, 'readOnlyHint fixtures must overlap at runtime', report);
+assertGate(proof.write_serial === true, 'write-capable MCP fixtures must be serialized', report);
+assertGate(proof.destructive_false_positive_blocked === true, 'destructive readOnlyHint false positive must be blocked', report);
+assertGate(proof.tools.every((row) => Number.isFinite(row.started_at_ms) && Number.isFinite(row.ended_at_ms)), 'MCP scheduler proof must include timestamps', report);
+assertGate(proof.ok === true, 'MCP runtime scheduler proof must be blocker-free', report);
+assertGate(proof.overlap_evidence.length >= 1, 'MCP scheduler proof must include actual overlap evidence rows', report);
+assertGate(proof.tools.filter((row) => row.scheduled_mode === 'parallel_readonly_batch').length >= 3, 'MCP scheduler proof must use at least three read-only tools', report);
+emitGate('mcp:readonly-runtime-scheduler', { overlaps: proof.overlap_evidence.length });
+//# sourceMappingURL=mcp-readonly-runtime-scheduler-check.js.map

package/dist/scripts/mcp-tool-naming-parity-check.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'mcp', 'mcp-tool-name-normalizer.js')).href);
+const report = mod.normalizeMcpToolInventory([{ server: 'github', name: 'search issues' }, { server: 'github', name: 'search_issues' }]);
+const ok = report.ok && report.collision_count === 1 && report.normalized.every((row) => row.normalized_name.includes('github'));
+emit({ schema: 'sks.mcp-tool-naming-parity-check.v1', ok, report });
+function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
+    process.exitCode = 1; }
+function fail(blocker, detail) { emit({ schema: 'sks.mcp-tool-naming-parity-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+//# sourceMappingURL=mcp-tool-naming-parity-check.js.map

package/dist/scripts/memory-summary-rebuild-check.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+const root = process.cwd();
+const wiki = spawnSync(process.execPath, [path.join(root, 'dist/bin/sks.js'), 'wiki', 'rebuild-summary', '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' },
+    timeout: 60_000
+});
+assert.equal(wiki.status, 0, wiki.stderr || wiki.stdout);
+const summary = JSON.parse(wiki.stdout);
+assert.equal(summary.schema, 'sks.memory-summary.v2');
+assert.equal(summary.summaries.triwiki.schema_version, 2);
+assert.equal(summary.summaries.wrongness.schema_version, 2);
+await fs.rm(path.join(root, '.sneakoscope/wiki/memory-summary.json'), { force: true });
+await fs.rm(path.join(root, '.sneakoscope/wiki/memory-summary.md'), { force: true });
+console.log(JSON.stringify({ schema: 'sks.memory-summary-rebuild-check.v1', ok: true, summary: summary.summaries }, null, 2));
+//# sourceMappingURL=memory-summary-rebuild-check.js.map

package/dist/scripts/model-call-concurrency-check.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { withModelCallSlot } from '../core/codex-control/model-call-concurrency.js';
+import { writeParallelRuntimeProof } from '../core/agents/parallel-runtime-proof.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const missionId = 'M-model-call-concurrency';
+const ledgerRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-model-call-'));
+await Promise.all(Array.from({ length: 8 }, (_, i) => withModelCallSlot({ root: ledgerRoot, missionId, provider: 'codex-sdk', budget: 3, slotId: `slot-${i}`, generationIndex: 1, sessionId: `s-${i}`, backend: 'codex-sdk' }, () => new Promise((resolve) => setTimeout(resolve, 80)))));
+const proof = await writeParallelRuntimeProof(ledgerRoot, missionId, { requestedWorkers: 1, targetActiveSlots: 1, minActiveWorkers: 0, minSpeedupRatio: 0 });
+assertGate(proof.max_observed_model_calls <= 3 && proof.unique_model_call_ids === 8, 'model-call semaphore did not enforce/record concurrency', proof);
+emitGate('model-call:concurrency', proof);
+//# sourceMappingURL=model-call-concurrency-check.js.map

package/dist/scripts/mutation-callsite-coverage-check.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+// @ts-nocheck
+// Repo-wide risky mutation callsite gate. Every raw mutation must be either a
+// guarded call or an external allowlist entry with a concrete function/symbol and
+// reason. The allowlist is intentionally data, not code, so unused/stale entries
+// fail the release gate.
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const allowlistPath = path.join(root, 'safety-mutation-allowlist.json');
+const allowlist = readAllowlist();
+const allowlistHits = new Set();
+const scanFiles = listScanFiles();
+const covered = [];
+const allowlisted = [];
+const uncovered = [];
+const GUARD_CALL = /\bguarded(WriteFile|Rm|Rename|Chmod|Xattr|Chflags|GlobalCodexConfigWrite|ProcessKill|PackageInstall|SkillSnapshotPromotion|Apply)\(/;
+const RISKY = [
+    { kind: 'write_file', token: 'fs.writeFile', re: /\bfs\.writeFile\(/ },
+    { kind: 'write_file', token: 'fs.promises.writeFile', re: /\bfs\.promises\.writeFile\(/ },
+    { kind: 'write_file', token: 'fsp.writeFile', re: /\bfsp\.writeFile\(/ },
+    { kind: 'write_file', token: 'writeFileSync', re: /\b(?:fs\.)?writeFileSync\(/ },
+    { kind: 'rm', token: 'fs.rm', re: /\bfs\.rm\(/ },
+    { kind: 'rm', token: 'fsp.rm', re: /\bfsp\.rm\(/ },
+    { kind: 'rm', token: 'rmSync', re: /\b(?:fs\.)?rmSync\(/ },
+    { kind: 'unlink', token: 'unlink', re: /\b(?:fs\.|fsp\.)?unlink\(/ },
+    { kind: 'unlink', token: 'unlinkSync', re: /\b(?:fs\.)?unlinkSync\(/ },
+    { kind: 'rename', token: 'rename', re: /\b(?:fs\.|fsp\.)?rename\(/ },
+    { kind: 'rename', token: 'renameSync', re: /\b(?:fs\.)?renameSync\(/ },
+    { kind: 'chmod', token: 'chmod', re: /\b(?:fs\.|fsp\.)?chmod\(/ },
+    { kind: 'chmod', token: 'chmodSync', re: /\b(?:fs\.)?chmodSync\(/ },
+    { kind: 'process_kill', token: 'process.kill', re: /\bprocess\.kill\(/ },
+    { kind: 'package_install', token: 'runProcess(npm/brew)', re: /runProcess\(\s*(?:npmBin|['"](?:npm|brew)['"])/ },
+    { kind: 'package_install', token: 'spawn(npm install)', re: /\bspawn(?:Sync)?\(\s*['"]npm['"][\s\S]{0,80}(?:install|i)\b/ },
+    { kind: 'xattr', token: 'xattr', re: /runProcess\(\s*['"]xattr['"]/ },
+    { kind: 'chflags', token: 'chflags', re: /runProcess\(\s*['"]chflags['"]/ },
+    { kind: 'codex_home_write', token: 'codex config write', re: /(?:~\/\.codex|CODEX_HOME|auth\.json|config\.toml)/ }
+];
+for (const rel of scanFiles) {
+    const text = fs.readFileSync(path.join(root, rel), 'utf8');
+    const lines = text.split('\n');
+    let currentSymbol = 'module';
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        currentSymbol = symbolFromLine(line) || currentSymbol;
+        if (isIgnoredLine(line))
+            continue;
+        if (GUARD_CALL.test(line)) {
+            covered.push({ file: rel, line: i + 1, symbol: currentSymbol, kind: 'guarded_call', snippet: snippet(line) });
+        }
+        for (const risky of RISKY) {
+            if (!risky.re.test(line))
+                continue;
+            if (risky.kind === 'package_install' && !packageMutationOnLine(line))
+                continue;
+            if (risky.kind === 'codex_home_write' && !codexHomeMutationOnLine(line))
+                continue;
+            if (risky.kind === 'process_kill' && processKillIsLivenessProbe(line))
+                continue;
+            const entry = { file: rel, line: i + 1, symbol: currentSymbol, kind: risky.kind, token: risky.token, snippet: snippet(line) };
+            const allow = findAllow(entry);
+            if (allow) {
+                allowlistHits.add(allow.id);
+                allowlisted.push({ ...entry, reason: allow.reason });
+            }
+            else {
+                uncovered.push(entry);
+            }
+        }
+    }
+}
+const unused_allowlist = allowlist.filter((entry) => !allowlistHits.has(entry.id)).map(({ id, file, symbol, token, reason }) => ({ id, file, symbol, token, reason }));
+const blanket_allowlist = allowlist.filter((entry) => !entry.symbol || entry.symbol === '*' || !entry.token || entry.token === '*');
+const ok = uncovered.length === 0 && unused_allowlist.length === 0 && blanket_allowlist.length === 0;
+const report = {
+    schema: 'sks.mutation-callsite-coverage.v2',
+    ok,
+    repo_wide: true,
+    allowlist_path: 'safety-mutation-allowlist.json',
+    scanned_file_count: scanFiles.length,
+    covered,
+    allowlisted,
+    uncovered,
+    unused_allowlist,
+    blanket_allowlist
+};
+const reportDir = path.join(root, '.sneakoscope', 'reports');
+fs.mkdirSync(reportDir, { recursive: true });
+fs.writeFileSync(path.join(reportDir, 'mutation-callsite-coverage.json'), `${JSON.stringify(report, null, 2)}\n`);
+assertGate(ok, 'repo-wide risky mutation call sites must be guarded or allowlisted-with-reason', {
+    scanned_file_count: scanFiles.length,
+    uncovered,
+    unused_allowlist,
+    blanket_allowlist
+});
+emitGate('safety:mutation-callsite-coverage', {
+    scanned_file_count: scanFiles.length,
+    covered: covered.length,
+    allowlisted: allowlisted.length,
+    uncovered: uncovered.length
+});
+function readAllowlist() {
+    const raw = JSON.parse(fs.readFileSync(allowlistPath, 'utf8'));
+    assertGate(raw.schema === 'sks.safety-mutation-allowlist.v1', 'mutation allowlist schema mismatch', raw);
+    assertGate(Array.isArray(raw.entries), 'mutation allowlist entries must be an array', raw);
+    return raw.entries.map((entry, index) => {
+        for (const key of ['file', 'symbol', 'token', 'reason']) {
+            assertGate(typeof entry[key] === 'string' && entry[key].trim().length > 0, `allowlist entry missing ${key}`, { index, entry });
+        }
+        assertGate(entry.reason.length >= 12, 'allowlist reason must be concrete', { index, entry });
+        return { ...entry, id: `${entry.file}:${entry.symbol}:${entry.token}:${index}` };
+    });
+}
+function listScanFiles() {
+    const files = [];
+    walk(path.join(root, 'src'), (file) => {
+        const relative = rel(file);
+        if (relative.startsWith('src/scripts/'))
+            return;
+        if (file.endsWith('.ts'))
+            files.push(relative);
+    });
+    walk(path.join(root, 'src', 'scripts'), (file) => {
+        if (!file.endsWith('.ts'))
+            return;
+        const base = path.basename(file);
+        if (/(install|publish|release|doctor|codex|zellij|migration)/i.test(base))
+            files.push(rel(file));
+    });
+    return files.sort();
+}
+function walk(dir, visit) {
+    let entries = [];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const file = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!['node_modules', 'dist', 'target'].includes(entry.name))
+                walk(file, visit);
+        }
+        else if (entry.isFile()) {
+            visit(file);
+        }
+    }
+}
+function findAllow(entry) {
+    return allowlist.find((allow) => entry.file === allow.file && entry.symbol === allow.symbol && entry.token === allow.token);
+}
+function symbolFromLine(line) {
+    const match = line.match(/(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_$]+)/)
+        || line.match(/(?:const|let|var)\s+([A-Za-z0-9_$]+)\s*=\s*(?:async\s*)?\(/)
+        || line.match(/class\s+([A-Za-z0-9_$]+)/);
+    return match?.[1] || null;
+}
+function isIgnoredLine(line) {
+    const trimmed = line.trim();
+    return !trimmed || trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*');
+}
+function packageMutationOnLine(line) {
+    return /\b(?:install|i|add|uninstall|remove|publish)\b/.test(line);
+}
+function processKillIsLivenessProbe(line) {
+    return /\bprocess\.kill\([^,\n]+,\s*0\s*\)/.test(line);
+}
+function codexHomeMutationOnLine(line) {
+    return /\b(?:writeTextAtomic|writeJsonAtomic|writeFileSync|fs\.writeFile|fs\.promises\.writeFile|fsp\.writeFile|fs\.rm|fsp\.rm|fs\.rename|fsp\.rename|fs\.chmod|fsp\.chmod|copyFile|open)\b/.test(line)
+        && /(?:~\/\.codex|CODEX_HOME|codexHome|codexLbHome|auth\.json|config\.toml)/.test(line);
+}
+function snippet(line) {
+    return line.trim().slice(0, 160);
+}
+function rel(file) {
+    return path.relative(root, file).split(path.sep).join('/');
+}
+//# sourceMappingURL=mutation-callsite-coverage-check.js.map

package/dist/scripts/naruto-active-pool-check.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const workGraph = await importDist('core/naruto/naruto-work-graph.js');
+const governorMod = await importDist('core/naruto/naruto-concurrency-governor.js');
+const activePool = await importDist('core/naruto/naruto-active-pool.js');
+const graph = workGraph.buildNarutoWorkGraph({ requestedClones: 20, totalWorkItems: 20, writeCapable: true, maxActiveWorkers: 5 });
+const governor = governorMod.decideNarutoConcurrency({
+    requestedClones: 20,
+    totalWorkItems: 20,
+    pendingWorkQueueSize: 20,
+    backend: 'fake',
+    hardware: { remoteApiRateLimitBudget: 5, fileDescriptorLimit: 4096, freeMemoryBytes: 8 * 1024 * 1024 * 1024, totalMemoryBytes: 16 * 1024 * 1024 * 1024 }
+});
+const report = activePool.simulateNarutoActivePool({ graph, governor: { ...governor, safe_active_workers: 5 } });
+assertGate(report.ok === true, 'active pool must drain cleanly', report);
+assertGate(report.max_observed_active_workers <= 5, 'active pool must never exceed safe cap', report);
+assertGate(report.max_observed_write_lease_conflicts === 0, 'active pool must never run overlapping write leases concurrently', report);
+assertGate(report.completed_count >= graph.total_work_items, 'active pool must complete all base work items', report);
+assertGate(report.refill_events >= 5, 'active pool must refill slots as work drains', report);
+assertGate(report.duplicate_execution_count === 0, 'active pool must not duplicate work without retry', report);
+const sameLeaseGraph = workGraph.buildNarutoWorkGraph({
+    requestedClones: 10,
+    totalWorkItems: 10,
+    writeCapable: true,
+    targetPaths: ['src/shared-fixture.ts'],
+    maxActiveWorkers: 5
+});
+const sameLeaseReport = activePool.simulateNarutoActivePool({ graph: sameLeaseGraph, governor: { ...governor, safe_active_workers: 5 } });
+assertGate(sameLeaseReport.ok === true, 'same-file work graph must drain without overlapping write leases', sameLeaseReport);
+assertGate(sameLeaseReport.max_observed_write_lease_conflicts === 0, 'same-file write items must be serialized or interleaved with read-only work only', sameLeaseReport);
+emitGate('naruto:active-pool', {
+    safe_active_workers: report.safe_active_workers,
+    completed_count: report.completed_count,
+    refill_events: report.refill_events,
+    max_observed_active_workers: report.max_observed_active_workers,
+    same_lease_max_write_conflicts: sameLeaseReport.max_observed_write_lease_conflicts
+});
+//# sourceMappingURL=naruto-active-pool-check.js.map

package/dist/scripts/naruto-actual-worker-control-plane-check.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { buildNarutoWorkGraph } from '../core/naruto/naruto-work-graph.js';
+import { collectActualNarutoWorker, spawnActualNarutoWorker } from '../core/naruto/naruto-real-worker-runtime.js';
+import { narutoCommand } from '../core/commands/naruto-command.js';
+process.env.SKS_CODEX_SDK_FAKE = '1';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-actual-worker-'));
+const graph = buildNarutoWorkGraph({ requestedClones: 1, totalWorkItems: 1, readonly: true, writeCapable: false });
+const item = graph.work_items[0];
+const handle = await spawnActualNarutoWorker({
+    root,
+    missionId: `M-naruto-actual-worker-${process.pid}`,
+    item,
+    placement: { placement: 'headless', visible_index: null, reason: 'check' },
+    backend: 'fake',
+    visiblePaneCap: 0
+});
+const collected = await collectActualNarutoWorker(handle);
+const result = JSON.parse(fs.readFileSync(path.join(handle.worker_artifact_dir, 'worker-result.json'), 'utf8'));
+const fullRoute = await narutoCommand([
+    'run',
+    'Naruto actual worker full command control plane check',
+    '--json',
+    '--backend',
+    'fake',
+    '--backend-explicit',
+    '--clones',
+    '2',
+    '--work-items',
+    '2',
+    '--readonly',
+    '--no-open-zellij',
+    '--smoke'
+]);
+const missionRoot = path.join(process.cwd(), '.sneakoscope', 'missions', fullRoute.mission_id || '', 'agents', 'naruto-real-workers');
+const fullWorkerResults = fs.existsSync(missionRoot)
+    ? fs.readdirSync(missionRoot).map((name) => {
+        const file = path.join(missionRoot, name, 'worker-result.json');
+        return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : null;
+    }).filter(Boolean)
+    : [];
+const ok = collected.ok === true
+    && result.ok === true
+    && result.control_plane_result?.worker_result_path
+    && result.control_plane_result?.structured_output_valid === true
+    && fullRoute.active_pool?.real_runtime?.runtime_source_of_truth === 'pre_run_smoke_only'
+    && fullRoute.runtime_source_of_truth === 'agent-orchestrator-scheduler'
+    && fullWorkerResults.length >= 1
+    && fullWorkerResults.every((row) => row.control_plane_result?.structured_output_valid === true);
+assertGate(ok, 'Naruto actual worker must call Codex Control Plane directly and through the explicit full-route smoke path', { collected, result, fullRoute, fullWorkerResults });
+emitGate('naruto:actual-worker-control-plane', { collected, result, full_route_mission_id: fullRoute.mission_id, full_worker_result_count: fullWorkerResults.length });
+//# sourceMappingURL=naruto-actual-worker-control-plane-check.js.map

package/dist/scripts/naruto-allocation-policy-check.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { allocateNarutoTasksToWorkers, chooseNarutoTaskOwner } from '../core/naruto/naruto-allocation-policy.js';
+const base = {
+    kind: 'implementation',
+    title: 'impl',
+    target_paths: ['src/core/naruto/runtime.ts'],
+    readonly_paths: [],
+    write_paths: ['src/core/naruto/runtime.ts'],
+    required_role: 'implementer',
+    write_allowed: true,
+    verification_required: true,
+    dependencies: [],
+    can_run_in_parallel_with: [],
+    conflicts_with: [],
+    estimated_cost: { tokens: 1, latency_ms: 1, cpu_weight: 1, memory_mb: 1, gpu_weight: 0 },
+    lease_requirements: [{ path: 'src/core/naruto/runtime.ts', kind: 'write' }],
+    acceptance: { requires_patch_envelope: true, requires_verification: true, requires_gpt_final: true }
+};
+const workers = [
+    { id: 'w1', role: 'implementer', lane: 'src/core' },
+    { id: 'w2', role: 'verifier', lane: 'src/scripts' }
+];
+const decision = chooseNarutoTaskOwner({ ...base, id: 'T1' }, workers);
+const blocked = chooseNarutoTaskOwner({ ...base, id: 'T2', dependencies: ['T0'] }, workers);
+const assignments = allocateNarutoTasksToWorkers([{ ...base, id: 'T1' }, { ...base, id: 'T2', required_role: 'verifier' }], workers);
+const ok = decision.owner === 'w1'
+    && decision.score >= 24
+    && blocked.score === Number.NEGATIVE_INFINITY
+    && assignments.length === 2;
+assertGate(ok, 'Naruto allocation policy must score role/lane overlap and block incomplete dependencies with -Infinity', { decision, blocked, assignments });
+emitGate('naruto:allocation-policy', { decision, blocked, assignments });
+//# sourceMappingURL=naruto-allocation-policy-check.js.map