sneakoscope 4.1.0 → 4.2.0

package/dist/core/commands/mad-db-command.js

@@ -1,98 +1,178 @@
-import { initProject } from '../init.js';
-import { createMission, findLatestMission, setCurrent } from '../mission.js';
-import { exists, sksRoot } from '../fsx.js';
 import path from 'node:path';
-import { createMadDbCapability, isMadDbCapabilityActive, MAD_DB_ACK, readMadDbCapability, resolveMadDbMissionId, revokeMadDbCapability } from '../mad-db/mad-db-capability.js';
+import { initProject } from '../init.js';
+import { findLatestMission, setCurrent } from '../mission.js';
+import { exists, readText, sksRoot } from '../fsx.js';
+import { closeMadDbCycle, isMadDbCapabilityActive, MAD_DB_ACK, readMadDbCapability, resolveMadDbMissionId, revokeMadDbCapability } from '../mad-db/mad-db-capability.js';
+import { closeMadDbRuntimeProfile, verifyReadOnlyRestored } from '../mad-db/mad-db-runtime-profile.js';
+import { runMadDbCycle } from '../mad-db/mad-db-coordinator.js';
+import { resolveMadDbTarget } from '../mad-db/mad-db-target.js';
+import { quarantineStaleMadDbRuntimeProfiles } from '../mad-db/mad-db-recovery.js';
+import { sha256 } from '../fsx.js';
 export async function madDbCommand(args = []) {
     const action = String(args[0] && !String(args[0]).startsWith('--') ? args[0] : 'status');
     const rest = action === args[0] ? args.slice(1) : args;
     const root = await sksRoot();
     if (!(await exists(path.join(root, '.sneakoscope'))))
         await initProject(root, {});
+    if (action === 'run')
+        return runMadDb(root, rest);
+    if (action === 'exec')
+        return execMadDb(root, rest);
+    if (action === 'apply-migration')
+        return applyMigrationMadDb(root, rest);
+    if (action === 'doctor')
+        return doctorMadDb(root, rest);
+    if (action === 'close')
+        return closeMadDb(root, rest);
     if (action === 'enable')
         return enableMadDb(root, rest);
     if (action === 'revoke')
         return revokeMadDb(root, rest);
     if (action === 'status')
         return statusMadDb(root, rest);
-    console.error('Usage: sks mad-db enable --ack "I AUTHORIZE ONE-CYCLE DB BREAK-GLASS" [--mission latest|new|M-...] | status | revoke');
+    console.error('Usage: sks mad-db run "<task-or-sql>" | exec --sql "<SQL>" | apply-migration --name <name> --file <sql-file> | doctor|status|close|revoke [--json]');
     process.exitCode = 1;
 }
+async function runMadDb(root, args) {
+    const task = positionalText(args) || readOption(args, '--task', '');
+    const sql = readOption(args, '--sql', '');
+    const result = await runMadDbCycle({
+        root,
+        action: 'run',
+        task,
+        sql: sql || null,
+        verifySql: readOption(args, '--verify-sql', '') || null,
+        args
+    });
+    return printResult(result, args);
+}
+async function execMadDb(root, args) {
+    const sql = readOption(args, '--sql', '') || positionalText(args);
+    const result = await runMadDbCycle({
+        root,
+        action: 'exec',
+        task: sql || 'sks mad-db exec',
+        sql: sql || null,
+        verifySql: readOption(args, '--verify-sql', '') || null,
+        args
+    });
+    return printResult(result, args);
+}
+async function applyMigrationMadDb(root, args) {
+    const file = readOption(args, '--file', '');
+    const sql = readOption(args, '--sql', '') || (file ? await readText(path.resolve(file), '') : '');
+    const result = await runMadDbCycle({
+        root,
+        action: 'apply-migration',
+        task: `apply migration ${readOption(args, '--name', 'mad_db_migration')}`,
+        sql: sql || null,
+        migrationName: readOption(args, '--name', `mad_db_${Date.now()}`),
+        migrationFile: file || null,
+        verifySql: readOption(args, '--verify-sql', '') || null,
+        args
+    });
+    return printResult(result, args);
+}
+async function doctorMadDb(root, args) {
+    const target = await resolveMadDbTarget(root, { args });
+    const recovery = await quarantineStaleMadDbRuntimeProfiles(root);
+    const restoration = await verifyReadOnlyRestored(root, null);
+    const result = {
+        schema: 'sks.mad-db-doctor.v1',
+        ok: target.blockers.length === 0 && restoration.persistent_supabase_read_only,
+        target: { ...target, project_ref: target.project_ref ? `<hash:${target.project_ref_hash}>` : null },
+        stale_recovery: recovery,
+        read_only_restoration: restoration,
+        execute_sql_apply_migration_inventory_checked: false,
+        note: 'doctor does not open write transport; run/exec/apply-migration verifies tool inventory inside a bound cycle'
+    };
+    return printJsonOrText(result, args, result.ok ? 'MadDB doctor passed local checks.' : `MadDB doctor found blockers: ${[...target.blockers, ...restoration.blockers].join(', ')}`);
+}
 async function enableMadDb(root, args) {
     const json = hasFlag(args, '--json');
     const ack = readOption(args, '--ack', '');
     if (ack !== MAD_DB_ACK) {
-        const result = { schema: 'sks.mad-db-command.v1', ok: false, action: 'enable', reason: 'ack_phrase_required', required_ack: MAD_DB_ACK };
+        const result = { schema: 'sks.mad-db-command.v2', ok: false, action: 'enable', reason: 'deprecated_enable_no_capability', required_ack: MAD_DB_ACK, token_only: true };
         if (json)
             return console.log(JSON.stringify(result, null, 2));
-        console.error(`Mad-DB enable blocked. Required --ack ${JSON.stringify(MAD_DB_ACK)}`);
+        console.error(`MadDB enable is deprecated and does not create a capability. Use sks mad-db run|exec|apply-migration for an executable cycle. Legacy ack was ${JSON.stringify(MAD_DB_ACK)}.`);
         process.exitCode = 2;
         return result;
     }
-    const requestedMission = readOption(args, '--mission', 'latest');
-    let missionId = requestedMission === 'new' ? null : await resolveMadDbMissionId(root, {}, requestedMission);
-    if (!missionId) {
-        const created = await createMission(root, { mode: 'mad-db', prompt: 'sks mad-db enable one-cycle DB break-glass' });
-        missionId = created.id;
-    }
-    const capability = await createMadDbCapability(root, {
-        missionId,
-        ack,
-        cwd: process.cwd(),
-        ttlMs: Number(readOption(args, '--ttl-ms', String(2 * 60 * 60 * 1000)))
-    });
-    await setCurrent(root, {
-        mission_id: missionId,
-        route: 'MadDB',
-        route_command: '$MAD-DB',
-        mode: 'MADDB',
-        phase: 'MADDB_ONE_CYCLE_CAPABILITY_ACTIVE',
-        mad_db_active: true,
-        mad_db_cycle_id: capability.cycle_id,
-        mad_db_capability_file: 'mad-db-capability.json',
-        mad_db_ack_phrase: 'accepted',
-        stop_gate: 'mad-db-capability.json'
-    });
-    const result = { schema: 'sks.mad-db-command.v1', ok: true, action: 'enable', mission_id: missionId, capability };
+    const result = {
+        schema: 'sks.mad-db-command.v2',
+        ok: false,
+        action: 'enable',
+        reason: 'deprecated_enable_no_capability',
+        token_only: true,
+        executable_commands: ['sks mad-db run', 'sks mad-db exec', 'sks mad-db apply-migration']
+    };
     if (json)
         return console.log(JSON.stringify(result, null, 2));
-    console.log(`Mad-DB one-cycle capability active for ${missionId}; expires ${capability.expires_at}.`);
+    console.error('MadDB enable no longer creates a capability. Use sks mad-db run|exec|apply-migration to create the bound mission/profile/capability and execute SQL.');
+    process.exitCode = 2;
     return result;
 }
 async function statusMadDb(root, args) {
-    const json = hasFlag(args, '--json');
     const missionId = await resolveMadDbMissionId(root, {}, readOption(args, '--mission', 'latest'));
     const capability = missionId ? await readMadDbCapability(root, missionId) : null;
     const result = {
-        schema: 'sks.mad-db-command.v1',
+        schema: 'sks.mad-db-status.v2',
         ok: true,
         action: 'status',
         mission_id: missionId,
         active: isMadDbCapabilityActive(capability),
-        capability
+        capability: capability ? redactCapability(capability) : null
     };
-    if (json)
-        return console.log(JSON.stringify(result, null, 2));
-    if (!missionId || !capability)
-        console.log('Mad-DB: no capability found.');
-    else
-        console.log(`Mad-DB: ${result.active ? 'active' : 'inactive'} for ${missionId}; consumed=${capability.consumed}; expires=${capability.expires_at}.`);
-    return result;
+    return printJsonOrText(result, args, !missionId || !capability ? 'MadDB: no capability found.' : `MadDB: ${result.active ? 'active' : 'inactive'} for ${missionId}; status=${capability.status}; expires=${capability.expires_at}.`);
+}
+async function closeMadDb(root, args) {
+    const missionId = await resolveMadDbMissionId(root, {}, readOption(args, '--mission', 'latest')) || await findLatestMission(root);
+    const capability = missionId ? await readMadDbCapability(root, missionId) : null;
+    const restoration = missionId ? await closeMadDbRuntimeProfile({ root, missionId, reason: 'operator_close' }) : null;
+    const closed = missionId && capability ? await closeMadDbCycle(root, missionId, capability.cycle_id, 'operator_close') : null;
+    if (missionId)
+        await setCurrent(root, { mad_db_active: false, phase: 'MADDB_CLOSED' });
+    const result = { schema: 'sks.mad-db-close.v2', ok: Boolean(closed), action: 'close', mission_id: missionId, capability: closed ? redactCapability(closed) : null, read_only_restoration: restoration };
+    return printJsonOrText(result, args, closed ? `MadDB cycle closed for ${missionId}.` : 'MadDB: no capability to close.');
 }
 async function revokeMadDb(root, args) {
-    const json = hasFlag(args, '--json');
     const missionId = await resolveMadDbMissionId(root, {}, readOption(args, '--mission', 'latest')) || await findLatestMission(root);
     const revoked = missionId ? await revokeMadDbCapability(root, missionId, readOption(args, '--reason', 'operator_revoked')) : null;
+    const restoration = missionId ? await closeMadDbRuntimeProfile({ root, missionId, reason: 'operator_revoke' }) : null;
     await setCurrent(root, { mad_db_active: false, phase: 'MADDB_REVOKED' });
-    const result = { schema: 'sks.mad-db-command.v1', ok: Boolean(revoked), action: 'revoke', mission_id: missionId, capability: revoked };
-    if (json)
-        return console.log(JSON.stringify(result, null, 2));
-    if (!revoked)
-        console.log('Mad-DB: no capability to revoke.');
+    const result = { schema: 'sks.mad-db-command.v2', ok: Boolean(revoked), action: 'revoke', mission_id: missionId, capability: revoked ? redactCapability(revoked) : null, read_only_restoration: restoration };
+    return printJsonOrText(result, args, revoked ? `MadDB capability revoked for ${missionId}.` : 'MadDB: no capability to revoke.');
+}
+function printResult(result, args) {
+    if (hasFlag(args, '--json')) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (result.ok) {
+        console.log(`MadDB complete: mission=${result.mission_id} cycle=${result.cycle_id} execution=${result.execution?.ok ? 'succeeded' : 'unknown'} verification=${result.read_back?.ok === true ? 'passed' : 'not-requested'} read-only-restored=${result.read_only_restoration?.ok === true}`);
+    }
+    else {
+        console.error(`MadDB failed: mission=${result.mission_id} blockers=${(result.blockers || []).join(', ') || 'unknown'} read-only-restored=${result.read_only_restoration?.ok === true}`);
+        process.exitCode = 1;
+    }
+    return result;
+}
+function printJsonOrText(result, args, text) {
+    if (hasFlag(args, '--json'))
+        console.log(JSON.stringify(result, null, 2));
     else
-        console.log(`Mad-DB capability revoked for ${missionId}.`);
+        console.log(text);
+    if (result.ok === false)
+        process.exitCode = process.exitCode || 1;
     return result;
 }
+function redactCapability(capability) {
+    return {
+        ...capability,
+        project_ref: capability.project_ref ? `<hash:${sha256(capability.project_ref).slice(0, 16)}>` : null,
+        transport: capability.transport ? { ...capability.transport, server_url_redacted: capability.transport.server_url_redacted || '<redacted>' } : null
+    };
+}
 function hasFlag(args, flag) {
     return args.includes(flag);
 }
@@ -100,7 +180,22 @@ function readOption(args, name, fallback) {
     const index = args.indexOf(name);
     if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
         return String(args[index + 1]);
-    const prefixed = args.find((arg) => String(arg).startsWith(name + '='));
+    const prefixed = args.find((arg) => String(arg).startsWith(`${name}=`));
     return prefixed ? prefixed.slice(name.length + 1) : fallback;
 }
+function positionalText(args) {
+    const out = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg)
+            continue;
+        if (arg.startsWith('--')) {
+            if (!arg.includes('=') && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+                index += 1;
+            continue;
+        }
+        out.push(arg);
+    }
+    return out.join(' ').trim();
+}
 //# sourceMappingURL=mad-db-command.js.map

package/dist/core/commands/mad-sks-command.js

@@ -19,7 +19,6 @@ import { repairCodexConfigEperm } from '../codex/codex-config-eperm-repair.js';
 import { runCodexLaunchPreflight } from '../preflight/parallel-preflight-engine.js';
 import { diffCodexAppUiSnapshots, writeCodexAppUiSnapshot } from '../codex-app/codex-app-ui-state-snapshot.js';
 import { checkSksUpdateNotice } from '../update/update-notice.js';
-import { createMadDbCapability, MAD_DB_ACK } from '../mad-db/mad-db-capability.js';
 import { writeCodex0138CapabilityArtifacts } from '../codex-control/codex-0138-capability.js';
 import { writeCodex0139CapabilityArtifacts } from '../codex-control/codex-0139-capability.js';
 import { resolveCodexNativeInvocationPlan } from '../codex-native/codex-native-invocation-router.js';
@@ -100,7 +99,7 @@ export async function madHighCommand(args = [], deps = {}) {
         }
         return report;
     }
-    const codexUpdate = deps.maybePromptCodexUpdateForLaunch ? await deps.maybePromptCodexUpdateForLaunch(args, { label: glmMadLaunch ? 'GLM MAD launch' : 'MAD launch' }) : { status: 'skipped' };
+    const codexUpdate = { status: 'deferred_background', reason: 'update_prompt_deferred_until_after_mad_ui' };
     if (codexUpdate.status === 'failed' || codexUpdate.status === 'updated_not_reflected') {
         console.error(`Codex CLI update failed: ${codexUpdate.error || 'updated version was not visible on PATH'}`);
         process.exitCode = 1;
@@ -147,14 +146,15 @@ export async function madHighCommand(args = [], deps = {}) {
     }
     const lb = glmMadLaunch
         ? { status: 'skipped_glm_openrouter', ok: false, reason: 'glm_mad_uses_openrouter_directly' }
-        : deps.maybePromptCodexLbSetupForLaunch ? await deps.maybePromptCodexLbSetupForLaunch(args) : { status: 'skipped' };
+        : { status: 'deferred_until_provider_route', ok: true, reason: 'codex_lb_setup_prompt_deferred_until_provider_route' };
     if (!glmMadLaunch && lb.status === 'missing_api_key') {
         process.exitCode = 1;
         return;
     }
     const profile = buildMadHighLaunchProfileNoWrite();
     const uiSnapshotId = Date.now().toString(36);
-    const beforeUi = await writeCodexAppUiSnapshot(launchRoot, `mad-before-${uiSnapshotId}`).catch(() => null);
+    const strictUiSnapshot = process.env.SKS_MAD_STRICT_UI_SNAPSHOT === '1';
+    const beforeUi = strictUiSnapshot ? await writeCodexAppUiSnapshot(launchRoot, `mad-before-${uiSnapshotId}`).catch(() => null) : null;
     // launchFast skips the redundant live-`codex exec` config probe (up to ~20s, run
     // up to 3x via repair re-inspections): the real codex profile is exercised moments
     // later when the Zellij session opens. All filesystem/permission/EPERM/symlink/ACL
@@ -202,64 +202,48 @@ export async function madHighCommand(args = [], deps = {}) {
         process.exitCode = 1;
         return glmRuntime;
     }
-    const madDbCapability = madDbGrant.enabled
-        ? await createMadDbCapability(madLaunch.root, { missionId: madLaunch.mission_id, ack: madDbGrant.ack, cwd: process.cwd() })
-        : null;
-    if (madDbCapability) {
+    if (madDbGrant.requested) {
         const grantReport = {
-            schema: 'sks.mad-sks-launch-grants.v1',
+            schema: 'sks.mad-sks-launch-grants.v2',
             generated_at: nowIso(),
             mission_id: madLaunch.mission_id,
             mad_sks_active: true,
-            mad_db_active: true,
-            mad_db_default_grant: madDbGrant.source === 'sks_mad_default',
+            mad_db_active: false,
+            mad_db_default_grant: false,
             mad_db_grant_source: madDbGrant.source,
-            mad_db_one_cycle_only: true,
-            mad_db_capability_file: 'mad-db-capability.json',
-            mad_db_cycle_id: madDbCapability.cycle_id,
-            mad_db_expires_at: madDbCapability.expires_at,
+            mad_db_requires_first_class_route: true,
+            mad_db_cli: 'sks mad-db run|exec|apply-migration',
+            mad_db_capability_file: null,
             standalone_mad_db_enable_still_requires_ack: true
         };
         await writeJsonAtomic(path.join(madLaunch.dir, 'mad-sks-launch-grants.json'), grantReport);
-        await setCurrent(madLaunch.root, {
-            mission_id: madLaunch.mission_id,
-            mad_db_active: true,
-            mad_db_cycle_id: madDbCapability.cycle_id,
-            mad_db_capability_file: 'mad-db-capability.json',
-            mad_db_break_glass: true,
-            mad_db_default_grant: madDbGrant.source === 'sks_mad_default',
-            mad_db_grant_source: madDbGrant.source,
-            mad_db_one_cycle_only: true,
-            mad_db_priority_override_active: true,
-            mad_sks_launch_grants_file: 'mad-sks-launch-grants.json'
-        });
-        await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_db.capability_created', grant_source: madDbGrant.source, cycle_id: madDbCapability.cycle_id, expires_at: madDbCapability.expires_at });
+        await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_db.first_class_route_required', grant_source: madDbGrant.source, cli: grantReport.mad_db_cli });
     }
-    const updateNotice = await checkSksUpdateNotice({
-        packageName: deps.packageName || 'sneakoscope',
-        currentVersion: deps.packageVersion || PACKAGE_VERSION,
-        missionDir: madLaunch.dir
-    }).catch((err) => ({
+    const updateNotice = {
         schema: 'sks.update-notice.v1',
         checked_at: nowIso(),
         package_name: deps.packageName || 'sneakoscope',
         current_version: deps.packageVersion || PACKAGE_VERSION,
         latest_version: null,
         update_available: false,
-        source: 'error',
+        source: 'deferred_background',
         cache_ttl_ms: 0,
-        message: 'SKS update notice check failed; MAD launch continues.',
-        error: err?.message || String(err)
-    }));
+        message: 'SKS update notice refresh deferred until after MAD UI launch.'
+    };
+    void checkSksUpdateNotice({
+        packageName: deps.packageName || 'sneakoscope',
+        currentVersion: deps.packageVersion || PACKAGE_VERSION,
+        missionDir: madLaunch.dir
+    }).then((notice) => appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_refreshed_background', non_blocking: true, update_available: notice.update_available === true, source: notice.source })).catch((err) => appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_background_failed', error: err?.message || String(err) }));
     await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_checked', non_blocking: true, update_available: updateNotice.update_available === true, source: updateNotice.source });
     console.log(`SKS MAD ready: ${glmRuntime?.profile?.profile_name || madHighProfileName()} | gate ${madLaunch.mission_id}`);
     if (glmRuntime?.profile)
         console.log(`GLM MAD launch active: ${glmRuntime.profile.model} via OpenRouter; GPT fallback blocked.`);
-    if (madDbCapability)
-        console.log(`MAD-DB one-cycle capability active (${madDbGrant.source}); expires ${madDbCapability.expires_at}.`);
+    if (madDbGrant.requested)
+        console.log('MAD-DB flag observed; use the first-class route: sks mad-db run|exec|apply-migration.');
     if (updateNotice.update_available === true)
         console.log(`SKS update notice: ${updateNotice.latest_version} available (non-blocking).`);
-    console.log('Scoped high-power maintenance authority active; add explicit --allow-* flags for packages, services, network, browser/Computer Use, generated assets, file permissions, or system/admin scopes. MAD-DB one-cycle DB break-glass is already active for this launch; protected-core, audit, and one-cycle bounds remain.');
+    console.log('Scoped high-power maintenance authority active; add explicit --allow-* flags for packages, services, network, browser/Computer Use, generated assets, file permissions, or system/admin scopes. MAD-DB SQL-plane execution is not active in MAD-SKS; use the first-class MadDB route for DROP/TRUNCATE/all-row SQL-plane work.');
     const launchLb = lb.status === 'present' ? { ...lb, status: 'configured' } : lb;
     const madSksEnv = {
         SKS_PROTECTED_CORE_POLICY: madLaunch.gate.protected_core_policy,
@@ -311,7 +295,7 @@ export async function madHighCommand(args = [], deps = {}) {
         worker_panes_created: 0,
         right_column_mode: 'spawn-on-first-worker'
     });
-    const madNativeSwarm = await startMadNativeSwarm(madLaunch.root, madLaunch, args, launchProfile, {
+    const madNativeSwarmPromise = startMadNativeSwarm(madLaunch.root, madLaunch, args, launchProfile, {
         env: {
             ...madSksEnv,
             ...(launch.session_name ? { SKS_ZELLIJ_SESSION_NAME: launch.session_name } : {})
@@ -320,7 +304,8 @@ export async function madHighCommand(args = [], deps = {}) {
         zellijSessionName: launch.session_name || null,
         workerPlacement: headlessZellij ? 'process' : shouldAutoAttachZellij(args) ? 'zellij-pane' : 'process',
         zellijVisiblePaneCap: Number(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || 8)
-    });
+    }).catch((err) => appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.native_swarm_background_failed', error: err?.message || String(err) }));
+    void madNativeSwarmPromise;
     // The launcher only creates a detached background session. In an interactive
     // terminal, immediately attach so the session actually opens for the user
     // instead of leaving them to copy/paste the attach command by hand.
@@ -409,10 +394,11 @@ function buildGlmMadLaunchOpts(cleanArgs = [], opts = {}) {
 }
 export function resolveMadLaunchMadDbGrant(args = []) {
     const list = (args || []).map((arg) => String(arg));
+    const requested = list.includes('--mad-db');
     return {
-        enabled: true,
-        source: list.includes('--mad-db') ? 'sks_mad_explicit_redundant_flag' : 'sks_mad_default',
-        ack: MAD_DB_ACK,
+        enabled: false,
+        requested,
+        source: requested ? 'mad_db_first_class_route_required' : 'not_requested',
         one_cycle_only: true
     };
 }
@@ -646,16 +632,7 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     const has = (scope) => allowedScopes.has(scope);
     const dbWriteAllowed = has('db_write');
     const { id, dir } = await createMission(root, { mode: 'mad-sks', prompt: `${activatedBy} Zellij scoped high-power maintenance session` });
-    await writeCodex0138CapabilityArtifacts(root, { missionId: id }).catch(() => null);
-    await writeCodex0139CapabilityArtifacts(root, { missionId: id }).catch(() => null);
-    const codexNativeInvocation = await resolveCodexNativeInvocationPlan({
-        root,
-        missionId: id,
-        route: '$MAD',
-        desiredCapability: 'hook-evidence'
-    }).catch(() => null);
-    if (codexNativeInvocation)
-        await writeJsonAtomic(path.join(dir, 'mad-codex-native-invocation.json'), codexNativeInvocation).catch(() => undefined);
+    void refreshMadNativeLaunchArtifacts(root, id, dir).catch((err) => appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.native_artifact_background_failed', error: err?.message || String(err) }));
     const protectedCore = resolveProtectedCore({ packageRoot: packageRoot(), targetRoot: cwd });
     // The interactive launch 'before' snapshot is only persisted (env + policy json)
     // and is never compared against an 'after' snapshot during the session, so the
@@ -699,13 +676,13 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
         protected_core_policy: protectedCorePolicyPath,
         protected_core_before: protectedCoreBeforePath,
         protected_core_digest: protectedCoreBefore.digest,
-        codex_native_invocation_plan: codexNativeInvocation ? {
-            selected_strategy: codexNativeInvocation.selected_strategy,
-            hook_evidence_policy: codexNativeInvocation.env.SKS_CODEX_NATIVE_HOOK_EVIDENCE_POLICY,
-            blockers: codexNativeInvocation.blockers,
-            warnings: codexNativeInvocation.warnings,
+        codex_native_invocation_plan: {
+            selected_strategy: 'message-role-fallback',
+            hook_evidence_policy: 'background-verification-do-not-count-until-refreshed',
+            blockers: [],
+            warnings: ['native_invocation_plan_deferred_until_after_ui'],
             artifact_path: 'mad-codex-native-invocation.json'
-        } : null,
+        },
         activated_by: activatedBy,
         cwd: path.resolve(cwd || process.cwd())
     };
@@ -740,6 +717,19 @@ async function activateMadZellijPermissionState(cwd = process.cwd(), args = [])
     });
     return { mission_id: id, dir, gate, root };
 }
+async function refreshMadNativeLaunchArtifacts(root, missionId, dir) {
+    await writeCodex0138CapabilityArtifacts(root, { missionId }).catch(() => null);
+    await writeCodex0139CapabilityArtifacts(root, { missionId }).catch(() => null);
+    const codexNativeInvocation = await resolveCodexNativeInvocationPlan({
+        root,
+        missionId,
+        route: '$MAD',
+        desiredCapability: 'hook-evidence'
+    }).catch(() => null);
+    if (codexNativeInvocation)
+        await writeJsonAtomic(path.join(dir, 'mad-codex-native-invocation.json'), codexNativeInvocation).catch(() => undefined);
+    await appendJsonlBounded(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.native_artifacts_refreshed_background', ok: Boolean(codexNativeInvocation) });
+}
 function baseMadLaunchOnlyFlags() {
     return new Set([
         '--mad',

package/dist/core/db-safety.js

@@ -3,9 +3,10 @@ import { exists, readJson, writeJsonAtomic, readText, nowIso, appendJsonlBounded
 import { missionDir, setCurrent } from './mission.js';
 import { evaluateMadSksPermissionGate, isMadSksRouteState } from './permission-gates.js';
 import { resolveMadDbMutationPolicy } from './mad-db/mad-db-policy-resolver.js';
-import { recordMadDbOperation } from './mad-db/mad-db-capability.js';
-import { appendMadDbLedgerEvent, appendMadDbOperationLifecycle } from './mad-db/mad-db-ledger.js';
-import { lifecycleHookFromUnknown, recordPendingMadDbLifecycleHook } from './mad-db/mad-db-result-lifecycle.js';
+import { appendMadDbLedgerEvent } from './mad-db/mad-db-ledger.js';
+import { lifecycleHookFromUnknown } from './mad-db/mad-db-result-lifecycle.js';
+import { extractCanonicalToolCallId, reserveMadDbOperation, transitionMadDbOperation } from './mad-db/mad-db-operation-store.js';
+import { madDbOperationClassesFromClassification } from './mad-db/mad-db-policy.js';
 export const DEFAULT_DB_SAFETY_POLICY = Object.freeze({
     schema_version: 1,
     mode: 'read_only_default',
@@ -511,19 +512,29 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
     const madDb = await resolveMadDbMutationPolicy(root, state, classification);
     if (madDb.allowed === true && state?.mission_id) {
         const madDbDecision = madDb;
-        const operationId = `mad-db-op-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-        const sqlHash = classification.sql?.statements?.length ? sha256(String(classification.sql.statements.join('\n'))) : null;
-        await appendMadDbOperationLifecycle(root, state.mission_id, {
-            type: 'db_operation.started',
-            operationId,
-            cycleId: madDbDecision.cycle_id,
-            toolName: classification.toolName || null,
-            sqlHash,
-            destructive: classification.level === 'destructive'
+        const sqlText = classification.sql?.statements?.length ? String(classification.sql.statements.join('\n')) : null;
+        const sqlHash = sqlText ? sha256(sqlText) : null;
+        const toolCallId = extractCanonicalToolCallId(payload) || `payload-${sha256(JSON.stringify({ tool: classification.toolName || '', sqlHash, level: classification.level })).slice(0, 16)}`;
+        const operationClasses = madDbDecision.operation_classes?.length ? madDbDecision.operation_classes : madDbOperationClassesFromClassification(classification);
+        const reservation = await reserveMadDbOperation({
+            root,
+            missionId: String(state.mission_id),
+            capability: madDbDecision.capability,
+            toolCallId,
+            toolName: classification.toolName || 'unknown_database_tool',
+            sql: sqlText,
+            operationClasses
+        });
+        await transitionMadDbOperation({
+            root,
+            missionId: String(state.mission_id),
+            toolCallId,
+            state: 'started'
         });
         const lifecycleHook = {
             mission_id: String(state.mission_id),
-            operation_id: operationId,
+            operation_id: reservation.operation.operation_id,
+            tool_call_id: toolCallId,
             cycle_id: madDbDecision.cycle_id || null,
             tool_name: classification.toolName || null,
             sql_hash: sqlHash,
@@ -538,35 +549,22 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
             mad_db: {
                 active: true,
                 priority: 'highest',
+                capability_schema: 'sks.mad-db-capability.v2',
                 one_cycle_only: true,
                 cycle_id: madDbDecision.cycle_id,
                 capability_file: 'mad-db-capability.json',
-                consumed: false,
-                operation_id: operationId,
+                status: reservation.capability.status,
+                operation_id: reservation.operation.operation_id,
+                tool_call_id: toolCallId,
+                tool_call_id_missing: extractCanonicalToolCallId(payload) === null,
                 lifecycle_result_pending: true,
                 ledger_result_hook: lifecycleHook,
-                operation_count: Number(madDbDecision.operation_count || 0) + 1,
-                max_operations: madDbDecision.max_operations || 20
+                operation_classes: operationClasses,
+                counters: reservation.capability.counters,
+                idempotent_reservation_reused: reservation.reused
             }
         };
-        await appendMadDbLedgerEvent(root, state.mission_id, { type: 'db_mutation.allowed', cycle_id: madDbDecision.cycle_id, mode: madDbDecision.mode, classification, operation_id: operationId });
-        await appendMadDbOperationLifecycle(root, state.mission_id, {
-            type: 'db_operation.allowed',
-            operationId,
-            cycleId: madDbDecision.cycle_id,
-            toolName: classification.toolName || null,
-            sqlHash,
-            destructive: classification.level === 'destructive',
-            resultStatus: 'unknown_pending_tool_result'
-        });
-        const updatedCapability = await recordMadDbOperation(root, state.mission_id, {
-            operationId,
-            ...(classification.toolName ? { toolName: classification.toolName } : {}),
-            ...(sqlHash ? { sqlHash } : {})
-        });
-        decision.mad_db.consumed = updatedCapability?.consumed === true;
-        decision.mad_db.operation_count = updatedCapability?.operation_count ?? decision.mad_db.operation_count;
-        await recordPendingMadDbLifecycleHook(root, state.mission_id, lifecycleHook);
+        await appendMadDbLedgerEvent(root, state.mission_id, { type: 'db_mutation.allowed', cycle_id: madDbDecision.cycle_id, mode: madDbDecision.mode, classification, operation_id: reservation.operation.operation_id, tool_call_id: toolCallId });
         await appendJsonlBounded(path.join(missionDir(root, state.mission_id), 'db-safety.jsonl'), { ts: nowIso(), decision });
         return decision;
     }
@@ -605,8 +603,8 @@ export function dbBlockReason(decision) {
     return [
         'Sneakoscope Codex Database Safety Gate blocked this operation.',
         `Reasons: ${(decision.reasons || []).join(', ') || 'unknown'}.`,
-        'Destructive database operations are never allowed. Production writes are forbidden. Supabase/Postgres MCP write tools must not be used for live destructive changes.',
-        'Use read-only/project-scoped Supabase MCP URLs, create migration files, and apply them only to local or preview/branch environments when explicitly allowed by the sealed contract.'
+        'Default DB mode is read-only. Destructive SQL-plane operations require an explicit active MadDB v2 capability opened by $MAD-DB or sks mad-db run|exec|apply-migration.',
+        'Use read-only/project-scoped Supabase MCP URLs outside MadDB. Supabase project/account/billing/credential control-plane operations remain denied even in MadDB.'
     ].join(' ');
 }
 export async function scanDbSafety(root, opts = {}) {

package/dist/core/doctor/doctor-dirty-planner.js

@@ -3,7 +3,6 @@ import path from 'node:path';
 import { MANAGED_ASSET_VERSION } from '../managed-assets/managed-assets-manifest.js';
 import { PACKAGE_VERSION, packageRoot, sha256 } from '../fsx.js';
 import { hashJson } from '../triwiki/triwiki-cache-key.js';
-import { triWikiProofBankDir } from '../triwiki/triwiki-proof-bank.js';
 export const DOCTOR_DIRTY_PLAN_SCHEMA = 'sks.doctor-dirty-plan.v2';
 export function planDoctorDirtyRepair(root, phaseIds) {
     const phases = phaseIds.map((id) => {
@@ -205,10 +204,16 @@ function proofExists(root, proofId) {
     const transaction = path.join(root, '.sneakoscope', 'reports', 'doctor-fix-transaction.json');
     if (fs.existsSync(transaction) && fs.readFileSync(transaction, 'utf8').includes(proofId))
         return true;
-    const bank = triWikiProofBankDir(root);
-    if (!fs.existsSync(bank))
+    const index = path.join(root, '.sneakoscope', 'cache', 'proof-index.json');
+    if (!fs.existsSync(index))
         return false;
-    return walkFiles(bank).some((file) => path.basename(file) === `${proofId}.json` || fs.readFileSync(file, 'utf8').includes(proofId));
+    try {
+        const text = fs.readFileSync(index, 'utf8');
+        return text.includes(`"${proofId}"`) || text.includes(proofId);
+    }
+    catch {
+        return false;
+    }
 }
 function phaseRequiresPostcheck(id) {
     return /zellij|context7|startup|supabase|native|secret/i.test(id);