sneakoscope 4.1.1 → 4.2.0

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

@@ -0,0 +1,64 @@
+import path from 'node:path';
+import { exists, readText, sha256 } from '../fsx.js';
+export async function resolveMadDbTarget(root, input = {}) {
+    const args = input.args || [];
+    const explicit = input.projectRef || readOption(args, '--project-ref', '') || process.env.SKS_MAD_DB_PROJECT_REF || process.env.SKS_MAD_DB_E2E_PROJECT_REF || '';
+    const candidates = explicit ? [explicit] : await projectRefCandidates(root);
+    const projectRef = explicit || (candidates.length === 1 ? candidates[0] || '' : '');
+    const target = normalizeTarget(input.target || readOption(args, '--target', '') || process.env.SKS_MAD_DB_TARGET || process.env.SKS_MAD_DB_E2E_TARGET || 'production');
+    const allowedSchemas = input.allowedSchemas?.length
+        ? input.allowedSchemas
+        : splitCsv(readOption(args, '--schema', readOption(args, '--schemas', process.env.SKS_MAD_DB_SCHEMAS || 'public')));
+    const blockers = [];
+    if (!projectRef)
+        blockers.push(candidates.length > 1 ? 'mad_db_project_ref_ambiguous' : 'mad_db_project_ref_missing');
+    return {
+        schema: 'sks.mad-db-target.v1',
+        project_ref: projectRef || null,
+        project_ref_hash: projectRef ? sha256(projectRef).slice(0, 16) : null,
+        target_environment: target,
+        allowed_schemas: allowedSchemas.length ? allowedSchemas : ['public'],
+        source: explicit ? 'explicit_or_environment' : candidates.length === 1 ? 'managed_config_single_candidate' : 'unresolved',
+        blockers,
+        candidates: candidates.map((candidate) => `${sha256(candidate).slice(0, 8)}:${candidate.slice(0, 2)}...`)
+    };
+}
+export async function projectRootHash(root) {
+    return sha256(path.resolve(root)).slice(0, 24);
+}
+async function projectRefCandidates(root) {
+    const files = ['.codex/config.toml', '.mcp.json', 'mcp.json', '.cursor/mcp.json', '.vscode/mcp.json'];
+    const out = new Set();
+    for (const rel of files) {
+        const file = path.join(root, rel);
+        if (!(await exists(file)))
+            continue;
+        const text = await readText(file, '');
+        for (const match of String(text).matchAll(/project_ref=([a-z0-9_-]+)/gi))
+            out.add(match[1] || '');
+        for (const match of String(text).matchAll(/project_ref["']?\s*[:=]\s*["']([a-z0-9_-]+)["']/gi))
+            out.add(match[1] || '');
+    }
+    return [...out].filter(Boolean);
+}
+function normalizeTarget(value) {
+    const text = String(value || '').toLowerCase();
+    if (text === 'local')
+        return 'local';
+    if (text === 'branch')
+        return 'branch';
+    if (text === 'preview')
+        return 'preview';
+    return 'production';
+}
+function splitCsv(value) {
+    return String(value || '').split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+function readOption(args, name, fallback) {
+    const index = args.indexOf(name);
+    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
+        return String(args[index + 1]);
+    const prefixed = args.find((arg) => String(arg).startsWith(`${name}=`));
+    return prefixed ? prefixed.slice(name.length + 1) : fallback;
+}
+//# sourceMappingURL=mad-db-target.js.map

package/dist/core/managed-assets/managed-assets-manifest.js

@@ -1,6 +1,6 @@
 import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 export const MANAGED_ASSET_SCHEMA_VERSION = 1;
-export const MANAGED_ASSET_VERSION = '4.1.1';
+export const MANAGED_ASSET_VERSION = '4.2.0';
 export const MANAGED_ASSET_MARKER = 'SKS-MANAGED-ASSET';
 export const MANAGED_AGENT_ROLES = Object.freeze([
     role('sks-explorer', 'analysis-scout.toml', 'analysis_scout', 'Read-only SKS analysis scout retained for stale Codex agent-role config repair.', 'read-only', ['analysis-scout', 'analysis_scout', 'native_agent']),

package/dist/core/pipeline-internals/runtime-core.js

@@ -22,6 +22,7 @@ import { SPEED_LANE_POLICY } from '../proof-field.js';
 import { validateRouteCompletionProof } from '../proof/route-proof-gate.js';
 import { routeFromState, routeRequiresCompletionProof } from '../proof/route-proof-policy.js';
 import { permissionGateSummary } from '../permission-gates.js';
+import { prepareMadDbMission } from '../mad-db/mad-db-coordinator.js';
 import { AGENT_INTAKE_STAGE_ID, AGENT_COUNT } from '../agents/agent-schema.js';
 import { normalizeAgentPolicy, routeRequiresAgentIntake, agentPipelineStage } from '../agents/agent-plan.js';
 import { readAgentGateStatus } from '../agents/agent-gate.js';
@@ -458,6 +459,8 @@ export function promptPipelineContext(prompt, route = null) {
         lines.push('AutoResearch route: load autoresearch-loop plus seo-geo-optimizer when SEO/GEO, discoverability, README, npm, GitHub stars, ranking, or AI-search visibility is relevant.');
     if (route?.id === 'DB')
         lines.push('DB route: scan/check database risk first; destructive DB operations remain forbidden.');
+    if (route?.id === 'MadDB')
+        lines.push('MadDB route: explicit invocation is the SQL-plane approval boundary. Use the mission-local write-capable Supabase MCP profile only for the bound cycle, verify execute_sql/apply_migration inventory before claiming ready, execute requested SQL-plane mutations, read back postconditions, then close the capability/profile and prove normal read-only restoration. Supabase project/account/billing/credential control-plane actions remain denied.');
     if (route?.id === 'GX')
         lines.push('GX route: use deterministic vgraph/beta render, validate, drift, and snapshot artifacts.');
     return lines.join('\n');
@@ -517,6 +520,8 @@ export async function prepareRoute(root, prompt, state = {}) {
         return withSkillDreamContext(await prepareGoal(root, route, task, routeNeedsContext7(route, cleanPrompt)), dreamContext);
     if (route.id === 'ImageUXReview')
         return withSkillDreamContext(await prepareImageUxReview(root, route, task, routeNeedsContext7(route, cleanPrompt)), dreamContext);
+    if (route.id === 'MadDB')
+        return withSkillDreamContext(await prepareMadDb(root, route, task, routeNeedsContext7(route, cleanPrompt)), dreamContext);
     const required = routeNeedsContext7(route, cleanPrompt);
     const reasoning = routeReasoning(route, cleanPrompt);
     const nativeSessionsRequired = routeRequiresSubagents(route, cleanPrompt);
@@ -1111,6 +1116,41 @@ async function prepareDb(root, route, task, required) {
     await setCurrent(root, routeState(id, route, 'DB_REVIEW_REQUIRED', required, { prompt: task, pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT }));
     return routeContext(route, id, task, required, 'Run sks db policy/scan/check as needed, keep DB operations read-only, record safe MCP policy, and pass db-review.json.');
 }
+async function prepareMadDb(root, route, task, required) {
+    const prepared = await prepareMadDbMission({ root, task, verifyTools: false });
+    const dir = missionDir(root, prepared.mission_id);
+    const pipelinePlan = await writePipelinePlan(dir, {
+        missionId: prepared.mission_id,
+        route,
+        task,
+        required,
+        ambiguity: { required: true, slots: 0, auto_sealed: true, passed: true, contract_hash: prepared.capability.operator_intent_hash }
+    });
+    await appendJsonl(path.join(dir, 'events.jsonl'), {
+        ts: nowIso(),
+        type: 'mad_db.route_prepared',
+        mission_id: prepared.mission_id,
+        cycle_id: prepared.cycle_id,
+        blockers: prepared.blockers
+    });
+    await setCurrent(root, routeState(prepared.mission_id, route, prepared.ok ? 'MADDB_SQL_PLANE_CAPABILITY_ACTIVE' : 'MADDB_BLOCKED', required, {
+        prompt: task,
+        questions_allowed: false,
+        implementation_allowed: prepared.ok,
+        ambiguity_gate_required: true,
+        ambiguity_gate_passed: true,
+        mad_db_active: prepared.ok,
+        mad_db_cycle_id: prepared.cycle_id,
+        mad_db_runtime_session_id: prepared.capability.runtime_session_id,
+        mad_db_profile_sha256: prepared.capability.transport.profile_sha256,
+        mad_db_capability_mission_id: prepared.mission_id,
+        mad_db_capability_file: 'mad-db-capability.json',
+        stop_gate: 'mad-db-gate.json',
+        pipeline_plan_ready: validatePipelinePlan(pipelinePlan).ok,
+        pipeline_plan_path: PIPELINE_PLAN_ARTIFACT
+    }));
+    return routeContext(route, prepared.mission_id, task, required, `MadDB mission/capability/profile were created atomically for cycle ${prepared.cycle_id}. Verify Supabase MCP tool inventory exposes execute_sql and apply_migration before claiming ready; after execution require read-back proof, finally close the profile/capability and prove read-only restoration.`);
+}
 async function prepareGx(root, route, task, required) {
     const { id, dir } = await createMission(root, { mode: 'gx', prompt: task });
     await writeJsonAtomic(path.join(dir, 'gx-gate.json'), { passed: false, vgraph_beta_render: false, validation: false, drift_snapshot: false, context7_evidence: false });

package/dist/core/providers/glm/bench/glm-benchmark-types.js

@@ -1,2 +1,2 @@
-export const GLM_BENCHMARK_VERSION = '4.1.1';
+export const GLM_BENCHMARK_VERSION = '4.2.0';
 //# sourceMappingURL=glm-benchmark-types.js.map

package/dist/core/release/release-gate-dag.js

@@ -28,15 +28,16 @@ export async function runReleaseGateDag(input) {
     const preset = input.preset || 'release';
     const manifest = loadReleaseGateManifest(root);
     const presetGates = selectReleaseGatePreset(manifest, preset);
-    const triwikiGraph = input.triwiki !== false && (preset === 'affected' || preset === 'fast' || preset === 'confidence') && input.full !== true
-        ? computeTriWikiAffectedGraph({ root, tier: preset === 'fast' ? 'affected' : 'confidence', changedSince: input.changedSince || 'auto', ...(input.changedFiles ? { changedFiles: input.changedFiles } : {}) })
-        : null;
     const affected = (preset === 'affected' || preset === 'fast' || preset === 'confidence') && input.full !== true
         ? selectAffectedReleaseGates(root, manifest, presetGates, { changedSince: input.changedSince || 'auto', ...(input.changedFiles ? { changedFiles: input.changedFiles } : {}), preset })
         : selectAffectedReleaseGates(root, manifest, presetGates, { full: true, preset });
+    const rootReleaseSurfaceChanged = affected.selection.changed_files.some((file) => file === 'package.json' || file === 'package-lock.json' || file === 'release-gates.v2.json');
+    const triwikiGraph = input.triwiki !== false && !rootReleaseSurfaceChanged && (preset === 'affected' || preset === 'fast' || preset === 'confidence') && input.full !== true
+        ? computeTriWikiAffectedGraph({ root, tier: preset === 'fast' ? 'affected' : 'confidence', changedSince: input.changedSince || 'auto', ...(input.changedFiles ? { changedFiles: input.changedFiles } : {}) })
+        : null;
     const triwikiSelectionUsed = Boolean(triwikiGraph);
     const triwikiConservative = Boolean(triwikiGraph?.conservative_reason);
-    const triwikiSelectedIds = new Set(triwikiGraph && !triwikiConservative ? triwikiGraph.gates : presetGates.map((gate) => gate.id));
+    const triwikiSelectedIds = new Set(triwikiGraph && !triwikiConservative ? triwikiGraph.gates : affected.gates.map((gate) => gate.id));
     const selected = triwikiGraph
         ? presetGates.filter((gate) => triwikiSelectedIds.has(gate.id))
         : affected.gates;
@@ -45,7 +46,7 @@ export async function runReleaseGateDag(input) {
         affected.selection.mode = 'affected';
         affected.selection.selected_gate_ids = selected.map((gate) => gate.id);
         affected.selection.skipped_gate_ids = triwikiSkippedGates;
-        affected.selection.reasons = Object.fromEntries(selected.map((gate) => [gate.id, triwikiConservative ? `triwiki_conservative:${triwikiGraph.conservative_reason}` : 'triwiki-affected']));
+        affected.selection.reasons = Object.fromEntries(selected.map((gate) => [gate.id, triwikiConservative ? `triwiki_conservative_fallback:${triwikiGraph.conservative_reason}` : 'triwiki-affected']));
     }
     const selectedIds = new Set(selected.map((gate) => gate.id));
     const affectedExternalSatisfiedDeps = affected.selection.mode === 'affected'

package/dist/core/routes.js

@@ -231,7 +231,7 @@ export function stackCurrentDocsPolicy(commandPrefix = 'sks') {
         validate_command: `${prefix} wiki validate .sneakoscope/wiki/context-pack.json`,
         priority: 'must_precede_coding_style_defaults',
         examples: [
-            'Supabase hosted projects should prefer sb_publishable_ and sb_secret_ keys over legacy anon/service_role keys when current docs apply.',
+            'Supabase hosted projects should prefer sb_publishable_ and sb_secret_ keys over legacy anon and service role keys when current docs apply.',
             'Next.js 16 deprecates the middleware file convention in favor of proxy.ts/proxy.js.',
             'Vercel Function duration limits, including the 300s default with Fluid Compute, are deployment constraints that must shape long-running server work.'
         ]
@@ -239,7 +239,7 @@ export function stackCurrentDocsPolicy(commandPrefix = 'sks') {
 }
 export function stackCurrentDocsPolicyText(commandPrefix = 'sks') {
     const policy = stackCurrentDocsPolicy(commandPrefix);
-    return `Stack current-docs policy: whenever project tech stack is added or a framework/package/runtime/platform version changes, fetch current docs with Context7 (resolve-library-id then query-docs) or official vendor web docs before coding, record the syntax/limits/security guidance as high-priority TriWiki claims in ${policy.memory_path}, run "${policy.refresh_command}", then "${policy.validate_command}". Treat these claims as higher priority than model-memory defaults. Examples include Supabase publishable/secret keys replacing legacy anon/service_role guidance for hosted projects, Next.js 16 proxy.ts/proxy.js replacing the deprecated middleware file convention, avoiding stale webpack defaults when newer framework guidance says otherwise, and Vercel Function duration limits such as the 300s default under Fluid Compute.`;
+    return `Stack current-docs policy: whenever project tech stack is added or a framework/package/runtime/platform version changes, fetch current docs with Context7 (resolve-library-id then query-docs) or official vendor web docs before coding, record the syntax/limits/security guidance as high-priority TriWiki claims in ${policy.memory_path}, run "${policy.refresh_command}", then "${policy.validate_command}". Treat these claims as higher priority than model-memory defaults. Examples include Supabase publishable/secret keys replacing legacy anon and service role guidance for hosted projects, Next.js 16 proxy.ts/proxy.js replacing the deprecated middleware file convention, avoiding stale webpack defaults when newer framework guidance says otherwise, and Vercel Function duration limits such as the 300s default under Fluid Compute.`;
 }
 export function triwikiContextTrackingText(commandPrefix = 'sks') {
     const ctx = triwikiContextTracking(commandPrefix);
@@ -549,21 +549,34 @@ export const ROUTES = [
         cliEntrypoint: 'sks db scan',
         examples: ['$DB check this migration safely']
     },
+    {
+        id: 'MadDB',
+        command: '$MAD-DB',
+        mode: 'MADDB',
+        route: 'first-class MadDB SQL-plane execution',
+        description: 'Explicit one-cycle MadDB route. When invoked by $MAD-DB or sks mad-db run|exec|apply-migration, SQL-plane mutations such as CREATE, ALTER, table/schema DROP, column add/drop/rename, INSERT, UPDATE, DELETE including all-row mutations, TRUNCATE, execute_sql, and apply_migration are authorized for the bound Supabase project and must be executed with tool-result plus read-back proof. Supabase project/account/billing/credential control-plane actions remain denied.',
+        requiredSkills: ['mad-db', 'db-safety-guard', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
+        appSkillAliases: ['mad-db'],
+        lifecycle: ['explicit_invocation', 'single_mission_capability_v2', 'ephemeral_write_profile', 'tool_inventory', 'execute_sql_or_apply_migration', 'read_back_verification', 'close_and_read_only_restore', 'post_route_reflection', 'honest_mode'],
+        context7Policy: 'required',
+        reasoningPolicy: 'xhigh',
+        stopGate: 'mad-db-gate.json',
+        cliEntrypoint: 'sks mad-db run|exec|apply-migration|status|close|revoke|doctor',
+        examples: ['$MAD-DB public.users legacy_code 컬럼 삭제', '$MAD-DB truncate public.staging_events']
+    },
     {
         id: 'MadSKS',
         command: '$MAD-SKS',
         mode: 'MADSKS',
         route: 'explicit scoped permission-widening modifier',
-        description: 'Explicit high-risk authorization modifier that can be combined with other $ commands to temporarily open approved target-project scopes such as files, shell, package installs, services, network, Computer Use/browser workflows, generated assets, file permissions, migrations, Supabase MCP DB writes, direct execute SQL, schema cleanup, and normal targeted DB writes for the active invocation, while preserving catastrophic wipe/all-row/project-management, credential-exfiltration, persistent security-weakening, and unrequested fallback safeguards.',
+        description: 'Explicit high-risk authorization modifier that can be combined with other $ commands to temporarily open approved target-project scopes such as files, shell, package installs, services, network, Computer Use/browser workflows, generated assets, file permissions, migrations, Supabase MCP DB writes, direct execute SQL, schema cleanup, and normal targeted DB writes for the active invocation, while preserving catastrophic wipe/all-row/project-management, credential-exfiltration, persistent security-weakening, and unrequested fallback safeguards. It is not the first-class MadDB destructive SQL-plane route.',
         requiredSkills: ['mad-sks', 'db-safety-guard', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
-        dollarAliases: ['$MAD-DB'],
-        appSkillAliases: ['mad-db'],
         lifecycle: ['explicit_invocation', 'auto_sealed_permission_scope', 'scoped_permission_override', 'catastrophic_guard', 'permission_deactivation', 'post_route_reflection', 'honest_mode'],
         context7Policy: 'required',
         reasoningPolicy: 'xhigh',
         stopGate: 'mad-sks-gate.json',
         cliEntrypoint: 'Codex App prompt route only: $MAD-SKS <task>',
-        examples: ['$MAD-SKS $Team target project maintenance with package/service/file and DB scopes', '$DB Supabase 점검 $MAD-SKS', '$MAD-DB enable one-cycle DB break-glass only after explicit ack']
+        examples: ['$MAD-SKS $Team target project maintenance with package/service/file and DB scopes', '$DB Supabase 점검 $MAD-SKS']
     },
     {
         id: 'GX',
@@ -964,6 +977,8 @@ export function routeRequiresSubagents(route, prompt = '') {
         return false;
     if (route.id === 'ImageUXReview')
         return false;
+    if (route.id === 'MadDB')
+        return false;
     if (route.id === 'Research' || route.id === 'AutoResearch')
         return true;
     if (route.id === 'Goal')
@@ -996,7 +1011,7 @@ export function simpleGitOnlyRouteId(prompt = '') {
 }
 export function reflectionRequiredForRoute(route) {
     const id = String(route?.id || route?.mode || route?.route || route || '').replace(/^\$/, '');
-    return /^(team|naruto|shadowclone|shadow-clone|kagebunshin|kage-bunshin|qaloop|qa-loop|ppt|imageuxreview|image-ux-review|research|autoresearch|db|database|madsks|mad-sks|gx)$/i.test(id);
+    return /^(team|naruto|shadowclone|shadow-clone|kagebunshin|kage-bunshin|qaloop|qa-loop|ppt|imageuxreview|image-ux-review|research|autoresearch|db|database|madsks|mad-sks|maddb|mad-db|gx)$/i.test(id);
 }
 export function looksLikeCodeChangingWork(prompt = '') {
     const text = String(prompt || '');
@@ -1038,7 +1053,7 @@ export function routeReasoning(route, prompt = '') {
     const base = ALLOWED_REASONING_EFFORTS.has(route?.reasoningPolicy) ? route.reasoningPolicy : 'medium';
     if (hasFromChatImgSignal(text))
         return reasoning('xhigh', 'from_chat_img_image_work_order_analysis');
-    if (/(?:^|\s)sks\s+--mad\b|(?:^|\s)--mad\b|\$MAD-SKS\b|\bmad-sks\b|\bmadsks\b/i.test(text))
+    if (/(?:^|\s)sks\s+--mad\b|(?:^|\s)--mad\b|\$MAD-SKS\b|\$MAD-DB\b|\bmad-sks\b|\bmadsks\b|\bmad-db\b|\bmaddb\b/i.test(text))
         return reasoning('xhigh', 'mad_sks_or_mad_launch_default');
     if (route?.id === 'Team' || route?.id === 'Naruto')
         return teamRouteReasoning(text);

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '4.1.1';
+export const PACKAGE_VERSION = '4.2.0';
 //# sourceMappingURL=version.js.map

package/dist/core/zellij/zellij-slot-column-anchor.js

@@ -115,7 +115,11 @@ function renderTelemetrySlotRows(snapshot) {
     });
 }
 function isMadDbActive(capability) {
-    if (!capability || capability.enabled !== true || capability.consumed === true)
+    if (!capability)
+        return false;
+    if (capability.schema === 'sks.mad-db-capability.v2' && !['transport_ready', 'active'].includes(String(capability.status || '')))
+        return false;
+    if (capability.schema !== 'sks.mad-db-capability.v2' && (capability.enabled !== true || capability.consumed === true))
         return false;
     const expires = Date.parse(capability.expires_at || '');
     return Number.isFinite(expires) && expires > Date.now();

package/dist/scripts/check-dist-runtime.js

@@ -8,6 +8,7 @@ import { sourceSnapshot } from './lib/ensure-dist-fresh.js';
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 const distRoot = path.join(root, 'dist');
 const issues = [];
+const contractOnlyMarker = 'contract' + '_only';
 if (!fs.existsSync(distRoot))
     issues.push('dist_missing');
 requiredFile('dist/bin/sks.js');
@@ -63,8 +64,8 @@ if (fs.existsSync(distRoot)) {
         if (!rel.endsWith('.js'))
             continue;
         const text = fs.readFileSync(file, 'utf8');
-        if (text.includes('contract_only'))
-            issues.push(`contract_only:${rel}`);
+        if (text.includes(contractOnlyMarker))
+            issues.push(`${contractOnlyMarker}:${rel}`);
         if (/from\s+['"][^'"]+\.mjs['"]|import\(\s*['"][^'"]+\.mjs['"]\s*\)/.test(text)) {
             issues.push(`imports_mjs:${rel}`);
         }

package/dist/scripts/codex-0142-manifest-check.js

@@ -8,11 +8,12 @@ const manifest = parity.manifest;
 const dep = pkg.dependencies?.['@openai/codex-sdk'];
 const lockSdk = lock.packages?.['node_modules/@openai/codex-sdk']?.version;
 const lockCli = lock.packages?.['node_modules/@openai/codex']?.version;
+const lockRootVersion = lock.packages?.['']?.version || lock.version;
 assertGate(parity.ok, 'Codex release manifest TS/JSON parity must hold', parity);
 assertGate(dep === manifest.sdkVersion, 'package.json must pin @openai/codex-sdk exactly to manifest sdkVersion', { dep, sdkVersion: manifest.sdkVersion });
 assertGate(lockSdk === manifest.sdkVersion, 'package-lock must resolve @openai/codex-sdk to manifest sdkVersion', { lockSdk, sdkVersion: manifest.sdkVersion });
 assertGate(lockCli === manifest.requiredCliVersion, 'package-lock must resolve @openai/codex to manifest requiredCliVersion', { lockCli, requiredCliVersion: manifest.requiredCliVersion });
-assertGate(pkg.version === '4.1.1', 'package version must be 4.1.1', { version: pkg.version });
+assertGate(pkg.version === lockRootVersion, 'package version must match package-lock root version', { version: pkg.version, lockRootVersion });
 emitGate('codex:0142:manifest', {
     manifest_sha256: parity.manifest_sha256,
     target_tag: manifest.targetTag,

package/dist/scripts/mad-db-capability-check.js

@@ -7,9 +7,20 @@ const missionMod = await importDist('core/mission.js');
 const capMod = await importDist('core/mad-db/mad-db-capability.js');
 const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-mad-db-cap-'));
 const mission = await missionMod.createMission(root, { mode: 'mad-db', prompt: 'fixture' });
-const cap = await capMod.createMadDbCapability(root, { missionId: mission.id, ack: capMod.MAD_DB_ACK, cwd: root });
+const cap = await capMod.createMadDbCapability(root, {
+    missionId: mission.id,
+    ack: capMod.MAD_DB_ACK,
+    cwd: root,
+    projectRef: 'fixture-project-ref',
+    runtimeSessionId: 'fixture-session',
+    profilePath: '.sneakoscope/missions/M/mad-db/runtime/codex-mad-db.config.toml',
+    profileSha256: 'fixture-profile-sha',
+    status: 'active'
+});
 assertGate(cap.schema === capMod.MAD_DB_CAPABILITY_SCHEMA, 'Mad-DB capability schema mismatch', cap);
-assertGate(cap.enabled === true && cap.one_cycle_only === true && cap.priority === 'highest', 'Mad-DB capability must be one-cycle highest priority', cap);
+assertGate(cap.legacy_compat?.one_cycle_only === true && cap.legacy_compat?.priority === 'highest', 'Mad-DB capability must retain legacy one-cycle priority metadata', cap);
+assertGate(cap.project_ref === 'fixture-project-ref' && cap.runtime_session_id === 'fixture-session' && cap.transport.profile_sha256 === 'fixture-profile-sha', 'Mad-DB capability v2 must bind project/session/profile', cap);
+assertGate(cap.scope.sql_plane === 'all_mutations' && cap.scope.control_plane === 'deny' && cap.scope.operations.includes('truncate'), 'Mad-DB capability v2 must authorize SQL-plane operation classes only', cap);
 assertGate(capMod.isMadDbCapabilityActive(cap) === true, 'Mad-DB capability must be active before consumption', cap);
 emitGate('mad-db:capability', { mission_id: mission.id, cycle_id: cap.cycle_id });
 //# sourceMappingURL=mad-db-capability-check.js.map

package/dist/scripts/mad-db-command-check.js

@@ -3,11 +3,13 @@ import { DOLLAR_COMMAND_ALIASES, DOLLAR_COMMANDS, routeByDollarCommand } from '.
 import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
 assertGate(readText('src/cli/command-registry.ts').includes("'mad-db'"), 'mad-db command must be registered');
 assertGate(readText('src/commands/mad-db.ts').includes('madDbCommand'), 'mad-db command wrapper missing');
-assertGate(readText('src/core/commands/mad-db-command.ts').includes('I AUTHORIZE ONE-CYCLE DB BREAK-GLASS'), 'mad-db command must require exact ack phrase');
+assertGate(readText('src/core/commands/mad-db-command.ts').includes('deprecated_enable_no_capability'), 'legacy mad-db enable must be deprecated and must not create capabilities');
 assertGate(DOLLAR_COMMANDS.some((entry) => entry.command === '$MAD-DB'), '$MAD-DB dollar command must be visible in sks dollar-commands');
-assertGate(DOLLAR_COMMAND_ALIASES.some((entry) => entry.canonical === '$MAD-SKS' && entry.app_skill === '$mad-db'), '$mad-db app skill alias must be visible in sks dollar-commands');
-assertGate(routeByDollarCommand('MAD-DB')?.command === '$MAD-SKS', '$MAD-DB must resolve to the MAD-SKS permission route');
-assertGate(routeByDollarCommand('mad-db')?.command === '$MAD-SKS', '$mad-db must resolve to the MAD-SKS permission route');
-assertGate(readText('src/core/init.ts').includes("'mad-db':") && readText('src/core/init.ts').includes('sks mad-db enable'), 'mad-db generated picker skill template missing');
+assertGate(DOLLAR_COMMAND_ALIASES.some((entry) => entry.canonical === '$MAD-DB' && entry.app_skill === '$mad-db'), '$mad-db app skill alias must point at first-class $MAD-DB');
+assertGate(routeByDollarCommand('MAD-DB')?.command === '$MAD-DB', '$MAD-DB must resolve to the first-class MadDB route');
+assertGate(routeByDollarCommand('mad-db')?.command === '$MAD-DB', '$mad-db must resolve to the first-class MadDB route');
+const initText = readText('src/core/init.ts');
+assertGate(initText.includes("'mad-db':") && initText.includes('madDbSkillText()') && initText.includes('dbSafetyGuardSkillText()'), 'mad-db generated picker skill template must come from typed SSOT');
+assertGate(readText('src/core/commands/mad-db-command.ts').includes('run|exec|apply-migration'), 'mad-db command must expose execution subcommands');
 emitGate('mad-db:command', { command: 'sks mad-db', dollar_command: '$MAD-DB', app_skill_alias: '$mad-db' });
 //# sourceMappingURL=mad-db-command-check.js.map

package/dist/scripts/mad-db-hook-idempotency-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createMission } from '../core/mission.js';
+import { checkDbOperation } from '../core/db-safety.js';
+import { createMadDbCapability, MAD_DB_ACK, readMadDbCapability } from '../core/mad-db/mad-db-capability.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-mad-db-idempotency-'));
+const mission = await createMission(root, { mode: 'mad-db', prompt: 'idempotency fixture' });
+await createMadDbCapability(root, { missionId: mission.id, ack: MAD_DB_ACK, cwd: root, projectRef: 'fixture-project-ref', status: 'active' });
+const payload = { tool_name: 'supabase.execute_sql', tool_call_id: 'canonical-call-id-1', sql: 'delete from public.fixture;' };
+const first = await checkDbOperation(root, { mission_id: mission.id }, payload);
+const second = await checkDbOperation(root, { mission_id: mission.id }, payload);
+const cap = await readMadDbCapability(root, mission.id);
+assertGate(first.allowed === true && second.allowed === true, 'same canonical call should be allowed while active', { first, second });
+assertGate(first.mad_db.operation_id === second.mad_db.operation_id, 'same canonical tool_call_id must map to the same operation', { first, second });
+assertGate(second.mad_db.idempotent_reservation_reused === true, 'second reservation must be marked reused', second);
+assertGate(Boolean(cap) && cap.counters.attempts === 1 && cap.counters.reserved === 1, 'PreToolUse/PermissionRequest duplicate handling must not double-count one call', cap || {});
+emitGate('mad-db:hook-idempotency', { operation_id: first.mad_db.operation_id, counters: cap.counters });
+//# sourceMappingURL=mad-db-hook-idempotency-check.js.map

package/dist/scripts/mad-db-ledger-check.js

@@ -2,6 +2,7 @@
 import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
 const ledger = readText('src/core/mad-db/mad-db-ledger.ts');
 const cap = readText('src/core/mad-db/mad-db-capability.ts');
-assertGate(ledger.includes('mad-db-ledger.jsonl') && cap.includes('capability.consumed'), 'Mad-DB ledger must record lifecycle and consumption events');
+assertGate(ledger.includes('mad-db-ledger.jsonl') && cap.includes('mad-db-capability.closed.json'), 'Mad-DB ledger must record lifecycle and closed capability events');
+assertGate(!ledger.includes('unknown_pending_tool_result'), 'Mad-DB ledger must not use old pending-latest fallback wording');
 emitGate('mad-db:ledger', { file: 'mad-db-ledger.jsonl' });
 //# sourceMappingURL=mad-db-ledger-check.js.map

package/dist/scripts/mad-db-lifecycle-hook-decision-check.js

@@ -5,13 +5,14 @@ import os from 'node:os';
 import path from 'node:path';
 import { checkDbOperation, madDbLifecycleHookFromDecision } from '../core/db-safety.js';
 import { createMadDbCapability, MAD_DB_ACK } from '../core/mad-db/mad-db-capability.js';
+import { createMission } from '../core/mission.js';
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-db-hook-decision-'));
-const missionId = 'M-mad-db-hook-decision';
-await createMadDbCapability(root, { missionId, ack: MAD_DB_ACK, ttlMs: 60000 });
-const decision = await checkDbOperation(root, { mission_id: missionId }, { tool_name: 'supabase.execute_sql', sql: 'insert into audit_log(id) values (1)' });
+const mission = await createMission(root, { mode: 'mad-db', prompt: 'hook fixture' });
+await createMadDbCapability(root, { missionId: mission.id, ack: MAD_DB_ACK, ttlMs: 60000, projectRef: 'fixture-project-ref', status: 'active' });
+const decision = await checkDbOperation(root, { mission_id: mission.id }, { tool_name: 'supabase.execute_sql', tool_call_id: 'hook-decision-call-1', sql: 'insert into audit_log(id) values (1)' });
 const hook = madDbLifecycleHookFromDecision(decision);
 assertGate(decision.allowed === true && decision.mad_db?.lifecycle_result_pending === true, 'Mad-DB decision must mark pending lifecycle result', decision);
-assertGate(Boolean(hook?.mission_id === missionId && hook?.operation_id && hook?.cycle_id && hook?.tool_name), 'Mad-DB decision must expose ledger result hook', { decision, hook });
+assertGate(Boolean(hook?.mission_id === mission.id && hook?.operation_id && hook?.tool_call_id === 'hook-decision-call-1' && hook?.cycle_id && hook?.tool_name), 'Mad-DB decision must expose canonical tool_call_id ledger result hook', { decision, hook });
 emitGate('mad-db:lifecycle-hook-decision', { operation_id: hook.operation_id, cycle_id: hook.cycle_id });
 //# sourceMappingURL=mad-db-lifecycle-hook-decision-check.js.map

package/dist/scripts/mad-db-mad-command-check.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { madHighCommand } from '../core/commands/mad-sks-command.js';
+import { madHighCommand, resolveMadLaunchMadDbGrant } from '../core/commands/mad-sks-command.js';
 import { checkDbOperation } from '../core/db-safety.js';
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 const original = {
@@ -53,27 +53,29 @@ try {
     assertGate(launch?.ok === true && launch.status === 'headless-fallback', 'sks --mad fixture launch must complete headless', launch);
     const state = await readJson(path.join(tmp, '.sneakoscope', 'state', 'current.json'));
     assert.equal(state.mad_sks_active, true);
-    assert.equal(state.mad_db_active, true);
-    assert.equal(state.mad_db_grant_source, 'sks_mad_default');
-    assert.equal(state.mad_db_priority_override_active, true);
+    assert.notEqual(state.mad_db_active, true);
+    assert.notEqual(state.mad_db_grant_source, 'sks_mad_default');
+    assert.notEqual(state.mad_db_priority_override_active, true);
     const missionDir = path.join(tmp, '.sneakoscope', 'missions', state.mission_id);
-    const grants = await readJson(path.join(missionDir, 'mad-sks-launch-grants.json'));
-    const capability = await readJson(path.join(missionDir, 'mad-db-capability.json'));
-    assert.equal(grants.mad_sks_active, true);
-    assert.equal(grants.mad_db_active, true);
-    assert.equal(grants.mad_db_default_grant, true);
-    assert.equal(capability.enabled, true);
-    assert.equal(capability.one_cycle_only, true);
-    assert.equal(capability.consumed, false);
+    await assertMissing(path.join(missionDir, 'mad-db-capability.json'), 'bare sks --mad must not create a MadDB capability');
+    await assertMissing(path.join(missionDir, 'mad-sks-launch-grants.json'), 'bare sks --mad must not create MadDB grant artifacts');
     const decision = await checkDbOperation(tmp, state, {
         tool_name: 'supabase.execute_sql',
-        sql: "insert into sks_mad_db_probe(message) values ('default grant proof');"
+        tool_call_id: 'mad-sks-default-does-not-open-maddb',
+        sql: 'truncate sks_mad_db_probe;'
     });
-    assertGate(decision.allowed === true && decision.mad_db?.active === true, 'sks --mad default MAD-DB grant must satisfy DB mutation policy locally', decision);
+    assertGate(decision.allowed === false && decision.mad_db?.active !== true, 'sks --mad default must not satisfy MadDB mutation policy locally', decision);
+    const defaultGrant = resolveMadLaunchMadDbGrant([]);
+    const explicitGrant = resolveMadLaunchMadDbGrant(['--mad-db']);
+    assert.equal(defaultGrant.enabled, false);
+    assert.equal(defaultGrant.requested, false);
+    assert.equal(explicitGrant.enabled, false);
+    assert.equal(explicitGrant.requested, true);
+    assert.equal(explicitGrant.source, 'mad_db_first_class_route_required');
     emitGate('mad-db:mad-command', {
         mission_id: state.mission_id,
-        grant_source: state.mad_db_grant_source,
-        cycle_id: capability.cycle_id
+        default_mad_db_active: state.mad_db_active === true,
+        explicit_flag_source: explicitGrant.source
     });
 }
 finally {
@@ -91,6 +93,17 @@ finally {
 async function readJson(file) {
     return JSON.parse(await fs.readFile(file, 'utf8'));
 }
+async function assertMissing(file, message) {
+    try {
+        await fs.access(file);
+        assertGate(false, message, { file });
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return;
+        throw err;
+    }
+}
 function restoreEnv(key, value) {
     if (value == null)
         delete process.env[key];

package/dist/scripts/mad-db-mcp-result-lifecycle-check.js

@@ -6,25 +6,26 @@ import path from 'node:path';
 import { checkDbOperation, madDbLifecycleHookFromDecision } from '../core/db-safety.js';
 import { evaluateHookPayload } from '../core/hooks-runtime.js';
 import { createMadDbCapability, MAD_DB_ACK } from '../core/mad-db/mad-db-capability.js';
-import { missionDir } from '../core/mission.js';
+import { createMission, missionDir } from '../core/mission.js';
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-db-mcp-result-'));
-const missionId = 'M-mad-db-mcp-result';
-await createMadDbCapability(root, { missionId, ack: MAD_DB_ACK, ttlMs: 60000 });
-const successPayload = { tool_name: 'supabase.execute_sql', sql: 'insert into audit_log(id) values (1)' };
-const successDecision = await checkDbOperation(root, { mission_id: missionId }, successPayload);
+const mission = await createMission(root, { mode: 'mad-db', prompt: 'mcp result fixture' });
+await createMadDbCapability(root, { missionId: mission.id, ack: MAD_DB_ACK, ttlMs: 60000, projectRef: 'fixture-project-ref', status: 'active' });
+const successPayload = { tool_name: 'supabase.execute_sql', tool_call_id: 'mcp-success-call', sql: 'insert into audit_log(id) values (1)' };
+const successDecision = await checkDbOperation(root, { mission_id: mission.id }, successPayload);
 const successHook = madDbLifecycleHookFromDecision(successDecision);
 assertGate(Boolean(successHook), 'Mad-DB lifecycle hook missing before post-tool success result', successDecision);
-await evaluateHookPayload('post-tool', { tool_name: successPayload.tool_name, success: true, row_count: 1 }, { root, state: { mission_id: missionId } });
-const failurePayload = { tool_name: 'supabase.execute_sql', sql: 'update audit_log set id = 2 where id = 1' };
-const failureDecision = await checkDbOperation(root, { mission_id: missionId }, failurePayload);
+await evaluateHookPayload('post-tool', { tool_name: successPayload.tool_name, tool_call_id: successHook.tool_call_id, success: true, row_count: 1 }, { root, state: { mission_id: mission.id } });
+const failurePayload = { tool_name: 'supabase.execute_sql', tool_call_id: 'mcp-failure-call', sql: 'update audit_log set id = 2 where id = 1' };
+const failureDecision = await checkDbOperation(root, { mission_id: mission.id }, failurePayload);
 const failureHook = madDbLifecycleHookFromDecision(failureDecision);
 assertGate(Boolean(failureHook), 'Mad-DB lifecycle hook missing before post-tool MCP isError result', failureDecision);
 await evaluateHookPayload('post-tool', {
     tool_name: failurePayload.tool_name,
+    tool_call_id: failureHook.tool_call_id,
     result: { isError: true, content: [{ type: 'text', text: 'fixture MCP error' }] }
-}, { root, state: { mission_id: missionId } });
-const ledger = await fs.readFile(path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl'), 'utf8');
+}, { root, state: { mission_id: mission.id } });
+const ledger = await fs.readFile(path.join(missionDir(root, mission.id), 'mad-db-ledger.jsonl'), 'utf8');
 assertGate(ledger.includes('db_operation.succeeded') && ledger.includes('db_operation.failed') && ledger.includes('fixture MCP error'), 'PostToolUse must append succeeded and MCP isError failed lifecycle events', { ledger });
 emitGate('mad-db:mcp-result-lifecycle', { success_operation_id: successHook.operation_id, failure_operation_id: failureHook.operation_id, status: 'succeeded_and_failed_checked' });
 //# sourceMappingURL=mad-db-mcp-result-lifecycle-check.js.map

package/dist/scripts/mad-db-one-cycle-bounded-check.js

@@ -3,25 +3,22 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { closeMadDbCycle, createMadDbCapability, MAD_DB_ACK, readMadDbCapability } from '../core/mad-db/mad-db-capability.js';
+import { closeMadDbCycle, createMadDbCapability, isMadDbCapabilityActive, MAD_DB_ACK, readMadDbCapability } from '../core/mad-db/mad-db-capability.js';
 import { checkDbOperation } from '../core/db-safety.js';
+import { createMission } from '../core/mission.js';
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-mad-db-bounded-'));
-const missionId = 'M-mad-db-bounded';
-process.env.SKS_MAD_DB_MAX_OPERATIONS = '2';
-const cap = await createMadDbCapability(root, { missionId, ack: MAD_DB_ACK, ttlMs: 60000 });
-assertGate(cap.max_operations >= 2 && cap.operation_count === 0, 'capability must start as bounded one-cycle', cap);
-const payload = { tool_name: 'supabase.execute_sql', sql: 'update users set flag = true where id = 1' };
-const first = await checkDbOperation(root, { mission_id: missionId }, payload);
-const afterFirst = await readMadDbCapability(root, missionId);
-assertGate(first.allowed === true && afterFirst.operation_count === 1 && afterFirst.consumed === false, 'capability must remain active after operation 1 when max_operations > 1', { first, afterFirst });
-const second = await checkDbOperation(root, { mission_id: missionId }, payload);
-const afterSecond = await readMadDbCapability(root, missionId);
-assertGate(second.allowed === true && afterSecond.operation_count === 2 && afterSecond.consumed === true, 'capability must be consumed when operation_count reaches max_operations', { second, afterSecond });
-const closeMissionId = 'M-mad-db-close-cycle';
-process.env.SKS_MAD_DB_MAX_OPERATIONS = '20';
-const closeCap = await createMadDbCapability(root, { missionId: closeMissionId, ack: MAD_DB_ACK, ttlMs: 60000 });
-const closed = await closeMadDbCycle(root, closeMissionId, closeCap.cycle_id);
-assertGate(closed?.consumed === true && closed?.consumed_by === 'mad-db-cycle-close', 'explicit cycle close must consume active capability', closed);
-emitGate('mad-db:one-cycle-bounded', { cycle_id: cap.cycle_id, operation_count: afterSecond.operation_count, max_operations: afterSecond.max_operations, close_cycle: closed?.consumed === true });
+const mission = await createMission(root, { mode: 'mad-db', prompt: 'bounded fixture' });
+const cap = await createMadDbCapability(root, { missionId: mission.id, ack: MAD_DB_ACK, ttlMs: 60000, projectRef: 'fixture-project-ref', status: 'active' });
+assertGate(isMadDbCapabilityActive(cap) === true && Date.parse(cap.expires_at) > Date.now(), 'capability must start active with bounded TTL', cap);
+const payload = { tool_name: 'supabase.execute_sql', tool_call_id: 'bounded-call-1', sql: 'update users set flag = true where id = 1' };
+const first = await checkDbOperation(root, { mission_id: mission.id }, payload);
+const afterFirst = await readMadDbCapability(root, mission.id);
+assertGate(first.allowed === true && afterFirst.counters.reserved === 1 && afterFirst.status === 'active', 'capability must reserve one operation and remain active before final close', { first, afterFirst });
+const second = await checkDbOperation(root, { mission_id: mission.id }, payload);
+const afterSecond = await readMadDbCapability(root, mission.id);
+assertGate(second.allowed === true && second.mad_db?.idempotent_reservation_reused === true && afterSecond.counters.reserved === 1, 'same canonical tool_call_id must be idempotent and not double-counted', { second, afterSecond });
+const closed = await closeMadDbCycle(root, mission.id, cap.cycle_id);
+assertGate(closed?.status === 'closed' && isMadDbCapabilityActive(closed) === false, 'explicit cycle close must deactivate active capability', closed);
+emitGate('mad-db:one-cycle-bounded', { cycle_id: cap.cycle_id, reserved: afterSecond.counters.reserved, close_cycle: closed?.status === 'closed' });
 //# sourceMappingURL=mad-db-one-cycle-bounded-check.js.map

package/dist/scripts/mad-db-one-cycle-consumption-check.js

@@ -7,10 +7,10 @@ const missionMod = await importDist('core/mission.js');
 const capMod = await importDist('core/mad-db/mad-db-capability.js');
 const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-mad-db-consume-'));
 const mission = await missionMod.createMission(root, { mode: 'mad-db', prompt: 'fixture' });
-const cap = await capMod.createMadDbCapability(root, { missionId: mission.id, ack: capMod.MAD_DB_ACK, cwd: root });
+const cap = await capMod.createMadDbCapability(root, { missionId: mission.id, ack: capMod.MAD_DB_ACK, cwd: root, projectRef: 'fixture-project-ref', status: 'active' });
 await capMod.consumeMadDbCapability(root, mission.id, { consumedBy: 'fixture' });
 const consumed = await capMod.readMadDbCapability(root, mission.id);
-assertGate(capMod.isMadDbCapabilityActive(consumed) === false && consumed.consumed === true, 'Mad-DB capability must be inactive after consumption', consumed);
-assertGate(fs.existsSync(path.join(root, '.sneakoscope', 'missions', mission.id, 'mad-db-capability.consumed.json')), 'consumed proof artifact missing');
+assertGate(capMod.isMadDbCapabilityActive(consumed) === false && consumed.status === 'closed' && Boolean(consumed.closed_at), 'Mad-DB capability must be inactive after close/consumption compatibility call', consumed);
+assertGate(fs.existsSync(path.join(root, '.sneakoscope', 'missions', mission.id, 'mad-db-capability.closed.json')), 'closed proof artifact missing');
 emitGate('mad-db:one-cycle-consumption', { cycle_id: cap.cycle_id });
 //# sourceMappingURL=mad-db-one-cycle-consumption-check.js.map