sneakoscope 3.1.11 → 3.1.13

package/dist/core/doctor/doctor-transaction.js

@@ -0,0 +1,126 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+export async function runDoctorFixTransaction(input) {
+    const startedAt = nowIso();
+    const phases = [];
+    let rollbackPerformed = false;
+    for (const definition of input.phases) {
+        const phaseStarted = nowIso();
+        const startedMs = Date.now();
+        let phase = {
+            id: definition.id,
+            ok: false,
+            repaired: false,
+            manual_required: false,
+            required_for_ready: definition.required_for_ready !== false,
+            blockers: [],
+            warnings: [],
+            artifact_path: null,
+            started_at: phaseStarted
+        };
+        try {
+            const result = await definition.run();
+            phase = normalizePhase(definition, result, phase, startedMs);
+            if (definition.postcheck) {
+                const postcheck = await definition.postcheck(phase);
+                if (postcheck)
+                    phase = mergePhase(phase, postcheck);
+            }
+        }
+        catch (err) {
+            phase = normalizePhase(definition, {
+                id: definition.id,
+                ok: false,
+                blockers: [messageOf(err)]
+            }, phase, startedMs);
+        }
+        if (!phase.ok && definition.rollback) {
+            try {
+                await definition.rollback(phase);
+                phase.rollback_performed = true;
+                rollbackPerformed = true;
+            }
+            catch (err) {
+                phase.rollback_performed = true;
+                rollbackPerformed = true;
+                phase.blockers = [...(phase.blockers || []), `rollback_failed:${messageOf(err)}`];
+            }
+        }
+        phase.completed_at = phase.completed_at || nowIso();
+        phase.duration_ms = phase.duration_ms ?? Math.max(0, Date.now() - startedMs);
+        phases.push(phase);
+    }
+    const writeInput = {
+        root: input.root,
+        startedAt,
+        phases,
+        rollbackPerformed
+    };
+    if (input.reportPath !== undefined)
+        writeInput.reportPath = input.reportPath;
+    return writeDoctorFixTransaction(writeInput);
+}
+export async function writeDoctorFixTransaction(input) {
+    const root = path.resolve(input.root);
+    const phases = input.phases.map((phase) => ({
+        id: phase.id,
+        ok: phase.ok === true,
+        repaired: phase.repaired === true,
+        manual_required: phase.manual_required === true,
+        required_for_ready: phase.required_for_ready !== false,
+        blockers: phase.blockers || [],
+        warnings: phase.warnings || [],
+        artifact_path: phase.artifact_path || null,
+        started_at: phase.started_at || null,
+        completed_at: phase.completed_at || null,
+        duration_ms: Number.isFinite(phase.duration_ms) ? Number(phase.duration_ms) : null,
+        rollback_performed: phase.rollback_performed === true
+    }));
+    const postcheckOk = phases.every((phase) => phase.ok || (phase.manual_required && !phase.required_for_ready));
+    const report = {
+        schema: 'sks.doctor-fix-transaction.v1',
+        ok: postcheckOk,
+        root,
+        started_at: input.startedAt || nowIso(),
+        completed_at: nowIso(),
+        phases,
+        postcheck_ok: postcheckOk,
+        rollback_performed: input.rollbackPerformed === true,
+        raw_secret_values_recorded: false
+    };
+    if (input.reportPath !== null)
+        await writeJsonAtomic(input.reportPath || path.join(root, '.sneakoscope', 'reports', 'doctor-fix-transaction.json'), report).catch(() => undefined);
+    return report;
+}
+function normalizePhase(definition, result, fallback, startedMs) {
+    const phase = result || fallback;
+    return {
+        id: phase.id || definition.id,
+        ok: phase.ok === true,
+        repaired: phase.repaired === true,
+        manual_required: phase.manual_required === true,
+        required_for_ready: phase.required_for_ready ?? definition.required_for_ready !== false,
+        blockers: phase.blockers || [],
+        warnings: phase.warnings || [],
+        artifact_path: phase.artifact_path || null,
+        started_at: phase.started_at || fallback.started_at || nowIso(),
+        completed_at: phase.completed_at || nowIso(),
+        duration_ms: phase.duration_ms ?? Math.max(0, Date.now() - startedMs),
+        rollback_performed: phase.rollback_performed === true
+    };
+}
+function mergePhase(phase, update) {
+    return {
+        ...phase,
+        ...update,
+        ok: phase.ok === true && update.ok !== false,
+        repaired: phase.repaired === true || update.repaired === true,
+        manual_required: phase.manual_required === true || update.manual_required === true,
+        blockers: [...(phase.blockers || []), ...(update.blockers || [])],
+        warnings: [...(phase.warnings || []), ...(update.warnings || [])]
+    };
+}
+function messageOf(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=doctor-transaction.js.map

package/dist/core/doctor/supabase-mcp-repair.js

@@ -0,0 +1,66 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { mcpServerBlock, mcpServerExplicitlyDisabled, readProjectCodexConfig, replaceOrAppendMcpServerBlock } from '../mcp/mcp-config-preservation.js';
+export async function repairSupabaseMcp(input) {
+    const root = path.resolve(input.root);
+    const config = await readProjectCodexConfig(root);
+    const disabled = mcpServerExplicitlyDisabled(config.text, 'supabase') || mcpServerExplicitlyDisabled(config.text, 'supabase_sauron');
+    const block = mcpServerBlock(config.text, 'supabase') || '';
+    const configured = Boolean(block);
+    const tokenEnvPresent = Boolean(process.env.SUPABASE_ACCESS_TOKEN);
+    const readOnlyBefore = /read[_-]?only\s*=\s*true|access_mode\s*=\s*"read-only"|--read-only/.test(block);
+    const unsafeWriteAccessBefore = configured && !disabled && !readOnlyBefore && /write|service_role|SUPABASE_ACCESS_TOKEN/.test(block);
+    let afterText = config.text;
+    let readOnlyMigrated = false;
+    if (configured && !disabled && !readOnlyBefore && input.apply) {
+        afterText = replaceOrAppendMcpServerBlock(config.text, 'supabase', setReadOnly(block));
+        readOnlyMigrated = afterText !== config.text;
+        if (readOnlyMigrated)
+            await writeTextAtomic(config.path, afterText);
+    }
+    const afterBlock = readOnlyMigrated ? mcpServerBlock(afterText, 'supabase') || '' : block;
+    const readOnlyAfter = /read[_-]?only\s*=\s*true|access_mode\s*=\s*"read-only"|--read-only/.test(afterBlock);
+    const unsafeWriteAccess = configured && !disabled && !readOnlyAfter && /write|service_role|SUPABASE_ACCESS_TOKEN/.test(afterBlock);
+    const writeScopeRequiresConfirmation = configured && !disabled && (unsafeWriteAccessBefore || !readOnlyAfter);
+    const readyBlocking = unsafeWriteAccess;
+    const manualRequired = configured && !disabled && (!tokenEnvPresent || writeScopeRequiresConfirmation);
+    const report = {
+        schema: 'sks.doctor-supabase-mcp-repair.v1',
+        generated_at: nowIso(),
+        ok: !configured || disabled || !unsafeWriteAccess,
+        apply: input.apply === true,
+        configured,
+        disabled,
+        disabled_preserved: disabled,
+        token_env_present: tokenEnvPresent,
+        unsafe_write_access: unsafeWriteAccess,
+        read_only_migrated: readOnlyMigrated,
+        write_scope_requires_confirmation: writeScopeRequiresConfirmation,
+        ready_blocking: readyBlocking,
+        manual_required: manualRequired,
+        next_action: manualRequired
+            ? tokenEnvPresent
+                ? 'Set Supabase MCP to read-only or explicitly approve write-scoped MCP use.'
+                : 'Set SUPABASE_ACCESS_TOKEN only if Supabase write MCP features are required; otherwise keep Supabase MCP disabled/read-only.'
+            : null,
+        blockers: readyBlocking ? ['supabase_mcp_write_access_not_safe_by_default'] : [],
+        warnings: [
+            ...(configured && !tokenEnvPresent ? ['supabase_access_token_unset_write_features_manual_required'] : []),
+            ...(readOnlyMigrated ? ['supabase_mcp_migrated_to_read_only'] : [])
+        ],
+        raw_secret_values_recorded: false
+    };
+    if (input.reportPath !== null)
+        await writeJsonAtomic(input.reportPath || path.join(root, '.sneakoscope', 'reports', 'doctor-supabase-mcp-repair.json'), report).catch(() => undefined);
+    return report;
+}
+function setReadOnly(block) {
+    const lines = String(block || '').replace(/\s*$/, '').split(/\r?\n/);
+    const index = lines.findIndex((line) => /^\s*read[_-]?only\s*=/.test(line));
+    if (index >= 0)
+        lines[index] = 'read_only = true';
+    else
+        lines.push('read_only = true');
+    return `${lines.join('\n')}\n`;
+}
+//# sourceMappingURL=supabase-mcp-repair.js.map

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

package/dist/core/loops/loop-concurrency-budget.js

@@ -3,6 +3,10 @@ import { writeJsonAtomic } from '../fsx.js';
 import { loopConcurrencyBudgetPath } from './loop-artifacts.js';
 export function computeLoopConcurrencyBudget(input) {
     const env = input.env || process.env;
+    const codexUsageSignal = input.codexUsageSignal || codexUsageSignalFromEnv(env);
+    const usageBudgetSource = codexUsageSignal.available && (codexUsageSignal.certainty === 'actual' || codexUsageSignal.certainty === 'discovered')
+        ? 'codex-0140-usage'
+        : 'sks-local-estimate';
     const cores = Math.max(1, os.cpus().length || 1);
     const requestedLoops = input.parallelism === 'safe' ? 2 : input.parallelism === 'extreme' ? Math.min(16, cores) : Math.min(8, cores);
     const envLoops = positiveInt(env.SKS_LOOP_MAX_ACTIVE_LOOPS);
@@ -32,6 +36,8 @@ export function computeLoopConcurrencyBudget(input) {
     return {
         schema: 'sks.loop-concurrency-budget.v1',
         mission_id: input.plan.mission_id,
+        usage_budget_source: usageBudgetSource,
+        codex_usage_signal: codexUsageSignal,
         max_active_loops: maxActiveLoops,
         max_active_workers: maxActiveWorkers,
         max_model_calls: maxModelCalls,
@@ -52,4 +58,20 @@ function positiveInt(value) {
     const number = Number(value);
     return Number.isFinite(number) && number >= 1 ? Math.floor(number) : null;
 }
+function codexUsageSignalFromEnv(env) {
+    const certainty = normalizeUsageCertainty(env.SKS_CODEX_0140_USAGE_CERTAINTY);
+    const available = env.SKS_CODEX_0140_USAGE_AVAILABLE === '1' || certainty === 'actual' || certainty === 'discovered';
+    return {
+        available,
+        certainty,
+        source: available ? 'env' : 'none',
+        evidence: env.SKS_CODEX_0140_USAGE_EVIDENCE ? [env.SKS_CODEX_0140_USAGE_EVIDENCE] : [],
+        warnings: available ? [] : ['codex_0140_usage_signal_unavailable_using_local_estimate']
+    };
+}
+function normalizeUsageCertainty(value) {
+    if (value === 'actual' || value === 'discovered' || value === 'fixture' || value === 'assumed_by_version')
+        return value;
+    return 'unverified';
+}
 //# sourceMappingURL=loop-concurrency-budget.js.map

package/dist/core/mcp/mcp-config-preservation.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export const CONTEXT7_REMOTE_MCP_URL = 'https://mcp.context7.com/mcp';
+export async function readProjectCodexConfig(root) {
+    const file = path.join(path.resolve(root), '.codex', 'config.toml');
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    return { path: file, text };
+}
+export function mcpServerBlock(text, serverName) {
+    const range = tomlTableRange(text, `mcp_servers.${serverName}`, false);
+    return range ? String(text || '').slice(range.start, range.end) : null;
+}
+export function mcpServerBlockWithChildren(text, serverName) {
+    const range = tomlTableRange(text, `mcp_servers.${serverName}`, true);
+    return range ? String(text || '').slice(range.start, range.end) : null;
+}
+export function mcpServerExplicitlyDisabled(text, serverName) {
+    const block = mcpServerBlock(text, serverName);
+    return Boolean(block && /^\s*disabled\s*=\s*true\s*$/m.test(block));
+}
+export function replaceOrAppendMcpServerBlock(text, serverName, block) {
+    const normalizedBlock = block.endsWith('\n') ? block : `${block}\n`;
+    const range = tomlTableRange(text, `mcp_servers.${serverName}`, true);
+    if (range)
+        return `${text.slice(0, range.start)}${normalizedBlock}${text.slice(range.end).replace(/^\n+/, '')}`;
+    const prefix = text.trim() ? `${text.replace(/\s*$/, '\n\n')}` : '';
+    return `${prefix}${normalizedBlock}`;
+}
+export function removeMcpServerBlock(text, serverName) {
+    const range = tomlTableRange(text, `mcp_servers.${serverName}`, true);
+    if (!range)
+        return text;
+    return `${text.slice(0, range.start).trimEnd()}${range.start > 0 ? '\n\n' : ''}${text.slice(range.end).replace(/^\n+/, '')}`;
+}
+export function redactedMcpText(text) {
+    return String(text || '').replace(/(token|access_token|api_key|secret)\s*=\s*"[^"]*"/gi, '$1 = "<redacted>"');
+}
+export function tomlTableRange(text, table, includeChildren) {
+    const source = String(text || '');
+    const escaped = table.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const header = new RegExp(`(^|\\n)\\s*\\[${escaped}\\]\\s*(?:#.*)?(?:\\n|$)`, 'g');
+    const match = header.exec(source);
+    if (!match)
+        return null;
+    const start = Number(match.index || 0) + (match[1] ? 1 : 0);
+    const rest = source.slice(header.lastIndex);
+    const nextHeader = includeChildren
+        ? rest.search(new RegExp(`\\n\\s*\\[(?!${escaped}(?:\\.|\\]))[^\\]]+\\]\\s*(?:#.*)?(?:\\n|$)`))
+        : rest.search(/\n\s*\[[^\]]+\]\s*(?:#.*)?(?:\n|$)/);
+    const end = nextHeader >= 0 ? header.lastIndex + nextHeader : source.length;
+    return { start, end };
+}
+//# sourceMappingURL=mcp-config-preservation.js.map

package/dist/core/naruto/naruto-loop-mesh.js

@@ -10,7 +10,11 @@ export async function runNarutoLoopMesh(input) {
     await writeJsonAtomic(`${loopRoot(input.root, input.plan.mission_id)}/naruto-loop-worker-routes.json`, {
         schema: 'sks.naruto-loop-worker-routes.v1',
         mission_id: input.plan.mission_id,
-        active_worker_budget: activeWorkerBudget,
+        active_worker_budget: {
+            ...activeWorkerBudget,
+            usage_budget_source: loopConcurrencyBudget.usage_budget_source,
+            codex_usage_signal: loopConcurrencyBudget.codex_usage_signal
+        },
         loop_concurrency_budget: loopConcurrencyBudget,
         routes
     });

package/dist/core/version.js

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

package/dist/core/zellij/zellij-fake-adapter.js

@@ -13,8 +13,14 @@ export async function runFakeZellij(args = [], opts = {}) {
         result = ok(`zellij ${version}\n`);
     }
     else if (args[0] === 'attach' && args[1] === '--create-background') {
-        getSession(String(args[2] || 'default'));
-        result = ok('');
+        const name = String(args[2] || 'default');
+        if (env.SKS_ZELLIJ_FAKE_CREATE_BACKGROUND_EXISTS === '1' && sessions.has(name)) {
+            result = fail(`Session already exists: ${name}`);
+        }
+        else {
+            getSession(name);
+            result = ok('');
+        }
     }
     else if (args.includes('new-pane')) {
         if (args.includes('--stacked') && !supportsStacked(version)) {

package/dist/core/zellij/zellij-launcher.js

@@ -57,6 +57,9 @@ export async function launchZellijLayout(opts = {}) {
         ok: false,
         blockers: [`zellij_pane_proof_exception:${err?.message || String(err)}`]
     }));
+    if (launch?.create_background) {
+        launch.create_background = normalizeExistingZellijSession(sessionName, launch.create_background);
+    }
     const launchOk = launch?.create_background?.ok === true;
     const ok = capability.ok && (opts.dryRun === true || capability.status !== 'ok' || launchOk) && (opts.requireZellij === true ? paneProof.ok === true : true);
     const blockers = [
@@ -192,4 +195,17 @@ function readOption(args, name, fallback) {
     const index = list.indexOf(name);
     return index >= 0 && list[index + 1] ? String(list[index + 1]) : fallback;
 }
+function normalizeExistingZellijSession(sessionName, result) {
+    if (result.ok)
+        return result;
+    if (/Session already exists/i.test(result.stderr_tail || '')) {
+        return {
+            ...result,
+            ok: true,
+            blockers: [],
+            warnings: [...result.warnings, `zellij_session_already_exists:${sessionName}`]
+        };
+    }
+    return result;
+}
 //# sourceMappingURL=zellij-launcher.js.map

package/dist/core/zellij/zellij-worker-pane-manager.js

@@ -311,6 +311,20 @@ export async function openWorkerPane(input) {
         const stdoutPaneId = launch?.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
         const reconciledPane = stdoutPaneId ? null : launch?.ok ? await reconcileZellijWorkerPaneId(input.sessionName, paneName, path.join(root, input.resultPath), cwd) : null;
         const paneId = stdoutPaneId || reconciledPane?.pane_id || null;
+        const stackPaneIds = [...new Set([
+                ...(freshState?.visible_worker_panes || [])
+                    .filter((pane) => pane.pane_id && (pane.status === 'launching' || pane.status === 'running'))
+                    .sort((a, b) => Number(a.y_order || 0) - Number(b.y_order || 0))
+                    .map((pane) => String(pane.pane_id)),
+                paneId || ''
+            ].filter(Boolean))];
+        const stackPanes = stackRequested && paneId && stackPaneIds.length >= 2
+            ? await runZellij(['--session', input.sessionName, 'action', 'stack-panes', '--', ...stackPaneIds], {
+                cwd,
+                timeoutMs: 5000,
+                optional: true
+            })
+            : null;
         const renamePane = paneId ? await renameZellijPaneById(input.sessionName, paneId, paneName, cwd) : null;
         const paneIdSource = stdoutPaneId
             ? 'zellij_worker_new_pane_stdout'
@@ -329,7 +343,8 @@ export async function openWorkerPane(input) {
         ];
         const warnings = [
             ...(stackIntent && stackedCapability && !stackedCapability.supports_stacked_panes ? [`zellij_stacked_pane_fallback:${stackedCapability.fallback_mode}`] : []),
-            ...(stackedRejectedFallback ? ['zellij_stacked_pane_rejected_fallback_down'] : [])
+            ...(stackedRejectedFallback ? ['zellij_stacked_pane_rejected_fallback_down'] : []),
+            ...(stackPanes && !stackPanes.ok ? stackPanes.blockers.map((blocker) => `zellij_stack_panes_reconcile_${blocker}`) : [])
         ];
         const record = buildWorkerPaneArtifact({
             ...input,
@@ -343,7 +358,9 @@ export async function openWorkerPane(input) {
                 focus_degraded: focus ? focus.ok !== true : false,
                 slot_column_anchor_pane_id: slotColumnAnchorPaneId,
                 slot_column_anchor_launch: anchorLaunch,
-                rename_pane: renamePane
+                rename_pane: renamePane,
+                stack_panes: stackPanes,
+                stack_pane_ids: stackPaneIds
             },
             directionRequested,
             directionApplied,

package/dist/scripts/codex-0140-feature-gate-lib.js

@@ -0,0 +1,14 @@
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { detectCodex0140Capability } from '../core/codex-control/codex-0140-capability.js';
+export async function runCodex0140FeatureGate(gate, feature) {
+    process.env.SKS_CODEX_0140_FAKE = '1';
+    process.env.SKS_CODEX_VERSION_FAKE = 'codex-cli 0.140.0';
+    process.env.SKS_CODEX_0140_PROBE = '1';
+    const cap = await detectCodex0140Capability({ codexBin: 'codex' });
+    assertGate(cap.ok === true && cap.supports_0140 === true, `${gate} requires passing Codex 0.140 capability fixture`, cap);
+    const state = cap.feature_states[feature];
+    assertGate(cap.features[feature] === true && state?.supported === true, `${gate} requires feature ${feature}`, cap);
+    assertGate(state.certainty !== 'assumed_by_version' && state.certainty !== 'unverified' && state.certainty !== 'failed', `${gate} requires probed feature certainty for ${feature}`, state);
+    emitGate(gate, { feature, schema: cap.schema, certainty: state.certainty });
+}
+//# sourceMappingURL=codex-0140-feature-gate-lib.js.map

package/dist/scripts/release-3112-required-gates.js

@@ -0,0 +1,30 @@
+export const REQUIRED_3112_RELEASE_IDS = [
+    'release:gate-script-parity',
+    'release:wiring-3112-blackbox',
+    'codex:0140-capability',
+    'codex:0140-feature-probes',
+    'codex:0140-usage',
+    'codex:0140-goal-attachment-preservation',
+    'codex:0140-session-delete',
+    'codex:0140-import',
+    'codex:0140-unified-mentions',
+    'codex:0140-bedrock-managed-auth',
+    'codex:0140-mcp-reliability',
+    'codex:0140-sqlite-recovery',
+    'codex:0140-non-tty-interrupt',
+    'codex:0140-large-repo-performance',
+    'pipeline:codex-0140-integration',
+    'codex:0140-integration-blackbox',
+    'doctor:fix-production-blackbox',
+    'doctor:startup-config-repair',
+    'doctor:startup-config-repair-blackbox',
+    'doctor:context7-mcp-repair',
+    'doctor:context7-mcp-repair-blackbox',
+    'doctor:supabase-mcp-repair',
+    'doctor:supabase-mcp-repair-blackbox',
+    'sks:3112-all-feature-regression'
+];
+export const REQUIRED_3112_REAL_CHECK_IDS = [
+    'codex:0140-real-probes:require-real'
+];
+//# sourceMappingURL=release-3112-required-gates.js.map

package/dist/scripts/release-3113-required-gates.js

@@ -0,0 +1,25 @@
+export const REQUIRED_3113_RELEASE_IDS = [
+    'release:gate-script-parity',
+    'release:wiring-3113-blackbox',
+    'codex:0140-deep-probes',
+    'codex:0140-goal-attachment-roundtrip',
+    'codex:0140-usage-real-parser',
+    'pipeline:codex-0140-integration',
+    'doctor:transaction-engine',
+    'doctor:transaction-engine-blackbox',
+    'doctor:fix-production-blackbox',
+    'doctor:startup-config-repair',
+    'doctor:startup-config-repair-blackbox',
+    'doctor:context7-mcp-repair',
+    'doctor:context7-mcp-repair-blackbox',
+    'doctor:supabase-mcp-repair',
+    'doctor:supabase-mcp-repair-blackbox',
+    'native-capability:postcheck',
+    'secret:line-rollback',
+    'secret:preservation-guard',
+    'sks:3113-all-feature-regression'
+];
+export const REQUIRED_3113_REAL_CHECK_IDS = [
+    'codex:0140-real-probes:require-real'
+];
+//# sourceMappingURL=release-3113-required-gates.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "3.1.11",
+  "version": "3.1.13",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -23,6 +23,8 @@
   },
   "files": [
     "dist",
+    "!dist/*.json",
+    "!dist/.sks-build-stamp.json",
     "!dist/build-manifest.json",
     "!dist/**/*.d.ts",
     "!dist/**/*.d.ts.map",
@@ -31,6 +33,7 @@
     "!dist/vendor/openai-codex/rust-v0.131.0",
     "!dist/scripts/*-blackbox.js",
     "!dist/scripts/*-check.js",
+    "!dist/scripts/*-check-lib.js",
     "!dist/scripts/*-report.js",
     "!dist/scripts/release-readiness-report.js",
     "schemas",
@@ -922,7 +925,40 @@
     "doctor:codex-native-readiness-ux": "node ./dist/scripts/doctor-codex-native-readiness-ux-check.js",
     "doctor:codex-native-repair-actions": "node ./dist/scripts/doctor-codex-native-repair-actions-check.js",
     "codex-native:feature-broker-blackbox": "node ./dist/scripts/codex-native-feature-broker-blackbox.js",
-    "pipeline:codex-native-e2e-blackbox": "node ./dist/scripts/pipeline-codex-native-e2e-blackbox.js"
+    "pipeline:codex-native-e2e-blackbox": "node ./dist/scripts/pipeline-codex-native-e2e-blackbox.js",
+    "release:wiring-3112-blackbox": "node ./dist/scripts/release-wiring-3112-blackbox.js",
+    "release:wiring-3113-blackbox": "node ./dist/scripts/release-wiring-3113-blackbox.js",
+    "codex:0140-capability": "node ./dist/scripts/codex-0140-capability-check.js",
+    "codex:0140-feature-probes": "node ./dist/scripts/codex-0140-feature-probes-check.js",
+    "codex:0140-deep-probes": "node ./dist/scripts/codex-0140-deep-probes-check.js",
+    "codex:0140-usage": "node ./dist/scripts/codex-0140-usage-check.js",
+    "codex:0140-usage-real-parser": "node ./dist/scripts/codex-0140-usage-real-parser-check.js",
+    "codex:0140-goal-attachment-preservation": "node ./dist/scripts/codex-0140-goal-attachment-preservation-check.js",
+    "codex:0140-goal-attachment-roundtrip": "node ./dist/scripts/codex-0140-goal-attachment-roundtrip-check.js",
+    "codex:0140-session-delete": "node ./dist/scripts/codex-0140-session-delete-check.js",
+    "codex:0140-import": "node ./dist/scripts/codex-0140-import-check.js",
+    "codex:0140-unified-mentions": "node ./dist/scripts/codex-0140-unified-mentions-check.js",
+    "codex:0140-bedrock-managed-auth": "node ./dist/scripts/codex-0140-bedrock-managed-auth-check.js",
+    "codex:0140-mcp-reliability": "node ./dist/scripts/codex-0140-mcp-reliability-check.js",
+    "codex:0140-sqlite-recovery": "node ./dist/scripts/codex-0140-sqlite-recovery-check.js",
+    "codex:0140-non-tty-interrupt": "node ./dist/scripts/codex-0140-non-tty-interrupt-check.js",
+    "codex:0140-large-repo-performance": "node ./dist/scripts/codex-0140-large-repo-performance-check.js",
+    "codex:0140-real-probes": "node ./dist/scripts/codex-0140-real-probes-check.js",
+    "codex:0140-real-probes:require-real": "node ./dist/scripts/codex-0140-real-probes-check.js --require-real --allow-network",
+    "pipeline:codex-0140-integration": "node ./dist/scripts/pipeline-codex-0140-integration-check.js",
+    "codex:0140-integration-blackbox": "node ./dist/scripts/codex-0140-integration-blackbox.js",
+    "doctor:transaction-engine": "node ./dist/scripts/doctor-transaction-engine-check.js",
+    "doctor:transaction-engine-blackbox": "node ./dist/scripts/doctor-transaction-engine-blackbox.js",
+    "doctor:fix-production-blackbox": "node ./dist/scripts/doctor-fix-production-blackbox.js",
+    "doctor:startup-config-repair": "node ./dist/scripts/doctor-startup-config-repair-check.js",
+    "doctor:startup-config-repair-blackbox": "node ./dist/scripts/doctor-startup-config-repair-blackbox.js",
+    "doctor:context7-mcp-repair": "node ./dist/scripts/doctor-context7-mcp-repair-check.js",
+    "doctor:context7-mcp-repair-blackbox": "node ./dist/scripts/doctor-context7-mcp-repair-blackbox.js",
+    "doctor:supabase-mcp-repair": "node ./dist/scripts/doctor-supabase-mcp-repair-check.js",
+    "doctor:supabase-mcp-repair-blackbox": "node ./dist/scripts/doctor-supabase-mcp-repair-blackbox.js",
+    "secret:line-rollback": "node ./dist/scripts/secret-line-rollback-check.js",
+    "sks:3112-all-feature-regression": "node ./dist/scripts/sks-3112-all-feature-regression-blackbox.js",
+    "sks:3113-all-feature-regression": "node ./dist/scripts/sks-3113-all-feature-regression-blackbox.js"
   },
   "keywords": [
     "sneakoscope",

package/dist/.sks-build-stamp.json

@@ -1,8 +0,0 @@
-{
-  "schema": "sks.dist-build-stamp.v1",
-  "package_name": "sneakoscope",
-  "package_version": "3.1.11",
-  "source_digest": "932de0e70bb2a5b787aef2782fa56cbc4956c6077d099d9e1067b9406fd8412a",
-  "source_file_count": 2613,
-  "built_at_source_time": 1781554790419
-}