sneakoscope 4.1.1 → 4.2.1

package/README.md

@@ -35,15 +35,18 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## 🚀 Current Release
 
-SKS **4.1.1** tightens the 4.1 readiness path for publishing and first-command migration. Doctor now keeps optional native surfaces route-gated, writes v2 project migration receipts tied to an installation epoch, and keeps the migration profile fast enough for update gates.
+SKS **4.2.1** stabilizes MadDB SQL-plane execution so explicit `$MAD-DB` and `sks mad-db run|exec|apply-migration` invocations use a first-class, mission-bound break-glass route instead of inheriting `$MAD-SKS` state.
 
-What changed in 4.1.1:
+What changed in 4.2.0:
+
+- **First-class MadDB route.** `$MAD-DB` no longer aliases `$MAD-SKS`; it creates one authoritative mission, capability, runtime profile, inventory check, execution, read-back, and closeout cycle.
+- **Capability v2 binding.** MadDB capabilities bind project root, project ref hash, mission/cycle/session identity, runtime profile hash, TTL, operator intent, and SQL-plane operation classes.
+- **Ephemeral Supabase write profile.** Persistent Supabase MCP config stays read-only; write-capable MCP settings exist only inside the active MadDB mission and are removed in `finally`.
+- **Exact lifecycle correlation.** Hook/result handling is keyed by canonical `tool_call_id`, uses idempotent operation state, and avoids unsafe tool-name result matching under parallel calls.
+- **Policy/docs/test SSOT.** MadDB route metadata, generated skill guidance, DB safety wording, Doctor guidance, release gates, docs, scanner coverage, and local regression tests share the typed MadDB policy surface.
+- **Release metadata truth.** Package, CLI version constants, Rust crate metadata, README, changelog, and release checks all point at 4.2.0.
 
-- **Core vs route readiness.** Computer Use and Chrome/web review are manual-required route gates, not core blockers for ordinary Doctor/update readiness.
-- **Migration receipt v2.** First-command migration writes project receipts with installation epoch, project hash, required blockers, and optional warnings so stale locks or optional capabilities do not block normal commands.
-- **Fast migration Doctor.** `sks doctor --fix --profile migration --machine-only` skips optional Codex App, Zellij, provider, native, and deep diagnostic work while preserving core readiness checks.
-- **MAD bootstrap latency.** MAD defers update prompts, provider setup, UI snapshots, pane proof, and native swarm proof until the route actually needs them.
-- **Release metadata truth.** Package, CLI version constants, Rust crate metadata, README, changelog, and release checks all point at 4.1.1.
+What changed in 4.1.1:
 
 What changed in 4.1.0:
 
@@ -504,7 +507,7 @@ sks --mad
 sks --mad --allow-package-install --allow-service-control --allow-network --yes
 ```
 
-This syncs existing codex-lb provider auth, creates/uses the `sks-mad-high` xhigh maintenance profile, opens the MAD-SKS permission gate for that Zellij run, starts a same-mission read-only native agent swarm, and launches a Codex CLI layout whose right-side lanes read that MAD ledger. Bare `sks --mad` grants target-project file and shell scope only; add explicit `--allow-*` flags for packages, services, network, Computer Use, browser use, generated assets, file permissions, DB writes, or other high-risk scopes. MAD-SKS is not a DB-only unlock: it is explicit user authorization to widen approved target-project scopes. Catastrophic database wipe/all-row/project-management safeguards remain active, and the pipeline contract still forbids unrequested fallback implementation code.
+This syncs existing codex-lb provider auth, creates/uses the `sks-mad-high` xhigh maintenance profile, opens the MAD-SKS permission gate for that Zellij run, starts a same-mission read-only native agent swarm, and launches a Codex CLI layout whose right-side lanes read that MAD ledger. Bare `sks --mad` grants target-project file and shell scope only; add explicit `--allow-*` flags for packages, services, network, Computer Use, browser use, generated assets, file permissions, DB writes, or other high-risk scopes. MAD-SKS is not a DB-only unlock and does not create a MadDB capability. Catastrophic database wipe/all-row/project-management safeguards remain active outside the first-class MadDB route, and the pipeline contract still forbids unrequested fallback implementation code.
 
 Before launching, SKS checks npm for a newer `sneakoscope` and prints a non-blocking update notice when one is available; use `sks update now` or `sks doctor --fix` when you want SKS to update itself. Use `--yes` to approve missing dependency installs automatically. Tune MAD swarm startup with `--mad-agents <n>`, `--mad-swarm-work-items <n>`, and `--mad-swarm-backend <backend>`; `--no-mad-swarm` keeps only the cockpit UI if you need a temporary fallback.
 
@@ -717,7 +720,7 @@ Use these inside Codex App or another agent prompt. They are prompt commands, no
 
 Common prompts: `$Team`, `$From-Chat-IMG`, `$with-local-llm-on`, `$with-local-llm-off`, `$DFix`, `$Answer`, `$SKS`, `$QA-LOOP`, `$PPT`, `$Computer-Use`/`$CU`, `$Goal`, `$Research`, `$AutoResearch`, `$DB`, `$MAD-SKS`, `$MAD-DB`, `$GX`, `$Wiki`, and `$Help`.
 
-`$MAD-DB` is the prompt-visible Mad-DB alias for one-cycle DB break-glass work. It maps to the same guarded MAD-SKS permission route, while the terminal lifecycle remains `sks mad-db status|enable|revoke`; it is not a permanent DB unlock and catastrophic DB safeguards remain active.
+`$MAD-DB` is the first-class MadDB SQL-plane execution route. `sks mad-db run|exec|apply-migration` creates the bound mission/capability/runtime profile, verifies Supabase `execute_sql` and `apply_migration`, executes the requested SQL-plane mutation, reads back postconditions, and then closes the write profile while proving normal read-only restoration. Supabase project/account/billing/credential control-plane actions remain denied. See `docs/mad-db.md`.
 
 ## 🔁 Common Workflows
 
@@ -863,7 +866,7 @@ npm run release:check
 npm run publish:dry
 ```
 
-`release:check` runs the change-aware affected release gate for ordinary local checks. Publish readiness uses `release:check:full`, which runs the full release DAG and writes a source digest stamp under `.sneakoscope/reports/` so publish commands can verify the same source/dist state. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, Goal mode propagation checks, slot telemetry, update notice, MAD-DB, and Naruto SSOT gates. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. `npm run publish:dry` runs `release:check:full`, verifies the fresh stamp, and then performs provenance/registry and npm dry-run checks. npm's `prepublishOnly` uses `prepublish-release-check-or-fast` to accept that current stamp before the real publish; if the stamp is missing or stale, it runs `release:check:full` once before continuing.
+`release:check` runs the change-aware affected release gate for ordinary local checks. Publish readiness uses `release:check:full`, which runs the full release DAG and writes a source digest stamp under `.sneakoscope/reports/` so publish commands can verify the same source/dist state. The DAG preserves the 1.18 baseline gates and adds Codex 0.136 compatibility, inherited Codex 0.135/0.134 runner truth, patch swarm runtime truth, transaction journaling, serial conflict rebase, strict strategy-to-patch proof, rollback command proof, Native CLI Session Swarm 5/10/20-process proof, Real Worker Backend Router proof, Codex child overlap proof, model-authored patch-envelope separation, Zellij layout/pane/screen/socket-dir proof, no-subagent-scaling proof, Fast mode default/worker/Codex/MAD propagation proof, Appshots attachment provenance, MCP runtime overlap evidence, task graph expansion, schema-bound follow-up work, actual Agent/Team/Research/QA route blackboxes, scheduler proof hardening, Source Intelligence propagation, Goal mode propagation checks, slot telemetry, update notice, MAD-DB, and Naruto SSOT gates. Broader live gates remain explicit scripts such as `release:real-check`; real Codex patch smoke, real Codex parallel worker proof, and real Zellij proof are optional unless their `SKS_REQUIRE_REAL_*` or `SKS_REQUIRE_ZELLIJ=1` environment variables are set. Generate the human-readable registry with `sks features inventory --write-docs`. Plain `npm publish` uses the `latest` dist-tag. `npm run publish:dry` runs `release:check:full`, verifies the fresh stamp, and then performs provenance/registry and npm dry-run checks. `npm run publish:npm` and `npm run release:publish` run the same prepublish gate and then `npm publish --ignore-scripts`, so the real publish path stays strict even when lifecycle scripts are skipped. npm's `prepublishOnly` uses `prepublish-release-check-or-fast` to accept that current stamp before the real publish; if the stamp is missing or stale, it runs `release:check:full` once before continuing.
 
 Version bumps are manual. Run `sks versioning bump` only when preparing release metadata; SKS will not create `.git/hooks/pre-commit` or auto-bump during ordinary commits.
 

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "4.1.1"
+version = "4.2.1"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "4.1.1"
+version = "4.2.1"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 4.1.1"),
+        Some("--version") => println!("sks-rs 4.2.1"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '4.1.1';
+const FAST_PACKAGE_VERSION = '4.2.1';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--agent' && args[1] === 'worker') {

package/dist/cli/command-registry.js

@@ -112,7 +112,7 @@ export const COMMANDS = {
     zellij: entry('beta', 'Inspect Zellij runtime status and explain repair (no auto-install)', 'dist/commands/zellij.js', directCommand(() => import('../commands/zellij.js'), 'dist/commands/zellij.js')),
     'mad-sks': entry('beta', 'MAD-SKS scoped permission modifier', 'dist/commands/mad-sks.js', directCommand(() => import('../commands/mad-sks.js'), 'dist/commands/mad-sks.js')),
     glm: entry('beta', 'Run GLM 5.2 MAD mode through OpenRouter', 'dist/core/commands/glm-command.js', argsCommand(() => import('../core/commands/glm-command.js'), 'glmCommand', 'dist/core/commands/glm-command.js')),
-    'mad-db': entry('beta', 'Create or inspect one-cycle Mad-DB break-glass capability tokens', 'dist/commands/mad-db.js', directCommand(() => import('../commands/mad-db.js'), 'dist/commands/mad-db.js')),
+    'mad-db': entry('beta', 'Run first-class MadDB SQL-plane execution cycles with mission-local Supabase write transport', 'dist/commands/mad-db.js', directCommand(() => import('../commands/mad-db.js'), 'dist/commands/mad-db.js')),
     'auto-review': entry('beta', 'Manage auto-review profile', 'dist/commands/auto-review.js', directCommand(() => import('../commands/auto-review.js'), 'dist/commands/auto-review.js')),
     'dollar-commands': entry('stable', 'List Codex App dollar commands', 'dist/core/commands/basic-cli.js', basicArgs('dollarCommandsCommand')),
     'fast-mode': entry('stable', 'Toggle SKS Fast mode default for dollar-command routes', 'dist/core/commands/fast-mode-command.js', argsCommand(() => import('../core/commands/fast-mode-command.js'), 'fastModeCommand', 'dist/core/commands/fast-mode-command.js')),

package/dist/core/auto-review.js

@@ -314,7 +314,7 @@ function removeLegacyProfileConfig(text, profile) {
 function upsertAutoReviewPolicy(text) {
     const policy = [
         '[auto_review]',
-        'policy = "In MAD launches, allow live-server work, normal DB writes, Supabase MCP DB writes, direct execute SQL, schema cleanup, and migration application for the active invocation. Deny only catastrophic database wipes, all-row value deletion/update, dangerous project or branch management, credential exfiltration, persistent security weakening, broad unrelated file deletion, and unrequested fallback implementation code."'
+        'policy = "In MAD-SKS launches, allow only scoped non-MadDB high-risk work approved for the active invocation and keep catastrophic DB wipe/all-row safeguards active. In first-class MAD-DB cycles, the explicit $MAD-DB or sks mad-db run|exec|apply-migration invocation is the SQL-plane approval boundary: execute requested execute_sql/apply_migration mutations with mission-local write transport, read-back proof, and final read-only restoration. Supabase project/account/billing/credential control-plane actions remain denied."'
     ].join('\n');
     const existing = readTableString(text, 'auto_review', 'policy');
     if (existing && /unrequested fallback implementation code/i.test(existing))

package/dist/core/codex-control/codex-app-server-v2-client.js

@@ -8,10 +8,12 @@ export class CodexAppServerV2Client {
     cwd;
     timeoutMs;
     currentTimeProvider;
+    approvalPolicy;
     child = null;
     nextId = 1;
     pending = new Map();
     notifications = [];
+    listeners = new Set();
     stdoutBuffer = '';
     stderr = '';
     constructor(options) {
@@ -21,6 +23,7 @@ export class CodexAppServerV2Client {
         this.cwd = options.cwd || process.cwd();
         this.timeoutMs = Number(options.timeoutMs || 20_000);
         this.currentTimeProvider = options.currentTimeProvider || (() => new Date());
+        this.approvalPolicy = options.approvalPolicy || {};
     }
     async initialize() {
         this.start();
@@ -36,18 +39,58 @@ export class CodexAppServerV2Client {
                 optOutNotificationMethods: []
             }
         });
-        this.notify('notifications/initialized', {});
+        this.notify('initialized', {});
         return result;
     }
     async listThreads(params = {}) {
         return await this.request('thread/list', normalizeThreadListParams(params));
     }
+    async startThread(params = {}) {
+        return await this.request('thread/start', params);
+    }
+    async resumeThread(params = {}) {
+        return await this.request('thread/resume', params);
+    }
     async searchThreads(searchTerm, params = {}) {
         return await this.listThreads({ ...params, searchTerm });
     }
     async readThread(threadId, includeTurns = false) {
         return await this.request('thread/read', { threadId, includeTurns });
     }
+    async startTurn(params = {}) {
+        return await this.request('turn/start', params);
+    }
+    async steerTurn(params = {}) {
+        return await this.request('turn/steer', params);
+    }
+    async interruptTurn(params = {}) {
+        return await this.request('turn/interrupt', params);
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    waitForNotification(methods, timeoutMs = this.timeoutMs) {
+        const expected = new Set(Array.isArray(methods) ? methods.map(String) : [String(methods)]);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                dispose();
+                reject(new Error(`Timed out waiting for app-server notification: ${Array.from(expected).join(', ')}`));
+            }, timeoutMs);
+            timer.unref?.();
+            const dispose = this.onEvent((event) => {
+                if (event && expected.has(String(event.method || ''))) {
+                    clearTimeout(timer);
+                    dispose();
+                    resolve(event);
+                }
+            });
+        });
+    }
+    async waitForTurnCompletion(threadId, turnId, timeoutMs = this.timeoutMs) {
+        const expected = turnId ? ['turn/completed', 'thread/closed', 'thread/status/changed'] : ['turn/completed', 'thread/closed'];
+        return await this.waitForNotification(expected, timeoutMs);
+    }
     start() {
         if (this.child)
             return;
@@ -107,7 +150,14 @@ export class CodexAppServerV2Client {
                 void this.respondToServerRequest(message);
             }
             else {
-                this.notifications.push({ ...message, received_at: nowIso() });
+                const event = { ...message, received_at: nowIso() };
+                this.notifications.push(event);
+                for (const listener of this.listeners) {
+                    try {
+                        listener(event);
+                    }
+                    catch { }
+                }
             }
         }
     }
@@ -119,6 +169,38 @@ export class CodexAppServerV2Client {
                 this.write({ jsonrpc: '2.0', id, result: currentTimeResponse(this.currentTimeProvider()) });
                 return;
             }
+            if (method === 'item/commandExecution/requestApproval' || method === 'commandExecution/requestApproval') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.commandExecution?.(message.params) || { decision: 'cancel' } });
+                return;
+            }
+            if (method === 'item/fileChange/requestApproval' || method === 'fileChange/requestApproval') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.fileChange?.(message.params) || { decision: 'cancel' } });
+                return;
+            }
+            if (method === 'item/permissions/requestApproval' || method === 'permissions/requestApproval') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.permissions?.(message.params) || { permissions: { network: { enabled: false }, fileSystem: { read: [], write: [], entries: [] } }, scope: 'turn', strictAutoReview: true } });
+                return;
+            }
+            if (method === 'item/tool/requestUserInput') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.toolRequestUserInput?.(message.params) || { answers: {} } });
+                return;
+            }
+            if (method === 'item/tool/call') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.dynamicToolCall?.(message.params) || { contentItems: [], success: false } });
+                return;
+            }
+            if (method === 'mcpServer/elicitation/request') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.mcpElicitation?.(message.params) || { contentItems: [], success: false } });
+                return;
+            }
+            if (method === 'attestation/generate') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.attestation?.(message.params) || { decision: 'cancel' } });
+                return;
+            }
+            if (method === 'account/chatgptAuthTokens/refresh') {
+                this.write({ jsonrpc: '2.0', id, result: this.approvalPolicy.chatgptAuthTokensRefresh?.(message.params) || { ok: false } });
+                return;
+            }
             this.write({
                 jsonrpc: '2.0',
                 id,
@@ -182,6 +264,8 @@ export async function createCodexAppServerV2Client(options = {}) {
         clientOptions.timeoutMs = options.timeoutMs;
     if (options.currentTimeProvider !== undefined)
         clientOptions.currentTimeProvider = options.currentTimeProvider;
+    if (options.approvalPolicy !== undefined)
+        clientOptions.approvalPolicy = options.approvalPolicy;
     return {
         client: new CodexAppServerV2Client(clientOptions),
         runtimeIdentity: runtime.identity

package/dist/core/codex-control/codex-reliability-shield.js

@@ -37,6 +37,7 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
             break;
     }
     const blockers = attempts.flatMap((attempt) => attempt.blockers);
+    const modelCapacityRetryCount = attempts.filter((attempt) => attempt.model_capacity_error && attempt.retryable).length;
     const report = {
         schema: CODEX_RELIABILITY_SHIELD_SCHEMA,
         generated_at: nowIso(),
@@ -52,6 +53,8 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
         heartbeat_count: attempts.reduce((sum, attempt) => sum + attempt.heartbeat_count, 0),
         repaired_tool_result_count: attempts.reduce((sum, attempt) => sum + attempt.repaired_tool_result_count, 0),
         no_duplicate_streamed_output: attempts.slice(0, -1).every((attempt) => attempt.meaningful_event_count === 0),
+        model_capacity_retry_count: modelCapacityRetryCount,
+        selected_model_capacity_fallback: selectedAttempt > 1 && modelCapacityRetryCount > 0,
         blockers
     };
     return {
@@ -61,24 +64,27 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
 }
 export function evaluateCodexReliabilityAttempt(result, events, policy, attempt) {
     const meaningful = events.filter(isMeaningfulEvent);
-    const fatal = hasFatalError(result, events);
+    const modelCapacity = isCodexModelCapacityError(result, events);
+    const fatal = !modelCapacity && hasFatalError(result, events);
     const idle = hasIdleTimeout(events, policy.idleTimeoutMs);
     const empty = events.length === 0 || (!String(result.finalResponse || '').trim() && meaningful.length === 0);
     const partial = meaningful.length > 0 && !result.structuredOutput;
     const blockers = [];
     let retryable = false;
     let retryReason = null;
-    if (idle && partial)
+    if (modelCapacity)
+        blockers.push('codex_model_capacity_unavailable');
+    if (!modelCapacity && idle && partial)
         blockers.push('codex_reliability_idle_after_partial_output');
-    if (partial && !idle)
+    if (!modelCapacity && partial && !idle)
         blockers.push('codex_reliability_partial_output_without_structured_result');
     if (fatal)
         blockers.push('codex_reliability_fatal_error_no_retry');
-    if (!fatal && idle && meaningful.length === 0) {
+    if (!modelCapacity && !fatal && idle && meaningful.length === 0) {
         retryable = true;
         retryReason = 'stream_idle_before_meaningful_event';
     }
-    else if (!fatal && empty) {
+    else if (!modelCapacity && !fatal && empty) {
         retryable = true;
         retryReason = 'empty_sdk_result_before_meaningful_event';
     }
@@ -92,11 +98,26 @@ export function evaluateCodexReliabilityAttempt(result, events, policy, attempt)
         retry_reason: retryReason,
         idle_timeout: idle,
         fatal_error: fatal,
+        model_capacity_error: modelCapacity,
+        capacity_fallback_hint: null,
         repaired_tool_result_count: 0,
         heartbeat_count: 0,
         blockers
     };
 }
+export function isCodexModelCapacityError(result, events) {
+    const text = [
+        String(result.finalResponse || ''),
+        ...(Array.isArray(result.blockers) ? result.blockers : []),
+        ...events.map((event) => [
+            event?.error?.message,
+            event?.message,
+            event?.item?.text,
+            event?.raw?.failed_event?.error?.message
+        ].filter(Boolean).join('\n'))
+    ].join('\n');
+    return /selected model is at capacity|model(?:\s+[\w.-]+)?\s+is\s+at\s+capacity|try a different model|capacity(?:\s+is)?\s+exhausted|temporarily at capacity/i.test(text);
+}
 export function repairToolCallSequence(events) {
     const repaired = [...events];
     const openToolCalls = new Set();

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

@@ -118,6 +118,8 @@ export async function runCodexTask(input) {
         patchEnvelopePath,
         blockers: finalBlockers,
         reliabilityShield: adapterResult?.reliabilityShield || null,
+        capacityFallback: adapterResult?.reliabilityShield?.selected_model_capacity_fallback === true,
+        modelCapacityRetryCount: Number(adapterResult?.reliabilityShield?.model_capacity_retry_count || 0),
         ultraRouterDecision: routerDecision,
         outputSchemaId: task.outputSchemaId,
         finalResponse: adapterResult?.finalResponse || '',
@@ -146,7 +148,11 @@ export async function runCodexTask(input) {
         result,
         capability: capability,
         sandbox,
-        envProof: runtime.env.proof,
+        envProof: {
+            ...runtime.env.proof,
+            capacity_fallback_selected: result.capacityFallback === true,
+            model_capacity_retry_count: result.modelCapacityRetryCount
+        },
         config: runtime.config,
         reliabilityShield: adapterResult?.reliabilityShield || null,
         routerDecision: routerDecision,

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

@@ -56,7 +56,7 @@ 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);
+    return envInt('SKS_REMOTE_API_PARALLEL_BUDGET', 3);
 }
 class ModelCallSemaphoreImpl {
     provider;

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