sneakoscope 6.2.0 → 6.4.0

package/dist/core/{mad-db/mad-db-operation-store.js → mad-sks/sql-plane/operation-store.js}

@@ -1,19 +1,19 @@
 import path from 'node:path';
-import { ensureDir, nowIso, readJson, sha256, writeJsonAtomic } from '../fsx.js';
-import { missionDir } from '../mission.js';
-import { appendMadDbLedgerEvent } from './mad-db-ledger.js';
-import { withMadDbLock } from './mad-db-lock.js';
-import { updateMadDbCapabilityCounters } from './mad-db-capability.js';
-export async function reserveMadDbOperation(input) {
-    return withMadDbLock(input.root, input.missionId, `operation-${safeKey(input.toolCallId)}`, async () => {
+import { ensureDir, nowIso, readJson, sha256, writeJsonAtomic } from '../../fsx.js';
+import { appendMadSksSqlPlaneLedgerEvent } from './ledger.js';
+import { withMadSksSqlPlaneLock } from './lock.js';
+import { updateMadSksSqlPlaneCapabilityCounters } from './capability.js';
+import { madSksSqlPlaneRuntimeDir } from './paths.js';
+export async function reserveMadSksSqlPlaneOperation(input) {
+    return withMadSksSqlPlaneLock(input.root, input.missionId, `operation-${safeKey(input.toolCallId)}`, async () => {
         const file = operationFile(input.root, input.missionId, input.toolCallId);
         const existing = await readJson(file, null);
-        if (existing?.schema === 'sks.mad-db-operation.v2') {
+        if (existing?.schema === 'sks.mad-sks-sql-plane-operation.v2') {
             return { operation: existing, reused: true, capability: input.capability };
         }
-        const operationId = `mad-db-op-${sha256(`${input.missionId}:${input.capability.cycle_id}:${input.toolCallId}`).slice(0, 16)}`;
+        const operationId = `mad-sks-sql-plane-op-${sha256(`${input.missionId}:${input.capability.cycle_id}:${input.toolCallId}`).slice(0, 16)}`;
         const operation = {
-            schema: 'sks.mad-db-operation.v2',
+            schema: 'sks.mad-sks-sql-plane-operation.v2',
             operation_id: operationId,
             tool_call_id: input.toolCallId,
             mission_id: input.missionId,
@@ -33,11 +33,11 @@ export async function reserveMadDbOperation(input) {
         };
         await ensureDir(path.dirname(file));
         await writeJsonAtomic(file, operation);
-        const capability = await updateMadDbCapabilityCounters(input.root, input.missionId, {
+        const capability = await updateMadSksSqlPlaneCapabilityCounters(input.root, input.missionId, {
             attemptsDelta: 1,
             reservedDelta: 1
         });
-        await appendMadDbLedgerEvent(input.root, input.missionId, {
+        await appendMadSksSqlPlaneLedgerEvent(input.root, input.missionId, {
             type: 'db_operation.reserved',
             operation_id: operation.operation_id,
             tool_call_id: operation.tool_call_id,
@@ -49,8 +49,8 @@ export async function reserveMadDbOperation(input) {
         return { operation, reused: false, capability: capability || input.capability };
     });
 }
-export async function transitionMadDbOperation(input) {
-    return withMadDbLock(input.root, input.missionId, `operation-${safeKey(input.toolCallId)}`, async () => {
+export async function transitionMadSksSqlPlaneOperation(input) {
+    return withMadSksSqlPlaneLock(input.root, input.missionId, `operation-${safeKey(input.toolCallId)}`, async () => {
         const file = operationFile(input.root, input.missionId, input.toolCallId);
         const existing = await readJson(file, null);
         if (!existing)
@@ -68,10 +68,10 @@ export async function transitionMadDbOperation(input) {
         };
         await writeJsonAtomic(file, updated);
         if (input.state === 'succeeded')
-            await updateMadDbCapabilityCounters(input.root, input.missionId, { succeededDelta: 1 });
+            await updateMadSksSqlPlaneCapabilityCounters(input.root, input.missionId, { succeededDelta: 1 });
         if (input.state === 'failed')
-            await updateMadDbCapabilityCounters(input.root, input.missionId, { failedDelta: 1 });
-        await appendMadDbLedgerEvent(input.root, input.missionId, {
+            await updateMadSksSqlPlaneCapabilityCounters(input.root, input.missionId, { failedDelta: 1 });
+        await appendMadSksSqlPlaneLedgerEvent(input.root, input.missionId, {
             type: `db_operation.${input.state}`,
             operation_id: updated.operation_id,
             tool_call_id: updated.tool_call_id,
@@ -102,7 +102,7 @@ export function extractCanonicalToolCallId(payload = {}) {
     return found ? String(found).trim() : null;
 }
 export function operationFile(root, missionId, toolCallId) {
-    return path.join(missionDir(root, missionId), 'mad-db', 'runtime', 'operations', `${safeKey(toolCallId)}.json`);
+    return path.join(madSksSqlPlaneRuntimeDir(root, missionId), 'operations', `${safeKey(toolCallId)}.json`);
 }
 function safeKey(value) {
     return sha256(value).slice(0, 24);
@@ -137,4 +137,3 @@ function redactSensitive(value, depth = 0) {
     }
     return value;
 }
-//# sourceMappingURL=mad-db-operation-store.js.map

package/dist/core/mad-sks/sql-plane/paths.js

@@ -0,0 +1,16 @@
+import path from 'node:path';
+import { missionDir } from '../../mission.js';
+export const MAD_SKS_SQL_PLANE_CAPABILITY_FILE = 'capability.json';
+export const MAD_SKS_SQL_PLANE_CLOSED_CAPABILITY_FILE = 'capability.closed.json';
+export const MAD_SKS_SQL_PLANE_LEDGER_FILE = 'ledger.jsonl';
+export const MAD_SKS_SQL_PLANE_LATEST_LEDGER_FILE = 'ledger.latest.json';
+export const MAD_SKS_SQL_PLANE_RESULT_FILE = 'result.json';
+export function madSksSqlPlaneDir(root, missionId) {
+    return path.join(missionDir(root, missionId), 'mad-sks', 'sql-plane');
+}
+export function madSksSqlPlaneRuntimeDir(root, missionId) {
+    return path.join(madSksSqlPlaneDir(root, missionId), 'runtime');
+}
+export function madSksSqlPlaneRelativePath(...segments) {
+    return path.posix.join('mad-sks', 'sql-plane', ...segments);
+}

package/dist/core/mad-sks/sql-plane/policy-resolver.js

@@ -0,0 +1,127 @@
+import { isMadSksSqlPlaneCapabilityActive, readMadSksSqlPlaneCapability } from './capability.js';
+import { activeMadSksSqlPlaneAllowsMutation, isMadSksSqlPlaneControlPlaneDeniedTool, madSksSqlPlaneOperationClassesFromClassification } from './policy.js';
+import { readJson, sha256 } from '../../fsx.js';
+import { missionsDir, stateFile } from '../../mission.js';
+export const MAD_SKS_SQL_PLANE_POLICY_DECISION_SCHEMA = 'sks.mad-sks-sql-plane-policy-decision.v2';
+export async function resolveMadSksSqlPlaneMutationPolicy(root, state = {}, classification = {}, explicitCapability) {
+    const primary = await resolveMadSksSqlPlaneMutationPolicyForState(root, state, classification, explicitCapability);
+    if (primary.allowed === true || explicitCapability)
+        return primary;
+    /* intentional: optional fallback lookup — primary policy already resolved, this only widens the search */
+    const persistedState = await readJson(stateFile(root), null).catch(() => null);
+    if (persistedState && persistedState !== state) {
+        const fallback = await resolveMadSksSqlPlaneMutationPolicyForState(root, persistedState, classification, null);
+        if (fallback.allowed === true) {
+            return {
+                ...fallback,
+                state_source: 'persisted_sks_state',
+                reasons: [...fallback.reasons, 'mad_sks_sql_plane_persisted_state_binding_used']
+            };
+        }
+    }
+    const latestCapability = await findLatestActiveMadSksSqlPlaneCapability(root);
+    if (latestCapability) {
+        const fallback = await resolveMadSksSqlPlaneMutationPolicyForState(root, {
+            mad_sks_sql_plane_active: true,
+            mad_sks_sql_plane_capability_mission_id: latestCapability.mission_id
+        }, classification, latestCapability);
+        if (fallback.allowed === true) {
+            return {
+                ...fallback,
+                state_source: 'latest_active_mad_sks_sql_plane_capability',
+                reasons: [...fallback.reasons, 'mad_sks_sql_plane_latest_active_capability_used']
+            };
+        }
+    }
+    return primary;
+}
+async function findLatestActiveMadSksSqlPlaneCapability(root) {
+    const fs = await import('node:fs/promises');
+    const entries = await fs.readdir(missionsDir(root), { withFileTypes: true }).catch(() => []);
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith('M-'))
+            continue;
+        /* intentional: scanning candidate mission dirs for an active capability — a missing/corrupt one is just not a candidate */
+        const capability = await readMadSksSqlPlaneCapability(root, entry.name).catch(() => null);
+        if (!capability || !isMadSksSqlPlaneCapabilityActive(capability))
+            continue;
+        const issuedMs = Date.parse(capability.issued_at || '');
+        const expiresMs = Date.parse(capability.expires_at || '');
+        candidates.push({
+            capability,
+            issuedMs: Number.isFinite(issuedMs) ? issuedMs : 0,
+            expiresMs: Number.isFinite(expiresMs) ? expiresMs : 0
+        });
+    }
+    candidates.sort((a, b) => ((a.issuedMs - b.issuedMs)
+        || (a.expiresMs - b.expiresMs)
+        || a.capability.mission_id.localeCompare(b.capability.mission_id)));
+    return candidates.at(-1)?.capability || null;
+}
+async function resolveMadSksSqlPlaneMutationPolicyForState(root, state = {}, classification = {}, explicitCapability) {
+    const missionId = explicitCapability?.mission_id || state?.mad_sks_sql_plane_capability_mission_id || state?.mission_id;
+    if (!missionId)
+        return inactive('mission_id_missing');
+    const capability = explicitCapability || await readMadSksSqlPlaneCapability(root, String(missionId));
+    const validation = validateCapabilityBinding(capability, state, classification);
+    if (!validation.ok)
+        return inactive(validation.reason);
+    if (isMadSksSqlPlaneControlPlaneDeniedTool(classification.toolName || classification.tool_name))
+        return inactive('mad_sks_sql_plane_control_plane_tool_denied');
+    if (!activeMadSksSqlPlaneAllowsMutation(classification))
+        return inactive('not_a_database_sql_plane_mutation');
+    return {
+        schema: MAD_SKS_SQL_PLANE_POLICY_DECISION_SCHEMA,
+        allowed: true,
+        action: 'allow',
+        mode: 'mad-sks-sql-plane-active',
+        priority: 0,
+        priority_order: ['mad-sks-sql-plane', 'sealed-contract', 'default-db-safety'],
+        reasons: ['mad_sks_sql_plane_capability_v2_bound_sql_plane_authorized'],
+        audit_required: true,
+        mission_id: capability.mission_id,
+        cycle_id: capability.cycle_id,
+        runtime_session_id: capability.runtime_session_id,
+        project_ref_hash: hashRef(capability.project_ref),
+        operation_classes: madSksSqlPlaneOperationClassesFromClassification(classification),
+        counters: capability.counters,
+        capability
+    };
+}
+export function validateCapabilityBinding(capability, state = {}, classification = {}) {
+    if (!capability)
+        return { ok: false, reason: 'mad_sks_sql_plane_capability_missing' };
+    if (!isMadSksSqlPlaneCapabilityActive(capability))
+        return { ok: false, reason: `mad_sks_sql_plane_capability_${capability.status || 'inactive'}` };
+    if (!capability.project_ref)
+        return { ok: false, reason: 'mad_sks_sql_plane_project_ref_missing' };
+    const boundMadSksSqlPlaneMissionId = state?.mad_sks_sql_plane_capability_mission_id ? String(state.mad_sks_sql_plane_capability_mission_id) : null;
+    if (boundMadSksSqlPlaneMissionId === capability.mission_id && state?.mad_sks_sql_plane_active === false)
+        return { ok: false, reason: 'mad_sks_sql_plane_state_inactive' };
+    if (state?.mission_id && String(state.mission_id) !== capability.mission_id && boundMadSksSqlPlaneMissionId !== capability.mission_id)
+        return { ok: false, reason: 'mad_sks_sql_plane_mission_binding_mismatch' };
+    if (state?.mad_sks_sql_plane_cycle_id && String(state.mad_sks_sql_plane_cycle_id) !== capability.cycle_id)
+        return { ok: false, reason: 'mad_sks_sql_plane_cycle_binding_mismatch' };
+    if (state?.mad_sks_sql_plane_runtime_session_id && String(state.mad_sks_sql_plane_runtime_session_id) !== capability.runtime_session_id)
+        return { ok: false, reason: 'mad_sks_sql_plane_runtime_session_binding_mismatch' };
+    if (state?.mad_sks_sql_plane_profile_sha256 && String(state.mad_sks_sql_plane_profile_sha256) !== capability.transport.profile_sha256)
+        return { ok: false, reason: 'mad_sks_sql_plane_profile_hash_mismatch' };
+    if (classification.toolReasons?.includes?.('dangerous_supabase_management_tool'))
+        return { ok: false, reason: 'mad_sks_sql_plane_control_plane_tool_denied' };
+    return { ok: true, reason: 'ok' };
+}
+function inactive(reason) {
+    return {
+        schema: MAD_SKS_SQL_PLANE_POLICY_DECISION_SCHEMA,
+        allowed: false,
+        action: 'defer',
+        mode: 'default-db-safety',
+        priority: 99,
+        reasons: [reason],
+        audit_required: false
+    };
+}
+function hashRef(projectRef) {
+    return sha256(projectRef).slice(0, 16);
+}

package/dist/core/{mad-db/mad-db-policy.js → mad-sks/sql-plane/policy.js}

@@ -1,5 +1,5 @@
-export const MAD_DB_POLICY_SCHEMA = 'sks.mad-db-policy.v2';
-export const MAD_DB_OPERATION_CLASSES = [
+export const MAD_SKS_SQL_PLANE_POLICY_SCHEMA = 'sks.mad-sks-sql-plane-policy.v2';
+export const MAD_SKS_SQL_PLANE_OPERATION_CLASSES = [
     'create',
     'alter',
     'drop',
@@ -17,19 +17,19 @@ export const MAD_DB_OPERATION_CLASSES = [
     'index_change',
     'unknown_sql_mutation'
 ];
-export const MAD_DB_SQL_PLANE_TOOL_NAMES = Object.freeze([
+export const MAD_SKS_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'
+    'supabase_mad_sks_sql_plane.execute_sql',
+    'supabase_mad_sks_sql_plane.apply_migration',
+    'mcp__supabase_mad_sks_sql_plane__execute_sql',
+    'mcp__supabase_mad_sks_sql_plane__apply_migration'
 ]);
-export const MAD_DB_CONTROL_PLANE_DENIED_TOOL_PATTERNS = Object.freeze([
+export const MAD_SKS_SQL_PLANE_CONTROL_PLANE_DENIED_TOOL_PATTERNS = Object.freeze([
     'delete_project',
     'pause_project',
     'restore_project',
@@ -45,8 +45,8 @@ export const MAD_DB_CONTROL_PLANE_DENIED_TOOL_PATTERNS = Object.freeze([
     'reset_branch',
     'merge_branch'
 ]);
-export const MAD_DB_POLICY = Object.freeze({
-    schema: MAD_DB_POLICY_SCHEMA,
+export const MAD_SKS_SQL_PLANE_POLICY = Object.freeze({
+    schema: MAD_SKS_SQL_PLANE_POLICY_SCHEMA,
     default_mode: 'deny_mutations',
     active_mode: {
         sql_plane: 'allow_all_mutations',
@@ -59,9 +59,9 @@ export const MAD_DB_POLICY = Object.freeze({
             '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,
+    sql_plane_allowed: MAD_SKS_SQL_PLANE_OPERATION_CLASSES,
+    sql_plane_tools: MAD_SKS_SQL_PLANE_TOOL_NAMES,
+    control_plane_denied: MAD_SKS_SQL_PLANE_CONTROL_PLANE_DENIED_TOOL_PATTERNS,
     normal_supabase_mcp: {
         read_only_required: true,
         project_ref_required: true
@@ -76,20 +76,20 @@ export const MAD_DB_POLICY = Object.freeze({
         hard_max_ms: 30 * 60 * 1000
     }
 });
-export function madDbPolicySnapshot() {
-    return MAD_DB_POLICY;
+export function madSksSqlPlanePolicySnapshot() {
+    return MAD_SKS_SQL_PLANE_POLICY;
 }
-export function isMadDbSqlPlaneToolName(toolName) {
+export function isMadSksSqlPlaneToolName(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)));
+    return MAD_SKS_SQL_PLANE_TOOL_NAMES.some((name) => normalized.endsWith(normalizeToolName(name)) || normalized.includes(normalizeToolName(name)));
 }
-export function isMadDbControlPlaneDeniedTool(toolName) {
+export function isMadSksSqlPlaneControlPlaneDeniedTool(toolName) {
     const normalized = normalizeToolName(toolName);
     if (!normalized)
         return false;
-    return MAD_DB_CONTROL_PLANE_DENIED_TOOL_PATTERNS.some((pattern) => normalized.includes(normalizeToolName(pattern)));
+    return MAD_SKS_SQL_PLANE_CONTROL_PLANE_DENIED_TOOL_PATTERNS.some((pattern) => normalized.includes(normalizeToolName(pattern)));
 }
 export function normalizeToolName(toolName) {
     return String(toolName || '')
@@ -97,7 +97,7 @@ export function normalizeToolName(toolName) {
         .toLowerCase()
         .replace(/[^a-z0-9_.-]+/g, '_');
 }
-export function madDbOperationClassesFromClassification(classification = {}) {
+export function madSksSqlPlaneOperationClassesFromClassification(classification = {}) {
     const reasons = new Set([
         ...stringArray(classification.reasons),
         ...stringArray(classification.sql?.reasons),
@@ -106,7 +106,7 @@ export function madDbOperationClassesFromClassification(classification = {}) {
     ]);
     const out = new Set();
     const toolName = classification.toolName || classification.tool_name || '';
-    if (isMadDbSqlPlaneToolName(toolName))
+    if (isMadSksSqlPlaneToolName(toolName))
         out.add('direct_execute_sql');
     if (reasons.has('migration_apply_tool') || reasons.has('supabase_migration_apply'))
         out.add('migration_apply');
@@ -148,25 +148,23 @@ export function madDbOperationClassesFromClassification(classification = {}) {
         out.add('unknown_sql_mutation');
     return [...out];
 }
-export function activeMadDbAllowsSqlPlane(classification = {}) {
+export function activeMadSksSqlPlaneAllowsMutation(classification = {}) {
     const toolName = classification.toolName || classification.tool_name || '';
-    if (isMadDbControlPlaneDeniedTool(toolName))
+    if (isMadSksSqlPlaneControlPlaneDeniedTool(toolName))
         return false;
     if (classification.toolReasons?.includes?.('dangerous_supabase_management_tool'))
         return false;
-    if (isMadDbSqlPlaneToolName(toolName))
+    if (isMadSksSqlPlaneToolName(toolName))
         return true;
     return ['write', 'destructive', 'possible_db'].includes(String(classification.level || ''));
 }
-export function madDbSkillText(commandPrefix = 'sks') {
+export function madSksSqlPlanePolicyText(commandPrefix = 'sks') {
     return `---
-name: mad-db
-description: Deprecated alias; MadDB SQL-plane execution is merged into mad-sks.
+name: mad-sks-sql-plane-policy
+description: Canonical MAD-SKS SQL-plane execution policy.
 ---
 
-Deprecated compatibility skill. Use mad-sks for all current SQL-plane execution. $MAD-DB and ${commandPrefix} mad-db run|exec|apply-migration redirect to MAD-SKS sql-plane for one release and must warn the operator.
-
-Merged SQL-plane rules for mad-sks: 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. Catastrophic SQL is allowed only in the sql-plane executor and only when the user's prompt or CLI SQL statement literally names the operation.
+MAD-SKS SQL-plane rules: execute SQL-plane mutations that the operator requested through $MAD-SKS or ${commandPrefix} mad-sks sql|apply-migration, including CREATE, ALTER, table/schema DROP, column add/drop/rename, INSERT, UPDATE, DELETE including all-row mutations, TRUNCATE, execute_sql, and apply_migration. Catastrophic SQL is allowed only in the SQL-plane executor and only when the user's prompt or CLI SQL statement literally names the operation.
 
 Keep normal Supabase MCP configuration read-only. MAD-SKS sql-plane 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.
 
@@ -182,7 +180,7 @@ Rules:
 - Default non-MAD-SKS mode is read-only and routes writes/destructive SQL to the DB safety gate.
 - Supabase MCP must be read-only and project-scoped by default.
 - Live execute_sql writes are blocked unless a bound active MAD-SKS sql-plane capability v2 is present.
-- Active MAD-SKS sql-plane is the explicit exception: SQL-plane mutations requested by $MAD-SKS/sks mad-sks sql|apply-migration, or deprecated $MAD-DB/sks mad-db redirects, are allowed, including DROP, DELETE, TRUNCATE, RLS/policy changes, and execute_sql/apply_migration, and must be executed with read-back verification.
+- Active MAD-SKS sql-plane is the explicit exception: SQL-plane mutations requested by $MAD-SKS or sks mad-sks sql|apply-migration are allowed, including DROP, DELETE, TRUNCATE, RLS/policy changes, and execute_sql/apply_migration, and must be executed with read-back verification.
 - Default read-only restrictions do not apply to SQL-plane work while the active MAD-SKS sql-plane capability v2 is bound.
 - Supabase project/account/billing/credential control-plane actions remain denied even in MAD-SKS sql-plane.
 - If no active bound MAD-SKS sql-plane cycle exists, fall back to read-only only.`;
@@ -195,4 +193,3 @@ function stringArray(value) {
 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 → mad-sks/sql-plane/postconditions.js}

@@ -1,6 +1,6 @@
 import path from 'node:path';
-import { nowIso, sha256, writeJsonAtomic } from '../fsx.js';
-import { missionDir } from '../mission.js';
+import { nowIso, sha256, writeJsonAtomic } from '../../fsx.js';
+import { madSksSqlPlaneDir } from './paths.js';
 export async function runReadBackChecks(input) {
     const rows = [];
     for (const check of input.checks) {
@@ -29,17 +29,16 @@ export async function runReadBackChecks(input) {
         });
     }
     const proof = {
-        schema: 'sks.mad-db-read-back-proof.v1',
+        schema: 'sks.mad-sks-sql-plane-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');
+    const proofPath = path.join(madSksSqlPlaneDir(input.root, input.missionId), '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, expected = {}) {
     return { id, query, expectOk: true, ...expected };
 }
-//# sourceMappingURL=mad-db-postconditions.js.map

package/dist/core/{mad-db/mad-db-recovery.js → mad-sks/sql-plane/recovery.js}

@@ -1,17 +1,18 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { exists, nowIso, writeJsonAtomic } from '../fsx.js';
-export async function quarantineStaleMadDbRuntimeProfiles(root) {
+import { exists, nowIso, writeJsonAtomic } from '../../fsx.js';
+import { madSksSqlPlaneRuntimeDir } from './paths.js';
+export async function quarantineStaleMadSksSqlPlaneRuntimeProfiles(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() };
+        return { schema: 'sks.mad-sks-sql-plane-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');
+        const runtime = madSksSqlPlaneRuntimeDir(root, mission.name);
+        const profile = path.join(runtime, 'codex-mad-sks-sql-plane.config.toml');
         if (!(await exists(profile)))
             continue;
         const dest = `${profile}.quarantined-${Date.now()}`;
@@ -21,9 +22,8 @@ export async function quarantineStaleMadDbRuntimeProfiles(root) {
         });
         quarantined.push(path.relative(root, dest).split(path.sep).join('/'));
     }
-    const report = { schema: 'sks.mad-db-recovery.v1', ok: true, quarantined, checked_at: nowIso() };
+    const report = { schema: 'sks.mad-sks-sql-plane-recovery.v1', ok: true, quarantined, checked_at: nowIso() };
     /* intentional: recovery report is diagnostic-only, already returned to the caller regardless of whether it persisted */
-    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'mad-db-recovery.json'), report).catch(() => undefined);
+    await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'mad-sks-sql-plane-recovery.json'), report).catch(() => undefined);
     return report;
 }
-//# sourceMappingURL=mad-db-recovery.js.map

package/dist/core/{mad-db/mad-db-result-lifecycle.js → mad-sks/sql-plane/result-lifecycle.js}

@@ -1,25 +1,25 @@
-import { extractCanonicalToolCallId, transitionMadDbOperation } from './mad-db-operation-store.js';
-export async function recordPendingMadDbLifecycleHook(_root, _missionId, hook) {
+import { extractCanonicalToolCallId, transitionMadSksSqlPlaneOperation } from './operation-store.js';
+export async function recordPendingMadSksSqlPlaneLifecycleHook(_root, _missionId, hook) {
     return {
-        schema: 'sks.mad-db-lifecycle-pending.v2',
+        schema: 'sks.mad-sks-sql-plane-lifecycle-pending.v2',
         pending_latest_removed: true,
         hook
     };
 }
-export async function readLatestPendingMadDbLifecycleHook(_root, _missionId, payload = {}) {
+export async function readLatestPendingMadSksSqlPlaneLifecycleHook(_root, _missionId, payload = {}) {
     return lifecycleHookFromUnknown(payload);
 }
-export async function recordMadDbToolResult(input) {
+export async function recordMadSksSqlPlaneToolResult(input) {
     if (!input.hook.tool_call_id) {
         return {
-            schema: 'sks.mad-db-tool-result-lifecycle.v2',
+            schema: 'sks.mad-sks-sql-plane-tool-result-lifecycle.v2',
             ok: false,
             skipped: true,
             reason: 'tool_call_id_required_for_result_correlation',
             operation_id: input.hook.operation_id
         };
     }
-    const operation = await transitionMadDbOperation({
+    const operation = await transitionMadSksSqlPlaneOperation({
         root: input.root,
         missionId: input.missionId,
         toolCallId: input.hook.tool_call_id,
@@ -28,7 +28,7 @@ export async function recordMadDbToolResult(input) {
         errorCode: input.ok ? null : input.error || 'tool_failed'
     });
     return {
-        schema: 'sks.mad-db-tool-result-lifecycle.v2',
+        schema: 'sks.mad-sks-sql-plane-tool-result-lifecycle.v2',
         ok: Boolean(operation),
         skipped: false,
         operation_id: input.hook.operation_id,
@@ -37,7 +37,7 @@ export async function recordMadDbToolResult(input) {
         operation
     };
 }
-export async function maybeRecordMadDbToolResultFromToolUse(input) {
+export async function maybeRecordMadSksSqlPlaneToolResultFromToolUse(input) {
     const payload = input.toolResult ?? input.toolCallPayload ?? {};
     const hook = lifecycleHookFromUnknown(input.decision)
         || lifecycleHookFromUnknown(input.toolCallPayload)
@@ -45,8 +45,8 @@ export async function maybeRecordMadDbToolResultFromToolUse(input) {
     const toolCallId = extractCanonicalToolCallId(payload) || hook?.tool_call_id || null;
     if (!toolCallId && !hook)
         return null;
-    const ok = !madDbToolUseFailed(payload);
-    return recordMadDbToolResult({
+    const ok = !madSksSqlPlaneToolUseFailed(payload);
+    return recordMadSksSqlPlaneToolResult({
         root: input.root,
         missionId: input.missionId,
         hook: hook || {
@@ -60,7 +60,7 @@ export async function maybeRecordMadDbToolResultFromToolUse(input) {
     });
 }
 export function lifecycleHookFromUnknown(value) {
-    const candidate = value?.ledger_result_hook || value?.mad_db?.ledger_result_hook || value;
+    const candidate = value?.ledger_result_hook || value?.mad_sks_sql_plane?.ledger_result_hook || value;
     const missionId = stringOrNull(candidate?.mission_id || candidate?.missionId);
     const operationId = stringOrNull(candidate?.operation_id || candidate?.operationId);
     if (!missionId || !operationId)
@@ -76,7 +76,7 @@ export function lifecycleHookFromUnknown(value) {
         destructive: candidate?.destructive === true
     };
 }
-function madDbToolUseFailed(payload = {}) {
+function madSksSqlPlaneToolUseFailed(payload = {}) {
     if (payload?.isError === true || payload?.tool_response?.isError === true || payload?.toolResponse?.isError === true || payload?.result?.isError === true)
         return true;
     const candidates = [
@@ -133,4 +133,3 @@ function stringOrNull(value) {
     const text = String(value || '').trim();
     return text ? text : null;
 }
-//# sourceMappingURL=mad-db-result-lifecycle.js.map

package/dist/core/{mad-db/mad-db-runtime-profile.js → mad-sks/sql-plane/runtime-profile.js}

@@ -1,30 +1,30 @@
 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');
+import { exists, nowIso, readText, sha256, writeJsonAtomic, writeTextAtomic } from '../../fsx.js';
+import { madSksSqlPlaneRuntimeDir } from './paths.js';
+export async function createMadSksSqlPlaneRuntimeProfile(input) {
+    const dir = madSksSqlPlaneRuntimeDir(input.root, input.missionId);
     await fs.mkdir(dir, { recursive: true });
-    const url = madDbMcpUrl(input.projectRef, input.mcpUrl);
+    const url = madSksSqlPlaneMcpUrl(input.projectRef, input.mcpUrl);
     /* intentional: this TOML block is never loaded into a live Codex session config — the
        agent's own Supabase MCP tool intentionally stays read-only for the whole cycle. It is
-       read only by MadDbMcpExecutor (via profile.server_url in-process) and by
-       mad-db-recovery.ts (existence check for crash cleanup). Keeping writes on that single
+       read only by MadSksSqlPlaneMcpExecutor (via profile.server_url in-process) and by
+       recovery.ts (existence check for crash cleanup). Keeping writes on that single
        JS-orchestrated path, rather than handing the model a write-capable MCP server directly,
        is what makes postcondition/read-back/rollback verification possible; do not "wire this up"
        into .codex/config.toml without re-deriving those guarantees for a model-driven write path. */
     const text = [
-        '[mcp_servers.supabase_mad_db]',
+        '[mcp_servers.supabase_mad_sks_sql_plane]',
         `url = "${url}"`,
         'enabled = true',
         ''
     ].join('\n');
-    const profilePath = path.join(dir, 'codex-mad-db.config.toml');
+    const profilePath = path.join(dir, 'codex-mad-sks-sql-plane.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',
+        schema: 'sks.mad-sks-sql-plane-runtime-profile.v1',
         mission_id: input.missionId,
         cycle_id: input.cycleId,
         runtime_session_id: input.runtimeSessionId,
@@ -42,8 +42,9 @@ export async function createMadDbRuntimeProfile(input) {
     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');
+export async function closeMadSksSqlPlaneRuntimeProfile(input) {
+    const runtimeDir = madSksSqlPlaneRuntimeDir(input.root, input.missionId);
+    const profilePath = input.profile?.profile_path ? path.join(input.root, input.profile.profile_path) : path.join(runtimeDir, 'codex-mad-sks-sql-plane.config.toml');
     if (await exists(profilePath)) {
         const quarantine = `${profilePath}.closed`;
         /* intentional: best-effort rename-then-rm quarantine of the closed runtime profile; read-only restoration is verified separately below */
@@ -52,7 +53,7 @@ export async function closeMadDbRuntimeProfile(input) {
         });
     }
     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'), {
+    await writeJsonAtomic(path.join(runtimeDir, 'read-only-restoration.json'), {
         ...proof,
         close_reason: input.reason || 'cycle_finally'
     });
@@ -69,7 +70,7 @@ export async function verifyReadOnlyRestored(root, normalConfigHashBefore, profi
         ...(runtimeExists ? ['runtime_write_profile_still_exists'] : [])
     ];
     return {
-        schema: 'sks.mad-db-read-only-restoration.v1',
+        schema: 'sks.mad-sks-sql-plane-read-only-restoration.v1',
         checked_at: nowIso(),
         ok: blockers.length === 0,
         normal_config_hash_before: normalConfigHashBefore,
@@ -83,7 +84,7 @@ export function redactedRuntimeProfile(profile) {
     const { server_url: _serverUrl, ...rest } = profile;
     return rest;
 }
-export function madDbMcpUrl(projectRef, explicitUrl) {
+export function madSksSqlPlaneMcpUrl(projectRef, explicitUrl) {
     if (explicitUrl) {
         const parsed = new URL(explicitUrl);
         if (projectRef && !parsed.searchParams.get('project_ref'))
@@ -135,4 +136,3 @@ function persistentSupabaseConfigReadOnly(text) {
         }
     });
 }
-//# sourceMappingURL=mad-db-runtime-profile.js.map