sneakoscope 3.1.12 → 3.1.13

package/dist/core/doctor/doctor-repair-postcheck.js

@@ -1,11 +1,17 @@
 import {} from './doctor-transaction.js';
 export function doctorRepairPostcheck(transaction) {
+    const phases = transaction?.phases || [];
+    const requiredBlockers = phases
+        .filter((phase) => phase.required_for_ready !== false && phase.ok !== true)
+        .flatMap((phase) => phase.blockers.length ? phase.blockers : [`required_phase_not_ready:${phase.id}`]);
     return {
         schema: 'sks.doctor-repair-postcheck.v1',
-        ok: transaction?.postcheck_ok === true,
+        ok: transaction?.postcheck_ok === true && requiredBlockers.length === 0,
         transaction_ok: transaction?.ok === true,
-        manual_required: (transaction?.phases || []).filter((phase) => phase.manual_required).map((phase) => phase.id),
-        blockers: (transaction?.phases || []).flatMap((phase) => phase.blockers)
+        required_ready: requiredBlockers.length === 0,
+        manual_required: phases.filter((phase) => phase.manual_required).map((phase) => phase.id),
+        optional_manual_required: phases.filter((phase) => phase.manual_required && phase.required_for_ready === false).map((phase) => phase.id),
+        blockers: [...new Set([...requiredBlockers, ...phases.flatMap((phase) => phase.blockers)])]
     };
 }
 //# sourceMappingURL=doctor-repair-postcheck.js.map

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

@@ -1,5 +1,65 @@
 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) => ({
@@ -7,11 +67,16 @@ export async function writeDoctorFixTransaction(input) {
         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
+        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);
+    const postcheckOk = phases.every((phase) => phase.ok || (phase.manual_required && !phase.required_for_ready));
     const report = {
         schema: 'sks.doctor-fix-transaction.v1',
         ok: postcheckOk,
@@ -27,4 +92,35 @@ export async function writeDoctorFixTransaction(input) {
         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

@@ -1,6 +1,6 @@
 import path from 'node:path';
-import { nowIso, writeJsonAtomic } from '../fsx.js';
-import { mcpServerBlock, mcpServerExplicitlyDisabled, readProjectCodexConfig } from '../mcp/mcp-config-preservation.js';
+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);
@@ -8,8 +8,22 @@ export async function repairSupabaseMcp(input) {
     const block = mcpServerBlock(config.text, 'supabase') || '';
     const configured = Boolean(block);
     const tokenEnvPresent = Boolean(process.env.SUPABASE_ACCESS_TOKEN);
-    const unsafeWriteAccess = configured && !/read[_-]?only\s*=\s*true|access_mode\s*=\s*"read-only"|--read-only/.test(block) && /write|service_role|SUPABASE_ACCESS_TOKEN/.test(block);
-    const manualRequired = configured && !disabled && (!tokenEnvPresent || unsafeWriteAccess);
+    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(),
@@ -17,20 +31,36 @@ export async function repairSupabaseMcp(input) {
         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: unsafeWriteAccess ? ['supabase_mcp_write_access_not_safe_by_default'] : [],
-        warnings: configured && !tokenEnvPresent ? ['supabase_access_token_unset_write_features_manual_required'] : [],
+        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.12';
+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

@@ -7,24 +7,47 @@ export async function readProjectCodexConfig(root) {
     return { path: file, text };
 }
 export function mcpServerBlock(text, serverName) {
-    const escaped = serverName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const re = new RegExp(`(^\\[mcp_servers\\.${escaped}\\]\\n[\\s\\S]*?)(?=^\\[|(?![\\s\\S]))`, 'm');
-    return String(text || '').match(re)?.[1] || null;
+    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 escaped = serverName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     const normalizedBlock = block.endsWith('\n') ? block : `${block}\n`;
-    const re = new RegExp(`(^\\[mcp_servers\\.${escaped}\\]\\n[\\s\\S]*?)(?=^\\[|(?![\\s\\S]))`, 'm');
-    if (re.test(text))
-        return text.replace(re, normalizedBlock);
+    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.12';
+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/scripts/codex-0140-feature-gate-lib.js

@@ -6,7 +6,9 @@ export async function runCodex0140FeatureGate(gate, feature) {
     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);
-    assertGate(cap.features[feature] === true, `${gate} requires feature ${feature}`, cap);
-    emitGate(gate, { feature, schema: cap.schema });
+    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-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.12",
+  "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",
@@ -33,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",
@@ -925,12 +926,15 @@
     "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",
-    "release:gate-script-parity": "node ./dist/scripts/release-gate-script-parity-check.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",
@@ -943,6 +947,8 @@
     "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",
@@ -950,7 +956,9 @@
     "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",
-    "sks:3112-all-feature-regression": "node ./dist/scripts/sks-3112-all-feature-regression-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",