sneakoscope 4.1.0 → 4.2.0

package/dist/core/mad-db/mad-db-policy-resolver.js

@@ -1,30 +1,56 @@
-import { readMadDbCapability, isMadDbCapabilityActive } from './mad-db-capability.js';
-export const MAD_DB_POLICY_DECISION_SCHEMA = 'sks.mad-db-policy-decision.v1';
-export async function resolveMadDbMutationPolicy(root, state = {}, classification = {}) {
-    const missionId = state?.mission_id ? String(state.mission_id) : null;
+import { isMadDbCapabilityActive, readMadDbCapability } from './mad-db-capability.js';
+import { activeMadDbAllowsSqlPlane, isMadDbControlPlaneDeniedTool, madDbOperationClassesFromClassification } from './mad-db-policy.js';
+import { sha256 } from '../fsx.js';
+export const MAD_DB_POLICY_DECISION_SCHEMA = 'sks.mad-db-policy-decision.v2';
+export async function resolveMadDbMutationPolicy(root, state = {}, classification = {}, explicitCapability) {
+    const missionId = explicitCapability?.mission_id || state?.mad_db_capability_mission_id || state?.mission_id;
     if (!missionId)
         return inactive('mission_id_missing');
-    const capability = await readMadDbCapability(root, missionId);
-    if (!isMadDbCapabilityActive(capability))
-        return inactive(capability?.consumed ? 'mad_db_capability_consumed' : 'mad_db_capability_inactive');
-    if (!isDbMutationOrDbTool(classification))
-        return inactive('not_a_database_mutation');
+    const capability = explicitCapability || await readMadDbCapability(root, String(missionId));
+    const validation = validateCapabilityBinding(capability, state, classification);
+    if (!validation.ok)
+        return inactive(validation.reason);
+    if (isMadDbControlPlaneDeniedTool(classification.toolName || classification.tool_name))
+        return inactive('mad_db_control_plane_tool_denied');
+    if (!activeMadDbAllowsSqlPlane(classification))
+        return inactive('not_a_database_sql_plane_mutation');
     return {
         schema: MAD_DB_POLICY_DECISION_SCHEMA,
         allowed: true,
         action: 'allow',
-        mode: 'mad-db-break-glass',
+        mode: 'mad-db-sql-plane-active',
         priority: 0,
         priority_order: ['mad-db', 'mad-sks', 'sealed-contract', 'default-db-safety'],
-        reasons: ['mad_db_one_cycle_break_glass_capability_active'],
+        reasons: ['mad_db_capability_v2_bound_sql_plane_authorized'],
         audit_required: true,
-        mission_id: missionId,
+        mission_id: capability.mission_id,
         cycle_id: capability.cycle_id,
-        operation_count: capability.operation_count || 0,
-        max_operations: capability.max_operations || 20,
+        runtime_session_id: capability.runtime_session_id,
+        project_ref_hash: hashRef(capability.project_ref),
+        operation_classes: madDbOperationClassesFromClassification(classification),
+        counters: capability.counters,
         capability
     };
 }
+export function validateCapabilityBinding(capability, state = {}, classification = {}) {
+    if (!capability)
+        return { ok: false, reason: 'mad_db_capability_missing' };
+    if (!isMadDbCapabilityActive(capability))
+        return { ok: false, reason: `mad_db_capability_${capability.status || 'inactive'}` };
+    if (!capability.project_ref)
+        return { ok: false, reason: 'mad_db_project_ref_missing' };
+    if (state?.mission_id && String(state.mission_id) !== capability.mission_id)
+        return { ok: false, reason: 'mad_db_mission_binding_mismatch' };
+    if (state?.mad_db_cycle_id && String(state.mad_db_cycle_id) !== capability.cycle_id)
+        return { ok: false, reason: 'mad_db_cycle_binding_mismatch' };
+    if (state?.mad_db_runtime_session_id && String(state.mad_db_runtime_session_id) !== capability.runtime_session_id)
+        return { ok: false, reason: 'mad_db_runtime_session_binding_mismatch' };
+    if (state?.mad_db_profile_sha256 && String(state.mad_db_profile_sha256) !== capability.transport.profile_sha256)
+        return { ok: false, reason: 'mad_db_profile_hash_mismatch' };
+    if (classification.toolReasons?.includes?.('dangerous_supabase_management_tool'))
+        return { ok: false, reason: 'mad_db_control_plane_tool_denied' };
+    return { ok: true, reason: 'ok' };
+}
 function inactive(reason) {
     return {
         schema: MAD_DB_POLICY_DECISION_SCHEMA,
@@ -36,13 +62,7 @@ function inactive(reason) {
         audit_required: false
     };
 }
-function isDbMutationOrDbTool(classification = {}) {
-    if (classification.level === 'write' || classification.level === 'destructive')
-        return true;
-    if (classification.toolReasons?.includes?.('database_tool'))
-        return true;
-    if (classification.toolReasons?.includes?.('migration_apply_tool'))
-        return true;
-    return false;
+function hashRef(projectRef) {
+    return sha256(projectRef).slice(0, 16);
 }
 //# sourceMappingURL=mad-db-policy-resolver.js.map

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

@@ -0,0 +1,195 @@
+export const MAD_DB_POLICY_SCHEMA = 'sks.mad-db-policy.v2';
+export const MAD_DB_OPERATION_CLASSES = [
+    'create',
+    'alter',
+    'drop',
+    'drop_database_sql',
+    'insert',
+    'update',
+    'delete',
+    'all_row_update',
+    'all_row_delete',
+    'truncate',
+    'migration_apply',
+    'direct_execute_sql',
+    'rls_policy_change',
+    'function_or_trigger_change',
+    'index_change',
+    'unknown_sql_mutation'
+];
+export const MAD_DB_SQL_PLANE_TOOL_NAMES = Object.freeze([
+    'execute_sql',
+    'apply_migration',
+    'supabase.execute_sql',
+    'supabase.apply_migration',
+    'mcp__supabase__execute_sql',
+    'mcp__supabase__apply_migration',
+    'supabase_mad_db.execute_sql',
+    'supabase_mad_db.apply_migration',
+    'mcp__supabase_mad_db__execute_sql',
+    'mcp__supabase_mad_db__apply_migration'
+]);
+export const MAD_DB_CONTROL_PLANE_DENIED_TOOL_PATTERNS = Object.freeze([
+    'delete_project',
+    'pause_project',
+    'restore_project',
+    'create_project',
+    'list_organizations',
+    'get_organization',
+    'billing',
+    'organization',
+    'credential',
+    'access_token',
+    'service_role',
+    'delete_branch',
+    'reset_branch',
+    'merge_branch'
+]);
+export const MAD_DB_POLICY = Object.freeze({
+    schema: MAD_DB_POLICY_SCHEMA,
+    default_mode: 'deny_mutations',
+    active_mode: {
+        sql_plane: 'allow_all_mutations',
+        control_plane: 'deny',
+        requires: [
+            'capability_v2',
+            'project_binding',
+            'session_binding',
+            'write_transport_ready',
+            'not_expired'
+        ]
+    },
+    sql_plane_allowed: MAD_DB_OPERATION_CLASSES,
+    sql_plane_tools: MAD_DB_SQL_PLANE_TOOL_NAMES,
+    control_plane_denied: MAD_DB_CONTROL_PLANE_DENIED_TOOL_PATTERNS,
+    normal_supabase_mcp: {
+        read_only_required: true,
+        project_ref_required: true
+    },
+    runtime_profile: {
+        mission_local_only: true,
+        read_only_omitted_only_for_active_capability: true,
+        features: ['database']
+    },
+    ttl: {
+        default_ms: 15 * 60 * 1000,
+        hard_max_ms: 30 * 60 * 1000
+    }
+});
+export function madDbPolicySnapshot() {
+    return MAD_DB_POLICY;
+}
+export function isMadDbSqlPlaneToolName(toolName) {
+    const normalized = normalizeToolName(toolName);
+    if (!normalized)
+        return false;
+    return MAD_DB_SQL_PLANE_TOOL_NAMES.some((name) => normalized.endsWith(normalizeToolName(name)) || normalized.includes(normalizeToolName(name)));
+}
+export function isMadDbControlPlaneDeniedTool(toolName) {
+    const normalized = normalizeToolName(toolName);
+    if (!normalized)
+        return false;
+    return MAD_DB_CONTROL_PLANE_DENIED_TOOL_PATTERNS.some((pattern) => normalized.includes(normalizeToolName(pattern)));
+}
+export function normalizeToolName(toolName) {
+    return String(toolName || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_.-]+/g, '_');
+}
+export function madDbOperationClassesFromClassification(classification = {}) {
+    const reasons = new Set([
+        ...stringArray(classification.reasons),
+        ...stringArray(classification.sql?.reasons),
+        ...stringArray(classification.command?.reasons),
+        ...stringArray(classification.toolReasons)
+    ]);
+    const out = new Set();
+    const toolName = classification.toolName || classification.tool_name || '';
+    if (isMadDbSqlPlaneToolName(toolName))
+        out.add('direct_execute_sql');
+    if (reasons.has('migration_apply_tool') || reasons.has('supabase_migration_apply'))
+        out.add('migration_apply');
+    if (hasAny(reasons, ['drop_database']))
+        out.add('drop_database_sql');
+    if (hasAny(reasons, ['drop_schema', 'drop_table', 'drop_view', 'drop_materialized_view', 'drop_extension', 'drop_policy', 'drop_statement', 'alter_table_drop']))
+        out.add('drop');
+    if (hasAny(reasons, ['truncate']))
+        out.add('truncate');
+    if (hasAny(reasons, ['insert_or_upsert']))
+        out.add('insert');
+    if (hasAny(reasons, ['update_with_where']))
+        out.add('update');
+    if (hasAny(reasons, ['update_without_where']))
+        out.add('all_row_update');
+    if (hasAny(reasons, ['delete_with_where']))
+        out.add('delete');
+    if (hasAny(reasons, ['delete_without_where']))
+        out.add('all_row_delete');
+    if (hasAny(reasons, ['schema_change', 'alter_table_rename']))
+        out.add('alter');
+    if (hasAny(reasons, ['create_or_replace']))
+        out.add('function_or_trigger_change');
+    const statements = stringArray(classification.sql?.statements);
+    for (const statement of statements) {
+        const normalized = statement.trim().toLowerCase();
+        if (/^create\s+(table|schema|view|materialized\s+view)/.test(normalized))
+            out.add('create');
+        if (/^create\s+(index|unique\s+index)/.test(normalized))
+            out.add('index_change');
+        if (/^drop\s+index/.test(normalized))
+            out.add('index_change');
+        if (/policy|row\s+level\s+security|rls/.test(normalized))
+            out.add('rls_policy_change');
+        if (/function|trigger|procedure/.test(normalized))
+            out.add('function_or_trigger_change');
+    }
+    if (!out.size && ['write', 'destructive', 'possible_db'].includes(String(classification.level || '')))
+        out.add('unknown_sql_mutation');
+    return [...out];
+}
+export function activeMadDbAllowsSqlPlane(classification = {}) {
+    const toolName = classification.toolName || classification.tool_name || '';
+    if (isMadDbControlPlaneDeniedTool(toolName))
+        return false;
+    if (classification.toolReasons?.includes?.('dangerous_supabase_management_tool'))
+        return false;
+    if (isMadDbSqlPlaneToolName(toolName))
+        return true;
+    return ['write', 'destructive', 'possible_db'].includes(String(classification.level || ''));
+}
+export function madDbSkillText(commandPrefix = 'sks') {
+    return `---
+name: mad-db
+description: First-class MadDB SQL-plane execution route for explicit $MAD-DB and ${commandPrefix} mad-db run|exec|apply-migration.
+---
+
+Use only when the operator explicitly invokes $MAD-DB/$mad-db or ${commandPrefix} mad-db run|exec|apply-migration. This is the single approval boundary for the active MadDB cycle: execute SQL-plane mutations that the operator requested, including CREATE, ALTER, table/schema DROP, column add/drop/rename, INSERT, UPDATE, DELETE including all-row mutations, TRUNCATE, execute_sql, and apply_migration. Do not ask again for each DROP/TRUNCATE/all-row DELETE inside the same bound cycle.
+
+Keep normal Supabase MCP configuration read-only. MadDB must create a mission-local ephemeral write-capable Supabase MCP profile bound to capability v2, project_ref, root, mission, thread/session, intent, runtime profile hash, TTL, and SQL-plane operation classes. Verify execute_sql and apply_migration availability before claiming readiness. Require actual tool results plus independent read-back verification before claiming success. Close/revoke the capability and runtime profile in finally and prove read-only restoration.
+
+Still deny Supabase account/project/billing/credential control-plane actions, credential exfiltration, unrelated storage/edge-function/admin changes, persistent security weakening, and unrequested fallback implementation. Pair with db-safety-guard, Context7 evidence for MCP/API docs, route-local reflection, and Honest Mode.`;
+}
+export function dbSafetyGuardSkillText() {
+    return `---
+name: db-safety-guard
+description: Enforce Sneakoscope Codex database safety before using SQL, Supabase MCP, Postgres, Prisma, Drizzle, Knex, or migration commands.
+---
+
+Rules:
+- Default mode is read-only: do not run DROP, TRUNCATE, mass DELETE/UPDATE, db reset, db push, project deletion, branch reset/merge/delete, or RLS-disabling operations.
+- Supabase MCP must be read-only and project-scoped by default.
+- Live execute_sql writes are blocked unless a bound active MadDB capability v2 is present.
+- Active MadDB is the explicit exception: SQL-plane mutations requested by $MAD-DB or sks mad-db run|exec|apply-migration are allowed and must be executed with read-back verification.
+- Supabase project/account/billing/credential control-plane actions remain denied even in MadDB.
+- If no active bound MadDB cycle exists, fall back to read-only only.`;
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((entry) => String(entry || '')).filter(Boolean);
+}
+function hasAny(values, keys) {
+    return keys.some((key) => values.has(key));
+}
+//# sourceMappingURL=mad-db-policy.js.map

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

@@ -0,0 +1,30 @@
+import path from 'node:path';
+import { nowIso, sha256, writeJsonAtomic } from '../fsx.js';
+import { missionDir } from '../mission.js';
+export async function runReadBackChecks(input) {
+    const rows = [];
+    for (const check of input.checks) {
+        const result = await input.executor.executeSql(check.query);
+        rows.push({
+            id: check.id,
+            query_sha256: sha256(check.query),
+            ok: result.ok === (check.expectOk ?? true),
+            result_digest: result.result_digest,
+            row_count: result.row_count
+        });
+    }
+    const proof = {
+        schema: 'sks.mad-db-read-back-proof.v1',
+        generated_at: nowIso(),
+        ok: rows.every((row) => row.ok),
+        checks: rows,
+        raw_rows_recorded: false
+    };
+    const proofPath = path.join(missionDir(input.root, input.missionId), 'mad-db', 'read-back-proof.json');
+    await writeJsonAtomic(proofPath, proof);
+    return { ...proof, proof_path: path.relative(input.root, proofPath).split(path.sep).join('/') };
+}
+export function readBackCheck(id, query) {
+    return { id, query, expectOk: true };
+}
+//# sourceMappingURL=mad-db-postconditions.js.map

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

@@ -0,0 +1,27 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { exists, nowIso, writeJsonAtomic } from '../fsx.js';
+export async function quarantineStaleMadDbRuntimeProfiles(root) {
+    const missionsDir = path.join(root, '.sneakoscope', 'missions');
+    const quarantined = [];
+    if (!(await exists(missionsDir)))
+        return { schema: 'sks.mad-db-recovery.v1', ok: true, quarantined, checked_at: nowIso() };
+    const missions = await fs.readdir(missionsDir, { withFileTypes: true }).catch(() => []);
+    for (const mission of missions) {
+        if (!mission.isDirectory())
+            continue;
+        const runtime = path.join(missionsDir, mission.name, 'mad-db', 'runtime');
+        const profile = path.join(runtime, 'codex-mad-db.config.toml');
+        if (!(await exists(profile)))
+            continue;
+        const dest = `${profile}.quarantined-${Date.now()}`;
+        await fs.rename(profile, dest).catch(async () => {
+            await fs.rm(profile, { force: true }).catch(() => undefined);
+        });
+        quarantined.push(path.relative(root, dest).split(path.sep).join('/'));
+    }
+    const report = { schema: 'sks.mad-db-recovery.v1', ok: true, quarantined, checked_at: nowIso() };
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'mad-db-recovery.json'), report).catch(() => undefined);
+    return report;
+}
+//# sourceMappingURL=mad-db-recovery.js.map

package/dist/core/mad-db/mad-db-result-lifecycle.js

@@ -1,92 +1,59 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { appendJsonlBounded, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
-import { missionDir } from '../mission.js';
-import { appendMadDbOperationLifecycle } from './mad-db-ledger.js';
-const PENDING_FILE = 'mad-db-lifecycle-pending.jsonl';
-const PENDING_LATEST_FILE = 'mad-db-lifecycle-pending.latest.json';
-export async function recordPendingMadDbLifecycleHook(root, missionId, hook) {
-    const dir = missionDir(root, missionId);
-    const row = {
-        schema: 'sks.mad-db-lifecycle-pending.v1',
-        ts: nowIso(),
-        mission_id: missionId,
+import { extractCanonicalToolCallId, transitionMadDbOperation } from './mad-db-operation-store.js';
+export async function recordPendingMadDbLifecycleHook(_root, _missionId, hook) {
+    return {
+        schema: 'sks.mad-db-lifecycle-pending.v2',
+        pending_latest_removed: true,
         hook
     };
-    await appendJsonlBounded(path.join(dir, PENDING_FILE), row);
-    await writeJsonAtomic(path.join(dir, PENDING_LATEST_FILE), row).catch(() => undefined);
-    return row;
 }
-export async function readLatestPendingMadDbLifecycleHook(root, missionId, payload = {}) {
-    const dir = missionDir(root, missionId);
-    const embedded = lifecycleHookFromUnknown(payload);
-    if (embedded)
-        return embedded;
-    const latest = await readJson(path.join(dir, PENDING_LATEST_FILE), null).catch(() => null);
-    const latestHook = lifecycleHookFromUnknown(latest?.hook);
-    if (latestHook && hookMatchesPayload(latestHook, payload))
-        return latestHook;
-    const text = await readText(path.join(dir, PENDING_FILE), '').catch(() => '');
-    const rows = String(text).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).reverse();
-    for (const line of rows.slice(0, 50)) {
-        try {
-            const row = JSON.parse(line);
-            const hook = lifecycleHookFromUnknown(row?.hook);
-            if (hook && hookMatchesPayload(hook, payload))
-                return hook;
-        }
-        catch {
-            // Ignore malformed pending rows.
-        }
-    }
-    return null;
+export async function readLatestPendingMadDbLifecycleHook(_root, _missionId, payload = {}) {
+    return lifecycleHookFromUnknown(payload);
 }
 export async function recordMadDbToolResult(input) {
-    const terminalType = input.ok ? 'db_operation.succeeded' : 'db_operation.failed';
-    if (await hasTerminalLifecycleEvent(input.root, input.missionId, input.hook.operation_id)) {
+    if (!input.hook.tool_call_id) {
         return {
-            schema: 'sks.mad-db-tool-result-lifecycle.v1',
-            ok: true,
+            schema: 'sks.mad-db-tool-result-lifecycle.v2',
+            ok: false,
             skipped: true,
-            reason: 'mad_db_operation_terminal_event_already_recorded',
+            reason: 'tool_call_id_required_for_result_correlation',
             operation_id: input.hook.operation_id
         };
     }
-    const event = await appendMadDbOperationLifecycle(input.root, input.missionId, {
-        type: terminalType,
-        operationId: input.hook.operation_id,
-        cycleId: input.hook.cycle_id || null,
-        mcpServer: input.hook.mcp_server || null,
-        toolName: input.hook.tool_name || null,
-        sqlHash: input.hook.sql_hash || null,
-        destructive: input.hook.destructive === true,
-        resultStatus: input.ok ? 'succeeded' : 'failed',
-        rowCount: input.rowCount ?? null,
-        error: input.error || null
+    const operation = await transitionMadDbOperation({
+        root: input.root,
+        missionId: input.missionId,
+        toolCallId: input.hook.tool_call_id,
+        state: input.ok ? 'succeeded' : 'failed',
+        result: { ok: input.ok, row_count: input.rowCount ?? null },
+        errorCode: input.ok ? null : input.error || 'tool_failed'
     });
-    await markPendingHookResolved(input.root, input.missionId, input.hook, input.ok);
     return {
-        schema: 'sks.mad-db-tool-result-lifecycle.v1',
-        ok: true,
+        schema: 'sks.mad-db-tool-result-lifecycle.v2',
+        ok: Boolean(operation),
         skipped: false,
         operation_id: input.hook.operation_id,
+        tool_call_id: input.hook.tool_call_id,
         result_status: input.ok ? 'succeeded' : 'failed',
-        event
+        operation
     };
 }
 export async function maybeRecordMadDbToolResultFromToolUse(input) {
     const payload = input.toolResult ?? input.toolCallPayload ?? {};
     const hook = lifecycleHookFromUnknown(input.decision)
         || lifecycleHookFromUnknown(input.toolCallPayload)
-        || lifecycleHookFromUnknown(input.toolResult)
-        || await readLatestPendingMadDbLifecycleHook(input.root, input.missionId, input.toolCallPayload || payload);
-    if (!hook)
+        || lifecycleHookFromUnknown(input.toolResult);
+    const toolCallId = extractCanonicalToolCallId(payload) || hook?.tool_call_id || null;
+    if (!toolCallId && !hook)
         return null;
     const ok = !madDbToolUseFailed(payload);
     return recordMadDbToolResult({
         root: input.root,
         missionId: input.missionId,
-        hook,
+        hook: hook || {
+            mission_id: input.missionId,
+            operation_id: `unknown-${toolCallId}`,
+            tool_call_id: toolCallId
+        },
         ok,
         rowCount: extractRowCount(payload),
         error: ok ? null : extractToolError(payload)
@@ -101,6 +68,7 @@ export function lifecycleHookFromUnknown(value) {
     return {
         mission_id: missionId,
         operation_id: operationId,
+        tool_call_id: stringOrNull(candidate?.tool_call_id || candidate?.toolCallId),
         cycle_id: stringOrNull(candidate?.cycle_id || candidate?.cycleId),
         tool_name: stringOrNull(candidate?.tool_name || candidate?.toolName),
         sql_hash: stringOrNull(candidate?.sql_hash || candidate?.sqlHash),
@@ -108,23 +76,6 @@ export function lifecycleHookFromUnknown(value) {
         destructive: candidate?.destructive === true
     };
 }
-function hookMatchesPayload(hook, payload) {
-    if (!hook.tool_name)
-        return true;
-    const toolText = [
-        payload.tool_name,
-        payload.toolName,
-        payload.name,
-        payload.tool?.name,
-        payload.server,
-        payload.mcp_tool,
-        payload.tool,
-        payload.type
-    ].filter(Boolean).join(' ').toLowerCase();
-    if (!toolText)
-        return true;
-    return toolText.includes(String(hook.tool_name).toLowerCase()) || String(hook.tool_name).toLowerCase().includes(toolText);
-}
 function madDbToolUseFailed(payload = {}) {
     if (payload?.isError === true || payload?.tool_response?.isError === true || payload?.toolResponse?.isError === true || payload?.result?.isError === true)
         return true;
@@ -178,28 +129,6 @@ function extractToolError(payload = {}) {
     }
     return String(payload.error || payload.message || payload.stderr || payload.tool_response?.stderr || payload.toolResponse?.stderr || payload.result?.stderr || payload.result?.error || 'tool_failed');
 }
-async function hasTerminalLifecycleEvent(root, missionId, operationId) {
-    const ledger = path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl');
-    const text = await readText(ledger, '').catch(() => '');
-    return String(text).split(/\r?\n/).some((line) => {
-        if (!line.includes(operationId))
-            return false;
-        return line.includes('db_operation.succeeded') || line.includes('db_operation.failed');
-    });
-}
-async function markPendingHookResolved(root, missionId, hook, ok) {
-    const dir = missionDir(root, missionId);
-    const row = {
-        schema: 'sks.mad-db-lifecycle-pending-resolution.v1',
-        ts: nowIso(),
-        mission_id: missionId,
-        operation_id: hook.operation_id,
-        cycle_id: hook.cycle_id || null,
-        result_status: ok ? 'succeeded' : 'failed'
-    };
-    await appendJsonlBounded(path.join(dir, 'mad-db-lifecycle-resolved.jsonl'), row).catch(() => undefined);
-    await fs.rm(path.join(dir, PENDING_LATEST_FILE), { force: true }).catch(() => undefined);
-}
 function stringOrNull(value) {
     const text = String(value || '').trim();
     return text ? text : null;

package/dist/core/mad-db/mad-db-runtime-profile.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { exists, nowIso, readText, sha256, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { missionDir } from '../mission.js';
+export async function createMadDbRuntimeProfile(input) {
+    const dir = path.join(missionDir(input.root, input.missionId), 'mad-db', 'runtime');
+    await fs.mkdir(dir, { recursive: true });
+    const url = madDbMcpUrl(input.projectRef);
+    const text = [
+        '[mcp_servers.supabase_mad_db]',
+        `url = "${url}"`,
+        'enabled = true',
+        ''
+    ].join('\n');
+    const profilePath = path.join(dir, 'codex-mad-db.config.toml');
+    await writeTextAtomic(profilePath, text);
+    const profileHash = sha256(text);
+    const normalHash = await normalCodexConfigHash(input.root);
+    const profile = {
+        schema: 'sks.mad-db-runtime-profile.v1',
+        mission_id: input.missionId,
+        cycle_id: input.cycleId,
+        runtime_session_id: input.runtimeSessionId,
+        project_ref_hash: sha256(input.projectRef).slice(0, 16),
+        profile_path: path.relative(input.root, profilePath).split(path.sep).join('/'),
+        profile_sha256: profileHash,
+        server_url_redacted: redactSupabaseUrl(url),
+        server_url: url,
+        features: ['database'],
+        write_capable: true,
+        normal_config_hash_before: normalHash,
+        created_at: nowIso()
+    };
+    await writeJsonAtomic(path.join(dir, 'runtime-profile-manifest.json'), redactedRuntimeProfile(profile));
+    return profile;
+}
+export async function closeMadDbRuntimeProfile(input) {
+    const profilePath = input.profile?.profile_path ? path.join(input.root, input.profile.profile_path) : path.join(missionDir(input.root, input.missionId), 'mad-db', 'runtime', 'codex-mad-db.config.toml');
+    if (await exists(profilePath)) {
+        const quarantine = `${profilePath}.closed`;
+        await fs.rename(profilePath, quarantine).catch(async () => {
+            await fs.rm(profilePath, { force: true }).catch(() => undefined);
+        });
+    }
+    const proof = await verifyReadOnlyRestored(input.root, input.profile?.normal_config_hash_before || null, profilePath);
+    await writeJsonAtomic(path.join(missionDir(input.root, input.missionId), 'mad-db', 'runtime', 'read-only-restoration.json'), {
+        ...proof,
+        close_reason: input.reason || 'cycle_finally'
+    });
+    return proof;
+}
+export async function verifyReadOnlyRestored(root, normalConfigHashBefore, profilePath) {
+    const after = await normalCodexConfigHash(root);
+    const text = await readText(path.join(root, '.codex', 'config.toml'), '');
+    const persistentSupabaseReadOnly = persistentSupabaseConfigReadOnly(text);
+    const runtimeExists = profilePath ? await exists(profilePath) : false;
+    const blockers = [
+        ...(normalConfigHashBefore && after && normalConfigHashBefore !== after ? ['normal_codex_config_hash_changed'] : []),
+        ...(persistentSupabaseReadOnly ? [] : ['persistent_supabase_mcp_not_read_only']),
+        ...(runtimeExists ? ['runtime_write_profile_still_exists'] : [])
+    ];
+    return {
+        schema: 'sks.mad-db-read-only-restoration.v1',
+        checked_at: nowIso(),
+        ok: blockers.length === 0,
+        normal_config_hash_before: normalConfigHashBefore,
+        normal_config_hash_after: after,
+        persistent_supabase_read_only: persistentSupabaseReadOnly,
+        runtime_profile_exists: runtimeExists,
+        blockers
+    };
+}
+export function redactedRuntimeProfile(profile) {
+    const { server_url: _serverUrl, ...rest } = profile;
+    return rest;
+}
+export function madDbMcpUrl(projectRef) {
+    const params = new URLSearchParams();
+    params.set('project_ref', projectRef);
+    params.set('features', 'database');
+    return `https://mcp.supabase.com/mcp?${params.toString()}`;
+}
+export function redactSupabaseUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const ref = parsed.searchParams.get('project_ref') || '';
+        if (ref)
+            parsed.searchParams.set('project_ref', `<hash:${sha256(ref).slice(0, 12)}>`);
+        for (const key of ['access_token', 'token', 'apikey', 'key', 'password']) {
+            if (parsed.searchParams.has(key))
+                parsed.searchParams.set(key, '<redacted>');
+        }
+        return parsed.toString();
+    }
+    catch {
+        return '<redacted-invalid-url>';
+    }
+}
+async function normalCodexConfigHash(root) {
+    const file = path.join(root, '.codex', 'config.toml');
+    if (!(await exists(file)))
+        return null;
+    return sha256(await readText(file, ''));
+}
+function persistentSupabaseConfigReadOnly(text) {
+    if (!/supabase|mcp\.supabase\.com/i.test(text))
+        return true;
+    const urls = [...String(text).matchAll(/https:\/\/mcp\.supabase\.com\/mcp[^"'\s)>,]*/gi)].map((match) => match[0] || '');
+    if (!urls.length)
+        return /read[_-]?only\s*=\s*true|access_mode\s*=\s*"read-only"|--read-only/.test(text);
+    return urls.every((url) => {
+        try {
+            const parsed = new URL(url);
+            return parsed.searchParams.get('read_only') === 'true';
+        }
+        catch {
+            return false;
+        }
+    });
+}
+//# sourceMappingURL=mad-db-runtime-profile.js.map