sneakoscope 2.0.14 → 2.0.16

package/dist/core/agents/parallel-runtime-proof.js

@@ -0,0 +1,217 @@
+import path from 'node:path';
+import { appendJsonlBounded, ensureDir, nowIso, readText, writeJsonAtomic } from '../fsx.js';
+export const PARALLEL_RUNTIME_EVENT_SCHEMA = 'sks.parallel-runtime-event.v1';
+export const PARALLEL_RUNTIME_PROOF_SCHEMA = 'sks.parallel-runtime-proof.v1';
+export function parallelRuntimeEventPath(root, missionId) {
+    return path.join(inferAgentsDir(root, missionId), 'parallel-runtime.events.jsonl');
+}
+export function parallelRuntimeProofPath(root, missionId) {
+    return path.join(inferAgentsDir(root, missionId), 'parallel-runtime-proof.json');
+}
+export async function appendParallelRuntimeEvent(root, missionId, event) {
+    const row = normalizeParallelRuntimeEvent(missionId, event);
+    const file = parallelRuntimeEventPath(root, missionId);
+    await ensureDir(path.dirname(file));
+    await appendJsonlBounded(file, row);
+    return row;
+}
+export async function buildParallelRuntimeProof(root, missionId, opts = {}) {
+    const events = await readParallelRuntimeEvents(root, missionId);
+    const sorted = events.sort((a, b) => a.ms - b.ms);
+    const firstMs = sorted[0]?.ms || Date.now();
+    const lastMs = sorted[sorted.length - 1]?.ms || firstMs;
+    const workerActive = new Set();
+    const processActive = new Set();
+    const modelActive = new Set();
+    const workerStarts = new Map();
+    const workerDurations = [];
+    const workerPids = new Set();
+    const modelIds = new Set();
+    const overlapWindows = [];
+    let maxWorkers = 0;
+    let maxProcesses = 0;
+    let maxModels = 0;
+    let previousMs = firstMs;
+    let firstBatchLaunchSpanMs = 0;
+    const batchStart = new Map();
+    const batchCompleted = new Map();
+    for (const event of sorted) {
+        if (event.ms > previousMs) {
+            overlapWindows.push({
+                start_ms: previousMs - firstMs,
+                end_ms: event.ms - firstMs,
+                active_workers: workerActive.size,
+                active_model_calls: modelActive.size
+            });
+            previousMs = event.ms;
+        }
+        const workerKey = event.session_id || event.slot_id || (event.pid == null ? '' : `pid:${event.pid}`);
+        const processKey = event.pid == null ? workerKey : `pid:${event.pid}`;
+        if (event.event_type === 'batch_dispatch_started' && event.batch_id)
+            batchStart.set(event.batch_id, event.ms);
+        if (event.event_type === 'batch_dispatch_completed' && event.batch_id) {
+            batchCompleted.set(event.batch_id, event.ms);
+            const started = batchStart.get(event.batch_id);
+            if (started != null && firstBatchLaunchSpanMs === 0)
+                firstBatchLaunchSpanMs = Math.max(0, event.ms - started);
+        }
+        if (event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned') {
+            if (workerKey) {
+                workerActive.add(workerKey);
+                if (!workerStarts.has(workerKey))
+                    workerStarts.set(workerKey, event.ms);
+            }
+            if (event.event_type === 'worker_process_spawned' && processKey)
+                processActive.add(processKey);
+            if (event.pid != null)
+                workerPids.add(event.pid);
+        }
+        if (event.event_type === 'worker_completed' || event.event_type === 'worker_failed') {
+            if (workerKey) {
+                workerActive.delete(workerKey);
+                const started = workerStarts.get(workerKey);
+                if (started != null)
+                    workerDurations.push(Math.max(0, event.ms - started));
+            }
+            if (processKey)
+                processActive.delete(processKey);
+        }
+        if (event.event_type === 'model_call_started') {
+            const id = event.model_call_id || event.session_id || `model:${event.ms}:${modelActive.size}`;
+            modelActive.add(id);
+            modelIds.add(id);
+        }
+        if (event.event_type === 'model_call_completed') {
+            const id = event.model_call_id || event.session_id || '';
+            if (id)
+                modelActive.delete(id);
+        }
+        maxWorkers = Math.max(maxWorkers, workerActive.size);
+        maxProcesses = Math.max(maxProcesses, processActive.size);
+        maxModels = Math.max(maxModels, modelActive.size);
+    }
+    const requestedWorkers = positiveInt(opts.requestedWorkers, workerStarts.size || workerPids.size || maxWorkers);
+    const targetActiveSlots = positiveInt(opts.targetActiveSlots, requestedWorkers);
+    const wallMs = Math.max(0, lastMs - firstMs);
+    const sequentialEstimateMs = workerDurations.length
+        ? workerDurations.reduce((sum, value) => sum + value, 0)
+        : requestedWorkers * positiveInt(opts.expectedWorkerRuntimeMs, 4000);
+    const visiblePanes = nonNegativeInt(opts.visiblePanes, sorted.filter((event) => event.placement === 'zellij-pane').length ? new Set(sorted.filter((event) => event.placement === 'zellij-pane').map((event) => event.slot_id || event.session_id || '')).size : 0);
+    const observedHeadlessWorkers = sorted.filter((event) => event.placement === 'headless' && (event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned')).length;
+    const headlessWorkers = Math.max(observedHeadlessWorkers, Math.max(0, targetActiveSlots - visiblePanes));
+    const minActiveWorkers = opts.minActiveWorkers === undefined
+        ? Math.min(targetActiveSlots, requestedWorkers)
+        : nonNegativeInt(opts.minActiveWorkers, Math.min(targetActiveSlots, requestedWorkers));
+    const minSpeedup = Number.isFinite(Number(opts.minSpeedupRatio)) ? Number(opts.minSpeedupRatio) : requestedWorkers >= 16 ? 5 : 1;
+    const speedupRatio = wallMs > 0 ? Number((sequentialEstimateMs / wallMs).toFixed(3)) : 0;
+    const launchEvents = sorted.filter((event) => event.event_type === 'worker_launch_invoked' || event.event_type === 'worker_process_spawned');
+    const launchSpanMs = launchEvents.length ? Math.max(...launchEvents.map((event) => event.ms)) - Math.min(...launchEvents.map((event) => event.ms)) : 0;
+    const firstBatchLimit = positiveInt(opts.firstBatchLaunchSpanLimitMs, requestedWorkers >= 16 ? 2500 : 30000);
+    const blockers = [
+        ...(sorted.length ? [] : ['parallel_runtime_events_missing']),
+        ...(minActiveWorkers <= 0 || maxWorkers >= minActiveWorkers ? [] : ['max_observed_active_workers_below_target']),
+        ...(requestedWorkers >= 16 && workerPids.size && workerPids.size < minActiveWorkers ? ['unique_worker_pids_below_target'] : []),
+        ...(speedupRatio >= minSpeedup ? [] : ['speedup_ratio_below_target']),
+        ...(firstBatchLaunchSpanMs <= firstBatchLimit ? [] : ['first_batch_launch_span_above_limit'])
+    ];
+    return {
+        schema: PARALLEL_RUNTIME_PROOF_SCHEMA,
+        mission_id: missionId,
+        generated_at: nowIso(),
+        requested_workers: requestedWorkers,
+        target_active_slots: targetActiveSlots,
+        max_observed_active_workers: maxWorkers,
+        max_observed_worker_processes: Math.max(maxProcesses, workerPids.size ? maxProcesses : maxWorkers),
+        unique_worker_pids: workerPids.size,
+        unique_model_call_ids: modelIds.size,
+        max_observed_model_calls: maxModels,
+        launch_span_ms: launchSpanMs,
+        first_batch_launch_span_ms: firstBatchLaunchSpanMs,
+        wall_ms: wallMs,
+        sequential_estimate_ms: sequentialEstimateMs,
+        speedup_ratio: speedupRatio,
+        overlap_windows: coalesceOverlapWindows(overlapWindows),
+        visible_panes: visiblePanes,
+        headless_workers: headlessWorkers,
+        passed: blockers.length === 0,
+        blockers
+    };
+}
+export async function writeParallelRuntimeProof(root, missionId, opts = {}) {
+    const proof = await buildParallelRuntimeProof(root, missionId, opts);
+    await writeJsonAtomic(parallelRuntimeProofPath(root, missionId), proof);
+    return proof;
+}
+async function readParallelRuntimeEvents(root, missionId) {
+    const text = await readText(parallelRuntimeEventPath(root, missionId), '');
+    return String(text)
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return parsed?.schema === PARALLEL_RUNTIME_EVENT_SCHEMA ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => Boolean(row));
+}
+function normalizeParallelRuntimeEvent(missionId, event) {
+    return {
+        schema: PARALLEL_RUNTIME_EVENT_SCHEMA,
+        ts: nowIso(),
+        ms: Date.now(),
+        mission_id: missionId,
+        event_type: event.event_type,
+        slot_id: event.slot_id == null ? null : String(event.slot_id),
+        generation_index: event.generation_index == null ? null : Math.max(1, Math.floor(Number(event.generation_index) || 1)),
+        session_id: event.session_id == null ? null : String(event.session_id),
+        pid: event.pid == null || !Number.isFinite(Number(event.pid)) ? null : Math.floor(Number(event.pid)),
+        backend: String(event.backend || 'unknown'),
+        placement: normalizePlacement(event.placement),
+        ...(event.worktree_id === undefined ? {} : { worktree_id: event.worktree_id == null ? null : String(event.worktree_id) }),
+        ...(event.model_call_id === undefined ? {} : { model_call_id: event.model_call_id == null ? null : String(event.model_call_id) }),
+        ...(event.batch_id === undefined ? {} : { batch_id: event.batch_id == null ? null : String(event.batch_id) }),
+        ...(event.meta && typeof event.meta === 'object' ? { meta: event.meta } : {})
+    };
+}
+function normalizePlacement(value) {
+    const text = String(value || 'unknown');
+    if (text === 'zellij-pane' || text === 'process' || text === 'headless')
+        return text;
+    return 'unknown';
+}
+function positiveInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return Math.max(1, Math.floor(fallback || 1));
+    return Math.floor(parsed);
+}
+function nonNegativeInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return Math.max(0, Math.floor(fallback || 0));
+    return Math.floor(parsed);
+}
+function coalesceOverlapWindows(windows) {
+    return windows
+        .filter((window) => window.end_ms > window.start_ms)
+        .filter((window) => window.active_workers > 0 || window.active_model_calls > 0)
+        .slice(0, 2000);
+}
+function inferAgentsDir(root, missionId) {
+    const resolved = path.resolve(root);
+    if (path.basename(resolved) === 'agents' && path.basename(path.dirname(resolved)) === missionId)
+        return resolved;
+    if (path.basename(resolved) === missionId && path.basename(path.dirname(resolved)) === 'missions')
+        return path.join(resolved, 'agents');
+    const marker = `${path.sep}.sneakoscope${path.sep}missions${path.sep}${missionId}${path.sep}`;
+    const index = resolved.indexOf(marker);
+    if (index >= 0)
+        return path.join(resolved.slice(0, index + marker.length - 1), 'agents');
+    return path.join(resolved, '.sneakoscope', 'missions', missionId, 'agents');
+}
+//# sourceMappingURL=parallel-runtime-proof.js.map

package/dist/core/codex-control/codex-task-runner.js

@@ -16,6 +16,7 @@ import { writeUltraRouterProof } from '../router/router-proof.js';
 import { readLocalModelConfig } from '../agents/ollama-worker-config.js';
 import { runLocalLlmTask } from '../local-llm/local-llm-control-adapter.js';
 import { detectPythonCodexSdkCapability, runPythonCodexSdkTask } from './python-codex-sdk-adapter.js';
+import { defaultModelCallBudget, withModelCallSlot } from './model-call-concurrency.js';
 export async function runCodexTask(input) {
     const root = path.resolve(input.mutationLedgerRoot);
     await ensureDir(root);
@@ -46,7 +47,16 @@ export async function runCodexTask(input) {
     ];
     let adapterResult = null;
     if (!blockers.length) {
-        adapterResult = await runWithCodexReliabilityShield(task, async () => {
+        adapterResult = await withModelCallSlot({
+            root,
+            missionId: task.missionId,
+            provider: 'codex-sdk',
+            budget: defaultModelCallBudget('codex-sdk'),
+            slotId: task.slotId || null,
+            generationIndex: task.generationIndex ?? null,
+            sessionId: task.sessionId || null,
+            backend: 'codex-sdk'
+        }, () => runWithCodexReliabilityShield(task, async () => {
             try {
                 return fakeAllowed
                     ? await runFakeCodexSdkTask(task)
@@ -63,7 +73,7 @@ export async function runCodexTask(input) {
                     blockers: ['codex_sdk_run_failed:' + String(err?.message || err)]
                 };
             }
-        });
+        }));
     }
     const events = Array.isArray(adapterResult?.events) ? adapterResult.events : [];
     const translatedEvents = translateCodexSdkEvents(events);
@@ -153,7 +163,16 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
         await ensureDir(runtime.env.env.CODEX_HOME);
     const fakeAllowed = process.env.SKS_PYTHON_CODEX_SDK_FAKE === '1';
     const adapterResult = capability.ok || fakeAllowed
-        ? await runPythonCodexSdkTask(task, { env: runtime.env.env, config: runtime.config })
+        ? await withModelCallSlot({
+            root,
+            missionId: task.missionId,
+            provider: 'python-codex-sdk',
+            budget: defaultModelCallBudget('python-codex-sdk'),
+            slotId: task.slotId || null,
+            generationIndex: task.generationIndex ?? null,
+            sessionId: task.sessionId || null,
+            backend: 'python-codex-sdk'
+        }, () => runPythonCodexSdkTask(task, { env: runtime.env.env, config: runtime.config }))
         : { ok: false, events: [], translatedEvents: [], finalResponse: '', threadId: '', turnId: '', blockers: capability.blockers, capability };
     const events = Array.isArray(adapterResult.events) ? adapterResult.events : [];
     const translatedEvents = Array.isArray(adapterResult.translatedEvents) ? adapterResult.translatedEvents : [];
@@ -251,7 +270,16 @@ async function runPythonControlTask(root, task, schema, routerDecision) {
 }
 async function runLocalControlTask(root, task, schema, routerDecision) {
     const config = await readLocalModelConfig();
-    const adapterResult = await runLocalLlmTask(task, { config, outputSchema: schema });
+    const adapterResult = await withModelCallSlot({
+        root,
+        missionId: task.missionId,
+        provider: 'local-llm',
+        budget: defaultModelCallBudget('local-llm'),
+        slotId: task.slotId || null,
+        generationIndex: task.generationIndex ?? null,
+        sessionId: task.sessionId || null,
+        backend: 'local-llm'
+    }, () => runLocalLlmTask(task, { config, outputSchema: schema }));
     for (const event of adapterResult.events || [])
         await appendJsonl(path.join(root, 'local-llm-events.jsonl'), event);
     const structuredOutput = adapterResult.structuredOutput;

package/dist/core/codex-control/model-call-concurrency.js

@@ -0,0 +1,106 @@
+import { appendParallelRuntimeEvent } from '../agents/parallel-runtime-proof.js';
+const semaphores = new Map();
+export function getModelCallSemaphore(provider, budget) {
+    const normalizedProvider = String(provider || 'codex-sdk');
+    const normalizedBudget = Math.max(1, Math.floor(Number(budget || 1)));
+    const key = `${normalizedProvider}:${normalizedBudget}`;
+    const existing = semaphores.get(key);
+    if (existing)
+        return existing;
+    const created = new ModelCallSemaphoreImpl(normalizedProvider, normalizedBudget);
+    semaphores.set(key, created);
+    return created;
+}
+export async function withModelCallSlot(input, fn) {
+    const semaphore = getModelCallSemaphore(input.provider, input.budget);
+    const modelCallId = input.modelCallId || `${input.provider}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+    return semaphore.run(async () => {
+        await appendParallelRuntimeEvent(input.root, input.missionId, {
+            event_type: 'model_call_started',
+            slot_id: input.slotId ?? null,
+            generation_index: input.generationIndex ?? null,
+            session_id: input.sessionId ?? null,
+            model_call_id: modelCallId,
+            backend: input.backend || input.provider,
+            placement: 'unknown',
+            meta: {
+                provider: input.provider,
+                budget: semaphore.budget,
+                active_model_calls: semaphore.active,
+                queued_model_calls: semaphore.queued
+            }
+        }).catch(() => undefined);
+        try {
+            return await fn();
+        }
+        finally {
+            await appendParallelRuntimeEvent(input.root, input.missionId, {
+                event_type: 'model_call_completed',
+                slot_id: input.slotId ?? null,
+                generation_index: input.generationIndex ?? null,
+                session_id: input.sessionId ?? null,
+                model_call_id: modelCallId,
+                backend: input.backend || input.provider,
+                placement: 'unknown',
+                meta: {
+                    provider: input.provider,
+                    budget: semaphore.budget,
+                    max_observed_model_calls: semaphore.maxObserved,
+                    queued_model_calls: semaphore.queued
+                }
+            }).catch(() => undefined);
+        }
+    });
+}
+export function defaultModelCallBudget(provider) {
+    const text = String(provider || '');
+    if (text === 'local-llm' || text === 'ollama')
+        return envInt('SKS_LOCAL_LLM_MAX_PARALLEL_REQUESTS', 4);
+    return envInt('SKS_REMOTE_API_PARALLEL_BUDGET', 12);
+}
+class ModelCallSemaphoreImpl {
+    provider;
+    budget;
+    active = 0;
+    queued = 0;
+    maxObserved = 0;
+    waiters = [];
+    constructor(provider, budget) {
+        this.provider = provider;
+        this.budget = budget;
+    }
+    async run(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    async acquire() {
+        if (this.active < this.budget) {
+            this.active += 1;
+            this.maxObserved = Math.max(this.maxObserved, this.active);
+            return;
+        }
+        this.queued += 1;
+        await new Promise((resolve) => this.waiters.push(resolve));
+        this.queued = Math.max(0, this.queued - 1);
+        this.active += 1;
+        this.maxObserved = Math.max(this.maxObserved, this.active);
+    }
+    release() {
+        this.active = Math.max(0, this.active - 1);
+        const next = this.waiters.shift();
+        if (next)
+            next();
+    }
+}
+function envInt(name, fallback) {
+    const parsed = Number(process.env[name]);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return fallback;
+    return Math.floor(parsed);
+}
+//# sourceMappingURL=model-call-concurrency.js.map

package/dist/core/commands/basic-cli.js

@@ -101,7 +101,7 @@ export function quickstartCommand() {
   sks dollar-commands
   sks all-features selftest --mock --execute-fixtures --strict-artifacts --json
 
-For implementation work, use Codex App prompt routes such as $Team, $Goal, $QA-LOOP, $Image-UX-Review, and $Computer-Use.`);
+For implementation work, use Codex App prompt routes such as $Naruto, $Goal, $QA-LOOP, $Image-UX-Review, and $Computer-Use.`);
 }
 export async function updateCheckCommand(args = []) {
     const result = await runSksUpdateCheck();

package/dist/core/commands/command-suggestions.js

@@ -1,7 +1,7 @@
 export const COMMAND_SUGGESTIONS_SCHEMA = 'sks.command-suggestions.v1';
 export function suggestSksCommands(input) {
     const query = String(input || '').toLowerCase();
-    const commands = ['$Team', '$Goal', '$DFix', '$QA-LOOP', '$Research', '$PPT', '$Image-UX-Review', '$Computer-Use'];
+    const commands = ['$Naruto', '$Goal', '$DFix', '$QA-LOOP', '$Research', '$PPT', '$Image-UX-Review', '$Computer-Use'];
     const suggestions = commands.filter((command) => command.toLowerCase().includes(query.replace(/^\$/, ''))).slice(0, 8);
     return {
         schema: COMMAND_SUGGESTIONS_SCHEMA,

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

@@ -0,0 +1,106 @@
+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';
+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 === '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');
+    process.exitCode = 1;
+}
+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 };
+        if (json)
+            return console.log(JSON.stringify(result, null, 2));
+        console.error(`Mad-DB enable blocked. Required --ack ${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 };
+    if (json)
+        return console.log(JSON.stringify(result, null, 2));
+    console.log(`Mad-DB one-cycle capability active for ${missionId}; expires ${capability.expires_at}.`);
+    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',
+        ok: true,
+        action: 'status',
+        mission_id: missionId,
+        active: isMadDbCapabilityActive(capability),
+        capability
+    };
+    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;
+}
+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;
+    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.');
+    else
+        console.log(`Mad-DB capability revoked for ${missionId}.`);
+    return result;
+}
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+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 + '='));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+//# sourceMappingURL=mad-db-command.js.map

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { spawn } from 'node:child_process';
-import { appendJsonlBounded, exists, nowIso, packageRoot, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
+import { PACKAGE_VERSION, appendJsonlBounded, exists, nowIso, packageRoot, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { initProject } from '../init.js';
 import { createMission, setCurrent } from '../mission.js';
 import { buildMadHighLaunchProfileNoWrite, madHighProfileName } from '../auto-review.js';
@@ -18,6 +18,8 @@ import { applyMadSksRollbackPlan } from '../mad-sks/rollback-apply.js';
 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';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
@@ -27,16 +29,7 @@ export async function madHighCommand(args = [], deps = {}) {
         const profile = buildMadHighLaunchProfileNoWrite();
         return console.log(JSON.stringify(profile, null, 2));
     }
-    const update = deps.maybePromptSksUpdateForLaunch ? await deps.maybePromptSksUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
-    if (update.status === 'updated') {
-        console.log(`SKS updated from ${deps.packageVersion} to ${update.latest}. Rerun: sks --mad`);
-        return;
-    }
-    if (update.status === 'failed') {
-        console.error(`SKS update failed: ${update.error}`);
-        process.exitCode = 1;
-        return;
-    }
+    const update = { status: 'notice_only', non_blocking: true };
     const codexUpdate = deps.maybePromptCodexUpdateForLaunch ? await deps.maybePromptCodexUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
     if (codexUpdate.status === 'failed' || codexUpdate.status === 'updated_not_reflected') {
         console.error(`Codex CLI update failed: ${codexUpdate.error || 'updated version was not visible on PATH'}`);
@@ -68,6 +61,13 @@ export async function madHighCommand(args = [], deps = {}) {
     // readability + repair checks still run. SKS_LAUNCH_FULL_CODEX_PROBE=1 restores the
     // old behavior.
     const rawArgs = (args || []).map((arg) => String(arg));
+    const madDbRequested = rawArgs.includes('--mad-db');
+    const madDbAck = readOption(rawArgs, '--ack', '');
+    if (madDbRequested && madDbAck !== MAD_DB_ACK) {
+        console.error(`SKS MAD-DB launch blocked. Required --ack ${JSON.stringify(MAD_DB_ACK)}`);
+        process.exitCode = 2;
+        return { ok: false, status: 'blocked', reason: 'mad_db_ack_phrase_required', required_ack: MAD_DB_ACK };
+    }
     const allowMadRepair = rawArgs.includes('--repair-config') || rawArgs.includes('--fix') || rawArgs.includes('--yes-repair');
     const launchPreflight = await runCodexLaunchPreflight(launchRoot, { fix: allowMadRepair, launchFast: process.env.SKS_LAUNCH_FULL_CODEX_PROBE !== '1', profile: profile.profile_name, sandbox: 'danger-full-access', serviceTier: 'fast' });
     const afterPreflightUi = beforeUi ? await writeCodexAppUiSnapshot(launchRoot, `mad-after-preflight-${uiSnapshotId}`).catch(() => null) : null;
@@ -88,7 +88,41 @@ export async function madHighCommand(args = [], deps = {}) {
         return launchPreflight;
     }
     const madLaunch = await activateMadZellijPermissionState(process.cwd(), args);
+    const madDbCapability = madDbRequested
+        ? await createMadDbCapability(madLaunch.root, { missionId: madLaunch.mission_id, ack: madDbAck, cwd: process.cwd() })
+        : null;
+    if (madDbCapability) {
+        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
+        });
+        await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_db.capability_created', cycle_id: madDbCapability.cycle_id, expires_at: madDbCapability.expires_at });
+    }
+    const updateNotice = await checkSksUpdateNotice({
+        packageName: deps.packageName || 'sneakoscope',
+        currentVersion: deps.packageVersion || PACKAGE_VERSION,
+        missionDir: madLaunch.dir
+    }).catch((err) => ({
+        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',
+        cache_ttl_ms: 0,
+        message: 'SKS update notice check failed; MAD launch continues.',
+        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: ${madHighProfileName()} | gate ${madLaunch.mission_id}`);
+    if (madDbCapability)
+        console.log(`MAD-DB one-cycle capability active; expires ${madDbCapability.expires_at}.`);
+    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, DB writes, or system/admin scopes. Catastrophic guards remain.');
     const launchLb = lb.status === 'present' ? { ...lb, status: 'configured' } : lb;
     const madSksEnv = {
@@ -445,6 +479,7 @@ function madLaunchOnlyFlags() {
         '--allow-file-permissions',
         '--allow-chmod',
         '--allow-delete',
+        '--mad-db',
         '--confirm-delete',
         '--confirm-destructive-delete',
         '--no-swarm',
@@ -460,7 +495,8 @@ function madLaunchOnlyFlags() {
         '--yes',
         '-y',
         '--dry-run',
-        '--plan-only'
+        '--plan-only',
+        '--ack'
     ]);
 }
 function madLaunchValueFlags() {
@@ -469,7 +505,8 @@ function madLaunchValueFlags() {
         '--mad-swarm-agents',
         '--mad-swarm-work-items',
         '--mad-swarm-backend',
-        '--mad-swarm-prompt'
+        '--mad-swarm-prompt',
+        '--ack'
     ]);
 }
 export function defaultMadSwarmBackend(args = [], opts = {}) {