sneakoscope 2.0.16 → 2.0.17

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.16';
+export const PACKAGE_VERSION = '2.0.17';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/hooks-runtime.js

@@ -3,6 +3,7 @@ import { projectRoot, readJson, readText, writeJsonAtomic, appendJsonl, readStdi
 import { looksInteractiveCommand, interactiveCommandReason } from './no-question-guard.js';
 import { missionDir, setCurrent, stateFile } from './mission.js';
 import { checkDbOperation, dbBlockReason, handleMadSksUserConfirmation } from './db-safety.js';
+import { readLatestPendingMadDbLifecycleHook, recordMadDbToolResult } from './mad-db/mad-db-result-lifecycle.js';
 import { checkHarnessModification, harnessGuardBlockReason, isHarnessSourceProject } from './harness-guard.js';
 import { isMadSksRouteState } from './permission-gates.js';
 import { classifyMadSksShellCommand } from './mad-sks/write-guard.js';
@@ -422,10 +423,7 @@ function agentWorkerHookContext(state = {}, payload = {}) {
         || payload.agentWorker === true);
 }
 async function hookPostTool(root, state, payload, noQuestion) {
-    const dbDecision = await checkDbOperation(root, state, payload, { duringNoQuestion: noQuestion });
-    if (dbDecision.action === 'block' || dbDecision.action === 'confirm') {
-        return { decision: 'block', reason: dbBlockReason(dbDecision) };
-    }
+    await recordMadDbPostToolLifecycle(root, state, payload).catch(() => null);
     await recordContext7Evidence(root, state, payload).catch(() => null);
     await recordSubagentEvidence(root, state, payload).catch(() => null);
     if (toolFailed(payload))
@@ -449,6 +447,45 @@ async function hookPostTool(root, state, payload, noQuestion) {
         ? { continue: true, additionalContext: teamDigest.context, systemMessage: joinSystemMessages(visibleHookMessage('post-tool'), teamDigest.system) }
         : { continue: true };
 }
+async function recordMadDbPostToolLifecycle(root, state = {}, payload = {}) {
+    if (!state?.mission_id)
+        return null;
+    const hook = await readLatestPendingMadDbLifecycleHook(root, String(state.mission_id), payload);
+    if (!hook)
+        return null;
+    return recordMadDbToolResult({
+        root,
+        missionId: String(state.mission_id),
+        hook,
+        ok: !toolFailed(payload),
+        rowCount: extractRowCount(payload),
+        error: toolFailed(payload) ? extractToolError(payload) : null
+    });
+}
+function extractRowCount(payload = {}) {
+    const candidates = [
+        payload.row_count,
+        payload.rowCount,
+        payload.tool_response?.row_count,
+        payload.tool_response?.rowCount,
+        payload.toolResponse?.rowCount,
+        payload.result?.row_count,
+        payload.result?.rowCount,
+        payload.result?.rows_affected,
+        payload.tool_response?.rows_affected
+    ];
+    for (const candidate of candidates) {
+        if (candidate === undefined || candidate === null || candidate === '')
+            continue;
+        const parsed = Number(candidate);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function extractToolError(payload = {}) {
+    return String(payload.error || payload.message || payload.stderr || payload.tool_response?.stderr || payload.toolResponse?.stderr || payload.result?.stderr || payload.result?.error || 'tool_failed');
+}
 async function recordToolErrorTaxonomy(root, state = {}, payload = {}) {
     if (!state?.mission_id)
         return null;

package/dist/core/init.js

@@ -1043,6 +1043,7 @@ export async function installSkills(root) {
         'research': `---\nname: research\ndescription: Dollar-command route for $Research or $research frontier discovery workflows.\n---\n\nUse when the user invokes $Research/$research or asks for research, hypotheses, new mechanisms, falsification, or testable predictions. Prefer sks research prepare and sks research run. Research is not an implementation route: do not edit repository source, docs, package metadata, generated skills, or harness files; write only route-local mission artifacts under .sneakoscope/missions/<mission-id>/. Run the genius-lens agent council with named persona-inspired cognitive roles: Einstein Agent, Feynman Agent, Turing Agent, von Neumann Agent, and Skeptic Agent. These are lenses only; do not impersonate the historical people. Every Research agent ledger row must include display_name, persona, persona_boundary, effort=xhigh, reasoning_effort=xhigh, service_tier when available, one literal "Eureka!" idea, falsifiers, cheap_probes, and challenge_or_response before synthesis. This is not a fixed three-cycle route: repeat source gathering, Eureka ideas, evidence-bound debate, falsification, and synthesis pressure until every agent records final agreement, or until the explicit max-cycle safety cap pauses with an unpassed gate. Create research-source-skill.md as a route-local Skill Creator artifact, then maximize layered public web/source search across latest papers, official/government or leading-institution data, standards/primary docs, current news, public discourse, developer/practitioner sources, traditional background sources, and counterevidence before synthesis. Record research-source-skill.md, source-ledger.json, agent-ledger.json, debate-ledger.json, novelty-ledger.json, falsification-ledger.json, research-report.md, research-paper.md, genius-opinion-summary.md, and research-gate.json. debate-ledger.json must include consensus_iterations, unanimous_consensus, and per-agent agreements; research-gate.json cannot pass until unanimous_consensus=true with every agent agreement recorded. Context7 is optional and only needed when the research topic depends on external package/API/framework docs; do not use it as the default research evidence layer. Normal Research may take one or two hours when needed; favor real source collection, cross-layer comparison, falsification, and a concise paper manuscript over speed. Do not use --mock except for selftests or dry harness checks; if live source execution is unavailable, record a blocker and keep the gate unpassed. Do not use for ordinary code edits.\n`,
         'autoresearch': `---\nname: autoresearch\ndescription: Dollar-command route for $AutoResearch or $autoresearch iterative experiment loops.\n---\n\nUse for $AutoResearch, iterative improvement, SEO/GEO, ranking, workflow, benchmark, or experiments. Define program, hypothesis, experiment, metric, keep/discard, falsification, next step, and Honest Mode. Load seo-geo-optimizer for README/npm/GitHub/schema/AI-search work.\n`,
         'db': `---\nname: db\ndescription: Dollar-command route for $DB or $db database and Supabase safety checks.\n---\n\nUse when the user invokes $DB/$db or the task touches SQL, Supabase, Postgres, migrations, Prisma, Drizzle, Knex, MCP database tools, or production data. Run or follow sks db policy, sks db scan, sks db classify, and sks db check. Destructive database operations remain forbidden.\n`,
+        'mad-db': `---\nname: mad-db\ndescription: One-cycle Mad-DB break-glass route alias for $MAD-DB and $mad-db database safety work.\n---\n\nUse only when the user explicitly invokes $MAD-DB/$mad-db or asks for Mad-DB visibility. Treat it as a DB safety route with one-cycle break-glass controls, not as a general permanent DB unlock. Prefer \`sks mad-db status --json\` for inspection, \`sks mad-db enable --ack "I AUTHORIZE ONE-CYCLE DB BREAK-GLASS" [--mission latest|new|M-...] --json\` only after explicit user authorization, and \`sks mad-db revoke --mission <id|latest> --json\` to close the cycle. Keep catastrophic safeguards active: whole database/schema/table removal, truncate, all-row delete/update, reset, dangerous project/branch management, credential exfiltration, persistent security weakening, and unrequested fallback implementation remain blocked. Pair with db-safety-guard, Context7 evidence when external DB/API docs are involved, route-local reflection, and Honest Mode.\n`,
         'mad-sks': `---\nname: mad-sks\ndescription: Explicit high-risk authorization modifier for $MAD-SKS scoped permission widening across approved target-project surfaces.\n---\n\nUse only when the user explicitly invokes $MAD-SKS or top-level sks --mad. It can be combined with another route, such as $MAD-SKS $Team or $DB ... $MAD-SKS; in that case the other command remains the primary workflow and MAD-SKS is only the temporary permission grant. The widened permission applies only while the active mission gate is open, must be deactivated when the task ends, and can open approved scopes such as target-project file writes, shell commands, package installs, local service control, network operations, browser/Computer Use workflows, generated assets, file permissions, migrations, Supabase MCP database writes, column/schema cleanup, direct execute SQL, and normal targeted DB writes. Keep catastrophic safeguards active: whole database/schema/table removal, truncate, all-row delete/update, reset, dangerous project/branch management, credential exfiltration, persistent security weakening, destructive delete without explicit confirmation, and unrequested fallback implementation remain blocked. Do not carry MAD-SKS permission into later prompts or routes. The permission profile source is centralized in src/core/permission-gates.ts and emitted as dist/core/permission-gates.js so skill/hook/MCP-style gates share one decision function.\n`,
         'gx': `---\nname: gx\ndescription: Dollar-command route for $GX or $gx deterministic GX visual context cartridges.\n---\n\nUse when the user invokes $GX/$gx or asks for architecture/context visualization through SKS. Prefer sks gx init, render, validate, drift, and snapshot. vgraph.json remains the source of truth.\n`,
         'help': `---\nname: help\ndescription: Dollar-command route for $Help or $help explaining installed SKS commands and workflows.\n---\n\nUse when the user invokes $Help/$help or asks what commands exist. Prefer concise output from sks commands, sks usage <topic>, sks quickstart, sks aliases, and sks codex-app.\n`,

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

@@ -89,7 +89,7 @@ export async function recordMadDbOperation(root, missionId, input = {}) {
 }
 export async function consumeMadDbCapability(root, missionId, input = {}) {
     const capability = await readMadDbCapability(root, missionId);
-    if (!isMadDbCapabilityActive(capability))
+    if (!capability || capability.consumed === true)
         return capability;
     const consumed = {
         ...capability,
@@ -103,6 +103,14 @@ export async function consumeMadDbCapability(root, missionId, input = {}) {
     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 closeMadDbCycle(root, missionId, cycleId) {
+    const capability = await readMadDbCapability(root, missionId);
+    if (!capability || capability.cycle_id !== cycleId)
+        return capability;
+    if (capability.consumed === true)
+        return capability;
+    return consumeMadDbCapability(root, missionId, { consumedBy: 'mad-db-cycle-close', reason: 'mad_db_cycle_closed' });
+}
 export async function revokeMadDbCapability(root, missionId, reason = 'operator_revoked') {
     const capability = await readMadDbCapability(root, missionId);
     if (!capability)

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

@@ -0,0 +1,136 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { appendJsonlBounded, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+import { missionDir } from '../mission.js';
+import { appendMadDbOperationLifecycle } from './mad-db-ledger.js';
+const PENDING_FILE = 'mad-db-lifecycle-pending.jsonl';
+const PENDING_LATEST_FILE = 'mad-db-lifecycle-pending.latest.json';
+export async function recordPendingMadDbLifecycleHook(root, missionId, hook) {
+    const dir = missionDir(root, missionId);
+    const row = {
+        schema: 'sks.mad-db-lifecycle-pending.v1',
+        ts: nowIso(),
+        mission_id: missionId,
+        hook
+    };
+    await appendJsonlBounded(path.join(dir, PENDING_FILE), row);
+    await writeJsonAtomic(path.join(dir, PENDING_LATEST_FILE), row).catch(() => undefined);
+    return row;
+}
+export async function readLatestPendingMadDbLifecycleHook(root, missionId, payload = {}) {
+    const dir = missionDir(root, missionId);
+    const embedded = lifecycleHookFromUnknown(payload);
+    if (embedded)
+        return embedded;
+    const latest = await readJson(path.join(dir, PENDING_LATEST_FILE), null).catch(() => null);
+    const latestHook = lifecycleHookFromUnknown(latest?.hook);
+    if (latestHook && hookMatchesPayload(latestHook, payload))
+        return latestHook;
+    const text = await readText(path.join(dir, PENDING_FILE), '').catch(() => '');
+    const rows = String(text).split(/\r?\n/).map((line) => line.trim()).filter(Boolean).reverse();
+    for (const line of rows.slice(0, 50)) {
+        try {
+            const row = JSON.parse(line);
+            const hook = lifecycleHookFromUnknown(row?.hook);
+            if (hook && hookMatchesPayload(hook, payload))
+                return hook;
+        }
+        catch {
+            // Ignore malformed pending rows.
+        }
+    }
+    return null;
+}
+export async function recordMadDbToolResult(input) {
+    const terminalType = input.ok ? 'db_operation.succeeded' : 'db_operation.failed';
+    if (await hasTerminalLifecycleEvent(input.root, input.missionId, input.hook.operation_id)) {
+        return {
+            schema: 'sks.mad-db-tool-result-lifecycle.v1',
+            ok: true,
+            skipped: true,
+            reason: 'mad_db_operation_terminal_event_already_recorded',
+            operation_id: input.hook.operation_id
+        };
+    }
+    const event = await appendMadDbOperationLifecycle(input.root, input.missionId, {
+        type: terminalType,
+        operationId: input.hook.operation_id,
+        cycleId: input.hook.cycle_id || null,
+        mcpServer: input.hook.mcp_server || null,
+        toolName: input.hook.tool_name || null,
+        sqlHash: input.hook.sql_hash || null,
+        destructive: input.hook.destructive === true,
+        resultStatus: input.ok ? 'succeeded' : 'failed',
+        rowCount: input.rowCount ?? null,
+        error: input.error || null
+    });
+    await markPendingHookResolved(input.root, input.missionId, input.hook, input.ok);
+    return {
+        schema: 'sks.mad-db-tool-result-lifecycle.v1',
+        ok: true,
+        skipped: false,
+        operation_id: input.hook.operation_id,
+        result_status: input.ok ? 'succeeded' : 'failed',
+        event
+    };
+}
+export function lifecycleHookFromUnknown(value) {
+    const candidate = value?.ledger_result_hook || value?.mad_db?.ledger_result_hook || value;
+    const missionId = stringOrNull(candidate?.mission_id || candidate?.missionId);
+    const operationId = stringOrNull(candidate?.operation_id || candidate?.operationId);
+    if (!missionId || !operationId)
+        return null;
+    return {
+        mission_id: missionId,
+        operation_id: operationId,
+        cycle_id: stringOrNull(candidate?.cycle_id || candidate?.cycleId),
+        tool_name: stringOrNull(candidate?.tool_name || candidate?.toolName),
+        sql_hash: stringOrNull(candidate?.sql_hash || candidate?.sqlHash),
+        mcp_server: stringOrNull(candidate?.mcp_server || candidate?.mcpServer),
+        destructive: candidate?.destructive === true
+    };
+}
+function hookMatchesPayload(hook, payload) {
+    if (!hook.tool_name)
+        return true;
+    const toolText = [
+        payload.tool_name,
+        payload.toolName,
+        payload.name,
+        payload.tool?.name,
+        payload.server,
+        payload.mcp_tool,
+        payload.tool,
+        payload.type
+    ].filter(Boolean).join(' ').toLowerCase();
+    if (!toolText)
+        return true;
+    return toolText.includes(String(hook.tool_name).toLowerCase()) || String(hook.tool_name).toLowerCase().includes(toolText);
+}
+async function hasTerminalLifecycleEvent(root, missionId, operationId) {
+    const ledger = path.join(missionDir(root, missionId), 'mad-db-ledger.jsonl');
+    const text = await readText(ledger, '').catch(() => '');
+    return String(text).split(/\r?\n/).some((line) => {
+        if (!line.includes(operationId))
+            return false;
+        return line.includes('db_operation.succeeded') || line.includes('db_operation.failed');
+    });
+}
+async function markPendingHookResolved(root, missionId, hook, ok) {
+    const dir = missionDir(root, missionId);
+    const row = {
+        schema: 'sks.mad-db-lifecycle-pending-resolution.v1',
+        ts: nowIso(),
+        mission_id: missionId,
+        operation_id: hook.operation_id,
+        cycle_id: hook.cycle_id || null,
+        result_status: ok ? 'succeeded' : 'failed'
+    };
+    await appendJsonlBounded(path.join(dir, 'mad-db-lifecycle-resolved.jsonl'), row).catch(() => undefined);
+    await fs.rm(path.join(dir, PENDING_LATEST_FILE), { force: true }).catch(() => undefined);
+}
+function stringOrNull(value) {
+    const text = String(value || '').trim();
+    return text ? text : null;
+}
+//# sourceMappingURL=mad-db-result-lifecycle.js.map

package/dist/core/release/release-gate-affected-selector.js

@@ -10,7 +10,7 @@ export function selectAffectedReleaseGates(root, manifest, gates, input = {}) {
     if (input.full) {
         return selectionResult(gates, gates, [], 'full', {}, []);
     }
-    const changedFiles = resolveChangedFiles(root, input.changedSince || 'auto');
+    const changedFiles = input.changedFiles ? [...new Set(input.changedFiles)].sort() : resolveChangedFiles(root, input.changedSince || 'auto');
     const selected = [];
     const reasons = {};
     for (const gate of gates) {
@@ -28,7 +28,9 @@ export function selectAffectedReleaseGates(root, manifest, gates, input = {}) {
             reasons[gate.id] = 'always_keep_core_release_safety';
         }
     }
-    const expanded = expandWithDependencies(selected, manifest);
+    const expanded = input.preset === 'affected' || input.preset === 'fast'
+        ? selected
+        : expandWithDependencies(selected, manifest);
     const ordered = manifest.gates.filter((gate) => expanded.some((row) => row.id === gate.id));
     return selectionResult(gates, ordered, changedFiles, 'affected', reasons, gates.filter((gate) => !ordered.some((row) => row.id === gate.id)).map((gate) => gate.id));
 }
@@ -53,19 +55,32 @@ function gateSelectionReason(gate, changedFiles, preset) {
         return 'always_keep_core_release_safety';
     if (!changedFiles.length)
         return preset === 'fast' ? 'fast_no_diff_core_only_skip' : 'no_changed_files';
+    const releaseGate = /^(release:|publish:|prepublish)/.test(gate.id);
     if (changedFiles.some((file) => file === 'package.json' || file === 'package-lock.json')) {
         if (/^(release:|publish:|prepublish|runtime:|typecheck|schema:check)/.test(gate.id))
             return 'package_metadata_changed';
     }
-    if (changedFiles.some((file) => file === 'release-gates.v2.json' || file.startsWith('src/core/release/') || file.startsWith('src/scripts/release-')))
-        return 'release_gate_system_changed';
+    if (changedFiles.some((file) => file === 'release-gates.v2.json' || file.startsWith('src/core/release/'))) {
+        if (releaseGate)
+            return 'release_gate_system_changed';
+    }
+    const matchingReleaseScript = changedFiles.some((file) => releaseScriptGateCandidates(file).includes(gate.id));
+    if (matchingReleaseScript)
+        return 'release_script_changed';
+    if (changedFiles.some((file) => file.startsWith('src/scripts/prepublish-') || file.startsWith('src/scripts/publish-'))) {
+        if (releaseGate && gate.id === 'release:version-truth')
+            return 'publish_or_prepublish_script_changed';
+    }
+    if (changedFiles.some((file) => file.startsWith('src/scripts/scheduler-') || file.startsWith('src/core/scheduler/'))) {
+        return gate.id.startsWith('scheduler:') ? 'scheduler_source_changed' : null;
+    }
     if (changedFiles.some((file) => file.startsWith('src/core/research/')))
         return gate.id.startsWith('research:') ? 'research_source_changed' : null;
     if (changedFiles.some((file) => file.startsWith('src/core/zellij/') || file.startsWith('src/commands/zellij')))
         return gate.id.startsWith('zellij:') || gate.id.startsWith('agent:zellij') || gate.id.startsWith('naruto:zellij') ? 'zellij_source_changed' : null;
     if (changedFiles.some((file) => file.includes('/db') || file.includes('mad-db') || file.includes('mcp')))
         return /db|mcp|mad-db|mad-sks/.test(gate.id) ? 'db_mcp_or_mad_db_changed' : null;
-    const inputs = gate.cache?.inputs || [];
+    const inputs = (gate.cache?.inputs || []).filter((pattern) => !isBroadAffectedInput(pattern));
     if (inputs.some((pattern) => changedFiles.some((file) => matchesGlobish(file, pattern))))
         return 'cache_input_changed';
     return null;
@@ -110,4 +125,31 @@ function matchesGlobish(file, pattern) {
         return file.startsWith(normalized.slice(0, -1));
     return false;
 }
+function isBroadAffectedInput(pattern) {
+    const normalized = pattern.replace(/\\/g, '/');
+    return new Set([
+        '**',
+        '**/*',
+        'src/**',
+        'src/**/*',
+        'schemas/**',
+        'schemas/**/*',
+        'package.json',
+        'package-lock.json',
+        'release-gates.v2.json'
+    ]).has(normalized);
+}
+function releaseScriptGateCandidates(file) {
+    const normalized = file.replace(/\\/g, '/');
+    const base = normalized.split('/').pop()?.replace(/\.(ts|js|mjs|cjs)$/, '') || '';
+    if (!base.startsWith('release-'))
+        return [];
+    const rest = base.slice('release-'.length);
+    const withoutCheck = rest.replace(/-check$/, '');
+    return [
+        `release:${rest}`,
+        `release:${withoutCheck}`,
+        `release:${withoutCheck}:check`
+    ];
+}
 //# sourceMappingURL=release-gate-affected-selector.js.map

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

@@ -26,6 +26,10 @@ export async function runReleaseGateDag(input) {
         ? selectAffectedReleaseGates(root, manifest, presetGates, { changedSince: input.changedSince || 'auto', preset })
         : selectAffectedReleaseGates(root, manifest, presetGates, { full: true, preset });
     const selected = affected.gates;
+    const selectedIds = new Set(selected.map((gate) => gate.id));
+    const affectedExternalSatisfiedDeps = affected.selection.mode === 'affected'
+        ? new Set(selected.flatMap((gate) => gate.deps || []).filter((dep) => !selectedIds.has(dep)))
+        : new Set();
     const runId = `rg-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
     const reportDir = path.join(root, '.sneakoscope', 'reports', 'release-gates', runId);
     fs.mkdirSync(reportDir, { recursive: true });
@@ -88,7 +92,7 @@ export async function runReleaseGateDag(input) {
         writeReleaseGateJson(path.join(reportDir, 'explain.json'), { schema: RELEASE_GATE_NODE_SCHEMA, preset, budget, gates: selected.map((gate) => ({ id: gate.id, deps: gate.deps, resource: gate.resource, command: gate.command })) });
     }
     while (pending.size || running.size) {
-        const ready = findReadyReleaseGateNodes({ pending, completed, failed });
+        const ready = findReadyReleaseGateNodes({ pending, completed, failed, satisfiedDeps: affectedExternalSatisfiedDeps });
         const launchable = pickReadyLaunchableReleaseGates({ ready, running: [...running.values()].map((row) => row.gate) });
         let progressed = false;
         for (const gate of launchable) {

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

@@ -1,6 +1,7 @@
 import { defaultReleaseGateBudget, pickLaunchableReleaseGates } from './release-gate-resource-governor.js';
 export function findReadyReleaseGateNodes(input) {
-    return [...input.pending.values()].filter((gate) => gate.deps.every((dep) => input.completed.has(dep)) && !gate.deps.some((dep) => input.failed.has(dep)));
+    const satisfiedDeps = input.satisfiedDeps || new Set();
+    return [...input.pending.values()].filter((gate) => gate.deps.every((dep) => input.completed.has(dep) || satisfiedDeps.has(dep)) && !gate.deps.some((dep) => input.failed.has(dep)));
 }
 export function findReleaseGatesBlockedByFailedDeps(input) {
     return [...input.pending.values()].filter((gate) => gate.deps.some((dep) => input.failed.has(dep)));

package/dist/core/routes.js

@@ -552,12 +552,14 @@ export const ROUTES = [
         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.',
         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']
+        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']
     },
     {
         id: 'GX',

package/dist/core/version.js

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

package/dist/core/zellij/zellij-slot-pane-renderer.js

@@ -31,21 +31,41 @@ export function renderZellijSlotPane(input) {
     return frameSlotPane(`LIVE SLOT ${input.slotId}`, rows.slice(0, Math.max(1, maxLines - 2)));
 }
 export async function renderZellijSlotPaneFromArtifacts(input) {
+    const artifactRender = await renderZellijSlotPaneFromArtifactDir(input).catch(() => null);
     if (input.missionId && input.missionId !== 'latest') {
         const telemetry = await tryRenderTelemetrySlotPane({
             artifactRoot: input.artifactRoot || input.artifactDir,
             missionId: input.missionId,
             slotId: input.slotId,
-            generationIndex: input.generationIndex
+            generationIndex: input.generationIndex,
+            artifactRender
         });
         if (telemetry)
             return telemetry;
+        if (artifactRender)
+            return artifactRender;
         return [
             `${input.slotId} gen-${Math.max(1, Math.floor(Number(input.generationIndex) || 1))}`,
             'waiting for telemetry...',
             `mission ${input.missionId}`
         ].join('\n');
     }
+    if (artifactRender)
+        return artifactRender;
+    const fallbackInput = {
+        slotId: input.slotId,
+        generationIndex: input.generationIndex,
+        status: 'launching',
+        currentTask: 'waiting for worker intake',
+        mode: input.mode || 'compact-slots'
+    };
+    if (input.role !== undefined)
+        fallbackInput.role = input.role;
+    if (input.backend !== undefined)
+        fallbackInput.backend = input.backend;
+    return renderZellijSlotPane(fallbackInput);
+}
+async function renderZellijSlotPaneFromArtifactDir(input) {
     const artifactDir = path.resolve(input.artifactDir);
     const result = await readJson(path.join(artifactDir, 'worker-result.json'));
     const intake = await readJson(path.join(artifactDir, 'worker-intake.json'));
@@ -77,6 +97,8 @@ export async function renderZellijSlotPaneFromArtifacts(input) {
         ...(Array.isArray(intake?.input_files) ? intake.input_files : [])
     ]);
     const now = Date.now();
+    if (!result && !intake && !backendReport && !fastReport && !paneReport && !codexProof && !localProof && !heartbeatMtime && !eventRows.length)
+        return null;
     return renderZellijSlotPane({
         slotId: input.slotId,
         generationIndex: input.generationIndex,
@@ -136,6 +158,20 @@ export async function renderZellijSlotPaneFromArtifacts(input) {
         mode: input.mode || 'compact-slots'
     });
 }
+export async function renderZellijSlotPaneStatusFromArtifacts(input) {
+    const snapshot = input.missionId && input.missionId !== 'latest'
+        ? await readZellijSlotTelemetrySnapshot(path.resolve(input.artifactRoot || input.artifactDir), input.missionId).catch(() => null)
+        : null;
+    const status = telemetryStatus(snapshot);
+    return {
+        schema: 'sks.zellij-slot-pane-status.v1',
+        mission_id: input.missionId || null,
+        slot_id: input.slotId,
+        generation_index: Math.max(1, Math.floor(Number(input.generationIndex) || 1)),
+        telemetry_stale: status.telemetry_stale,
+        telemetry_age_ms: status.telemetry_age_ms
+    };
+}
 export function buildZellijSlotPaneCommand(input) {
     const args = [
         input.cliPath,
@@ -159,9 +195,14 @@ async function tryRenderTelemetrySlotPane(input) {
     const slot = findTelemetrySlot(snapshot, input.slotId, input.generationIndex);
     if (!slot)
         return null;
+    const staleRows = staleTelemetryRows(telemetryStatus(snapshot).telemetry_age_ms);
+    const fallbackRows = artifactFallbackRows(input.artifactRender);
+    const liveRows = staleRows.length || !slot.progress ? fallbackRows : [];
     if (slot.status === 'failed') {
         return [
             `${slot.slot_id} gen-${slot.generation_index} · FAILED`,
+            ...staleRows,
+            ...liveRows,
             `blocker: ${trimInline(slot.blockers[0] || 'worker_failed', 78)}`,
             `artifact: ${trimInline(slot.artifact_paths[slot.artifact_paths.length - 1] || '-', 78)}`
         ].join('\n');
@@ -169,6 +210,8 @@ async function tryRenderTelemetrySlotPane(input) {
     if (slot.status === 'completed' || slot.status === 'drained') {
         return [
             `${slot.slot_id} gen-${slot.generation_index} · done`,
+            ...staleRows,
+            ...liveRows,
             `artifacts ${slot.artifact_paths.length} · ${slot.latest_event_type === 'verification_passed' ? 'verify passed' : 'verify queued'}`,
             'closing in 3s'
         ].join('\n');
@@ -177,12 +220,25 @@ async function tryRenderTelemetrySlotPane(input) {
     const heartbeat = slot.latest_ts ? `${Math.max(0, Math.round((Date.now() - Date.parse(slot.latest_ts)) / 1000))}s` : '?';
     return [
         `${slot.slot_id} gen-${slot.generation_index} · ${trimInline(slot.role || 'worker', 28)}`,
+        ...staleRows,
+        ...liveRows,
         trimInline(backend, 78),
         `${slot.status}: ${trimInline(slot.task_title || 'worker task', 68)}`,
         `${formatTelemetryProgress(slot.progress)} · latest ${slot.latest_event_type} ${heartbeat}`,
         `${slot.latest_event_type === 'patch_candidate' ? 'patch candidate' : 'patch'}: ${slot.latest_event_type === 'patch_candidate' ? 'queued' : trimInline(slot.current_file || '-', 42)}`
     ].join('\n');
 }
+function artifactFallbackRows(text) {
+    if (!text)
+        return [];
+    return String(text)
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^\|\s?/, '').replace(/\s?\|$/, '').trim())
+        .filter((line) => /^(heartbeat|doing|files|event|out|err):\s+/i.test(line))
+        .filter((line) => !/unknown|waiting for worker intake|no changed file yet/i.test(line))
+        .slice(-4)
+        .map((line) => `live: ${trimInline(line, 72)}`);
+}
 function findTelemetrySlot(snapshot, slotId, generationIndex) {
     const generation = Math.max(1, Math.floor(Number(generationIndex) || 1));
     return Object.values(snapshot.slots || {}).find((row) => row.slot_id === slotId && Number(row.generation_index) === generation) || null;
@@ -192,6 +248,23 @@ function formatTelemetryProgress(progress) {
         return 'progress ?';
     return `progress ${progress.done}/${progress.total}${progress.label ? ` ${trimInline(progress.label, 24)}` : ''}`;
 }
+function telemetryStatus(snapshot) {
+    const parsed = snapshot?.updated_at ? Date.parse(snapshot.updated_at) : NaN;
+    const telemetryAgeMs = Number.isFinite(parsed) ? Math.max(0, Date.now() - parsed) : Number.MAX_SAFE_INTEGER;
+    return {
+        telemetry_stale: telemetryAgeMs > 3000,
+        telemetry_age_ms: telemetryAgeMs
+    };
+}
+function staleTelemetryRows(ageMs) {
+    if (!Number.isFinite(ageMs))
+        return ['telemetry stale; worker may still be running'];
+    if (ageMs > 10000)
+        return ['telemetry stale; worker may still be running'];
+    if (ageMs > 3000)
+        return [`telemetry stale ${(ageMs / 1000).toFixed(1)}s`];
+    return [];
+}
 async function readJson(file) {
     try {
         return JSON.parse(await fs.promises.readFile(file, 'utf8'));

package/dist/core/zellij/zellij-slot-telemetry.js

@@ -1,10 +1,12 @@
 import path from 'node:path';
 import fsp from 'node:fs/promises';
-import { appendJsonlBounded, ensureDir, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
+import { appendJsonlBounded, ensureDir, nowIso, readJson, readText } from '../fsx.js';
 export const ZELLIJ_SLOT_TELEMETRY_EVENT_SCHEMA = 'sks.zellij-slot-telemetry-event.v1';
 export const ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA = 'sks.zellij-slot-telemetry-snapshot.v1';
 const telemetrySnapshotCache = new Map();
 const telemetrySnapshotWriteCounts = new Map();
+const telemetrySnapshotFlushCounts = new Map();
+const telemetrySnapshotLastFlushMs = new Map();
 export function slotTelemetryEventPath(root, missionId) {
     return path.join(inferMissionDir(root, missionId), 'zellij', 'slot-telemetry.events.jsonl');
 }
@@ -60,6 +62,7 @@ export function applyTelemetryEventToSnapshot(snapshot, event) {
         schema: ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA,
         mission_id: event.mission_id || snapshot.mission_id,
         updated_at: nowIso(),
+        flush_count: snapshot.flush_count || 0,
         slots,
         counts: countSlotTelemetry(slots)
     };
@@ -79,11 +82,11 @@ export async function rebuildZellijSlotTelemetrySnapshot(root, missionId) {
         schema: ZELLIJ_SLOT_TELEMETRY_SNAPSHOT_SCHEMA,
         mission_id: missionId,
         updated_at: nowIso(),
+        flush_count: 0,
         slots,
         counts: countSlotTelemetry(slots)
     };
-    await writeJsonAtomic(slotTelemetrySnapshotPath(root, missionId), snapshot);
-    telemetrySnapshotCache.set(slotTelemetrySnapshotPath(root, missionId), snapshot);
+    await writeTelemetrySnapshotFast(slotTelemetrySnapshotPath(root, missionId), snapshot);
     return snapshot;
 }
 async function readTelemetryEvents(file) {
@@ -210,17 +213,37 @@ function tail(value, max) {
 }
 async function writeTelemetrySnapshotFast(file, snapshot) {
     await ensureDir(path.dirname(file));
-    await fsp.writeFile(file, `${JSON.stringify(snapshot)}\n`, 'utf8');
+    const flushCount = Number(telemetrySnapshotFlushCounts.get(file) || 0) + 1;
+    telemetrySnapshotFlushCounts.set(file, flushCount);
+    telemetrySnapshotLastFlushMs.set(file, Date.now());
+    const next = { ...snapshot, flush_count: flushCount };
+    telemetrySnapshotCache.set(file, next);
+    await fsp.writeFile(file, `${JSON.stringify(next)}\n`, 'utf8');
 }
 function shouldFlushTelemetrySnapshot(file, event) {
     const next = (telemetrySnapshotWriteCounts.get(file) || 0) + 1;
     telemetrySnapshotWriteCounts.set(file, next);
-    return next === 1
-        || next % 100 === 0
+    const now = Date.now();
+    const last = telemetrySnapshotLastFlushMs.get(file) || 0;
+    const parsedFlushMs = Number(process.env.SKS_ZELLIJ_SLOT_TELEMETRY_FLUSH_MS || 1000);
+    const parsedFlushEvery = Number(process.env.SKS_ZELLIJ_SLOT_TELEMETRY_FLUSH_EVERY_N || 100);
+    const flushMs = Math.max(250, Number.isFinite(parsedFlushMs) ? parsedFlushMs : 1000);
+    const flushEvery = Math.max(1, Number.isFinite(parsedFlushEvery) ? Math.floor(parsedFlushEvery) : 100);
+    const important = event.event_type === 'task_started'
+        || event.event_type === 'task_progress'
+        || event.event_type === 'artifact_written'
+        || event.event_type === 'patch_candidate'
         || event.event_type === 'worker_completed'
         || event.event_type === 'worker_failed'
         || event.status === 'completed'
         || event.status === 'failed';
+    const should = next === 1
+        || important
+        || now - last >= flushMs
+        || next % flushEvery === 0;
+    if (should)
+        telemetrySnapshotLastFlushMs.set(file, now);
+    return should;
 }
 function inferMissionDir(root, missionId) {
     const resolved = path.resolve(root);

package/dist/core/zellij/zellij-ui-mode.js

@@ -1,16 +1,26 @@
 export function resolveZellijUiMode(args = [], env = process.env) {
+    return resolveExplicitZellijUiMode(args, env) || 'compact-slots';
+}
+export function resolveZellijWorkerPaneUiMode(args = [], env = process.env) {
+    return resolveExplicitZellijUiMode(args, env) || 'full-debug';
+}
+function resolveExplicitZellijUiMode(args = [], env = process.env) {
     const fromEnv = String(env.SKS_ZELLIJ_UI_MODE || '').trim();
+    if (fromEnv === 'compact-slots')
+        return 'compact-slots';
     if (fromEnv === 'full-debug')
         return 'full-debug';
     if (fromEnv === 'dashboard-plus-slots')
         return 'dashboard-plus-slots';
+    if (args.includes('--zellij-compact-slots'))
+        return 'compact-slots';
     if (args.includes('--zellij-dashboard'))
         return 'dashboard-plus-slots';
     if (args.includes('--zellij-full-debug'))
         return 'full-debug';
-    return 'compact-slots';
+    return null;
 }
 export function zellijUiModeCreatesDashboard(mode) {
-    return mode !== 'compact-slots';
+    return mode === 'dashboard-plus-slots';
 }
 //# sourceMappingURL=zellij-ui-mode.js.map