sneakoscope 2.0.14 → 2.0.15

package/dist/core/commands/mad-sks-command.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { spawn } from 'node:child_process';
-import { appendJsonlBounded, exists, nowIso, packageRoot, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
+import { PACKAGE_VERSION, appendJsonlBounded, exists, nowIso, packageRoot, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { initProject } from '../init.js';
 import { createMission, setCurrent } from '../mission.js';
 import { buildMadHighLaunchProfileNoWrite, madHighProfileName } from '../auto-review.js';
@@ -18,6 +18,8 @@ import { applyMadSksRollbackPlan } from '../mad-sks/rollback-apply.js';
 import { repairCodexConfigEperm } from '../codex/codex-config-eperm-repair.js';
 import { runCodexLaunchPreflight } from '../preflight/parallel-preflight-engine.js';
 import { diffCodexAppUiSnapshots, writeCodexAppUiSnapshot } from '../codex-app/codex-app-ui-state-snapshot.js';
+import { checkSksUpdateNotice } from '../update/update-notice.js';
+import { createMadDbCapability, MAD_DB_ACK } from '../mad-db/mad-db-capability.js';
 export async function madHighCommand(args = [], deps = {}) {
     const subcommand = firstSubcommand(args);
     if (subcommand)
@@ -27,16 +29,7 @@ export async function madHighCommand(args = [], deps = {}) {
         const profile = buildMadHighLaunchProfileNoWrite();
         return console.log(JSON.stringify(profile, null, 2));
     }
-    const update = deps.maybePromptSksUpdateForLaunch ? await deps.maybePromptSksUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
-    if (update.status === 'updated') {
-        console.log(`SKS updated from ${deps.packageVersion} to ${update.latest}. Rerun: sks --mad`);
-        return;
-    }
-    if (update.status === 'failed') {
-        console.error(`SKS update failed: ${update.error}`);
-        process.exitCode = 1;
-        return;
-    }
+    const update = { status: 'notice_only', non_blocking: true };
     const codexUpdate = deps.maybePromptCodexUpdateForLaunch ? await deps.maybePromptCodexUpdateForLaunch(args, { label: 'MAD launch' }) : { status: 'skipped' };
     if (codexUpdate.status === 'failed' || codexUpdate.status === 'updated_not_reflected') {
         console.error(`Codex CLI update failed: ${codexUpdate.error || 'updated version was not visible on PATH'}`);
@@ -68,6 +61,13 @@ export async function madHighCommand(args = [], deps = {}) {
     // readability + repair checks still run. SKS_LAUNCH_FULL_CODEX_PROBE=1 restores the
     // old behavior.
     const rawArgs = (args || []).map((arg) => String(arg));
+    const madDbRequested = rawArgs.includes('--mad-db');
+    const madDbAck = readOption(rawArgs, '--ack', '');
+    if (madDbRequested && madDbAck !== MAD_DB_ACK) {
+        console.error(`SKS MAD-DB launch blocked. Required --ack ${JSON.stringify(MAD_DB_ACK)}`);
+        process.exitCode = 2;
+        return { ok: false, status: 'blocked', reason: 'mad_db_ack_phrase_required', required_ack: MAD_DB_ACK };
+    }
     const allowMadRepair = rawArgs.includes('--repair-config') || rawArgs.includes('--fix') || rawArgs.includes('--yes-repair');
     const launchPreflight = await runCodexLaunchPreflight(launchRoot, { fix: allowMadRepair, launchFast: process.env.SKS_LAUNCH_FULL_CODEX_PROBE !== '1', profile: profile.profile_name, sandbox: 'danger-full-access', serviceTier: 'fast' });
     const afterPreflightUi = beforeUi ? await writeCodexAppUiSnapshot(launchRoot, `mad-after-preflight-${uiSnapshotId}`).catch(() => null) : null;
@@ -88,7 +88,41 @@ export async function madHighCommand(args = [], deps = {}) {
         return launchPreflight;
     }
     const madLaunch = await activateMadZellijPermissionState(process.cwd(), args);
+    const madDbCapability = madDbRequested
+        ? await createMadDbCapability(madLaunch.root, { missionId: madLaunch.mission_id, ack: madDbAck, cwd: process.cwd() })
+        : null;
+    if (madDbCapability) {
+        await setCurrent(madLaunch.root, {
+            mission_id: madLaunch.mission_id,
+            mad_db_active: true,
+            mad_db_cycle_id: madDbCapability.cycle_id,
+            mad_db_capability_file: 'mad-db-capability.json',
+            mad_db_break_glass: true
+        });
+        await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_db.capability_created', cycle_id: madDbCapability.cycle_id, expires_at: madDbCapability.expires_at });
+    }
+    const updateNotice = await checkSksUpdateNotice({
+        packageName: deps.packageName || 'sneakoscope',
+        currentVersion: deps.packageVersion || PACKAGE_VERSION,
+        missionDir: madLaunch.dir
+    }).catch((err) => ({
+        schema: 'sks.update-notice.v1',
+        checked_at: nowIso(),
+        package_name: deps.packageName || 'sneakoscope',
+        current_version: deps.packageVersion || PACKAGE_VERSION,
+        latest_version: null,
+        update_available: false,
+        source: 'error',
+        cache_ttl_ms: 0,
+        message: 'SKS update notice check failed; MAD launch continues.',
+        error: err?.message || String(err)
+    }));
+    await appendJsonlBounded(path.join(madLaunch.dir, 'events.jsonl'), { ts: nowIso(), type: 'mad_sks.update_notice_checked', non_blocking: true, update_available: updateNotice.update_available === true, source: updateNotice.source });
     console.log(`SKS MAD ready: ${madHighProfileName()} | gate ${madLaunch.mission_id}`);
+    if (madDbCapability)
+        console.log(`MAD-DB one-cycle capability active; expires ${madDbCapability.expires_at}.`);
+    if (updateNotice.update_available === true)
+        console.log(`SKS update notice: ${updateNotice.latest_version} available (non-blocking).`);
     console.log('Scoped high-power maintenance authority active; add explicit --allow-* flags for packages, services, network, browser/Computer Use, generated assets, file permissions, DB writes, or system/admin scopes. Catastrophic guards remain.');
     const launchLb = lb.status === 'present' ? { ...lb, status: 'configured' } : lb;
     const madSksEnv = {
@@ -445,6 +479,7 @@ function madLaunchOnlyFlags() {
         '--allow-file-permissions',
         '--allow-chmod',
         '--allow-delete',
+        '--mad-db',
         '--confirm-delete',
         '--confirm-destructive-delete',
         '--no-swarm',
@@ -460,7 +495,8 @@ function madLaunchOnlyFlags() {
         '--yes',
         '-y',
         '--dry-run',
-        '--plan-only'
+        '--plan-only',
+        '--ack'
     ]);
 }
 function madLaunchValueFlags() {
@@ -469,7 +505,8 @@ function madLaunchValueFlags() {
         '--mad-swarm-agents',
         '--mad-swarm-work-items',
         '--mad-swarm-backend',
-        '--mad-swarm-prompt'
+        '--mad-swarm-prompt',
+        '--ack'
     ]);
 }
 export function defaultMadSwarmBackend(args = [], opts = {}) {

package/dist/core/commands/naruto-command.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { createMission, findLatestMission, loadMission } from '../mission.js';
+import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
 import { nowIso, readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { classifyOllamaWorkerSlice } from '../agents/agent-runner-ollama.js';
@@ -235,6 +235,51 @@ async function narutoRun(parsed) {
         placeholderGuard,
         gitWorktreeCapability
     });
+    await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
+        schema: 'sks.naruto-gate.v1',
+        passed: false,
+        mission_id: mission.id,
+        clone_roster_built: true,
+        clone_count: roster.agent_count,
+        work_graph_ready: workGraph.ok === true,
+        role_distribution_ready: roleDistribution.ok === true,
+        allocation_ready: allocationPolicy.ok === true,
+        rebalance_ready: rebalancePolicy.ok === true,
+        concurrency_governor_ready: true,
+        active_pool_simulated: activePool.ok === true,
+        verification_dag_ready: true,
+        gpt_final_pack_ready: true,
+        zellij_dashboard_ready: zellijDashboard.ok === true,
+        native_agent_proof: false,
+        final_arbiter_accepted: false,
+        session_cleanup: false,
+        blockers: [],
+        updated_at: nowIso()
+    });
+    await setCurrent(root, {
+        mission_id: mission.id,
+        route: 'Naruto',
+        route_command: '$Naruto',
+        mode: 'NARUTO',
+        phase: 'NARUTO_NATIVE_AGENT_INTAKE',
+        questions_allowed: false,
+        implementation_allowed: true,
+        context7_required: false,
+        context7_verified: parsed.mock,
+        subagents_required: true,
+        subagents_verified: false,
+        native_sessions_required: true,
+        native_sessions_verified: false,
+        reflection_required: true,
+        visible_progress_required: true,
+        required_skills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
+        stop_gate: 'naruto-gate.json',
+        clone_count: roster.agent_count,
+        target_active_slots: activeSlots,
+        work_graph_ready: workGraph.ok === true,
+        naruto_gate_file: 'naruto-gate.json',
+        prompt: parsed.prompt
+    });
     let liveZellij = null;
     if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
         liveZellij = await launchZellijLayout({
@@ -311,6 +356,41 @@ async function narutoRun(parsed) {
         narutoRebalancePolicy: rebalancePolicy,
         json: parsed.json
     });
+    const nativeProofOk = result.proof?.ok === true || result.proof?.status === 'passed';
+    const finalAccepted = result.proof?.status === 'passed' || result.proof?.gpt_final_status === 'approved';
+    await writeJsonAtomic(path.join(mission.dir, 'naruto-gate.json'), {
+        schema: 'sks.naruto-gate.v1',
+        passed: result.ok === true && nativeProofOk && finalAccepted,
+        mission_id: mission.id,
+        clone_roster_built: true,
+        clone_count: roster.agent_count,
+        work_graph_ready: workGraph.ok === true,
+        role_distribution_ready: roleDistribution.ok === true,
+        allocation_ready: allocationPolicy.ok === true,
+        rebalance_ready: rebalancePolicy.ok === true,
+        concurrency_governor_ready: true,
+        active_pool_simulated: activePool.ok === true,
+        verification_dag_ready: true,
+        gpt_final_pack_ready: true,
+        zellij_dashboard_ready: zellijDashboard.ok === true,
+        native_agent_proof: nativeProofOk,
+        final_arbiter_accepted: finalAccepted,
+        session_cleanup: result.proof?.all_sessions_closed === true || nativeProofOk,
+        blockers: result.proof?.blockers || [],
+        updated_at: nowIso()
+    });
+    await setCurrent(root, {
+        mission_id: mission.id,
+        route: 'Naruto',
+        route_command: '$Naruto',
+        mode: 'NARUTO',
+        phase: result.ok === true ? 'NARUTO_COMPLETE_OR_REVIEW' : 'NARUTO_BLOCKED',
+        native_sessions_verified: nativeProofOk,
+        subagents_verified: nativeProofOk,
+        naruto_gate_file: 'naruto-gate.json',
+        stop_gate: 'naruto-gate.json',
+        prompt: parsed.prompt
+    });
     const clones = result.roster?.agent_count ?? roster.agent_count;
     const localWorkerSummary = summarizeNarutoLocalWorkerResult(localWorker, result);
     const summary = {

package/dist/core/commands/research-command.js

@@ -277,8 +277,10 @@ async function researchRun(args) {
 }
 function printResearchCompletion(id, root, dir, plan, gate) {
     const metrics = gate?.metrics || {};
+    const synthesis = metrics.synthesis || {};
     const rel = (artifact) => path.relative(root, path.join(dir, artifact));
     console.log(`Research done: ${id}`);
+    console.log(`Synthesis: ${synthesis.writer || 'missing'}`);
     console.log(`Report: ${rel('research-report.md')}`);
     console.log(`Paper: ${rel(researchPaperArtifactForPlan(plan))}`);
     console.log(`Implementation blueprint: ${rel('implementation-blueprint.json')}`);
@@ -286,7 +288,8 @@ function printResearchCompletion(id, root, dir, plan, gate) {
     console.log(`Experiment plan: ${rel('experiment-plan.json')}`);
     console.log(`Replication pack: ${rel('replication-pack.json')}`);
     console.log(`Gate: ${gate?.passed ? 'passed' : 'blocked'}`);
-    console.log(`Quality: ${metrics.source_entries_total_with_counterevidence ?? metrics.source_entries ?? 0} sources / ${metrics.source_layers_covered ?? 0} layers / ${metrics.key_claims ?? 0} key claims / ${metrics.falsification_cases ?? 0} falsification cases`);
+    console.log(`Quality: ${metrics.report_word_count ?? 0} words / ${metrics.source_entries_total_with_counterevidence ?? metrics.source_entries ?? 0} sources / ${metrics.key_claims ?? 0} key claims / repetition ${synthesis.repetition_ratio ?? metrics.report_repetition?.repeated_paragraph_ratio ?? 'n/a'}`);
+    console.log(`Final review: static ${metrics.final_review_blockers?.length ? 'block' : 'pass'} / codex ${synthesis.codex_final_review_verdict || 'missing'}`);
     console.log(`Handoff: ${rel('team-handoff-goal.md')}`);
 }
 async function researchStatus(args) {
@@ -320,6 +323,7 @@ async function researchStatus(args) {
     const experimentPlan = await readExperimentPlan(dir);
     const replicationPack = await readReplicationPack(dir);
     const finalReview = await readResearchFinalReview(dir);
+    const synthesisOutput = await readJson(path.join(dir, 'research-synthesis-output.json'), null);
     const blueprintValidation = validateImplementationBlueprint(implementationBlueprint, qualityContract);
     const experimentValidation = validateExperimentPlan(experimentPlan, qualityContract);
     const replicationValidation = validateReplicationPack(replicationPack);
@@ -356,6 +360,14 @@ async function researchStatus(args) {
         research_quality: {
             contract: qualityContract,
             report_word_count: gate?.metrics?.report_word_count ?? null,
+            synthesis: {
+                writer: gate?.metrics?.synthesis?.writer ?? (synthesisOutput ? 'evidence-bound writer artifact present' : null),
+                repetition_ratio: gate?.metrics?.synthesis?.repetition_ratio ?? gate?.metrics?.report_repetition?.repeated_paragraph_ratio ?? null,
+                source_density_per_1000_words: gate?.metrics?.synthesis?.source_density_per_1000_words ?? gate?.metrics?.source_density_per_1000_words ?? null,
+                claim_density_per_1000_words: gate?.metrics?.synthesis?.claim_density_per_1000_words ?? gate?.metrics?.claim_density_per_1000_words ?? null,
+                template_phrase_hits: gate?.metrics?.synthesis?.template_phrase_hits ?? gate?.metrics?.template_phrase_hits ?? [],
+                codex_final_review_verdict: finalReview?.codex_review?.verdict || null
+            },
             claim_evidence_matrix_present: claimMatrix.present,
             key_claims: claimMatrix.key_claim_ids.length,
             triangulated_claims: claimMatrix.triangulated_claim_count,

package/dist/core/commands/team-command.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { appendJsonlBounded, exists, nowIso, readJson, sksRoot, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
 import { initProject } from '../init.js';
-import { createMission, loadMission, setCurrent } from '../mission.js';
+import { createMission, findLatestMission, loadMission, setCurrent } from '../mission.js';
 import { buildQuestionSchema, writeQuestions } from '../questions.js';
 import { CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_WEB_VERIFICATION_POLICY, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_SOURCE_INVENTORY_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_VISUAL_MAP_ARTIFACT, FROM_CHAT_IMG_WORK_ORDER_ARTIFACT, ROUTES, hasFromChatImgSignal, routePrompt, routeReasoning, triwikiContextTracking } from '../routes.js';
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, writeTeamRuntimeArtifacts } from '../team-dag.js';
@@ -18,11 +18,13 @@ import { attachZellijSessionInteractive, launchTeamZellijView } from '../zellij/
 import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
 import { ambientGoalContinuation, flag, readBoundedIntegerFlag, readFlagValue } from './command-utils.js';
+import { narutoCommand } from './naruto-command.js';
 const TEAM_SESSION_CLEANUP_ARTIFACT = 'team-session-cleanup.json';
 export async function team(args = []) {
     const teamSubcommands = new Set(['log', 'tail', 'watch', 'lane', 'status', 'dashboard', 'event', 'message', 'open-zellij', 'attach-zellij', 'cleanup-zellij', 'open-tmux', 'attach-tmux', 'cleanup-tmux']);
     if (teamSubcommands.has(args[0]))
         return teamCommand(args[0], args.slice(1));
+    return redirectTeamCreateToNaruto(args);
     const jsonOutput = flag(args, '--json');
     const mock = flag(args, '--mock');
     const openZellij = !mock && !jsonOutput && !flag(args, '--no-open-zellij') && !flag(args, '--no-zellij');
@@ -200,6 +202,28 @@ export async function team(args = []) {
     console.log(`Watch: sks team watch ${id}`);
     console.log(`Artifacts: .sneakoscope/missions/${id}`);
 }
+async function redirectTeamCreateToNaruto(args = []) {
+    const root = await sksRoot();
+    const list = (args || []).map((arg) => String(arg));
+    const narutoArgs = list[0] === 'run' ? list : ['run', ...list];
+    console.warn('SKS Team is deprecated for new execution missions; redirecting to $Naruto.');
+    const result = await narutoCommand(narutoArgs);
+    const missionId = result?.mission_id || await findLatestMission(root);
+    if (missionId) {
+        await writeJsonAtomic(path.join(root, '.sneakoscope', 'missions', missionId, 'team-alias-to-naruto.json'), {
+            schema: 'sks.team-alias-to-naruto.v1',
+            ok: true,
+            mission_id: missionId,
+            source_command: 'sks team',
+            redirected_to: 'sks naruto run',
+            route_command: '$Naruto',
+            deprecated_route: '$Team',
+            created_at: nowIso(),
+            args: list
+        });
+    }
+    return result;
+}
 export function parseTeamCreateArgs(args) {
     const spec = parseTeamSpecArgs(args);
     const prompt = spec.cleanArgs.join(' ').trim();

package/dist/core/db-safety.js

@@ -2,6 +2,9 @@ import path from 'node:path';
 import { exists, readJson, writeJsonAtomic, readText, nowIso, appendJsonlBounded } from './fsx.js';
 import { missionDir, setCurrent } from './mission.js';
 import { evaluateMadSksPermissionGate, isMadSksRouteState } from './permission-gates.js';
+import { resolveMadDbMutationPolicy } from './mad-db/mad-db-policy-resolver.js';
+import { consumeMadDbCapability } from './mad-db/mad-db-capability.js';
+import { appendMadDbLedgerEvent } from './mad-db/mad-db-ledger.js';
 export const DEFAULT_DB_SAFETY_POLICY = Object.freeze({
     schema_version: 1,
     mode: 'read_only_default',
@@ -504,6 +507,29 @@ export async function checkDbOperation(root, state, payload, { duringNoQuestion
     const policy = await loadDbSafetyPolicy(root);
     const contract = await loadMissionContract(root, state);
     const classification = classifyToolPayload(payload);
+    const madDb = await resolveMadDbMutationPolicy(root, state, classification);
+    if (madDb.allowed === true && state?.mission_id) {
+        const madDbDecision = madDb;
+        const decision = {
+            allowed: true,
+            action: 'allow',
+            reasons: madDb.reasons,
+            classification,
+            effective: { mode: 'mad-db-break-glass', env: 'operator_authorized_one_cycle', destructive: true, migrationApply: 'yes' },
+            mad_db: {
+                active: true,
+                priority: 'highest',
+                one_cycle_only: true,
+                cycle_id: madDbDecision.cycle_id,
+                capability_file: 'mad-db-capability.json',
+                consumed: true
+            }
+        };
+        await appendMadDbLedgerEvent(root, state.mission_id, { type: 'db_mutation.allowed', cycle_id: madDbDecision.cycle_id, mode: madDbDecision.mode, classification });
+        await consumeMadDbCapability(root, state.mission_id, { consumedBy: 'db-safety-checkDbOperation', reason: 'db_mutation_allowed' });
+        await appendJsonlBounded(path.join(missionDir(root, state.mission_id), 'db-safety.jsonl'), { ts: nowIso(), decision });
+        return decision;
+    }
     const madSks = await madSksOverrideState(root, state);
     const decision = evaluateDbSafety({ classification, policy, contract, duringNoQuestion, madSks });
     if (decision.action === 'confirm')

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.14';
+export const PACKAGE_VERSION = '2.0.15';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

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

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { findLatestMission, missionDir } from '../mission.js';
+export const MAD_DB_CAPABILITY_SCHEMA = 'sks.mad-db-capability.v1';
+export const MAD_DB_CAPABILITY_FILE = 'mad-db-capability.json';
+export const MAD_DB_ACK = 'I AUTHORIZE ONE-CYCLE DB BREAK-GLASS';
+export const MAD_DB_MAX_TTL_MS = 2 * 60 * 60 * 1000;
+export async function createMadDbCapability(root, input) {
+    if (input.ack !== MAD_DB_ACK)
+        throw new Error('mad_db_ack_phrase_mismatch');
+    const createdAt = nowIso();
+    const ttlMs = Math.min(MAD_DB_MAX_TTL_MS, Math.max(1, Math.floor(Number(input.ttlMs || MAD_DB_MAX_TTL_MS))));
+    const capability = {
+        schema: MAD_DB_CAPABILITY_SCHEMA,
+        mission_id: input.missionId,
+        cycle_id: input.cycleId || `mad-db-${Date.now().toString(36)}`,
+        enabled: true,
+        created_at: createdAt,
+        expires_at: new Date(Date.now() + ttlMs).toISOString(),
+        one_cycle_only: true,
+        priority: 'highest',
+        scope: 'all_database_mutations',
+        operator_ack: {
+            phrase: MAD_DB_ACK,
+            accepted_at: createdAt,
+            cwd: path.resolve(input.cwd || process.cwd())
+        },
+        consumed: false,
+        consumed_at: null,
+        consumed_by: null
+    };
+    const dir = missionDir(root, input.missionId);
+    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), capability);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.created', mission_id: capability.mission_id, cycle_id: capability.cycle_id, expires_at: capability.expires_at });
+    return capability;
+}
+export async function readMadDbCapability(root, missionId) {
+    const capability = await readJson(path.join(missionDir(root, missionId), MAD_DB_CAPABILITY_FILE), null);
+    return capability?.schema === MAD_DB_CAPABILITY_SCHEMA ? capability : null;
+}
+export async function resolveMadDbMissionId(root, state = {}, explicitMissionId = null) {
+    if (explicitMissionId && explicitMissionId !== 'latest')
+        return explicitMissionId;
+    if (state?.mission_id)
+        return String(state.mission_id);
+    return findLatestMission(root);
+}
+export function isMadDbCapabilityActive(capability, nowMs = Date.now()) {
+    if (!capability)
+        return false;
+    const expires = Date.parse(capability.expires_at || '');
+    return capability.enabled === true
+        && capability.consumed !== true
+        && capability.one_cycle_only === true
+        && Number.isFinite(expires)
+        && expires > nowMs;
+}
+export async function consumeMadDbCapability(root, missionId, input = {}) {
+    const capability = await readMadDbCapability(root, missionId);
+    if (!isMadDbCapabilityActive(capability))
+        return capability;
+    const consumed = {
+        ...capability,
+        consumed: true,
+        consumed_at: nowIso(),
+        consumed_by: input.consumedBy || input.reason || 'db-safety-policy-resolver'
+    };
+    const dir = missionDir(root, missionId);
+    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), consumed);
+    await writeJsonAtomic(path.join(dir, 'mad-db-capability.consumed.json'), consumed);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.consumed', mission_id: missionId, cycle_id: consumed.cycle_id, consumed_by: consumed.consumed_by });
+    return consumed;
+}
+export async function revokeMadDbCapability(root, missionId, reason = 'operator_revoked') {
+    const capability = await readMadDbCapability(root, missionId);
+    if (!capability)
+        return null;
+    const revoked = { ...capability, enabled: false, revoked_at: nowIso(), revoke_reason: reason };
+    const dir = missionDir(root, missionId);
+    await writeJsonAtomic(path.join(dir, MAD_DB_CAPABILITY_FILE), revoked);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), { ts: nowIso(), type: 'capability.revoked', mission_id: missionId, cycle_id: capability.cycle_id, reason });
+    return revoked;
+}
+//# sourceMappingURL=mad-db-capability.js.map

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

@@ -0,0 +1,17 @@
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, writeJsonAtomic } from '../fsx.js';
+import { missionDir } from '../mission.js';
+export const MAD_DB_LEDGER_EVENT_SCHEMA = 'sks.mad-db-ledger-event.v1';
+export async function appendMadDbLedgerEvent(root, missionId, event) {
+    const row = {
+        schema: MAD_DB_LEDGER_EVENT_SCHEMA,
+        ts: nowIso(),
+        mission_id: missionId,
+        ...event
+    };
+    const dir = missionDir(root, missionId);
+    await appendJsonlBounded(path.join(dir, 'mad-db-ledger.jsonl'), row);
+    await writeJsonAtomic(path.join(dir, 'mad-db-ledger.latest.json'), row).catch(() => undefined);
+    return row;
+}
+//# sourceMappingURL=mad-db-ledger.js.map

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

@@ -0,0 +1,46 @@
+import { readMadDbCapability, isMadDbCapabilityActive } from './mad-db-capability.js';
+export const MAD_DB_POLICY_DECISION_SCHEMA = 'sks.mad-db-policy-decision.v1';
+export async function resolveMadDbMutationPolicy(root, state = {}, classification = {}) {
+    const missionId = state?.mission_id ? String(state.mission_id) : null;
+    if (!missionId)
+        return inactive('mission_id_missing');
+    const capability = await readMadDbCapability(root, missionId);
+    if (!isMadDbCapabilityActive(capability))
+        return inactive(capability?.consumed ? 'mad_db_capability_consumed' : 'mad_db_capability_inactive');
+    if (!isDbMutationOrDbTool(classification))
+        return inactive('not_a_database_mutation');
+    return {
+        schema: MAD_DB_POLICY_DECISION_SCHEMA,
+        allowed: true,
+        action: 'allow',
+        mode: 'mad-db-break-glass',
+        priority: 0,
+        priority_order: ['mad-db', 'mad-sks', 'sealed-contract', 'default-db-safety'],
+        reasons: ['mad_db_one_cycle_break_glass_capability_active'],
+        audit_required: true,
+        mission_id: missionId,
+        cycle_id: capability.cycle_id,
+        capability
+    };
+}
+function inactive(reason) {
+    return {
+        schema: MAD_DB_POLICY_DECISION_SCHEMA,
+        allowed: false,
+        action: 'defer',
+        mode: 'default-db-safety',
+        priority: 99,
+        reasons: [reason],
+        audit_required: false
+    };
+}
+function isDbMutationOrDbTool(classification = {}) {
+    if (classification.level === 'write' || classification.level === 'destructive')
+        return true;
+    if (classification.toolReasons?.includes?.('database_tool'))
+        return true;
+    if (classification.toolReasons?.includes?.('migration_apply_tool'))
+        return true;
+    return false;
+}
+//# sourceMappingURL=mad-db-policy-resolver.js.map