sneakoscope 4.1.1 → 4.2.0

package/dist/core/init.js

@@ -13,6 +13,7 @@ import { CODEX_HOOK_EVENT_STATE_KEYS } from './codex-compat/codex-hook-events.js
 import { codexCommandHookCurrentHash } from './codex-hooks/codex-hook-hash.js';
 import { buildSksCoreSkillManifest, isCoreSkillName } from './codex-native/core-skill-manifest.js';
 import { syncCoreSkillsIntegrity } from './codex-native/core-skill-integrity.js';
+import { dbSafetyGuardSkillText, madDbSkillText } from './mad-db/mad-db-policy.js';
 const REFLECTION_MEMORY_PATH = '.sneakoscope/memory/q2_facts/post-route-reflection.md';
 const SKS_GENERATED_GIT_PATTERNS = [
     '.sneakoscope/missions/',
@@ -351,7 +352,7 @@ export async function initProject(root, opts = {}) {
                 state: 'git-common-dir/sks-version-state.json'
             }
         },
-        database_safety: 'default_safe; $MAD-SKS scoped permission profile is centralized in src/core/permission-gates.ts (emitted as dist/core/permission-gates.js) and keeps catastrophic safeguards active',
+        database_safety: 'default_safe; $MAD-SKS scoped permission profile keeps catastrophic safeguards active; first-class $MAD-DB is the explicit SQL-plane execution exception with mission-local write transport and read-back proof',
         gx_renderer: 'deterministic_svg_html'
     };
     await writeJsonAtomic(manifestPath, manifest);
@@ -826,7 +827,7 @@ export async function initProject(root, opts = {}) {
             // them relocated into the home config by the splitter, re-triggering the warning.
             {
                 table: 'auto_review',
-                text: '[auto_review]\npolicy = "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."'
+                text: '[auto_review]\npolicy = "In MAD-SKS launches, allow only the scoped non-MadDB high-risk surfaces 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."'
             }
         ];
     }
@@ -1058,7 +1059,7 @@ export async function installSkills(root) {
         'research': `---\nname: research\ndescription: Dollar-command route for $Research or $research frontier discovery workflows.\n---\n\nUse when the user invokes $Research/$research or asks for research, hypotheses, new mechanisms, falsification, or testable predictions. Prefer sks research prepare and sks research run. Research is not an implementation route: do not edit repository source, docs, package metadata, generated skills, or harness files; write only route-local mission artifacts under .sneakoscope/missions/<mission-id>/. Run the genius-lens agent council with named persona-inspired cognitive roles: Einstein Agent, Feynman Agent, Turing Agent, von Neumann Agent, and Skeptic Agent. These are lenses only; do not impersonate the historical people. Every Research agent ledger row must include display_name, persona, persona_boundary, effort=xhigh, reasoning_effort=xhigh, service_tier when available, one literal "Eureka!" idea, falsifiers, cheap_probes, and challenge_or_response before synthesis. This is not a fixed three-cycle route: repeat source gathering, Eureka ideas, evidence-bound debate, falsification, and synthesis pressure until every agent records final agreement, or until the explicit max-cycle safety cap pauses with an unpassed gate. Create research-source-skill.md as a route-local Skill Creator artifact, then maximize layered public web/source search across latest papers, official/government or leading-institution data, standards/primary docs, current news, public discourse, developer/practitioner sources, traditional background sources, and counterevidence before synthesis. Record research-source-skill.md, source-ledger.json, agent-ledger.json, debate-ledger.json, novelty-ledger.json, falsification-ledger.json, research-report.md, research-paper.md, genius-opinion-summary.md, and research-gate.json. debate-ledger.json must include consensus_iterations, unanimous_consensus, and per-agent agreements; research-gate.json cannot pass until unanimous_consensus=true with every agent agreement recorded. Context7 is optional and only needed when the research topic depends on external package/API/framework docs; do not use it as the default research evidence layer. Normal Research may take one or two hours when needed; favor real source collection, cross-layer comparison, falsification, and a concise paper manuscript over speed. Do not use --mock except for selftests or dry harness checks; if live source execution is unavailable, record a blocker and keep the gate unpassed. Do not use for ordinary code edits.\n`,
         'autoresearch': `---\nname: autoresearch\ndescription: Dollar-command route for $AutoResearch or $autoresearch iterative experiment loops.\n---\n\nUse for $AutoResearch, iterative improvement, SEO/GEO, ranking, workflow, benchmark, or experiments. Define program, hypothesis, experiment, metric, keep/discard, falsification, next step, and Honest Mode. Load seo-geo-optimizer for README/npm/GitHub/schema/AI-search work.\n`,
         'db': `---\nname: db\ndescription: Dollar-command route for $DB or $db database and Supabase safety checks.\n---\n\nUse when the user invokes $DB/$db or the task touches SQL, Supabase, Postgres, migrations, Prisma, Drizzle, Knex, MCP database tools, or production data. Run or follow sks db policy, sks db scan, sks db classify, and sks db check. Destructive database operations remain forbidden.\n`,
-        'mad-db': `---\nname: mad-db\ndescription: One-cycle Mad-DB break-glass route alias for $MAD-DB and $mad-db database safety work.\n---\n\nUse only when the user explicitly invokes $MAD-DB/$mad-db or asks for Mad-DB visibility. Treat it as a DB safety route with one-cycle break-glass controls, not as a general permanent DB unlock. Prefer \`sks mad-db status --json\` for inspection, \`sks mad-db enable --ack "I AUTHORIZE ONE-CYCLE DB BREAK-GLASS" [--mission latest|new|M-...] --json\` only after explicit user authorization, and \`sks mad-db revoke --mission <id|latest> --json\` to close the cycle. Keep catastrophic safeguards active: whole database/schema/table removal, truncate, all-row delete/update, reset, dangerous project/branch management, credential exfiltration, persistent security weakening, and unrequested fallback implementation remain blocked. Pair with db-safety-guard, Context7 evidence when external DB/API docs are involved, route-local reflection, and Honest Mode.\n`,
+        'mad-db': `${madDbSkillText()}\n`,
         'mad-sks': `---\nname: mad-sks\ndescription: Explicit high-risk authorization modifier for $MAD-SKS scoped permission widening across approved target-project surfaces.\n---\n\nUse only when the user explicitly invokes $MAD-SKS or top-level sks --mad. It can be combined with another route, such as $MAD-SKS $Team or $DB ... $MAD-SKS; in that case the other command remains the primary workflow and MAD-SKS is only the temporary permission grant. The widened permission applies only while the active mission gate is open, must be deactivated when the task ends, and can open approved scopes such as target-project file writes, shell commands, package installs, local service control, network operations, browser/Computer Use workflows, generated assets, file permissions, migrations, Supabase MCP database writes, column/schema cleanup, direct execute SQL, and normal targeted DB writes. Keep catastrophic safeguards active: whole database/schema/table removal, truncate, all-row delete/update, reset, dangerous project/branch management, credential exfiltration, persistent security weakening, destructive delete without explicit confirmation, and unrequested fallback implementation remain blocked. Do not carry MAD-SKS permission into later prompts or routes. The permission profile source is centralized in src/core/permission-gates.ts and emitted as dist/core/permission-gates.js so skill/hook/MCP-style gates share one decision function.\n`,
         'gx': `---\nname: gx\ndescription: Dollar-command route for $GX or $gx deterministic GX visual context cartridges.\n---\n\nUse when the user invokes $GX/$gx or asks for architecture/context visualization through SKS. Prefer sks gx init, render, validate, drift, and snapshot. vgraph.json remains the source of truth.\n`,
         'help': `---\nname: help\ndescription: Dollar-command route for $Help or $help explaining installed SKS commands and workflows.\n---\n\nUse when the user invokes $Help/$help or asks what commands exist. Prefer concise output from sks commands, sks usage <topic>, sks quickstart, sks aliases, and sks codex-app.\n`,
@@ -1073,7 +1074,7 @@ export async function installSkills(root) {
         'autoresearch-loop': `---\nname: autoresearch-loop\ndescription: Iterative AutoResearch-style loop for open-ended improvement, discovery, prompt, ranking, SEO/GEO, and workflow-quality tasks.\n---\n\nUse for research, ranking, prompt/workflow improvement, benchmark gains, or repeated refinement. Loop: program, hypothesis, smallest falsifying experiment, metric, keep/discard, falsify, next step. Keep a ledger and do not claim improvement without evidence.\n`,
         'hproof-claim-ledger': `---\nname: hproof-claim-ledger\ndescription: Extract atomic claims and classify support status.\n---\n\nEvery factual statement must become an atomic claim. Unsupported critical claims cannot be used for implementation or final answer. Database claims require DB safety evidence.\n`,
         'hproof-evidence-bind': `---\nname: hproof-evidence-bind\ndescription: Bind claims to code, tests, decision contract, vgraph, beta, wiki, or GX render evidence.\n---\n\nEvidence priority: current code/tests, decision-contract.json, vgraph.json, beta.json, GX snapshot/render metadata, LLM Wiki coordinate index, user prompt. Database claims must respect .sneakoscope/db-safety.json. Wiki claims should carry id, hash, source path, and RGBA/trig coordinate anchors so they can be hydrated instead of treated as unsupported summaries.\n`,
-        'db-safety-guard': `---\nname: db-safety-guard\ndescription: Enforce Sneakoscope Codex database safety before using SQL, Supabase MCP, Postgres, Prisma, Drizzle, Knex, or migration commands.\n---\n\nRules:\n- Never run DROP, TRUNCATE, mass DELETE/UPDATE, db reset, db push, project deletion, branch reset/merge/delete, or RLS-disabling operations.\n- Supabase MCP must be read-only and project-scoped by default.\n- Live writes through execute_sql are blocked; use migration files and only local/preview branches if explicitly allowed.\n- Production writes are forbidden.\n- If unsure, read-only only.\n`,
+        'db-safety-guard': `${dbSafetyGuardSkillText()}\n`,
         'gx-visual-generate': `---\nname: gx-visual-generate\ndescription: Render a deterministic SVG/HTML visual sheet from vgraph.json and beta.json.\n---\n\nUse sks gx render. vgraph.json is source of truth; renders embed source hash and RGBA wiki anchors.\n`,
         'gx-visual-read': `---\nname: gx-visual-read\ndescription: Read a Sneakoscope Codex deterministic visual sheet and produce context notes.\n---\n\nExtract nodes, edges, invariants, tests, risks, uncertainties, and RGBA anchors from source/render/snapshot. Do not infer hidden nodes.\n`,
         'gx-visual-validate': `---\nname: gx-visual-validate\ndescription: Validate render metadata against vgraph.json and beta.json.\n---\n\nRun sks gx validate and drift; fail stale or incomplete hashes, nodes, edges, invariants, or anchors.\n`,

package/dist/core/mad-db/mad-db-capability.js

@@ -1,48 +1,91 @@
 import path from 'node:path';
-import { appendJsonlBounded, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { appendJsonlBounded, nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
 import { findLatestMission, missionDir } from '../mission.js';
-export const MAD_DB_CAPABILITY_SCHEMA = 'sks.mad-db-capability.v1';
+import { withMadDbLock } from './mad-db-lock.js';
+import { MAD_DB_POLICY } from './mad-db-policy.js';
+export const MAD_DB_CAPABILITY_SCHEMA_V1 = 'sks.mad-db-capability.v1';
+export const MAD_DB_CAPABILITY_SCHEMA = 'sks.mad-db-capability.v2';
 export const MAD_DB_CAPABILITY_FILE = 'mad-db-capability.json';
 export const MAD_DB_ACK = 'I AUTHORIZE ONE-CYCLE DB BREAK-GLASS';
-export const MAD_DB_MAX_TTL_MS = 2 * 60 * 60 * 1000;
+export const MAD_DB_DEFAULT_TTL_MS = MAD_DB_POLICY.ttl.default_ms;
+export const MAD_DB_MAX_TTL_MS = MAD_DB_POLICY.ttl.hard_max_ms;
 export async function createMadDbCapability(root, input) {
     if (input.ack !== MAD_DB_ACK)
         throw new Error('mad_db_ack_phrase_mismatch');
     const createdAt = nowIso();
-    const ttlMs = Math.min(MAD_DB_MAX_TTL_MS, Math.max(1, Math.floor(Number(input.ttlMs || MAD_DB_MAX_TTL_MS))));
+    const ttlMs = Math.min(MAD_DB_MAX_TTL_MS, Math.max(1, Math.floor(Number(input.ttlMs || MAD_DB_DEFAULT_TTL_MS))));
+    const projectRef = String(input.projectRef || process.env.SKS_MAD_DB_PROJECT_REF || process.env.SKS_MAD_DB_E2E_PROJECT_REF || 'fixture-project-ref').trim();
+    const profilePath = input.profilePath || '.sneakoscope/missions/<mission>/mad-db/runtime/codex-mad-db.config.toml';
+    const profileSha256 = input.profileSha256 || sha256(`${input.missionId}:${projectRef}:placeholder-profile`);
     const capability = {
         schema: MAD_DB_CAPABILITY_SCHEMA,
+        revision: 1,
         mission_id: input.missionId,
         cycle_id: input.cycleId || `mad-db-${Date.now().toString(36)}`,
-        enabled: true,
-        created_at: createdAt,
+        project_root_hash: sha256(path.resolve(input.cwd || root)).slice(0, 24),
+        project_ref: projectRef,
+        target_environment: input.targetEnvironment || 'production',
+        allowed_schemas: input.allowedSchemas?.length ? input.allowedSchemas : ['public'],
+        codex_thread_id: input.codexThreadId ?? null,
+        runtime_session_id: input.runtimeSessionId || `mad-db-session-${Date.now().toString(36)}`,
+        operator_intent_hash: sha256(input.operatorIntent || input.ack || 'mad-db').slice(0, 32),
+        operator_ack_hash: sha256(input.ack).slice(0, 32),
+        scope: {
+            sql_plane: 'all_mutations',
+            control_plane: 'deny',
+            operations: input.operations?.length ? input.operations : [...MAD_DB_POLICY.sql_plane_allowed]
+        },
+        transport: {
+            profile_path: profilePath,
+            profile_sha256: profileSha256,
+            server_url_redacted: input.serverUrlRedacted || 'https://mcp.supabase.com/mcp?project_ref=<redacted>&features=database',
+            features: ['database'],
+            write_capable: true
+        },
+        issued_at: createdAt,
         expires_at: new Date(Date.now() + ttlMs).toISOString(),
-        one_cycle_only: true,
-        priority: 'highest',
-        scope: 'all_database_mutations',
-        operator_ack: {
-            phrase: MAD_DB_ACK,
-            accepted_at: createdAt,
-            cwd: path.resolve(input.cwd || process.cwd())
+        closed_at: null,
+        status: input.status || 'issued',
+        counters: {
+            attempts: 0,
+            reserved: 0,
+            succeeded: 0,
+            failed: 0
         },
-        consumed: false,
-        consumed_at: null,
-        consumed_by: null,
-        max_operations: Math.max(1, Math.floor(Number(process.env.SKS_MAD_DB_MAX_OPERATIONS || 20))),
-        operation_count: 0
+        legacy_compat: {
+            one_cycle_only: true,
+            priority: 'highest',
+            scope: 'all_database_mutations'
+        }
     };
     const dir = missionDir(root, input.missionId);
     await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), capability);
-    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.created', mission_id: capability.mission_id, cycle_id: capability.cycle_id, expires_at: capability.expires_at });
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), {
+        ts: nowIso(),
+        type: 'capability.created',
+        schema: capability.schema,
+        mission_id: capability.mission_id,
+        cycle_id: capability.cycle_id,
+        project_ref_hash: sha256(capability.project_ref).slice(0, 16),
+        runtime_session_id: capability.runtime_session_id,
+        expires_at: capability.expires_at,
+        status: capability.status
+    });
     return capability;
 }
 export async function readMadDbCapability(root, missionId) {
-    const capability = await readJson(path.join(missionDir(root, missionId), MAD_DB_CAPABILITY_FILE), null);
-    return capability?.schema === MAD_DB_CAPABILITY_SCHEMA ? capability : null;
+    const value = await readJson(path.join(missionDir(root, missionId), MAD_DB_CAPABILITY_FILE), null);
+    if (value?.schema === MAD_DB_CAPABILITY_SCHEMA)
+        return value;
+    if (value?.schema === MAD_DB_CAPABILITY_SCHEMA_V1)
+        return migrateV1Capability(value, missionId);
+    return null;
 }
 export async function resolveMadDbMissionId(root, state = {}, explicitMissionId = null) {
     if (explicitMissionId && explicitMissionId !== 'latest')
         return explicitMissionId;
+    if (state?.mad_db_capability_mission_id)
+        return String(state.mad_db_capability_mission_id);
     if (state?.mission_id)
         return String(state.mission_id);
     return findLatestMission(root);
@@ -51,74 +94,160 @@ export function isMadDbCapabilityActive(capability, nowMs = Date.now()) {
     if (!capability)
         return false;
     const expires = Date.parse(capability.expires_at || '');
-    return capability.enabled === true
-        && capability.consumed !== true
-        && capability.one_cycle_only === true
-        && Number(capability.operation_count || 0) < Number(capability.max_operations || 20)
+    return capability.schema === MAD_DB_CAPABILITY_SCHEMA
+        && ['transport_ready', 'active'].includes(capability.status)
+        && Boolean(capability.project_ref)
+        && capability.transport?.write_capable === true
+        && capability.transport?.features?.[0] === 'database'
         && Number.isFinite(expires)
         && expires > nowMs;
 }
+export async function activateMadDbCapability(root, missionId) {
+    return updateMadDbCapability(root, missionId, (capability) => ({
+        ...capability,
+        status: capability.status === 'issued' ? 'active' : capability.status
+    }));
+}
+export async function markMadDbTransportReady(root, missionId) {
+    return updateMadDbCapability(root, missionId, (capability) => ({
+        ...capability,
+        status: capability.status === 'issued' ? 'transport_ready' : capability.status
+    }));
+}
+export async function updateMadDbCapabilityCounters(root, missionId, delta) {
+    return updateMadDbCapability(root, missionId, (capability) => ({
+        ...capability,
+        counters: {
+            attempts: capability.counters.attempts + Number(delta.attemptsDelta || 0),
+            reserved: capability.counters.reserved + Number(delta.reservedDelta || 0),
+            succeeded: capability.counters.succeeded + Number(delta.succeededDelta || 0),
+            failed: capability.counters.failed + Number(delta.failedDelta || 0)
+        }
+    }));
+}
+export async function updateMadDbCapability(root, missionId, mutator) {
+    return withMadDbLock(root, missionId, 'capability', async () => {
+        const current = await readMadDbCapability(root, missionId);
+        if (!current)
+            return null;
+        const next = mutator(current);
+        const updated = {
+            ...next,
+            revision: Number(current.revision || 0) + 1
+        };
+        await writeJsonAtomic(path.join(missionDir(root, missionId), MAD_DB_CAPABILITY_FILE), updated);
+        await appendJsonlBounded(path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl'), {
+            ts: nowIso(),
+            type: 'capability.updated',
+            mission_id: missionId,
+            cycle_id: updated.cycle_id,
+            revision: updated.revision,
+            status: updated.status,
+            counters: updated.counters
+        });
+        return updated;
+    });
+}
 export async function recordMadDbOperation(root, missionId, input = {}) {
     const capability = await readMadDbCapability(root, missionId);
-    if (!isMadDbCapabilityActive(capability))
-        return capability;
-    const operationCount = Number(capability.operation_count || 0) + 1;
-    const maxOperations = Math.max(1, Number(capability.max_operations || 20));
-    const updated = {
-        ...capability,
-        operation_count: operationCount,
-        max_operations: maxOperations
-    };
-    const dir = missionDir(root, missionId);
-    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), updated);
-    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), {
+    if (!capability)
+        return null;
+    await appendJsonlBounded(path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl'), {
         ts: nowIso(),
-        type: 'db_operation.counted',
+        type: 'db_operation.legacy_recorded',
         mission_id: missionId,
-        cycle_id: updated.cycle_id,
+        cycle_id: capability.cycle_id,
         operation_id: input.operationId || null,
         tool_name: input.toolName || null,
-        sql_hash: input.sqlHash || null,
-        operation_count: operationCount,
-        max_operations: maxOperations
+        sql_hash: input.sqlHash || null
     });
-    if (operationCount >= maxOperations) {
-        return consumeMadDbCapability(root, missionId, { consumedBy: 'db-safety-checkDbOperation', reason: 'mad_db_max_operations_reached' });
-    }
-    return updated;
+    return capability;
 }
 export async function consumeMadDbCapability(root, missionId, input = {}) {
-    const capability = await readMadDbCapability(root, missionId);
-    if (!capability || capability.consumed === true)
-        return capability;
-    const consumed = {
-        ...capability,
-        consumed: true,
-        consumed_at: nowIso(),
-        consumed_by: input.consumedBy || input.reason || 'db-safety-policy-resolver'
-    };
-    const dir = missionDir(root, missionId);
-    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), consumed);
-    await writeJsonAtomic(path.join(dir, 'mad-db-capability.consumed.json'), consumed);
-    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.consumed', mission_id: missionId, cycle_id: consumed.cycle_id, consumed_by: consumed.consumed_by });
-    return consumed;
+    return closeMadDbCycle(root, missionId, '', input.consumedBy || input.reason || 'mad_db_cycle_closed');
 }
-export async function closeMadDbCycle(root, missionId, cycleId) {
-    const capability = await readMadDbCapability(root, missionId);
-    if (!capability || capability.cycle_id !== cycleId)
-        return capability;
-    if (capability.consumed === true)
-        return capability;
-    return consumeMadDbCapability(root, missionId, { consumedBy: 'mad-db-cycle-close', reason: 'mad_db_cycle_closed' });
+export async function closeMadDbCycle(root, missionId, cycleId = '', reason = 'mad_db_cycle_closed') {
+    const closed = await updateMadDbCapability(root, missionId, (capability) => {
+        if (cycleId && capability.cycle_id !== cycleId)
+            return capability;
+        return {
+            ...capability,
+            status: capability.status === 'revoked' ? 'revoked' : 'closed',
+            closed_at: nowIso()
+        };
+    });
+    if (closed) {
+        await writeJsonAtomic(path.join(missionDir(root, missionId), 'mad-db-capability.closed.json'), {
+            schema: closed.schema,
+            mission_id: closed.mission_id,
+            cycle_id: closed.cycle_id,
+            closed_at: closed.closed_at,
+            close_reason: reason,
+            counters: closed.counters,
+            project_ref_hash: sha256(closed.project_ref).slice(0, 16)
+        });
+    }
+    return closed;
 }
 export async function revokeMadDbCapability(root, missionId, reason = 'operator_revoked') {
-    const capability = await readMadDbCapability(root, missionId);
-    if (!capability)
-        return null;
-    const revoked = { ...capability, enabled: false, revoked_at: nowIso(), revoke_reason: reason };
-    const dir = missionDir(root, missionId);
-    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), revoked);
-    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.revoked', mission_id: missionId, cycle_id: capability.cycle_id, reason });
+    const revoked = await updateMadDbCapability(root, missionId, (capability) => ({
+        ...capability,
+        status: 'revoked',
+        closed_at: nowIso()
+    }));
+    if (revoked) {
+        await appendJsonlBounded(path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl'), {
+            ts: nowIso(),
+            type: 'capability.revoked',
+            mission_id: missionId,
+            cycle_id: revoked.cycle_id,
+            reason
+        });
+    }
     return revoked;
 }
+function migrateV1Capability(value, missionId) {
+    const projectRef = process.env.SKS_MAD_DB_PROJECT_REF || process.env.SKS_MAD_DB_E2E_PROJECT_REF || 'legacy-v1-missing-project-ref';
+    return {
+        schema: MAD_DB_CAPABILITY_SCHEMA,
+        revision: 0,
+        mission_id: String(value.mission_id || missionId),
+        cycle_id: String(value.cycle_id || `mad-db-${Date.now().toString(36)}`),
+        project_root_hash: sha256(String(value.operator_ack?.cwd || process.cwd())).slice(0, 24),
+        project_ref: projectRef,
+        target_environment: 'production',
+        allowed_schemas: ['public'],
+        codex_thread_id: null,
+        runtime_session_id: `legacy-v1-${Date.now().toString(36)}`,
+        operator_intent_hash: sha256('legacy-v1-migrated').slice(0, 32),
+        operator_ack_hash: sha256(MAD_DB_ACK).slice(0, 32),
+        scope: {
+            sql_plane: 'all_mutations',
+            control_plane: 'deny',
+            operations: [...MAD_DB_POLICY.sql_plane_allowed]
+        },
+        transport: {
+            profile_path: '.sneakoscope/missions/<mission>/mad-db/runtime/codex-mad-db.config.toml',
+            profile_sha256: sha256('legacy-v1-missing-profile'),
+            server_url_redacted: 'https://mcp.supabase.com/mcp?project_ref=<legacy-redacted>&features=database',
+            features: ['database'],
+            write_capable: true
+        },
+        issued_at: String(value.created_at || nowIso()),
+        expires_at: String(value.expires_at || new Date(Date.now() - 1000).toISOString()),
+        closed_at: value.consumed ? String(value.consumed_at || nowIso()) : null,
+        status: value.enabled === false ? 'revoked' : value.consumed ? 'closed' : 'quarantined',
+        counters: {
+            attempts: Number(value.operation_count || 0),
+            reserved: Number(value.operation_count || 0),
+            succeeded: 0,
+            failed: 0
+        },
+        legacy_compat: {
+            one_cycle_only: true,
+            priority: 'highest',
+            scope: 'all_database_mutations'
+        }
+    };
+}
 //# sourceMappingURL=mad-db-capability.js.map