sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/mad-db-mcp-result-lifecycle-check.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { checkDbOperation, madDbLifecycleHookFromDecision } from '../core/db-safety.js';
+import { evaluateHookPayload } from '../core/hooks-runtime.js';
+import { createMadDbCapability, MAD_DB_ACK } from '../core/mad-db/mad-db-capability.js';
+import { missionDir } from '../core/mission.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-db-mcp-result-'));
+const missionId = 'M-mad-db-mcp-result';
+await createMadDbCapability(root, { missionId, ack: MAD_DB_ACK, ttlMs: 60000 });
+const successPayload = { tool_name: 'supabase.execute_sql', sql: 'insert into audit_log(id) values (1)' };
+const successDecision = await checkDbOperation(root, { mission_id: missionId }, successPayload);
+const successHook = madDbLifecycleHookFromDecision(successDecision);
+assertGate(Boolean(successHook), 'Mad-DB lifecycle hook missing before post-tool success result', successDecision);
+await evaluateHookPayload('post-tool', { tool_name: successPayload.tool_name, success: true, row_count: 1 }, { root, state: { mission_id: missionId } });
+const failurePayload = { tool_name: 'supabase.execute_sql', sql: 'update audit_log set id = 2 where id = 1' };
+const failureDecision = await checkDbOperation(root, { mission_id: missionId }, failurePayload);
+const failureHook = madDbLifecycleHookFromDecision(failureDecision);
+assertGate(Boolean(failureHook), 'Mad-DB lifecycle hook missing before post-tool MCP isError result', failureDecision);
+await evaluateHookPayload('post-tool', {
+    tool_name: failurePayload.tool_name,
+    result: { isError: true, content: [{ type: 'text', text: 'fixture MCP error' }] }
+}, { root, state: { mission_id: missionId } });
+const ledger = await fs.readFile(path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl'), 'utf8');
+assertGate(ledger.includes('db_operation.succeeded') && ledger.includes('db_operation.failed') && ledger.includes('fixture MCP error'), 'PostToolUse must append succeeded and MCP isError failed lifecycle events', { ledger });
+emitGate('mad-db:mcp-result-lifecycle', { success_operation_id: successHook.operation_id, failure_operation_id: failureHook.operation_id, status: 'succeeded_and_failed_checked' });
+//# sourceMappingURL=mad-db-mcp-result-lifecycle-check.js.map

package/dist/scripts/mad-db-one-cycle-bounded-check.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { closeMadDbCycle, createMadDbCapability, MAD_DB_ACK, readMadDbCapability } from '../core/mad-db/mad-db-capability.js';
+import { checkDbOperation } from '../core/db-safety.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-db-bounded-'));
+const missionId = 'M-mad-db-bounded';
+process.env.SKS_MAD_DB_MAX_OPERATIONS = '2';
+const cap = await createMadDbCapability(root, { missionId, ack: MAD_DB_ACK, ttlMs: 60000 });
+assertGate(cap.max_operations >= 2 && cap.operation_count === 0, 'capability must start as bounded one-cycle', cap);
+const payload = { tool_name: 'supabase.execute_sql', sql: 'update users set flag = true where id = 1' };
+const first = await checkDbOperation(root, { mission_id: missionId }, payload);
+const afterFirst = await readMadDbCapability(root, missionId);
+assertGate(first.allowed === true && afterFirst.operation_count === 1 && afterFirst.consumed === false, 'capability must remain active after operation 1 when max_operations > 1', { first, afterFirst });
+const second = await checkDbOperation(root, { mission_id: missionId }, payload);
+const afterSecond = await readMadDbCapability(root, missionId);
+assertGate(second.allowed === true && afterSecond.operation_count === 2 && afterSecond.consumed === true, 'capability must be consumed when operation_count reaches max_operations', { second, afterSecond });
+const closeMissionId = 'M-mad-db-close-cycle';
+process.env.SKS_MAD_DB_MAX_OPERATIONS = '20';
+const closeCap = await createMadDbCapability(root, { missionId: closeMissionId, ack: MAD_DB_ACK, ttlMs: 60000 });
+const closed = await closeMadDbCycle(root, closeMissionId, closeCap.cycle_id);
+assertGate(closed?.consumed === true && closed?.consumed_by === 'mad-db-cycle-close', 'explicit cycle close must consume active capability', closed);
+emitGate('mad-db:one-cycle-bounded', { cycle_id: cap.cycle_id, operation_count: afterSecond.operation_count, max_operations: afterSecond.max_operations, close_cycle: closed?.consumed === true });
+//# sourceMappingURL=mad-db-one-cycle-bounded-check.js.map

package/dist/scripts/mad-db-one-cycle-consumption-check.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const missionMod = await importDist('core/mission.js');
+const capMod = await importDist('core/mad-db/mad-db-capability.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-mad-db-consume-'));
+const mission = await missionMod.createMission(root, { mode: 'mad-db', prompt: 'fixture' });
+const cap = await capMod.createMadDbCapability(root, { missionId: mission.id, ack: capMod.MAD_DB_ACK, cwd: root });
+await capMod.consumeMadDbCapability(root, mission.id, { consumedBy: 'fixture' });
+const consumed = await capMod.readMadDbCapability(root, mission.id);
+assertGate(capMod.isMadDbCapabilityActive(consumed) === false && consumed.consumed === true, 'Mad-DB capability must be inactive after consumption', consumed);
+assertGate(fs.existsSync(path.join(root, '.sneakoscope', 'missions', mission.id, 'mad-db-capability.consumed.json')), 'consumed proof artifact missing');
+emitGate('mad-db:one-cycle-consumption', { cycle_id: cap.cycle_id });
+//# sourceMappingURL=mad-db-one-cycle-consumption-check.js.map

package/dist/scripts/mad-db-operation-lifecycle-blackbox.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { checkDbOperation, madDbLifecycleHookFromDecision } from '../core/db-safety.js';
+import { createMadDbCapability, MAD_DB_ACK } from '../core/mad-db/mad-db-capability.js';
+import { recordMadDbToolResult } from '../core/mad-db/mad-db-result-lifecycle.js';
+import { missionDir } from '../core/mission.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-db-lifecycle-blackbox-'));
+const missionId = 'M-mad-db-lifecycle-blackbox';
+await createMadDbCapability(root, { missionId, ack: MAD_DB_ACK, ttlMs: 60000 });
+const success = await checkDbOperation(root, { mission_id: missionId }, { tool_name: 'supabase.execute_sql', sql: 'insert into audit_log(id) values (1)' });
+const successHook = madDbLifecycleHookFromDecision(success);
+assertGate(Boolean(successHook), 'success hook missing', success);
+await recordMadDbToolResult({ root, missionId, hook: successHook, ok: true, rowCount: 1 });
+const failure = await checkDbOperation(root, { mission_id: missionId }, { tool_name: 'supabase.execute_sql', sql: 'update users set flag = true where id = 1' });
+const failureHook = madDbLifecycleHookFromDecision(failure);
+assertGate(Boolean(failureHook), 'failure hook missing', failure);
+await recordMadDbToolResult({ root, missionId, hook: failureHook, ok: false, error: 'fixture failure' });
+const ledger = await fs.readFile(path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl'), 'utf8');
+for (const token of ['db_operation.started', 'db_operation.allowed', 'db_operation.succeeded', 'db_operation.failed']) {
+    assertGate(ledger.includes(token), `Mad-DB ledger missing ${token}`, { ledger });
+}
+assertGate((ledger.match(/db_operation\.succeeded/g) || []).length === 1, 'success terminal event must be recorded exactly once', { ledger });
+assertGate((ledger.match(/db_operation\.failed/g) || []).length === 1, 'failure terminal event must be recorded exactly once', { ledger });
+emitGate('mad-db:operation-lifecycle-blackbox', { succeeded: successHook.operation_id, failed: failureHook.operation_id });
+//# sourceMappingURL=mad-db-operation-lifecycle-blackbox.js.map

package/dist/scripts/mad-db-operation-lifecycle-ledger-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createMadDbCapability, MAD_DB_ACK } from '../core/mad-db/mad-db-capability.js';
+import { checkDbOperation } from '../core/db-safety.js';
+import { missionDir } from '../core/mission.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-db-ledger-'));
+const missionId = 'M-mad-db-ledger';
+await createMadDbCapability(root, { missionId, ack: MAD_DB_ACK, ttlMs: 60000 });
+await checkDbOperation(root, { mission_id: missionId }, { tool_name: 'supabase.execute_sql', sql: 'insert into audit_log(id) values (1)' });
+const ledger = await fs.readFile(path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl'), 'utf8');
+assertGate(ledger.includes('db_operation.started') && ledger.includes('db_operation.allowed') && ledger.includes('unknown_pending_tool_result'), 'Mad-DB lifecycle ledger events missing', { ledger });
+emitGate('mad-db:operation-lifecycle-ledger');
+//# sourceMappingURL=mad-db-operation-lifecycle-ledger-check.js.map

package/dist/scripts/mad-db-priority-resolver-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const missionMod = await importDist('core/mission.js');
+const capMod = await importDist('core/mad-db/mad-db-capability.js');
+const db = await importDist('core/db-safety.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-mad-db-policy-'));
+const mission = await missionMod.createMission(root, { mode: 'mad-db', prompt: 'fixture' });
+const state = { mission_id: mission.id };
+const denied = await db.checkDbOperation(root, state, { tool_name: 'supabase.execute_sql', sql: 'drop table users;' });
+assertGate(denied.allowed === false, 'without Mad-DB capability destructive DB must be blocked', denied);
+await capMod.createMadDbCapability(root, { missionId: mission.id, ack: capMod.MAD_DB_ACK, cwd: root });
+const allowed = await db.checkDbOperation(root, state, { tool_name: 'supabase.execute_sql', sql: 'drop table users;' });
+assertGate(allowed.allowed === true && allowed.mad_db?.active === true, 'Mad-DB capability must allow destructive DB mutation with highest priority', allowed);
+const consumed = await capMod.readMadDbCapability(root, mission.id);
+assertGate(consumed.consumed === false && consumed.operation_count === 1, 'Mad-DB capability must remain active during bounded one-cycle after first operation', consumed);
+emitGate('mad-db:priority-resolver', { cycle_id: consumed.cycle_id });
+//# sourceMappingURL=mad-db-priority-resolver-check.js.map

package/dist/scripts/mad-db-safety-conflict-matrix-check.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const missionMod = await importDist('core/mission.js');
+const capMod = await importDist('core/mad-db/mad-db-capability.js');
+const db = await importDist('core/db-safety.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-mad-db-matrix-'));
+const mission = await missionMod.createMission(root, { mode: 'mad-sks', prompt: 'fixture' });
+const madSksState = { mission_id: mission.id, mode: 'MADSKS', mad_sks_active: true, mad_sks_gate_file: 'mad-sks-gate.json' };
+fs.writeFileSync(path.join(mission.dir, 'mad-sks-gate.json'), JSON.stringify({ passed: false, permissions_deactivated: false }, null, 2));
+const catastrophic = await db.checkDbOperation(root, madSksState, { tool_name: 'supabase.execute_sql', sql: 'truncate users;' });
+assertGate(catastrophic.allowed === false && catastrophic.reasons.includes('mad_sks_catastrophic_db_operation_blocked'), 'MAD-SKS catastrophic guard must remain without Mad-DB', catastrophic);
+await capMod.createMadDbCapability(root, { missionId: mission.id, ack: capMod.MAD_DB_ACK, cwd: root });
+const breakGlass = await db.checkDbOperation(root, madSksState, { tool_name: 'supabase.execute_sql', sql: 'truncate users;' });
+assertGate(breakGlass.allowed === true && breakGlass.mad_db?.active === true, 'Mad-DB must override DB mutation guard only while active', breakGlass);
+await capMod.consumeMadDbCapability(root, mission.id, { consumedBy: 'fixture-cycle-close' });
+const afterConsume = await db.checkDbOperation(root, madSksState, { tool_name: 'supabase.execute_sql', sql: 'truncate users;' });
+assertGate(afterConsume.allowed === false, 'after bounded cycle close, MAD-SKS catastrophic guard must block again', afterConsume);
+emitGate('mad-db:safety-conflict-matrix', { states: ['mad-sks-blocks', 'mad-db-allows-cycle', 'mad-sks-blocks-after-cycle-close'] });
+//# sourceMappingURL=mad-db-safety-conflict-matrix-check.js.map

package/dist/scripts/mad-preflight-blocks-unreadable-config-check.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ensureDistFresh, root as repoRoot } from './lib/ensure-dist-fresh.js';
+const freshness = ensureDistFresh({ rebuild: true });
+if (!freshness.ok)
+    fail('dist_not_fresh', { freshness });
+const preflightMod = await import(pathToFileURL(path.join(repoRoot, 'dist', 'core', 'preflight', 'parallel-preflight-engine.js')).href);
+const readabilityMod = await import(pathToFileURL(path.join(repoRoot, 'dist', 'core', 'codex', 'codex-config-readability.js')).href);
+const initMod = await import(pathToFileURL(path.join(repoRoot, 'dist', 'core', 'init.js')).href);
+const fakeCodex = path.join(repoRoot, 'dist', 'scripts', 'fixtures', 'fake-codex-config-loader.js');
+// Case 1: an EXISTING but unreadable (EPERM) config MUST still block the launch — the
+// fresh-project bootstrap must never mask a genuine permission/EPERM problem.
+const epermFixture = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-preflight-eperm-'));
+await fs.mkdir(path.join(epermFixture, '.codex'), { recursive: true });
+await fs.mkdir(path.join(epermFixture, '.sneakoscope', 'reports'), { recursive: true });
+await fs.writeFile(path.join(epermFixture, '.codex', 'config.toml'), 'sandbox_mode = "workspace-write"\n');
+const oldEperm = process.env.SKS_FAKE_CODEX_CONFIG_EPERM;
+process.env.SKS_FAKE_CODEX_CONFIG_EPERM = '1';
+const epermReport = await preflightMod.runCodexLaunchPreflight(epermFixture, {
+    fix: false,
+    codexBin: fakeCodex,
+    tmuxSmoke: false
+});
+if (oldEperm === undefined)
+    delete process.env.SKS_FAKE_CODEX_CONFIG_EPERM;
+else
+    process.env.SKS_FAKE_CODEX_CONFIG_EPERM = oldEperm;
+const epermOk = epermReport.ok === false && epermReport.blockers.includes('codex_cli_config_eperm');
+// Case 2 (de-noise): a MISSING config must report only the honest missing_config /
+// missing_codex_dir blockers, NOT a cascade of macos_acl_ls_le_failed /
+// macos_flags_ls_lO_failed / spawned_child_read_failed from running file checks on a
+// nonexistent path.
+const missingFixture = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-preflight-missing-'));
+const missingReport = await readabilityMod.inspectCodexConfigReadability(missingFixture, { writeReport: false });
+const noiseBlockers = ['macos_acl_ls_le_failed', 'macos_flags_ls_lO_failed', 'spawned_child_read_failed', 'config_lstat_failed', 'config_stat_failed'];
+const denoiseOk = missingReport.ok === false
+    && missingReport.blockers.includes('missing_config')
+    && noiseBlockers.every((b) => !missingReport.blockers.includes(b));
+// Case 3 (bootstrap recovers): after regenerating the managed config in the same fresh
+// project (what `sks --mad` now does automatically), readability must pass with no
+// missing/cascade config blocker.
+await initMod.initProject(missingFixture, { installScope: 'global', globalCommand: 'sks' });
+const afterReport = await readabilityMod.inspectCodexConfigReadability(missingFixture, { writeReport: false });
+const bootstrapOk = afterReport.ok === true
+    && !afterReport.blockers.includes('missing_config')
+    && !afterReport.blockers.includes('missing_codex_dir')
+    && noiseBlockers.every((b) => !afterReport.blockers.includes(b));
+const ok = epermOk && denoiseOk && bootstrapOk;
+console.log(JSON.stringify({
+    schema: 'sks.mad-preflight-blocks-unreadable-config-check.v2',
+    ok,
+    eperm_blocks: { ok: epermOk, blockers: epermReport.blockers },
+    missing_config_denoise: { ok: denoiseOk, blockers: missingReport.blockers },
+    bootstrap_recovers: { ok: bootstrapOk, blockers: afterReport.blockers }
+}, null, 2));
+if (!ok)
+    process.exitCode = 1;
+function fail(blocker, detail) {
+    console.log(JSON.stringify({ schema: 'sks.mad-preflight-blocks-unreadable-config-check.v2', ok: false, blocker, detail }, null, 2));
+    process.exit(1);
+}
+//# sourceMappingURL=mad-preflight-blocks-unreadable-config-check.js.map

package/dist/scripts/mad-sks-actual-executor-blackbox.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runMadSksExecutorCheck } from './lib/mad-sks-actual-executor-check-lib.js';
+await runMadSksExecutorCheck('actual-executor-blackbox');
+//# sourceMappingURL=mad-sks-actual-executor-blackbox.js.map

package/dist/scripts/mad-sks-app-ui-no-mutation-check.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { madHighCommand } from '../core/commands/mad-sks-command.js';
+import { sha256 } from '../core/fsx.js';
+const original = {
+    cwd: process.cwd(),
+    home: process.env.HOME,
+    codexHome: process.env.CODEX_HOME,
+    noAttach: process.env.SKS_NO_ZELLIJ_ATTACH,
+    requireZellij: process.env.SKS_REQUIRE_ZELLIJ,
+    madSwarm: process.env.SKS_MAD_NATIVE_SWARM,
+    skipNpm: process.env.SKS_SKIP_NPM_FRESHNESS_CHECK
+};
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-ui-no-mutation-'));
+const home = path.join(tmp, 'home');
+const codexHome = path.join(home, '.codex');
+const configPath = path.join(codexHome, 'config.toml');
+try {
+    await fs.mkdir(codexHome, { recursive: true });
+    await fs.mkdir(path.join(tmp, '.sneakoscope'), { recursive: true });
+    await fs.writeFile(configPath, [
+        'service_tier = "fast"',
+        '[features]',
+        'fast_mode = true',
+        '[plugins."chrome@openai-bundled"]',
+        'enabled = false',
+        ''
+    ].join('\n'));
+    const before = await fs.readFile(configPath, 'utf8');
+    process.chdir(tmp);
+    process.env.HOME = home;
+    process.env.CODEX_HOME = codexHome;
+    process.env.SKS_NO_ZELLIJ_ATTACH = '1';
+    process.env.SKS_REQUIRE_ZELLIJ = '0';
+    process.env.SKS_MAD_NATIVE_SWARM = '0';
+    process.env.SKS_SKIP_NPM_FRESHNESS_CHECK = '1';
+    process.exitCode = 0;
+    await madHighCommand(['--no-attach', '--no-swarm'], {
+        maybePromptSksUpdateForLaunch: async () => ({ status: 'skipped' }),
+        maybePromptCodexUpdateForLaunch: async () => ({ status: 'skipped' }),
+        ensureMadLaunchDependencies: async () => ({ ready: true, actions: [] }),
+        maybePromptCodexLbSetupForLaunch: async () => ({ status: 'skipped' })
+    });
+    const after = await fs.readFile(configPath, 'utf8');
+    const entries = await fs.readdir(codexHome);
+    assert.equal(after, before);
+    assert.equal(entries.some((entry) => entry === 'sks-mad-high.config.toml'), false);
+    assert.equal(/\[profiles\.sks-mad-high\]/.test(after), false);
+    assert.equal(/enabled\s*=\s*false/.test(after), true);
+    process.exitCode = 0;
+    emit({
+        schema: 'sks.mad-sks-app-ui-no-mutation-check.v1',
+        ok: true,
+        before_hash: sha256(before),
+        after_hash: sha256(after),
+        profile_files_written: entries.filter((entry) => /sks-mad-high/.test(entry)),
+        plugin_disabled_preserved: true,
+        blockers: []
+    });
+}
+catch (err) {
+    emit({
+        schema: 'sks.mad-sks-app-ui-no-mutation-check.v1',
+        ok: false,
+        error: err?.message || String(err),
+        blockers: ['mad_sks_app_ui_no_mutation_failed']
+    });
+}
+finally {
+    process.chdir(original.cwd);
+    restoreEnv('HOME', original.home);
+    restoreEnv('CODEX_HOME', original.codexHome);
+    restoreEnv('SKS_NO_ZELLIJ_ATTACH', original.noAttach);
+    restoreEnv('SKS_REQUIRE_ZELLIJ', original.requireZellij);
+    restoreEnv('SKS_MAD_NATIVE_SWARM', original.madSwarm);
+    restoreEnv('SKS_SKIP_NPM_FRESHNESS_CHECK', original.skipNpm);
+}
+function restoreEnv(key, value) {
+    if (value == null)
+        delete process.env[key];
+    else
+        process.env[key] = value;
+}
+function emit(report) {
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.ok)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=mad-sks-app-ui-no-mutation-check.js.map

package/dist/scripts/mad-sks-audit-proof-check.js

@@ -0,0 +1,34 @@
+#!/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 permissionMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'mad-sks', 'permission-model.js')).href);
+const authMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'mad-sks', 'authorization-manifest.js')).href);
+const auditMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'mad-sks', 'audit-ledger.js')).href);
+const rollbackMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'mad-sks', 'rollback-plan.js')).href);
+const proofMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'mad-sks', 'proof-evidence.js')).href);
+const permission = permissionMod.buildMadSksPermissionModel({ targetRoot: root, flags: permissionMod.parseMadSksFlags(['--mad-sks', '--allow-system']) });
+const authorization = authMod.createMadSksAuthorizationManifest({ permission, userIntent: 'fixture' });
+const ledger = auditMod.createMadSksAuditLedger({ targetRoot: root, actions: [auditMod.madSksAuditAction({ type: 'file_write', target: path.join(root, '.sneakoscope/tmp/file'), rollback_available: true })] });
+const rollback = rollbackMod.createMadSksRollbackPlan({ targetRoot: root, fileRollbacks: [{ path: '.sneakoscope/tmp/file', previous_content_hash: 'abc' }] });
+const proof = proofMod.createMadSksProofEvidence({
+    authorizationManifestPath: 'mad-sks-authorization.json',
+    auditLedgerPath: 'mad-sks-audit-ledger.json',
+    rollbackPlanPath: 'mad-sks-rollback-plan.json',
+    protectedCoreComparison: { ok: true },
+    verification: [{ command: 'fixture', ok: true }]
+});
+const ok = authorization.schema === 'sks.mad-sks-authorization.v1'
+    && ledger.schema === 'sks.mad-sks-audit-ledger.v1'
+    && rollback.schema === 'sks.mad-sks-rollback-plan.v1'
+    && proof.schema === 'sks.mad-sks-proof-evidence.v1'
+    && proof.ok === true;
+emit({ schema: 'sks.mad-sks-audit-proof-check.v1', ok, authorization, ledger, rollback, proof });
+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-audit-proof-check.v1', ok: false, blocker, detail }); process.exit(1); }
+//# sourceMappingURL=mad-sks-audit-proof-check.js.map

package/dist/scripts/mad-sks-db-executor-check.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runMadSksExecutorCheck } from './lib/mad-sks-actual-executor-check-lib.js';
+await runMadSksExecutorCheck('db-executor');
+//# sourceMappingURL=mad-sks-db-executor-check.js.map

package/dist/scripts/mad-sks-executor-proof-graph-check.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runMadSksExecutorCheck } from './lib/mad-sks-actual-executor-check-lib.js';
+await runMadSksExecutorCheck('executor-proof-graph');
+//# sourceMappingURL=mad-sks-executor-proof-graph-check.js.map

package/dist/scripts/mad-sks-fast-mode-propagation-check.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'fast-mode-policy.js')).href);
+const policy = mod.resolveFastModePolicy({ fastMode: true });
+const env = mod.fastModeEnv(policy);
+const report = {
+    schema: 'sks.mad-sks-fast-mode-propagation-check.v1',
+    ok: policy.fast_mode === true && policy.service_tier === 'fast' && env.SKS_FAST_MODE === '1' && env.SKS_SERVICE_TIER === 'fast',
+    mad_target_worker_env: env,
+    fast_mode: policy.fast_mode,
+    service_tier: policy.service_tier,
+    proof_level: 'fixture_instrumented_real',
+    blockers: []
+};
+const out = path.join(root, '.sneakoscope', 'reports', 'mad-sks-fast-mode-propagation.json');
+fs.mkdirSync(path.dirname(out), { recursive: true });
+fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+assertGate(report.ok, 'MAD-SKS target worker fast env must default to fast', report);
+emitGate('mad-sks:fast-mode-propagation', { service_tier: report.service_tier });
+//# sourceMappingURL=mad-sks-fast-mode-propagation-check.js.map

package/dist/scripts/mad-sks-file-write-executor-check.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runMadSksExecutorCheck } from './lib/mad-sks-actual-executor-check-lib.js';
+await runMadSksExecutorCheck('file-write-executor');
+//# sourceMappingURL=mad-sks-file-write-executor-check.js.map

package/dist/scripts/mad-sks-immutable-harness-check.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+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', 'mad-sks', 'immutable-harness-guard.js')).href);
+const core = mod.resolveProtectedCore({ packageRoot: root, targetRoot: root });
+const engineAllowed = await mod.evaluateMadSksWrite({ packageRoot: root, targetRoot: root, operation: 'file_write', path: path.join(root, 'src', 'core', 'version.ts') });
+const installedRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-installed-core-'));
+await fs.mkdir(path.join(installedRoot, 'src', 'core'), { recursive: true });
+await fs.mkdir(path.join(installedRoot, 'scripts'), { recursive: true });
+await fs.writeFile(path.join(installedRoot, 'package.json'), '{"name":"sneakoscope","version":"1.18.13"}\n');
+await fs.writeFile(path.join(installedRoot, 'src', 'core', 'version.ts'), 'export const PACKAGE_VERSION = "1.18.13";\n');
+const installedCore = mod.resolveProtectedCore({ packageRoot: installedRoot, targetRoot: installedRoot });
+const blocked = await mod.evaluateMadSksWrite({ packageRoot: installedRoot, targetRoot: installedRoot, operation: 'file_write', path: path.join(installedRoot, 'src', 'core', 'version.ts') });
+const allowed = await mod.evaluateMadSksWrite({ packageRoot: root, targetRoot: root, operation: 'file_write', path: path.join(root, '.sneakoscope', 'tmp', 'target.txt') });
+const before = await mod.snapshotProtectedCore(root, 'before');
+const after = await mod.snapshotProtectedCore(root, 'after');
+const comparison = mod.compareProtectedCoreSnapshots(before, after);
+const ok = core.schema === 'sks.mad-sks-protected-core.v1'
+    && core.engine_source_exception === true
+    && engineAllowed.decision === 'allowed'
+    && installedCore.engine_source_exception === false
+    && blocked.decision === 'blocked'
+    && allowed.decision === 'allowed'
+    && comparison.ok === true;
+emit({ schema: 'sks.mad-sks-immutable-harness-check.v1', ok, core_count: core.protected_paths.length, core, engineAllowed, installedCore, blocked, allowed, comparison });
+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-immutable-harness-check.v1', ok: false, blocker, detail }); process.exit(1); }
+//# sourceMappingURL=mad-sks-immutable-harness-check.js.map

package/dist/scripts/mad-sks-no-harness-modification-check.js

@@ -0,0 +1,25 @@
+#!/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', 'mad-sks', 'immutable-harness-guard.js')).href);
+const before = await mod.snapshotProtectedCore(root, 'before');
+const engineSource = await mod.evaluateMadSksWrite({ packageRoot: root, targetRoot: root, operation: 'file_write', path: path.join(root, 'dist', 'bin', 'sks.js') });
+const installedRoot = path.join(root, 'node_modules', 'sneakoscope');
+const blocked = await mod.evaluateMadSksWrite({ packageRoot: installedRoot, targetRoot: installedRoot, operation: 'file_write', path: path.join(installedRoot, 'dist', 'bin', 'sks.js') });
+const after = await mod.snapshotProtectedCore(root, 'after');
+const comparison = mod.compareProtectedCoreSnapshots(before, after);
+const ok = engineSource.decision === 'allowed'
+    && engineSource.protected_core?.engine_source_exception === true
+    && blocked.decision === 'blocked'
+    && blocked.protected_core?.engine_source_exception === false
+    && comparison.ok === true;
+emit({ schema: 'sks.mad-sks-no-harness-modification-check.v1', ok, engineSource, blocked, comparison });
+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-no-harness-modification-check.v1', ok: false, blocker, detail }); process.exit(1); }
+//# sourceMappingURL=mad-sks-no-harness-modification-check.js.map

package/dist/scripts/mad-sks-package-executor-check.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runMadSksExecutorCheck } from './lib/mad-sks-actual-executor-check-lib.js';
+await runMadSksExecutorCheck('package-executor');
+//# sourceMappingURL=mad-sks-package-executor-check.js.map

package/dist/scripts/mad-sks-permission-model-check.js

@@ -0,0 +1,22 @@
+#!/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', 'mad-sks', 'permission-model.js')).href);
+const permission = mod.buildMadSksPermissionModel({
+    targetRoot: path.join(root, 'fixture-target'),
+    flags: mod.parseMadSksFlags(['--mad-sks', '--allow-system', '--allow-db-write', '--allow-package-install', '--allow-service-control', '--allow-network', '--allow-computer-use'])
+});
+const ok = permission.schema === 'sks.mad-sks-permission-model.v1'
+    && permission.mode === 'full_system_authority'
+    && permission.forbidden_scopes.includes('sks_harness_code')
+    && permission.allowed_scopes.includes('computer_use');
+emit({ schema: 'sks.mad-sks-permission-model-check.v1', ok, permission });
+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-permission-model-check.v1', ok: false, blocker, detail }); process.exit(1); }
+//# sourceMappingURL=mad-sks-permission-model-check.js.map

package/dist/scripts/mad-sks-rollback-apply-check.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runMadSksExecutorCheck } from './lib/mad-sks-actual-executor-check-lib.js';
+await runMadSksExecutorCheck('rollback-apply');
+//# sourceMappingURL=mad-sks-rollback-apply-check.js.map

package/dist/scripts/mad-sks-service-executor-check.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runMadSksExecutorCheck } from './lib/mad-sks-actual-executor-check-lib.js';
+await runMadSksExecutorCheck('service-executor');
+//# sourceMappingURL=mad-sks-service-executor-check.js.map

package/dist/scripts/mad-sks-shell-executor-check.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { runMadSksExecutorCheck } from './lib/mad-sks-actual-executor-check-lib.js';
+await runMadSksExecutorCheck('shell-executor');
+//# sourceMappingURL=mad-sks-shell-executor-check.js.map

package/dist/scripts/mad-sks-write-guard-check.js

@@ -0,0 +1,28 @@
+#!/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', 'mad-sks', 'write-guard.js')).href);
+const engineSource = await mod.guardMadSksFileOperation({ targetPath: path.join(root, 'package.json'), operation: 'file_write', root, targetRoot: root });
+const installedRoot = path.join(root, 'node_modules', 'sneakoscope');
+const blocked = await mod.guardMadSksFileOperation({ targetPath: path.join(installedRoot, 'package.json'), operation: 'file_write', root: installedRoot, targetRoot: installedRoot });
+const shell = await mod.classifyMadSksShellCommand({ command: 'sudo rm -rf ./src/core', cwd: root, root });
+const fakeOpenAi = `${'OPENAI'}_${'API'}_${'KEY'}=${'sk'}-${'proj'}-${'secretsecretsecret'}`;
+const fakeGithub = `${'github'}_${'pat'}_${'abcdef'}`;
+const redacted = mod.redactMadSksSecrets(`${fakeOpenAi} ${fakeGithub}`);
+const ok = engineSource.action === 'allow'
+    && engineSource.protected_core?.engine_source_exception === true
+    && blocked.action === 'block'
+    && blocked.protected_core?.engine_source_exception === false
+    && shell.action === 'confirm'
+    && !redacted.includes(fakeOpenAi.split('=').at(-1))
+    && !redacted.includes(fakeGithub);
+emit({ schema: 'sks.mad-sks-write-guard-check.v1', ok, engineSource, blocked, shell, redacted });
+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-write-guard-check.v1', ok: false, blocker, detail }); process.exit(1); }
+//# sourceMappingURL=mad-sks-write-guard-check.js.map

package/dist/scripts/mad-sks-zellij-default-pane-worker-check.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { packageRoot } from '../core/fsx.js';
+const root = packageRoot();
+const mad = await fs.readFile(path.join(root, 'src', 'core', 'commands', 'mad-sks-command.ts'), 'utf8');
+const parser = await fs.readFile(path.join(root, 'src', 'core', 'agents', 'agent-command-surface.ts'), 'utf8');
+const swarm = await fs.readFile(path.join(root, 'src', 'core', 'agents', 'native-cli-session-swarm.ts'), 'utf8');
+const manager = await fs.readFile(path.join(root, 'src', 'core', 'zellij', 'zellij-worker-pane-manager.ts'), 'utf8');
+const commandBody = mad.slice(mad.indexOf('export async function madHighCommand'), mad.indexOf('export async function startMadNativeSwarm'));
+const launchIndex = commandBody.indexOf('launchMadZellijUi(');
+const swarmIndex = commandBody.indexOf('startMadNativeSwarm(');
+const checks = {
+    no_runtime_enable_profile: !commandBody.includes('enableMadHighProfile('),
+    read_only_launch_profile: mad.includes('buildMadHighLaunchProfileNoWrite()'),
+    preflight_fix_default_false: mad.includes('fix: allowMadRepair'),
+    zellij_session_before_swarm: launchIndex >= 0 && swarmIndex >= 0 && launchIndex < swarmIndex,
+    main_only_session: mad.includes('slotCount: 0'),
+    zellij_default_backend: /return 'zellij'/.test(mad) && mad.includes("list.includes('--json')") && mad.includes("list.includes('--no-attach')"),
+    worker_command_real_zellij: mad.includes("command.push('--real')") && mad.includes("command.push('--zellij-session-name'") && mad.includes("command.push('--zellij-pane-worker')") && mad.includes("command.push('--worker-placement'"),
+    parser_accepts_worker_flags: parser.includes('--zellij-session-name') && parser.includes('--zellij-pane-worker') && parser.includes('--no-zellij-pane-worker'),
+    native_worker_pane_path: swarm.includes("this.input.backend === 'zellij'") && swarm.includes('ctx.opts.zellijPaneWorker !== false') && swarm.includes('openWorkerPane({'),
+    right_pane_requested: manager.includes("'--direction', directionRequested") && manager.includes("'--near-current-pane'")
+};
+const ok = Object.values(checks).every(Boolean);
+emit({
+    schema: 'sks.mad-sks-zellij-default-pane-worker-check.v1',
+    ok,
+    checks,
+    blockers: ok ? [] : Object.entries(checks).filter(([, passed]) => !passed).map(([name]) => name)
+});
+function emit(report) {
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.ok)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=mad-sks-zellij-default-pane-worker-check.js.map