sneakoscope 6.1.2 → 6.4.0

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

@@ -1,37 +1,39 @@
 import path from 'node:path';
-import { createMission, missionDir, setCurrent } from '../mission.js';
-import { ensureDir, nowIso, readJson, readText, sha256, writeJsonAtomic } from '../fsx.js';
-import { createMadDbCapability, activateMadDbCapability, closeMadDbCycle, MAD_DB_ACK, markMadDbTransportReady, readMadDbCapability } from './mad-db-capability.js';
-import { MadDbMcpExecutor } from './mad-db-executor.js';
-import { createMadDbRuntimeProfile, closeMadDbRuntimeProfile, redactedRuntimeProfile } from './mad-db-runtime-profile.js';
-import { reserveMadDbOperation, transitionMadDbOperation } from './mad-db-operation-store.js';
-import { readBackCheck, runReadBackChecks } from './mad-db-postconditions.js';
-import { madDbOperationClassesFromClassification } from './mad-db-policy.js';
-import { projectRootHash, resolveMadDbTarget } from './mad-db-target.js';
-import { classifySql } from '../db-safety.js';
-export async function prepareMadDbMission(input) {
-    const target = await resolveMadDbTarget(input.root, { args: input.args || [] });
-    const route = input.route || 'MadDB';
-    const routeCommand = input.routeCommand || (route === 'MadSKS' ? '$MAD-SKS' : '$MAD-DB');
+import { createMission, missionDir, setCurrent } from '../../mission.js';
+import { ensureDir, nowIso, readJson, readText, sha256, writeJsonAtomic } from '../../fsx.js';
+import { createMadSksSqlPlaneCapability, activateMadSksSqlPlaneCapability, closeMadSksSqlPlaneCycle, MAD_SKS_SQL_PLANE_ACK, markMadSksSqlPlaneTransportReady, readMadSksSqlPlaneCapability } from './capability.js';
+import { MadSksSqlPlaneMcpExecutor } from './mcp-executor.js';
+import { createMadSksSqlPlaneRuntimeProfile, closeMadSksSqlPlaneRuntimeProfile, redactedRuntimeProfile } from './runtime-profile.js';
+import { reserveMadSksSqlPlaneOperation, transitionMadSksSqlPlaneOperation } from './operation-store.js';
+import { readBackCheck, runReadBackChecks } from './postconditions.js';
+import { madSksSqlPlaneOperationClassesFromClassification } from './policy.js';
+import { projectRootHash, resolveMadSksSqlPlaneTarget } from './target.js';
+import { classifySql } from '../../db-safety.js';
+import { MAD_SKS_SQL_PLANE_CAPABILITY_FILE, MAD_SKS_SQL_PLANE_RESULT_FILE, madSksSqlPlaneDir, madSksSqlPlaneRelativePath, madSksSqlPlaneRuntimeDir } from './paths.js';
+export async function prepareMadSksSqlPlaneMission(input) {
+    const target = await resolveMadSksSqlPlaneTarget(input.root, { args: input.args || [] });
+    const route = 'MadSKS';
+    const routeCommand = '$MAD-SKS';
     const existingMissionId = input.missionId ? String(input.missionId) : '';
     const created = existingMissionId
         ? { id: existingMissionId, dir: missionDir(input.root, existingMissionId) }
-        : await createMission(input.root, { mode: route === 'MadSKS' ? 'mad-sks' : 'mad-db', prompt: input.task || 'MadDB SQL-plane execution', sessionKey: input.sessionKey });
+        : await createMission(input.root, { mode: 'mad-sks', prompt: input.task || 'MAD-SKS SQL-plane execution', sessionKey: input.sessionKey });
     const { id, dir } = created;
     await ensureDir(dir);
-    const cycleId = `mad-db-${Date.now().toString(36)}`;
-    const runtimeSessionId = input.runtimeSessionId || `mad-db-session-${Date.now().toString(36)}`;
+    const runtimeDir = madSksSqlPlaneRuntimeDir(input.root, id);
+    const cycleId = `mad-sks-sql-plane-${Date.now().toString(36)}`;
+    const runtimeSessionId = input.runtimeSessionId || `mad-sks-sql-plane-session-${Date.now().toString(36)}`;
     const blockers = [...target.blockers];
     let profile;
     if (!target.project_ref) {
-        profile = await createMadDbRuntimeProfile({ root: input.root, missionId: id, cycleId, projectRef: 'missing-project-ref', runtimeSessionId, mcpUrl: target.mcp_url });
+        profile = await createMadSksSqlPlaneRuntimeProfile({ root: input.root, missionId: id, cycleId, projectRef: 'missing-project-ref', runtimeSessionId, mcpUrl: target.mcp_url });
     }
     else {
-        profile = await createMadDbRuntimeProfile({ root: input.root, missionId: id, cycleId, projectRef: target.project_ref, runtimeSessionId, mcpUrl: target.mcp_url });
+        profile = await createMadSksSqlPlaneRuntimeProfile({ root: input.root, missionId: id, cycleId, projectRef: target.project_ref, runtimeSessionId, mcpUrl: target.mcp_url });
     }
-    const capability = await createMadDbCapability(input.root, {
+    const capability = await createMadSksSqlPlaneCapability(input.root, {
         missionId: id,
-        ack: MAD_DB_ACK,
+        ack: MAD_SKS_SQL_PLANE_ACK,
         cwd: input.root,
         cycleId,
         projectRef: target.project_ref || 'missing-project-ref',
@@ -43,44 +45,44 @@ export async function prepareMadDbMission(input) {
         profilePath: profile.profile_path,
         profileSha256: profile.profile_sha256,
         serverUrlRedacted: profile.server_url_redacted,
-        operations: [...madDbOperationClassesFromClassification(classifySql(input.task))],
+        operations: [...madSksSqlPlaneOperationClassesFromClassification(classifySql(input.task))],
         status: blockers.length ? 'quarantined' : 'transport_ready'
     });
     let toolInventory = null;
     if (input.verifyTools && !blockers.length) {
-        const executor = new MadDbMcpExecutor(profile);
+        const executor = new MadSksSqlPlaneMcpExecutor(profile);
         toolInventory = await executor.inventory();
         await executor.close();
-        await writeJsonAtomic(path.join(dir, 'mad-db', 'runtime', 'tool-inventory.json'), toolInventory);
+        await writeJsonAtomic(path.join(runtimeDir, 'tool-inventory.json'), toolInventory);
         if (!toolInventory.ok)
-            blockers.push('mad_db_execute_sql_or_apply_migration_unavailable');
+            blockers.push('mad_sks_sql_plane_execute_sql_or_apply_migration_unavailable');
         else
-            await markMadDbTransportReady(input.root, id);
+            await markMadSksSqlPlaneTransportReady(input.root, id);
     }
     await writeJsonAtomic(path.join(dir, 'route-context.json'), {
         route,
         command: routeCommand,
-        mode: route === 'MadSKS' ? 'MADSKS' : 'MADDB',
+        mode: 'MADSKS',
         task: input.task,
         target: redactTarget(target),
-        capability_file: 'mad-db-capability.json',
-        runtime_profile_manifest: 'mad-db/runtime/runtime-profile-manifest.json',
-        tool_inventory: toolInventory ? 'mad-db/runtime/tool-inventory.json' : null,
-        sql_plane_executor: route === 'MadSKS'
+        capability_file: madSksSqlPlaneRelativePath(MAD_SKS_SQL_PLANE_CAPABILITY_FILE),
+        runtime_profile_manifest: madSksSqlPlaneRelativePath('runtime', 'runtime-profile-manifest.json'),
+        tool_inventory: toolInventory ? madSksSqlPlaneRelativePath('runtime', 'tool-inventory.json') : null,
+        sql_plane_executor: true
     });
     await writeJsonAtomic(path.join(dir, 'mad-sks-gate.json'), {
         schema: 'sks.mad-sks-gate.v1',
         passed: false,
-        mad_sks_permission_active: route === 'MadSKS' && !blockers.length,
+        mad_sks_permission_active: !blockers.length,
         permissions_deactivated: false,
         sql_plane: {
             requested: true,
             capability_id: preparedCapabilityId(id, cycleId),
-            operation_classes: [...madDbOperationClassesFromClassification(classifySql(input.task))],
+            operation_classes: [...madSksSqlPlaneOperationClassesFromClassification(classifySql(input.task))],
             read_back_passed: false,
             profile_closed: false
         },
-        mad_db_capability_active: !blockers.length,
+        mad_sks_sql_plane_capability_active: !blockers.length,
         sql_plane_all_mutations_allowed: !blockers.length,
         control_plane_denied: true,
         mission_id: id,
@@ -90,25 +92,25 @@ export async function prepareMadDbMission(input) {
     });
     await setCurrent(input.root, {
         mission_id: id,
-        mad_db_capability_mission_id: id,
+        mad_sks_sql_plane_capability_mission_id: id,
         route,
         route_command: routeCommand,
-        mode: route === 'MadSKS' ? 'MADSKS' : 'MADDB',
+        mode: 'MADSKS',
         phase: blockers.length ? `${route.toUpperCase()}_BLOCKED` : `${route.toUpperCase()}_SQL_PLANE_CAPABILITY_ACTIVE`,
         questions_allowed: false,
         implementation_allowed: !blockers.length,
-        mad_db_active: !blockers.length,
+        mad_sks_sql_plane_active: !blockers.length,
         mad_sks_active: route === 'MadSKS' && !blockers.length,
-        mad_db_cycle_id: cycleId,
-        mad_db_runtime_session_id: runtimeSessionId,
-        mad_db_profile_sha256: profile.profile_sha256,
-        mad_db_capability_file: 'mad-db-capability.json',
+        mad_sks_sql_plane_cycle_id: cycleId,
+        mad_sks_sql_plane_runtime_session_id: runtimeSessionId,
+        mad_sks_sql_plane_profile_sha256: profile.profile_sha256,
+        mad_sks_sql_plane_capability_file: madSksSqlPlaneRelativePath(MAD_SKS_SQL_PLANE_CAPABILITY_FILE),
         mad_sks_gate_file: 'mad-sks-gate.json',
         stop_gate: 'mad-sks-gate.json',
         prompt: input.task
     }, { sessionKey: input.sessionKey });
     return {
-        schema: 'sks.mad-db-prepared-mission.v1',
+        schema: 'sks.mad-sks-sql-plane-prepared-mission.v1',
         ok: blockers.length === 0,
         mission_id: id,
         cycle_id: cycleId,
@@ -119,7 +121,7 @@ export async function prepareMadDbMission(input) {
         blockers
     };
 }
-export async function runMadDbCycle(input) {
+export async function runMadSksSqlPlaneCycle(input) {
     const timings = {};
     const start = Date.now();
     const prepareInput = {
@@ -134,10 +136,10 @@ export async function runMadDbCycle(input) {
         prepareInput.route = input.route;
     if (input.routeCommand)
         prepareInput.routeCommand = input.routeCommand;
-    const prepared = await prepareMadDbMission(prepareInput);
+    const prepared = await prepareMadSksSqlPlaneMission(prepareInput);
     timings.prepare_ms = Date.now() - start;
     const profile = await recreateProfileFromPrepared(input.root, prepared);
-    const executor = new MadDbMcpExecutor(profile);
+    const executor = new MadSksSqlPlaneMcpExecutor(profile);
     let inventory = null;
     let execution = null;
     let operation = null;
@@ -147,23 +149,23 @@ export async function runMadDbCycle(input) {
         const connectStart = Date.now();
         inventory = await executor.inventory();
         timings.mcp_connect_ms = Date.now() - connectStart;
-        await writeJsonAtomic(path.join(missionDir(input.root, prepared.mission_id), 'mad-db', 'runtime', 'tool-inventory.json'), inventory);
+        await writeJsonAtomic(path.join(madSksSqlPlaneRuntimeDir(input.root, prepared.mission_id), 'tool-inventory.json'), inventory);
         if (!inventory.ok) {
-            blockers.push('mad_db_execute_sql_or_apply_migration_unavailable');
+            blockers.push('mad_sks_sql_plane_execute_sql_or_apply_migration_unavailable');
             if (inventory.error_kind)
                 blockers.push(inventory.error_kind);
-            throw new Error('mad_db_tool_inventory_failed');
+            throw new Error('mad_sks_sql_plane_tool_inventory_failed');
         }
-        await activateMadDbCapability(input.root, prepared.mission_id);
+        await activateMadSksSqlPlaneCapability(input.root, prepared.mission_id);
         const sql = await resolveSqlInput(input);
         if (!sql) {
-            blockers.push('mad_db_sql_missing_for_execution');
-            throw new Error('mad_db_sql_missing_for_execution');
+            blockers.push('mad_sks_sql_plane_sql_missing_for_execution');
+            throw new Error('mad_sks_sql_plane_sql_missing_for_execution');
         }
         const classification = classifySql(sql);
         const toolName = input.action === 'apply-migration' ? 'apply_migration' : 'execute_sql';
         const toolCallId = `cli-${input.action}-${sha256(`${prepared.mission_id}:${sql}:${Date.now()}`).slice(0, 16)}`;
-        const reservation = await reserveMadDbOperation({
+        const reservation = await reserveMadSksSqlPlaneOperation({
             root: input.root,
             missionId: prepared.mission_id,
             capability: prepared.capability,
@@ -171,15 +173,15 @@ export async function runMadDbCycle(input) {
             toolName,
             sql,
             migrationName: input.migrationName || null,
-            operationClasses: madDbOperationClassesFromClassification({ ...classification, toolName })
+            operationClasses: madSksSqlPlaneOperationClassesFromClassification({ ...classification, toolName })
         });
-        await transitionMadDbOperation({ root: input.root, missionId: prepared.mission_id, toolCallId, state: 'started' });
+        await transitionMadSksSqlPlaneOperation({ root: input.root, missionId: prepared.mission_id, toolCallId, state: 'started' });
         const execStart = Date.now();
         execution = input.action === 'apply-migration'
-            ? await executor.applyMigration(input.migrationName || `mad_db_${Date.now()}`, sql)
+            ? await executor.applyMigration(input.migrationName || `mad_sks_sql_plane_${Date.now()}`, sql)
             : await executor.executeSql(sql);
         timings.execution_ms = Date.now() - execStart;
-        operation = await transitionMadDbOperation({
+        operation = await transitionMadSksSqlPlaneOperation({
             root: input.root,
             missionId: prepared.mission_id,
             toolCallId,
@@ -187,7 +189,7 @@ export async function runMadDbCycle(input) {
             result: execution
         });
         if (!execution.ok)
-            blockers.push('mad_db_tool_execution_failed');
+            blockers.push('mad_sks_sql_plane_tool_execution_failed');
         if (!execution.ok && execution.error_kind)
             blockers.push(execution.error_kind);
         if (execution.ok && input.verifySql) {
@@ -203,9 +205,9 @@ export async function runMadDbCycle(input) {
             });
             timings.verification_ms = Date.now() - verifyStart;
             if (!readBack.ok)
-                blockers.push('mad_db_read_back_verification_failed');
+                blockers.push('mad_sks_sql_plane_read_back_verification_failed');
             if (operation) {
-                operation = await transitionMadDbOperation({
+                operation = await transitionMadSksSqlPlaneOperation({
                     root: input.root,
                     missionId: prepared.mission_id,
                     toolCallId,
@@ -222,18 +224,18 @@ export async function runMadDbCycle(input) {
         // distinctly prefixed once there's already a domain-level blocker so it
         // isn't mistaken for one.
         const message = err instanceof Error ? err.message : String(err);
-        blockers.push(blockers.length ? `mad_db_cycle_exception:${message}` : message);
+        blockers.push(blockers.length ? `mad_sks_sql_plane_cycle_exception:${message}` : message);
     }
     finally {
         await executor.close();
     }
     const closeStart = Date.now();
-    const restoration = await closeMadDbRuntimeProfile({ root: input.root, missionId: prepared.mission_id, profile, reason: 'mad_db_cycle_finally' });
-    await closeMadDbCycle(input.root, prepared.mission_id, prepared.cycle_id, 'mad_db_cycle_finally');
+    const restoration = await closeMadSksSqlPlaneRuntimeProfile({ root: input.root, missionId: prepared.mission_id, profile, reason: 'mad_sks_sql_plane_cycle_finally' });
+    await closeMadSksSqlPlaneCycle(input.root, prepared.mission_id, prepared.cycle_id, 'mad_sks_sql_plane_cycle_finally');
     timings.close_ms = Date.now() - closeStart;
     timings.total_ms = Date.now() - start;
     const result = {
-        schema: 'sks.mad-db-cycle-result.v1',
+        schema: 'sks.mad-sks-sql-plane-cycle-result.v1',
         ok: blockers.length === 0 && execution?.ok === true && restoration.ok,
         mission_id: prepared.mission_id,
         cycle_id: prepared.cycle_id,
@@ -248,9 +250,9 @@ export async function runMadDbCycle(input) {
         timings_ms: timings,
         blockers: restoration.ok ? blockers : [...blockers, ...restoration.blockers]
     };
-    await writeJsonAtomic(path.join(missionDir(input.root, prepared.mission_id), 'mad-db-result.json'), redactCycleResult(result));
+    await writeJsonAtomic(path.join(madSksSqlPlaneDir(input.root, prepared.mission_id), MAD_SKS_SQL_PLANE_RESULT_FILE), redactCycleResult(result));
     await writeMadSksSqlPlaneGate(input.root, result);
-    await clearMadDbCurrentState(input.root, prepared.mission_id, result.ok, restoration);
+    await clearMadSksSqlPlaneCurrentState(input.root, prepared.mission_id, result.ok, restoration);
     return result;
 }
 function preparedCapabilityId(missionId, cycleId) {
@@ -280,7 +282,7 @@ export async function writeMadSksSqlPlaneGate(root, result) {
         mad_sks_permission_active: false,
         permissions_deactivated: true,
         sql_plane: sqlPlane,
-        mad_db_capability_active: false,
+        mad_sks_sql_plane_capability_active: false,
         sql_plane_all_mutations_allowed: result.execution?.ok === true,
         control_plane_denied: true,
         mission_id: result.mission_id,
@@ -293,21 +295,21 @@ export async function writeMadSksSqlPlaneGate(root, result) {
     await writeJsonAtomic(file, gate);
     return gate;
 }
-async function clearMadDbCurrentState(root, missionId, ok, restoration) {
+async function clearMadSksSqlPlaneCurrentState(root, missionId, ok, restoration) {
     const currentPath = path.join(root, '.sneakoscope', 'state', 'current.json');
     const current = await readJson(currentPath, {});
-    if (current.mission_id !== missionId && current.mad_db_capability_mission_id !== missionId)
+    if (current.mission_id !== missionId && current.mad_sks_sql_plane_capability_mission_id !== missionId)
         return;
     await setCurrent(root, {
-        phase: current.mode === 'MADSKS' ? (ok ? 'MADSKS_SQL_PLANE_CLOSED' : 'MADSKS_SQL_PLANE_FAILED_CLOSED') : (ok ? 'MADDB_CLOSED' : 'MADDB_FAILED_CLOSED'),
+        phase: ok ? 'MADSKS_SQL_PLANE_CLOSED' : 'MADSKS_SQL_PLANE_FAILED_CLOSED',
         implementation_allowed: false,
-        mad_db_active: false,
-        mad_sks_active: current.mode === 'MADSKS' ? false : current.mad_sks_active,
-        mad_db_runtime_session_id: null,
-        mad_db_profile_sha256: null,
-        mad_db_read_only_restored: restoration.ok,
-        mad_db_closed_at: nowIso(),
-        mad_db_last_result_file: 'mad-db-result.json'
+        mad_sks_sql_plane_active: false,
+        mad_sks_active: false,
+        mad_sks_sql_plane_runtime_session_id: null,
+        mad_sks_sql_plane_profile_sha256: null,
+        mad_sks_sql_plane_read_only_restored: restoration.ok,
+        mad_sks_sql_plane_closed_at: nowIso(),
+        mad_sks_sql_plane_last_result_file: madSksSqlPlaneRelativePath(MAD_SKS_SQL_PLANE_RESULT_FILE)
     }, { sessionKey: current._session_key });
 }
 function redactCycleResult(result) {
@@ -327,7 +329,7 @@ async function resolveSqlInput(input) {
 async function recreateProfileFromPrepared(root, prepared) {
     const projectRef = prepared.target.project_ref || 'missing-project-ref';
     return {
-        schema: 'sks.mad-db-runtime-profile.v1',
+        schema: 'sks.mad-sks-sql-plane-runtime-profile.v1',
         mission_id: prepared.mission_id,
         cycle_id: prepared.cycle_id,
         runtime_session_id: prepared.capability.runtime_session_id,
@@ -350,21 +352,21 @@ function redactTarget(target) {
         mcp_url: target.mcp_url ? '<redacted>' : null
     };
 }
-export async function madDbRouteIdentityProof(root, missionId) {
-    const capability = await readMadDbCapability(root, missionId);
+export async function madSksSqlPlaneRouteIdentityProof(root, missionId) {
+    const capability = await readMadSksSqlPlaneCapability(root, missionId);
     const state = await readJson(path.join(root, '.sneakoscope', 'state', 'current.json'), {});
-    const profile = await readJson(path.join(missionDir(root, missionId), 'mad-db', 'runtime', 'runtime-profile-manifest.json'), null);
+    const profile = await readJson(path.join(madSksSqlPlaneRuntimeDir(root, missionId), 'runtime-profile-manifest.json'), null);
     const sameMission = Boolean(capability && capability.mission_id === missionId && state?.mission_id === missionId);
-    const mergedMadSks = state?.route === 'MadSKS' && state?.route_command === '$MAD-SKS';
+    const currentMadSks = state?.route === 'MadSKS' && state?.route_command === '$MAD-SKS';
     return {
-        schema: 'sks.mad-db-route-identity-proof.v1',
-        ok: sameMission && (mergedMadSks || (state?.route === 'MadDB' && state?.route_command === '$MAD-DB')),
+        schema: 'sks.mad-sks-sql-plane-route-identity-proof.v1',
+        ok: sameMission && currentMadSks,
         mission_id: missionId,
         capability_mission_id: capability?.mission_id || null,
         same_mission: sameMission,
         route: state?.route || null,
         route_command: state?.route_command || null,
-        deprecated_route_accepted: mergedMadSks,
+        current_route_accepted: currentMadSks,
         cycle_id: capability?.cycle_id || null,
         project_root_hash: await projectRootHash(root),
         runtime_profile: profile,
@@ -372,9 +374,8 @@ export async function madDbRouteIdentityProof(root, missionId) {
             ...(capability ? [] : ['capability_missing']),
             ...(profile ? [] : ['runtime_profile_manifest_missing']),
             ...(sameMission ? [] : ['mission_binding_mismatch']),
-            ...(state?.route === 'MadDB' || mergedMadSks ? [] : ['route_state_not_maddb_or_merged_mad_sks']),
-            ...(state?.route_command === '$MAD-DB' || mergedMadSks ? [] : ['route_command_not_maddb_or_mad_sks'])
+            ...(currentMadSks ? [] : ['route_state_not_mad_sks']),
+            ...(currentMadSks ? [] : ['route_command_not_mad_sks'])
         ]
     };
 }
-//# sourceMappingURL=mad-db-coordinator.js.map

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

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, writeJsonAtomic } from '../../fsx.js';
+import { MAD_SKS_SQL_PLANE_LATEST_LEDGER_FILE, MAD_SKS_SQL_PLANE_LEDGER_FILE, madSksSqlPlaneDir } from './paths.js';
+export const MAD_SKS_SQL_PLANE_LEDGER_EVENT_SCHEMA = 'sks.mad-sks-sql-plane-ledger-event.v1';
+export async function appendMadSksSqlPlaneLedgerEvent(root, missionId, event) {
+    const row = {
+        schema: MAD_SKS_SQL_PLANE_LEDGER_EVENT_SCHEMA,
+        ts: nowIso(),
+        mission_id: missionId,
+        ...event
+    };
+    const dir = madSksSqlPlaneDir(root, missionId);
+    await appendJsonlBounded(path.join(dir, MAD_SKS_SQL_PLANE_LEDGER_FILE), row);
+    // The authoritative append above already succeeded or threw; this is a
+    // convenience "latest" pointer only. Its failure used to vanish silently
+    // (20차 P1-7) — readers of the latest-event pointer could see a stale
+    // pointer with no signal anything was wrong.
+    await writeJsonAtomic(path.join(dir, MAD_SKS_SQL_PLANE_LATEST_LEDGER_FILE), row).catch((err) => {
+        console.error(`MAD-SKS SQL-plane ledger: failed to update latest pointer for mission ${missionId}: ${err instanceof Error ? err.message : String(err)}`);
+    });
+    return row;
+}
+export async function appendMadSksSqlPlaneOperationLifecycle(root, missionId, input) {
+    return appendMadSksSqlPlaneLedgerEvent(root, missionId, {
+        type: input.type,
+        operation_id: input.operationId,
+        cycle_id: input.cycleId || null,
+        mcp_server: input.mcpServer || null,
+        tool_name: input.toolName || null,
+        sql_hash: input.sqlHash || null,
+        destructive: input.destructive === true,
+        result_status: input.resultStatus || 'pending_tool_result',
+        row_count: input.rowCount ?? null,
+        error: input.error || null
+    });
+}

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

@@ -1,13 +1,13 @@
 import path from 'node:path';
-import { ensureDir } from '../fsx.js';
-import { withFileLock } from '../locks/file-lock.js';
-import { missionDir } from '../mission.js';
+import { ensureDir } from '../../fsx.js';
+import { withFileLock } from '../../locks/file-lock.js';
+import { madSksSqlPlaneRuntimeDir } from './paths.js';
 // Previously a bespoke mkdir-lock with no owner-pid check and no stale
 // recovery at all — a crash mid-operation left the lock permanently stuck
 // (20차 P1-3). Reuses the single owner-token + heartbeat + quarantine-reclaim
 // lock implementation from core/locks/file-lock.ts instead of a second one.
-export async function withMadDbLock(root, missionId, name, fn) {
-    const dir = path.join(missionDir(root, missionId), 'mad-db', 'runtime', 'locks');
+export async function withMadSksSqlPlaneLock(root, missionId, name, fn) {
+    const dir = path.join(madSksSqlPlaneRuntimeDir(root, missionId), 'locks');
     await ensureDir(dir);
     const lockPath = path.join(dir, `${safeName(name)}.lock`);
     return withFileLock({ lockPath, timeoutMs: 15_000, staleMs: 60_000 }, fn);
@@ -15,4 +15,3 @@ export async function withMadDbLock(root, missionId, name, fn) {
 function safeName(value) {
     return value.replace(/[^a-z0-9_.-]+/gi, '_').slice(0, 80) || 'lock';
 }
-//# sourceMappingURL=mad-db-lock.js.map

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

@@ -1,6 +1,6 @@
 import { performance } from 'node:perf_hooks';
-import { nowIso, sha256 } from '../fsx.js';
-export class MadDbMcpExecutor {
+import { nowIso, sha256 } from '../../fsx.js';
+export class MadSksSqlPlaneMcpExecutor {
     profile;
     opts;
     client = null;
@@ -22,7 +22,7 @@ export class MadDbMcpExecutor {
         if (this.client)
             return;
         const { Client, StreamableHTTPClientTransport } = await loadMcpSdk();
-        this.client = new Client({ name: 'sneakoscope-mad-db', version: '4.2.0' });
+        this.client = new Client({ name: 'sneakoscope-mad-sks-sql-plane', version: '4.2.0' });
         const headers = authHeaders();
         const options = headers ? { requestInit: { headers } } : {};
         this.transport = new StreamableHTTPClientTransport(new URL(this.profile.server_url), options);
@@ -37,7 +37,7 @@ export class MadDbMcpExecutor {
             const result = await this.client.listTools({}, { timeout: this.opts.timeoutMs || 10_000 });
             const names = (result.tools || []).map((tool) => String(tool?.name || '')).filter(Boolean).sort();
             const inventory = {
-                schema: 'sks.mad-db-tool-inventory.v1',
+                schema: 'sks.mad-sks-sql-plane-tool-inventory.v1',
                 checked_at: nowIso(),
                 ok: hasTool(names, 'execute_sql') && hasTool(names, 'apply_migration'),
                 tool_names: names,
@@ -54,10 +54,10 @@ export class MadDbMcpExecutor {
             return inventory;
         }
         catch (err) {
-            const summary = summarizeMadDbError(err);
-            const kind = classifyMadDbError(summary);
+            const summary = summarizeMadSksSqlPlaneError(err);
+            const kind = classifyMadSksSqlPlaneError(summary);
             return {
-                schema: 'sks.mad-db-tool-inventory.v1',
+                schema: 'sks.mad-sks-sql-plane-tool-inventory.v1',
                 checked_at: nowIso(),
                 ok: false,
                 tool_names: [],
@@ -67,7 +67,7 @@ export class MadDbMcpExecutor {
                 error_digest: sha256(summary).slice(0, 32),
                 error_summary: summary,
                 error_kind: kind,
-                retry_guidance: madDbRetryGuidance(kind)
+                retry_guidance: madSksSqlPlaneRetryGuidance(kind)
             };
         }
     }
@@ -95,26 +95,26 @@ export class MadDbMcpExecutor {
             try {
                 const result = await this.client.callTool({ name: tool, arguments: args }, undefined, { timeout: this.opts.timeoutMs || 60_000, resetTimeoutOnProgress: true, maxTotalTimeout: 10 * 60_000 });
                 return {
-                    schema: 'sks.mad-db-tool-result.v1',
+                    schema: 'sks.mad-sks-sql-plane-tool-result.v1',
                     ok: result.isError !== true,
                     tool_name: tool,
                     result_digest: sha256(JSON.stringify(redactToolResult(result))).slice(0, 32),
                     row_count: extractRowCount(result),
                     is_error: result.isError === true,
                     duration_ms: Math.round(performance.now() - started),
-                    error_summary: result.isError === true ? summarizeMadDbToolError(result) : null,
-                    error_kind: result.isError === true ? classifyMadDbError(summarizeMadDbToolError(result)) : null,
-                    retry_guidance: result.isError === true ? madDbRetryGuidance(classifyMadDbError(summarizeMadDbToolError(result))) : null
+                    error_summary: result.isError === true ? summarizeMadSksSqlPlaneToolError(result) : null,
+                    error_kind: result.isError === true ? classifyMadSksSqlPlaneError(summarizeMadSksSqlPlaneToolError(result)) : null,
+                    retry_guidance: result.isError === true ? madSksSqlPlaneRetryGuidance(classifyMadSksSqlPlaneError(summarizeMadSksSqlPlaneToolError(result))) : null
                 };
             }
             catch (err) {
                 lastError = err;
             }
         }
-        const summary = summarizeMadDbError(lastError);
-        const kind = classifyMadDbError(summary);
+        const summary = summarizeMadSksSqlPlaneError(lastError);
+        const kind = classifyMadSksSqlPlaneError(summary);
         return {
-            schema: 'sks.mad-db-tool-result.v1',
+            schema: 'sks.mad-sks-sql-plane-tool-result.v1',
             ok: false,
             tool_name: tool,
             result_digest: sha256(summary).slice(0, 32),
@@ -123,7 +123,7 @@ export class MadDbMcpExecutor {
             duration_ms: 0,
             error_summary: summary,
             error_kind: kind,
-            retry_guidance: madDbRetryGuidance(kind)
+            retry_guidance: madSksSqlPlaneRetryGuidance(kind)
         };
     }
 }
@@ -139,16 +139,16 @@ function hasTool(names, name) {
     return names.some((candidate) => candidate === name || candidate.endsWith(`.${name}`) || candidate.endsWith(`__${name}`));
 }
 function authHeaders() {
-    const token = process.env.SUPABASE_ACCESS_TOKEN || process.env.SKS_MAD_DB_SUPABASE_ACCESS_TOKEN || '';
+    const token = process.env.SUPABASE_ACCESS_TOKEN || process.env.SKS_MAD_SKS_SQL_PLANE_SUPABASE_ACCESS_TOKEN || '';
     if (!token)
         return undefined;
     return { Authorization: `Bearer ${token}` };
 }
-export function summarizeMadDbError(err) {
+export function summarizeMadSksSqlPlaneError(err) {
     const text = err instanceof Error ? `${err.name}:${err.message}` : String(err);
     return redactErrorText(text).slice(0, 1200);
 }
-function summarizeMadDbToolError(result) {
+function summarizeMadSksSqlPlaneToolError(result) {
     return redactErrorText(JSON.stringify(redactToolResult(result))).slice(0, 1200);
 }
 function redactErrorText(text) {
@@ -157,7 +157,7 @@ function redactErrorText(text) {
         .replace(/(token|password|secret|apikey)=([^&\s]+)/gi, '$1=<redacted>')
         .replace(/(postgres(?:ql)?:\/\/[^:\s/]+:)([^@\s]+)(@)/gi, '$1<redacted>$3');
 }
-export function classifyMadDbError(summary) {
+export function classifyMadSksSqlPlaneError(summary) {
     const text = String(summary || '').toLowerCase();
     if (/read[_ -]?only|read only|permission denied.+read/i.test(text))
         return 'supabase_mcp_read_only_transport';
@@ -171,9 +171,9 @@ export function classifyMadDbError(summary) {
         return 'supabase_mcp_transport_unreachable';
     return 'supabase_mcp_tool_error';
 }
-export function madDbRetryGuidance(kind) {
+export function madSksSqlPlaneRetryGuidance(kind) {
     if (kind === 'supabase_mcp_read_only_transport')
-        return 'The active MadDB cycle must use the mission-local write-capable MCP URL. Pass --mcp-url or SKS_MAD_DB_MCP_URL if a project-local read-only Supabase MCP config is shadowing the intended transport.';
+        return 'The active MAD-SKS SQL-plane cycle must use the mission-local write-capable MCP URL. Pass --mcp-url or SKS_MAD_SKS_SQL_PLANE_MCP_URL if a project-local read-only Supabase MCP config is shadowing the intended transport.';
     if (kind === 'supabase_sql_plane_timeout')
         return 'Retry with an explicit Supabase pooler/session/direct MCP transport if available; Supabase CLI docs also support --db-url for CLI migration paths when pooler/direct connectivity differs.';
     if (kind === 'supabase_sql_plane_connection_interrupted')
@@ -181,8 +181,8 @@ export function madDbRetryGuidance(kind) {
     if (kind === 'supabase_sql_plane_auth_failed')
         return 'Check SUPABASE_ACCESS_TOKEN and the project/database credentials used by the Supabase MCP server; do not retry destructive SQL until auth is corrected.';
     if (kind === 'supabase_mcp_transport_unreachable')
-        return 'Check access to https://mcp.supabase.com/mcp or pass a trusted local MCP URL with --mcp-url for the active MadDB cycle.';
-    return 'Inspect error_summary in mad-db-result.json; the failure occurred after MadDB capability gating, so do not report it as a safety-gate denial.';
+        return 'Check access to https://mcp.supabase.com/mcp or pass a trusted local MCP URL with --mcp-url for the active MAD-SKS SQL-plane cycle.';
+    return 'Inspect error_summary in the SQL-plane result receipt; the failure occurred after MAD-SKS capability gating, so do not report it as a safety-gate denial.';
 }
 function redactToolResult(value) {
     if (value == null)
@@ -221,4 +221,3 @@ function extractRowCount(value) {
     }
     return null;
 }
-//# sourceMappingURL=mad-db-executor.js.map