sneakoscope 2.0.16 → 2.0.18

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/usage/codex-account-usage.js

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+export async function collectCodexAccountUsage() {
+    if (process.env.SKS_CODEX_ACCOUNT_USAGE_FAKE === '1') {
+        return {
+            schema: 'sks.codex-account-usage.v1',
+            generated_at: nowIso(),
+            ok: true,
+            source: 'fake',
+            account_id: 'fake-account',
+            token_usage: {
+                input_tokens: 1000,
+                output_tokens: 500,
+                total_tokens: 1500,
+                reset_at: null
+            },
+            usage_limit_tokens: 100000,
+            blockers: []
+        };
+    }
+    const url = String(process.env.SKS_CODEX_APP_SERVER_USAGE_URL || process.env.CODEX_APP_SERVER_USAGE_URL || '').trim();
+    if (!url)
+        return unavailable(['codex_app_server_usage_endpoint_unavailable']);
+    try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+        if (!response.ok)
+            return unavailable([`codex_app_server_usage_http_${response.status}`]);
+        const payload = await response.json();
+        return normalizeUsagePayload(payload, 'app-server');
+    }
+    catch (err) {
+        return unavailable([`codex_app_server_usage_fetch_failed:${err?.message || String(err)}`]);
+    }
+}
+export async function writeCodexAccountUsageArtifacts(root, input = {}) {
+    const snapshot = await collectCodexAccountUsage();
+    const rootArtifact = path.join(root, '.sneakoscope', 'codex-account-usage.json');
+    await writeJsonAtomic(rootArtifact, snapshot);
+    let missionArtifact = null;
+    if (input.missionId) {
+        missionArtifact = path.join(root, '.sneakoscope', 'missions', input.missionId, 'codex-account-usage.json');
+        await writeJsonAtomic(missionArtifact, snapshot);
+    }
+    return { snapshot, root_artifact: rootArtifact, mission_artifact: missionArtifact };
+}
+function normalizeUsagePayload(payload, source) {
+    const usage = payload?.token_usage || payload?.usage || payload;
+    const input = Number(usage?.input_tokens || usage?.inputTokens || 0);
+    const output = Number(usage?.output_tokens || usage?.outputTokens || 0);
+    const total = Number(usage?.total_tokens || usage?.totalTokens || input + output);
+    return {
+        schema: 'sks.codex-account-usage.v1',
+        generated_at: nowIso(),
+        ok: true,
+        source,
+        account_id: payload?.account_id || payload?.accountId || null,
+        token_usage: {
+            input_tokens: Number.isFinite(input) ? input : 0,
+            output_tokens: Number.isFinite(output) ? output : 0,
+            total_tokens: Number.isFinite(total) ? total : 0,
+            reset_at: usage?.reset_at || usage?.resetAt || null
+        },
+        usage_limit_tokens: Number.isFinite(Number(payload?.usage_limit_tokens || payload?.usageLimitTokens)) ? Number(payload?.usage_limit_tokens || payload?.usageLimitTokens) : null,
+        blockers: []
+    };
+}
+function unavailable(blockers) {
+    return {
+        schema: 'sks.codex-account-usage.v1',
+        generated_at: nowIso(),
+        ok: true,
+        source: 'unavailable',
+        token_usage: null,
+        usage_limit_tokens: null,
+        blockers
+    };
+}
+//# sourceMappingURL=codex-account-usage.js.map

package/dist/core/version.js

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

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

@@ -10,18 +10,21 @@ export function renderZellijSlotColumnAnchor(input = {}) {
     const fail = nonNegativeInt(input.failedWorkers, 0);
     const update = input.updateAvailableVersion ? ` · update ${trimInline(input.updateAvailableVersion, 18)} available` : '';
     const madDb = input.madDbActive ? ' · MAD-DB ACTIVE' : '';
+    const appHandoff = input.qaAppHandoffPending ? ' · QA /app handoff pending' : '';
     const header = done || fail
-        ? `SLOTS active ${active} · headless ${headless} · done ${done} · fail ${fail} · q ${queue}${update}${madDb}`
-        : `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}${update}${madDb}`;
+        ? `SLOTS active ${active} · headless ${headless} · done ${done} · fail ${fail} · q ${queue}${update}${madDb}${appHandoff}`
+        : `SLOTS active ${active}/${visible} · headless ${headless} · q ${queue}${update}${madDb}${appHandoff}`;
     const workers = Array.isArray(input.workerRows) ? input.workerRows : [];
+    const handoffLine = input.qaAppHandoffPending ? `QA app handoff pending · ${trimInline(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json', 64)}` : null;
     if (!workers.length)
-        return `${header}\nvisible slot panes stack below this anchor`;
+        return [header, handoffLine, 'visible slot panes stack below this anchor'].filter(Boolean).join('\n');
     const maxRows = Math.max(1, nonNegativeInt(input.maxWorkerRows, input.mode === 'full-debug' ? 24 : 12));
     const overflowRows = workers.filter((row) => row.placement === 'headless').slice(0, maxRows);
     const visibleRows = overflowRows.length ? overflowRows : workers.filter((row) => row.placement !== 'zellij-pane').slice(0, maxRows);
     const hidden = Math.max(0, workers.length - visibleRows.length);
     return [
         header,
+        handoffLine,
         `visible slot panes stack below this anchor`,
         ...visibleRows.map((row, index) => renderWorkerRow(row, index + 1)),
         ...(hidden && visibleRows.length ? [`+${hidden} worker${hidden === 1 ? '' : 's'} in dedicated panes or overflow`] : [])
@@ -33,8 +36,9 @@ export async function renderZellijSlotColumnAnchorFromArtifacts(input) {
     const telemetry = await readZellijSlotTelemetrySnapshot(root, input.missionId).catch(() => null);
     const updateNotice = await readJson(path.join(missionDir, 'update-notice.json'));
     const madDb = await readJson(path.join(missionDir, 'mad-db-capability.json'));
+    const appHandoff = await readJson(path.join(missionDir, 'qa-loop', 'app-handoff.json'));
     if (telemetry && Object.keys(telemetry.slots || {}).length) {
-        return renderTelemetryAnchor(telemetry, updateNotice, madDb);
+        return renderTelemetryAnchor(telemetry, updateNotice, madDb, appHandoff);
     }
     const snapshot = await readJson(path.join(missionDir, 'zellij-dashboard-snapshot.json'));
     const rightColumn = await readJson(path.join(missionDir, 'zellij-right-column-state.json'));
@@ -50,20 +54,25 @@ export async function renderZellijSlotColumnAnchorFromArtifacts(input) {
         anchorInput.updateAvailableVersion = String(updateNotice.latest_version);
     if (isMadDbActive(madDb))
         anchorInput.madDbActive = true;
+    if (['pending', 'blocked_for_desktop_review'].includes(String(appHandoff?.status || ''))) {
+        anchorInput.qaAppHandoffPending = true;
+        anchorInput.qaAppHandoffArtifact = appHandoff?.artifact_path || 'qa-loop/app-handoff.json';
+    }
     if (input.mode !== undefined)
         anchorInput.mode = input.mode;
     return renderZellijSlotColumnAnchor(anchorInput);
 }
-function renderTelemetryAnchor(snapshot, updateNotice = null, madDbCapability = null) {
+function renderTelemetryAnchor(snapshot, updateNotice = null, madDbCapability = null, appHandoff = null) {
     const updatedAt = Date.parse(snapshot.updated_at || '');
     const staleSeconds = Number.isFinite(updatedAt) ? Math.max(0, Math.round((Date.now() - updatedAt) / 1000)) : null;
     const counts = snapshot.counts || {};
     const active = Number(counts.running || 0) + Number(counts.verifying || 0);
     const update = updateNotice?.update_available && updateNotice?.latest_version ? ` · update ${trimInline(String(updateNotice.latest_version), 18)} available` : '';
     const madDb = isMadDbActive(madDbCapability) ? ' · MAD-DB ACTIVE' : '';
+    const qaHandoff = ['pending', 'blocked_for_desktop_review'].includes(String(appHandoff?.status || '')) ? ' · QA /app handoff pending' : '';
     if (staleSeconds != null && staleSeconds > 10)
-        return `SLOTS telemetry stale ${staleSeconds}s · active ?${update}${madDb}`;
-    return `SLOTS active ${active} · headless ${Number(counts.headless || 0)} · done ${Number(counts.completed || 0)} · fail ${Number(counts.failed || 0)} · q ${Number(counts.queued || 0)}${update}${madDb}`;
+        return `SLOTS telemetry stale ${staleSeconds}s · active ?${update}${madDb}${qaHandoff}`;
+    return `SLOTS active ${active} · headless ${Number(counts.headless || 0)} · done ${Number(counts.completed || 0)} · fail ${Number(counts.failed || 0)} · q ${Number(counts.queued || 0)}${update}${madDb}${qaHandoff}`;
 }
 function isMadDbActive(capability) {
     if (!capability || capability.enabled !== true || capability.consumed === true)

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

@@ -24,6 +24,7 @@ export function renderZellijSlotPane(input) {
         `doing: ${task}`,
         `files: ${trimInline(files.length ? files.join(', ') : 'no changed file yet', 78)}`,
         `patch: ${trimInline(input.patchStatus || 'queued', 24)}  verify: ${trimInline(input.verifyStatus || 'queued', 24)}`,
+        input.qaAppHandoffPending ? `QA app handoff pending: ${trimInline(input.qaAppHandoffArtifact || 'qa-loop/app-handoff.json', 55)}` : null,
         ...events.map((event) => `event: ${trimInline(event, 78)}`),
         ...stdout.map((line) => `out: ${trimInline(line, 79)}`),
         ...stderr.map((line) => `err: ${trimInline(line, 79)}`)
@@ -31,21 +32,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 +98,9 @@ export async function renderZellijSlotPaneFromArtifacts(input) {
         ...(Array.isArray(intake?.input_files) ? intake.input_files : [])
     ]);
     const now = Date.now();
+    const qaAppHandoff = await readQaAppHandoffNearArtifactDir(artifactDir);
+    if (!result && !intake && !backendReport && !fastReport && !paneReport && !codexProof && !localProof && !heartbeatMtime && !eventRows.length)
+        return null;
     return renderZellijSlotPane({
         slotId: input.slotId,
         generationIndex: input.generationIndex,
@@ -133,9 +157,39 @@ export async function renderZellijSlotPaneFromArtifacts(input) {
         eventLines: eventRows.map(formatArtifactEvent).filter(Boolean),
         stdoutTail: await readTextTailLines(path.join(artifactDir, 'worker.stdout.log'), 2),
         stderrTail: await readTextTailLines(path.join(artifactDir, 'worker.stderr.log'), 1),
+        qaAppHandoffPending: ['pending', 'blocked_for_desktop_review'].includes(String(qaAppHandoff?.status || '')),
+        qaAppHandoffArtifact: qaAppHandoff?.artifact_path || null,
         mode: input.mode || 'compact-slots'
     });
 }
+async function readQaAppHandoffNearArtifactDir(artifactDir) {
+    let current = path.resolve(artifactDir);
+    for (let i = 0; i < 8; i += 1) {
+        const candidate = path.join(current, 'qa-loop', 'app-handoff.json');
+        const json = await readJson(candidate);
+        if (json)
+            return json;
+        const next = path.dirname(current);
+        if (next === current)
+            break;
+        current = next;
+    }
+    return null;
+}
+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 +213,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 +228,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 +238,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 +266,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

package/dist/scripts/prepublish-release-check-or-fast.js

@@ -4,7 +4,7 @@
 //
 // Fast path: accept a current release-check stamp.
 // Repair path: if the stamp is missing/stale, run the authoritative full
-// `release:check` once, then require the fast check to pass.
+// `release:check:full` once, then require the fast check to pass.
 //
 // This keeps direct `npm publish` usable without weakening the publish gate:
 // stale stamp repair is the full release gate, not a synthetic stamp write.
@@ -37,7 +37,7 @@ function runReleaseCheck() {
             stdio: 'inherit'
         });
     }
-    return spawnSync(npmCmd, ['run', 'release:check'], {
+    return spawnSync(npmCmd, ['run', 'release:check:full'], {
         cwd: process.cwd(),
         encoding: 'utf8',
         env: process.env,
@@ -82,7 +82,7 @@ function main() {
         console.error('Prepublish release-check auto-repair disabled by SKS_PREPUBLISH_RUN_RELEASE_CHECK_ON_STALE=0.');
         process.exit(first.status || 1);
     }
-    console.error('Prepublish release stamp is stale or missing; running full `npm run release:check` before publish.');
+    console.error('Prepublish release stamp is stale or missing; running full `npm run release:check:full` before publish.');
     const releaseCheck = runReleaseCheck();
     if (releaseCheck.status !== 0)
         process.exit(releaseCheck.status || 1);

package/dist/scripts/release-gate-existence-audit.js

@@ -84,7 +84,11 @@ const required = [
     'git-collaboration:e2e'
 ];
 assertGate(releaseManifest.schema === 'sks.release-gates.v2', 'release gate manifest schema mismatch', { schema: releaseManifest.schema });
-assertGate(String(scripts['release:check'] || '').includes('release-gate-dag-runner') && String(scripts['release:check'] || '').includes('--preset release'), 'release:check must use the v2 DAG release preset', { release_check: scripts['release:check'] });
+const releaseCheck = String(scripts['release:check'] || '');
+const releaseCheckTarget = releaseCheck.includes('release:check:affected')
+    ? String(scripts['release:check:affected'] || '')
+    : releaseCheck;
+assertGate(releaseCheckTarget.includes('release-gate-dag-runner') && /--preset\s+(?:release|affected)/.test(releaseCheckTarget), 'release:check must use the v2 DAG release/affected preset', { release_check: scripts['release:check'], resolved_release_check: releaseCheckTarget });
 assertGate(releaseGates.length > 0, 'release v2 manifest must include release preset gates', { gate_count: releaseGates.length });
 for (const name of required) {
     assertGate(Boolean(scripts[name]), `missing release gate script: ${name}`, { required });

package/dist/scripts/release-speed-summary.js

@@ -9,19 +9,39 @@ const runs = fs.existsSync(reports)
     : [];
 const latest = runs.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs)[0];
 const summary = latest ? JSON.parse(fs.readFileSync(latest, 'utf8')) : null;
+const mode = summary?.affected_selection?.mode || summary?.selected_preset || (summary?.full === true ? 'full' : 'unknown');
+const affectedMode = mode === 'affected';
+const latestRuntimeProof = latestRuntimeProofSummaryPath();
 console.log(JSON.stringify({
     schema: 'sks.release-speed-summary.v1',
     ok: true,
     report: latest || null,
-    mode: summary?.affected_selection?.mode || (summary?.full === true ? 'full' : 'unknown'),
+    mode,
+    affected_mode: affectedMode,
+    affected_mode_warning: affectedMode ? 'Affected mode: true. This is not a full publish gate. Run npm run release:check:full before publishing.' : null,
     selected_gates: summary?.selected_gates || 0,
+    selected_gate_ids: summary?.selected_gate_ids || [],
     skipped_by_affected: summary?.skipped_by_affected?.length || 0,
+    skipped_gate_ids: summary?.skipped_by_affected || [],
     cached: summary?.cached || 0,
+    cached_gates: summary?.cached_gates || [],
     executed: summary?.executed_gates?.length || 0,
+    executed_gates: summary?.executed_gates || [],
     wall_ms: summary?.wall_ms || 0,
     cpu_time_saved_ms: summary?.cpu_time_saved_ms || 0,
     parallelism_gain: summary?.parallelism_gain || 0,
     max_running: summary?.peak_running || summary?.max_running || 0,
-    slowest_gates: summary?.slowest_gates || []
+    slowest_gates: summary?.slowest_gates || [],
+    proof_file_path: latestRuntimeProof
 }, null, 2));
+function latestRuntimeProofSummaryPath() {
+    const missions = path.join(root, '.sneakoscope', 'missions');
+    if (!fs.existsSync(missions))
+        return null;
+    const files = fs.readdirSync(missions)
+        .map((name) => path.join(missions, name, 'agents', 'runtime-proof-summary.json'))
+        .filter((file) => fs.existsSync(file))
+        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    return files[0] || null;
+}
 //# sourceMappingURL=release-speed-summary.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.16",
+  "version": "2.0.18",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -325,7 +325,7 @@
     "publish:dry": "npm run release:metadata && npm run release:version-truth && npm run publish:packlist-performance && npm run release:check:full && node ./dist/scripts/check-publish-tag.js && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && npm run release:dist-freshness && node ./dist/scripts/release-registry-check.js --require-unpublished && npm --cache /tmp/sks-npm-cache publish --dry-run --ignore-scripts --registry https://registry.npmjs.org/ --access public",
     "publish:npm": "npm --cache /tmp/sks-npm-cache publish --registry https://registry.npmjs.org/ --access public",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run release:metadata && npm run release:version-truth && npm run release:dist-freshness && npm run publish:packlist-performance && npm run release:check:full && node ./dist/scripts/check-publish-tag.js && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && node ./dist/scripts/release-registry-check.js --require-unpublished --require-publish-auth",
+    "prepublishOnly": "npm run release:metadata && npm run release:version-truth && npm run release:dist-freshness && npm run publish:packlist-performance && node ./dist/scripts/prepublish-release-check-or-fast.js && node ./dist/scripts/check-publish-tag.js && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && node ./dist/scripts/release-registry-check.js --require-unpublished --require-publish-auth",
     "dist:check": "node ./dist/scripts/check-dist-runtime.js",
     "ux-review:run-wires-imagegen": "node ./dist/scripts/ux-review-run-wires-imagegen-check.js",
     "ux-review:extract-wires-real-extractor": "node ./dist/scripts/ux-review-extract-wires-real-extractor-check.js",
@@ -557,6 +557,29 @@
     "release:check:dag:explain": "node ./dist/scripts/release-gate-dag-runner.js --preset release --explain",
     "release:check:dag:no-cache": "node ./dist/scripts/release-gate-dag-runner.js --preset release --no-cache",
     "release:check:dag:fail-fast": "node ./dist/scripts/release-gate-dag-runner.js --preset release --fail-fast",
+    "codex:0138-capability": "node ./dist/scripts/codex-0138-capability-check.js",
+    "codex:0138-capability-artifact": "node ./dist/scripts/codex-0138-capability-artifact-check.js",
+    "codex-sdk:version-compat": "node ./dist/scripts/codex-sdk-version-compat-check.js",
+    "codex-app:handoff": "node ./dist/scripts/codex-app-handoff-check.js",
+    "qa-loop:app-handoff": "node ./dist/scripts/qa-loop-app-handoff-check.js",
+    "qa-loop:app-handoff-capability": "node ./dist/scripts/qa-loop-app-handoff-capability-check.js",
+    "qa-loop:app-handoff-cli": "node ./dist/scripts/qa-loop-app-handoff-cli-check.js",
+    "zellij:qa-app-handoff-status": "node ./dist/scripts/zellij-qa-app-handoff-status-check.js",
+    "codex-plugin:json": "node ./dist/scripts/codex-plugin-json-check.js",
+    "codex-plugin:inventory": "node ./dist/scripts/codex-plugin-inventory-check.js",
+    "mcp:plugin-inventory": "node ./dist/scripts/mcp-plugin-inventory-check.js",
+    "codex-plugin:app-template-policy": "node ./dist/scripts/codex-plugin-app-template-policy-check.js",
+    "image:artifact-path-contract": "node ./dist/scripts/image-artifact-path-contract-check.js",
+    "qa-loop:image-path-exposure": "node ./dist/scripts/qa-loop-image-path-exposure-check.js",
+    "image:generation-path-handoff": "node ./dist/scripts/image-generation-path-handoff-check.js",
+    "image:followup-edit-path": "node ./dist/scripts/image-followup-edit-path-check.js",
+    "codex:effort-order": "node ./dist/scripts/codex-effort-order-check.js",
+    "qa-loop:effort-escalation": "node ./dist/scripts/qa-loop-effort-escalation-check.js",
+    "codex:account-usage": "node ./dist/scripts/codex-account-usage-check.js",
+    "qa-loop:budget-policy": "node ./dist/scripts/qa-loop-budget-policy-check.js",
+    "naruto:parallel-gate-consistency": "node ./dist/scripts/naruto-parallel-gate-consistency-check.js",
+    "codex:0138-doctor": "node ./dist/scripts/codex-0138-doctor-check.js",
+    "doctor:codex-0138-fix": "node ./dist/scripts/doctor-codex-0138-fix-check.js",
     "release:dag-runner": "node ./dist/scripts/release-gate-dag-runner-check.js",
     "release:parallel-speed-budget": "node ./dist/scripts/release-parallel-speed-budget-check.js",
     "release:stability-report": "node ./dist/scripts/release-stability-report-check.js",
@@ -646,7 +669,18 @@
     "naruto:ssot-gate-aliases": "node ./dist/scripts/naruto-ssot-gate-aliases-check.js",
     "naruto:ssot-pipeline-default": "node ./dist/scripts/naruto-ssot-pipeline-default-check.js",
     "team:alias-to-naruto": "node ./dist/scripts/team-alias-to-naruto-check.js",
-    "release:speed-summary:report": "node ./dist/scripts/release-speed-summary.js"
+    "release:speed-summary:report": "node ./dist/scripts/release-speed-summary.js",
+    "parallel:strict-pid-proof": "node ./dist/scripts/parallel-strict-pid-proof-check.js",
+    "parallel:missing-pid-rejection": "node ./dist/scripts/parallel-missing-pid-rejection-check.js",
+    "scheduler:utilization-integral": "node ./dist/scripts/scheduler-utilization-integral-check.js",
+    "scheduler:parallel-proof-consistency": "node ./dist/scripts/scheduler-parallel-proof-consistency-check.js",
+    "zellij:slot-telemetry-live-flush": "node ./dist/scripts/zellij-slot-telemetry-live-flush-check.js",
+    "zellij:slot-pane-stale-detection": "node ./dist/scripts/zellij-slot-pane-stale-detection-check.js",
+    "mad-db:lifecycle-hook-decision": "node ./dist/scripts/mad-db-lifecycle-hook-decision-check.js",
+    "mad-db:mcp-result-lifecycle": "node ./dist/scripts/mad-db-mcp-result-lifecycle-check.js",
+    "mad-db:operation-lifecycle-blackbox": "node ./dist/scripts/mad-db-operation-lifecycle-blackbox.js",
+    "runtime:proof-summary": "node ./dist/scripts/runtime-proof-summary-check.js",
+    "runtime:proof-summary-cli": "node ./dist/scripts/runtime-proof-summary-cli-check.js"
   },
   "keywords": [
     "sneakoscope",
@@ -700,7 +734,7 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@openai/codex-sdk": "0.137.0",
+    "@openai/codex-sdk": "^0.138.0",
     "figlet": "^1.11.0",
     "typescript": "^5.9.3"
   },