sneakoscope 9.2.6 → 10.0.0

package/README.md

@@ -22,7 +22,7 @@ Proof-first orchestration for Codex CLI, ChatGPT Desktop, AI coding agents, mult
 Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-This README documents package **SKS 9.2.6** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
+This README documents package **SKS 10.0.0** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
 
 Use the official latest stable SKS and Codex CLI releases. The Codex compatibility SSOT is always the **current latest stable** host; capability probes measure what that host can actually do. Product docs do not crown a fixed `0.x.y` string as SSOT (release pins and schema directories are measured artifacts for the current package, not a permanent product version claim). Menu Bar / Center induce updates to the latest stable build. Run `sks update-check` for what is installed and read the capability report for what is supported. Install SSOT is npm `sneakoscope@latest`; PATH `sks` and Menu Bar stamped generation must match that version or gates fail. It resolves managed SKS skills from the authoritative global install, preserves a runnable Naruto child slot when `max_threads=2`, and keeps Menu Bar repair transactional so stamped generations remain verifiable. Naruto uses stable opt-in multi-agent V2 when the host exposes it (Codex official multi-agent wrap-only; SKS does not reimplement a parallel runtime). Local code search is mode-separated (`sks search files|text|structure|symbol|context`); `context` is answered by the compiled TriWiki Context Graph (`context-graph.json` is exhaustive authority; `context-pack.json` and managed `AGENTS.md` are bounded projections) — see [docs/architecture/context-graph.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/architecture/context-graph.md) and [docs/PRODUCT-CONTRACT.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/PRODUCT-CONTRACT.md). See [CHANGELOG.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/CHANGELOG.md).
 
@@ -305,7 +305,7 @@ Adapter rules that keep updates safe:
 | --- | --- | --- |
 | Did tests/typecheck fail? | Another model may say so. | Machine check output is tagged `evidence: machine`. |
 | Are findings ranked? | Usually one blended opinion. | Machine evidence sorts before LLM findings. |
-| Can work stop? | The model decides. | Stop gates, Completion Proof, and Honest Mode decide. |
+| Can work stop? | The model decides. | Safety gates decide (`essential`, default: a finished turn finishes; `strict` adds Stop gates, Completion Proof, and Honest Mode). |
 | Can I inspect agent-thread progress? | Usually no runtime UI. | Use the official Codex subagent/thread surfaces and their proof artifacts. |
 
 ## Demo

package/config/skills-hash-ledger.v1.json

@@ -18,6 +18,7 @@
     {
       "canonical_name": "sks-answer",
       "trusted_sha256": [
+        "0e461537093215960734aaeafdccb125d2c3ca139dab5db8548d5c0bdd14d652",
         "3056ac543fa074868c7023097fdcb042d7175ab557d8e18cb7d92ce872785452",
         "bc8e2fc157b6c9819d32bb0a41bdf7f599a07693df18b0d80aa0ba103594f6eb"
       ]
@@ -65,6 +66,7 @@
     {
       "canonical_name": "sks-computer-use-fast",
       "trusted_sha256": [
+        "1d191ed0f9490fc320dd17b871ca556fa5835bfb372c38b62f3985e3369f685a",
         "57e4c1d04ae785b0a53711e53210f2ddabd6131041b97edb4b6d99f18b24155e",
         "b270d82e4057934d7f92ed4241d4ae86e22d0a9a08bceba1aa179d7535bda042",
         "b8736b2621398dfc85f7a2ff35d7a2fc728db0dfc0e964de69aebff93b5ed897"
@@ -207,6 +209,7 @@
     {
       "canonical_name": "sks-honest-mode",
       "trusted_sha256": [
+        "4a0722737a837b0de895b7c950da216a8641922e4da53d6b9c1681b957340e82",
         "d1216afadecd4d9c85a2fb54bd31ee77ba45f8071f43bb0e21305c5fcd870095",
         "4543d942cac510b1a23e2e842f944d033087bbc761f6abc4a27d0a015bf22235"
       ]
@@ -283,6 +286,7 @@
     {
       "canonical_name": "sks-pipeline-runner",
       "trusted_sha256": [
+        "66e105773b8e042eec5d5679b97b7cb305cad8d45671034907fbfa728fc4d68a",
         "020ba4da2f96bcda23cee4596b1e790816780178f1917dee748ff4b289cba0e5",
         "ffcbe0ea4b585e3d2886f1d9fa7a3b88706aaf42182fb177b2371b76beb0ddcd"
       ]

package/crates/sks-core/Cargo.lock

@@ -259,7 +259,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "9.2.6"
+version = "10.0.0"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "9.2.6"
+version = "10.0.0"
 edition = "2021"
 
 [dependencies]

package/dist/bin/fast-inline.js

@@ -11,9 +11,63 @@ function rootJsonFastInline(fs, cwd = process.cwd()) {
         using_global_root: !project
     })}\n`);
 }
+async function fastDesktopBridgeUpstreamEvidence(home) {
+    const notChecked = (reason) => ({
+        section: { schema: 'sks.desktop-bridge-fast-status.v1', status: 'not_checked', reason, secret_stores_read: false },
+        warnings: [], nextActions: [],
+    });
+    try {
+        const getBuiltinModule = process.getBuiltinModule;
+        const fs = typeof getBuiltinModule === 'function' ? getBuiltinModule('node:fs') : await import('node:fs');
+        const runtime = joinPath(joinPath(home, '.codex'), 'sks');
+        const statePath = joinPath(runtime, 'desktop-bridge-state.json');
+        if (!fs.existsSync(statePath))
+            return notChecked('bridge_state_missing');
+        const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        const startedAt = typeof state.started_at === 'string' ? state.started_at : null;
+        const logPath = joinPath(joinPath(runtime, 'logs'), 'desktop-bridge.out.log');
+        const { BRIDGE_LOG_TAIL_BYTES, UNREACHABLE_UPSTREAM_RECOVERY_ACTION, detectUnreachableUpstreamEvidence } = await import('../core/codex-lb/desktop-bridge/upstream-evidence.js');
+        let tail = '';
+        if (fs.existsSync(logPath)) {
+            const handle = fs.openSync(logPath, 'r');
+            try {
+                const size = fs.fstatSync(handle).size;
+                const start = Math.max(0, size - BRIDGE_LOG_TAIL_BYTES);
+                const buffer = Buffer.alloc(size - start);
+                fs.readSync(handle, buffer, 0, buffer.length, start);
+                tail = buffer.toString('utf8');
+            }
+            finally {
+                fs.closeSync(handle);
+            }
+        }
+        const code = detectUnreachableUpstreamEvidence(tail, startedAt, Date.now());
+        const blockers = code ? [`desktop_bridge_upstream_unreachable:${code}`] : [];
+        return {
+            section: {
+                schema: 'sks.desktop-bridge-fast-status.v1',
+                status: code ? 'upstream_unreachable_evidence' : 'log_evidence_clear',
+                reason: 'fast_readonly_json_log_evidence',
+                secret_stores_read: false,
+                serving_pid: typeof state.pid === 'number' ? state.pid : null,
+                started_at: startedAt,
+                blockers,
+                recovery_actions: code ? [UNREACHABLE_UPSTREAM_RECOVERY_ACTION] : [],
+            },
+            warnings: blockers,
+            nextActions: code ? [UNREACHABLE_UPSTREAM_RECOVERY_ACTION] : [],
+        };
+    }
+    catch {
+        return notChecked('evidence_read_failed');
+    }
+}
 async function doctorJsonFastInline(input = {}) {
     const startedAt = Date.now();
     const write = input.write || ((text) => process.stdout.write(text));
+    const env = input.processEnv || process.env;
+    const home = input.home || env.HOME || env.USERPROFILE || process.cwd();
+    const bridge = await fastDesktopBridgeUpstreamEvidence(home);
     write(`${JSON.stringify({
         schema: 'sks.doctor-status.v3',
         elapsed_ms: Math.max(0, Date.now() - startedAt),
@@ -23,7 +77,7 @@ async function doctorJsonFastInline(input = {}) {
         deep_diagnostics_skipped: true,
         deep_ok: null,
         not_counted_as_full_doctor: true,
-        next_actions: ['Run sks doctor --full --json for deep diagnostics.'],
+        next_actions: ['Run sks doctor --full --json for deep diagnostics.', ...bridge.nextActions],
         fast_path: true,
         profile: 'fast-readonly',
         root: process.cwd(),
@@ -40,13 +94,8 @@ async function doctorJsonFastInline(input = {}) {
         },
         doctor_fix_transaction: null,
         blockers: [],
-        warnings: ['fast_readonly_doctor_skipped_optional_deep_diagnostics'],
-        desktop_bridge: {
-            schema: 'sks.desktop-bridge-fast-status.v1',
-            status: 'not_checked',
-            reason: 'fast_readonly_json',
-            secret_stores_read: false
-        }
+        warnings: ['fast_readonly_doctor_skipped_optional_deep_diagnostics', ...bridge.warnings],
+        desktop_bridge: bridge.section
     }, null, 2)}\n`);
 }
 async function narutoHelpJsonFastInline() {

package/dist/bin/sks-dispatch.js

@@ -27,7 +27,7 @@ async function runSks(args) {
         const { hookUserPromptSubmitPerfInline } = await import('./fast-inline.js');
         await hookUserPromptSubmitPerfInline();
     }
-    else if (args[0] === 'hook' && args[1] && process.env.SKS_HOOK_DAEMON === '1') {
+    else if (args[0] === 'hook' && args[1] && (await import('../core/verification-profile.js')).hookDaemonEnabled()) {
         const { hookDaemonInline } = await import('../core/daemon/sksd-hook-dispatch.js');
         await hookDaemonInline(args[1]);
     }

package/dist/commands/doctor.js

@@ -73,6 +73,11 @@ export async function inspectDoctorDesktopBridgeStatus(input = {}, deps = {}) {
             ? (status.readiness.blockers || []).map(String).filter(Boolean)
             : [];
         const recoveryActions = (status.recovery_actions || []).map(String).filter(Boolean);
+        const warnings = (status.readiness.warnings || []).map(String).filter(Boolean);
+        if (expected && status.readiness.ready !== true && status.readiness.state === 'degraded' && blockers.length === 0) {
+            warnings.push('desktop_bridge_readiness_degraded:transport_unverified_for_current_process');
+            recoveryActions.push('Run `sks bridge verify --level transport` (or `sks doctor --fix`, which re-verifies after its repair) to bind a transport diagnostic to the serving bridge.');
+        }
         if (expected && status.management?.managed === true) {
             const evidence = await (deps.desktopBridgeUpstreamEvidenceImpl || readDesktopBridgeUnreachableUpstreamEvidence)(home).catch(() => null);
             if (evidence) {
@@ -89,7 +94,7 @@ export async function inspectDoctorDesktopBridgeStatus(input = {}, deps = {}) {
             status,
             providers: status.providers,
             blockers,
-            warnings: (status.readiness.warnings || []).map(String).filter(Boolean),
+            warnings,
             recovery_actions: recoveryActions
         };
     }

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "9.2.6",
+  "package_version": "10.0.0",
   "skills": [
     {
       "canonical_name": "sks",
@@ -23,8 +23,9 @@
     {
       "canonical_name": "sks-answer",
       "type": "official",
-      "content_sha256": "3056ac543fa074868c7023097fdcb042d7175ab557d8e18cb7d92ce872785452",
+      "content_sha256": "0e461537093215960734aaeafdccb125d2c3ca139dab5db8548d5c0bdd14d652",
       "hash_history": [
+        "3056ac543fa074868c7023097fdcb042d7175ab557d8e18cb7d92ce872785452",
         "bc8e2fc157b6c9819d32bb0a41bdf7f599a07693df18b0d80aa0ba103594f6eb"
       ],
       "deprecated_aliases": []
@@ -82,8 +83,9 @@
     {
       "canonical_name": "sks-computer-use-fast",
       "type": "official",
-      "content_sha256": "57e4c1d04ae785b0a53711e53210f2ddabd6131041b97edb4b6d99f18b24155e",
+      "content_sha256": "1d191ed0f9490fc320dd17b871ca556fa5835bfb372c38b62f3985e3369f685a",
       "hash_history": [
+        "57e4c1d04ae785b0a53711e53210f2ddabd6131041b97edb4b6d99f18b24155e",
         "b270d82e4057934d7f92ed4241d4ae86e22d0a9a08bceba1aa179d7535bda042",
         "b8736b2621398dfc85f7a2ff35d7a2fc728db0dfc0e964de69aebff93b5ed897"
       ],
@@ -263,8 +265,9 @@
     {
       "canonical_name": "sks-honest-mode",
       "type": "official",
-      "content_sha256": "d1216afadecd4d9c85a2fb54bd31ee77ba45f8071f43bb0e21305c5fcd870095",
+      "content_sha256": "4a0722737a837b0de895b7c950da216a8641922e4da53d6b9c1681b957340e82",
       "hash_history": [
+        "d1216afadecd4d9c85a2fb54bd31ee77ba45f8071f43bb0e21305c5fcd870095",
         "4543d942cac510b1a23e2e842f944d033087bbc761f6abc4a27d0a015bf22235"
       ],
       "deprecated_aliases": []
@@ -351,8 +354,9 @@
     {
       "canonical_name": "sks-pipeline-runner",
       "type": "official",
-      "content_sha256": "020ba4da2f96bcda23cee4596b1e790816780178f1917dee748ff4b289cba0e5",
+      "content_sha256": "66e105773b8e042eec5d5679b97b7cb305cad8d45671034907fbfa728fc4d68a",
       "hash_history": [
+        "020ba4da2f96bcda23cee4596b1e790816780178f1917dee748ff4b289cba0e5",
         "ffcbe0ea4b585e3d2886f1d9fa7a3b88706aaf42182fb177b2371b76beb0ddcd"
       ],
       "deprecated_aliases": []

package/dist/core/codex-hooks/codex-hook-managed-install.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { ensureDir, nowIso, readText, writeTextAtomic } from '../fsx.js';
 import { CODEX_HOOK_EVENTS } from '../codex-compat/codex-hook-events.js';
+import { postToolEvidenceEnabled } from '../verification-profile.js';
 import { buildCodexCommandHookToml, matcherApplies } from './codex-hook-config-writer.js';
 import { readCodexHookActualState } from './codex-hook-actual-discovery.js';
 import { writeTrustedHashStateForHooksFile } from './codex-hook-state-writer.js';
@@ -22,12 +23,13 @@ export async function installManagedCodexHooks(root, opts = {}) {
     const scriptPath = path.join(managedDir, 'sks-managed-hook.sh');
     const tomlPath = path.join(managedDir, 'sks-managed-hooks.toml');
     const binCommand = opts.binCommand || 'sks hook';
-    const hooksToml = CODEX_HOOK_EVENTS.map((event) => buildCodexCommandHookToml({
+    const installedEvents = CODEX_HOOK_EVENTS.filter((event) => event !== 'PostToolUse' || postToolEvidenceEnabled(root));
+    const hooksToml = installedEvents.map((event) => buildCodexCommandHookToml({
         event,
         matcher: matcherApplies(event) ? '*' : null,
         command: `${scriptPath} ${HOOK_SUBCOMMANDS[event] || event}`,
         timeout: event === 'Stop' ? 60 : 30,
-        statusMessage: event === 'Stop' ? 'SKS validating completion proof' : null
+        statusMessage: event === 'Stop' ? 'SKS checking done gate' : null
     })).join('\n');
     const requirementsToml = mergeRequirementsToml(await readText(requirementsPath, ''), {
         managedDir,

package/dist/core/codex-lb/desktop-bridge/server.js

@@ -306,7 +306,7 @@ export async function startPreparedDesktopBridge(input, options = {}) {
     }
     const freshnessMs = input.stateFreshnessMs ?? 5 * 60_000;
     const heartbeat = statePath ? setInterval(() => {
-        void refreshDesktopBridgeState(statePath, state, new Date(), freshnessMs).catch(() => undefined);
+        void refreshDesktopBridgeState(statePath, state, new Date(), freshnessMs, { preserveVerifiedProbeIds: true }).catch(() => undefined);
     }, Math.max(1_000, Math.floor(freshnessMs / 3))) : null;
     heartbeat?.unref();
     let skewCandidate = null;

package/dist/core/codex-lb/desktop-bridge/state.js

@@ -69,11 +69,13 @@ export function isDesktopBridgePublicState(value) {
         && Array.isArray(row.last_verified_probe_ids) && row.last_verified_probe_ids.every(isGeneration)
         && typeof row.config_generation === 'string' && /^[a-f0-9]{64}$/.test(row.config_generation);
 }
-export async function refreshDesktopBridgeState(file, state, now = new Date(), freshnessMs = DEFAULT_FRESHNESS_MS) {
+export async function refreshDesktopBridgeState(file, state, now = new Date(), freshnessMs = DEFAULT_FRESHNESS_MS, options = {}) {
     const current = await readDesktopBridgeState(file).catch(() => null);
     if (!current || current.schema !== DESKTOP_BRIDGE_STATE_SCHEMA || current.pid !== state.pid
         || current.process_generation !== state.process_generation || current.config_generation !== state.config_generation)
         return false;
+    if (options.preserveVerifiedProbeIds)
+        state.last_verified_probe_ids = [...current.last_verified_probe_ids];
     state.updated_at = now.toISOString();
     state.stale_after = new Date(now.getTime() + freshnessMs).toISOString();
     await writeDesktopBridgeState(file, state);

package/dist/core/codex-lb/desktop-bridge/upstream-evidence.js

@@ -0,0 +1,42 @@
+export const BRIDGE_UNREACHABLE_EVIDENCE_WINDOW_MS = 10 * 60_000;
+export const BRIDGE_LOG_TAIL_BYTES = 256 * 1024;
+const UNREACHABLE_REJECTION_CODE = /^bridge_(?:websocket_)?upstream_unavailable/;
+const REROUTED_REJECTION_CODE = /^bridge_upstream_unreachable_rerouted/;
+export function detectUnreachableUpstreamEvidence(logTail, startedAt, nowMs) {
+    const startedMs = startedAt ? Date.parse(startedAt) : Number.NaN;
+    const cutoffMs = Math.max(Number.isFinite(startedMs) ? startedMs : 0, nowMs - BRIDGE_UNREACHABLE_EVIDENCE_WINDOW_MS);
+    let latest = null;
+    let latestReroute = Number.NEGATIVE_INFINITY;
+    for (const line of logTail.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{') || !trimmed.includes('"sks.desktop_bridge.rejected'))
+            continue;
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (record.event !== 'sks.desktop_bridge.rejected' && record.event !== 'sks.desktop_bridge.rejected_summary')
+            continue;
+        const code = typeof record.code === 'string' ? record.code : '';
+        const unreachable = UNREACHABLE_REJECTION_CODE.test(code);
+        const rerouted = !unreachable && REROUTED_REJECTION_CODE.test(code);
+        if (!unreachable && !rerouted)
+            continue;
+        const at = typeof record.at === 'string' ? Date.parse(record.at) : Number.NaN;
+        if (!Number.isFinite(at) || at < cutoffMs)
+            continue;
+        if (rerouted) {
+            latestReroute = Math.max(latestReroute, at);
+            continue;
+        }
+        if (!latest || at > latest.at)
+            latest = { at, code };
+    }
+    if (!latest || latest.at <= latestReroute)
+        return null;
+    return latest.code;
+}
+export const UNREACHABLE_UPSTREAM_RECOVERY_ACTION = 'Run `sks doctor --fix` (or `sks bridge repair`) to restart the Desktop Bridge and re-resolve its upstream address.';

package/dist/core/daemon/sksd-hook-daemon-entrypoint.js

@@ -6,4 +6,4 @@ if (!root) {
     process.stderr.write('sksd-hook-daemon-entrypoint: root argument required\n');
     process.exit(1);
 }
-await startSksdHookDaemon(root, async (name, payload) => evaluateHookPayloadOnce(name, payload, { root }));
+await startSksdHookDaemon(root, async (name, payload) => evaluateHookPayloadOnce(name, payload, { root }), { exitOnRetire: true });

package/dist/core/daemon/sksd-hook-daemon.js

@@ -6,9 +6,11 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { sha256 } from '../fsx.js';
+import { PACKAGE_VERSION } from '../version.js';
 const IDLE_SHUTDOWN_MS = 30 * 60 * 1000;
 const CONNECT_TIMEOUT_MS = 150;
 const REQUEST_TIMEOUT_MS = 5_000;
+export const SKSD_VERSION_MISMATCH_ERROR = 'sksd_version_mismatch';
 export function sksdSocketPath(root) {
     return path.join(sksdRuntimeDir(), `sksd-${projectKey(root)}.sock`);
 }
@@ -125,7 +127,7 @@ async function removeStaleSocketPath(socketPath) {
         throw new Error('unsafe_sksd_socket_path_directory');
     await fsp.rm(socketPath, { force: true });
 }
-export async function startSksdHookDaemon(root, handleHook) {
+export async function startSksdHookDaemon(root, handleHook, options = {}) {
     const socketPath = sksdSocketPath(root);
     const pidFilePath = sksdPidFilePath(root);
     const runtimeDir = path.dirname(socketPath);
@@ -157,8 +159,13 @@ export async function startSksdHookDaemon(root, handleHook) {
         });
         async function respond(line) {
             let response;
+            let retire = false;
             try {
                 const request = JSON.parse(line);
+                if (request.sks_version && request.sks_version !== PACKAGE_VERSION) {
+                    retire = true;
+                    throw new Error(SKSD_VERSION_MISMATCH_ERROR);
+                }
                 const result = await handleHook(request.name, request.payload);
                 response = { schema: 'sks.sksd-hook-response.v1', ok: true, result };
             }
@@ -170,6 +177,11 @@ export async function startSksdHookDaemon(root, handleHook) {
             }
             catch { }
             socket.end();
+            if (retire) {
+                void close().then(() => { if (options.exitOnRetire)
+                    process.exit(0); });
+                return;
+            }
             resetIdleTimer();
         }
         socket.on('error', () => undefined);
@@ -270,7 +282,7 @@ export async function callSksdHookDaemon(root, name, payload) {
         let buffer = '';
         socket.on('connect', () => {
             clearTimeout(connectTimer);
-            const request = { schema: 'sks.sksd-hook-request.v1', name, payload };
+            const request = { schema: 'sks.sksd-hook-request.v1', name, payload, sks_version: PACKAGE_VERSION };
             socket.write(`${JSON.stringify(request)}\n`);
         });
         socket.on('data', (chunk) => {

package/dist/core/doctor/desktop-bridge-catalog-repair.js

@@ -4,48 +4,9 @@ import path from 'node:path';
 import { desktopBridgeStatusV3, executeDesktopBridgeCommandV3 } from '../codex-lb/desktop-controller-v3.js';
 import { bootstrapExistingDesktopBridgeService, desktopBridgeServicePaths, desktopBridgeServiceStatus } from '../codex-lb/desktop-service.js';
 import { desktopBridgeRuntimeVersion, desktopBridgeRuntimeVersionStale, readDesktopBridgeState } from '../codex-lb/desktop-bridge/state.js';
+import { BRIDGE_LOG_TAIL_BYTES, detectUnreachableUpstreamEvidence } from '../codex-lb/desktop-bridge/upstream-evidence.js';
 import { PACKAGE_VERSION } from '../version.js';
-export const BRIDGE_UNREACHABLE_EVIDENCE_WINDOW_MS = 10 * 60_000;
-const BRIDGE_LOG_TAIL_BYTES = 256 * 1024;
-const UNREACHABLE_REJECTION_CODE = /^bridge_(?:websocket_)?upstream_unavailable/;
-const REROUTED_REJECTION_CODE = /^bridge_upstream_unreachable_rerouted/;
-export function detectUnreachableUpstreamEvidence(logTail, startedAt, nowMs) {
-    const startedMs = startedAt ? Date.parse(startedAt) : Number.NaN;
-    const cutoffMs = Math.max(Number.isFinite(startedMs) ? startedMs : 0, nowMs - BRIDGE_UNREACHABLE_EVIDENCE_WINDOW_MS);
-    let latest = null;
-    let latestReroute = Number.NEGATIVE_INFINITY;
-    for (const line of logTail.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith('{') || !trimmed.includes('"sks.desktop_bridge.rejected'))
-            continue;
-        let record;
-        try {
-            record = JSON.parse(trimmed);
-        }
-        catch {
-            continue;
-        }
-        if (record.event !== 'sks.desktop_bridge.rejected' && record.event !== 'sks.desktop_bridge.rejected_summary')
-            continue;
-        const code = typeof record.code === 'string' ? record.code : '';
-        const unreachable = UNREACHABLE_REJECTION_CODE.test(code);
-        const rerouted = !unreachable && REROUTED_REJECTION_CODE.test(code);
-        if (!unreachable && !rerouted)
-            continue;
-        const at = typeof record.at === 'string' ? Date.parse(record.at) : Number.NaN;
-        if (!Number.isFinite(at) || at < cutoffMs)
-            continue;
-        if (rerouted) {
-            latestReroute = Math.max(latestReroute, at);
-            continue;
-        }
-        if (!latest || at > latest.at)
-            latest = { at, code };
-    }
-    if (!latest || latest.at <= latestReroute)
-        return null;
-    return latest.code;
-}
+export { BRIDGE_UNREACHABLE_EVIDENCE_WINDOW_MS, detectUnreachableUpstreamEvidence } from '../codex-lb/desktop-bridge/upstream-evidence.js';
 export async function readDesktopBridgeUnreachableUpstreamEvidence(home, deps = {}) {
     const paths = desktopBridgeServicePaths(home);
     const state = await readDesktopBridgeState(paths.state_path).catch(() => null);
@@ -142,14 +103,15 @@ export async function repairDoctorDesktopBridgeCatalog(input, deps = {}) {
         const status = await statusImpl({ home: bridgeHome, env: process.env });
         const blockers = (status?.readiness?.blockers || []).map(String);
         const stale = blockers.filter((blocker) => blocker.endsWith('_catalog_stale'));
+        const reverify = { fix: input.fix, bridgeHome, restarted: restarted.restarted };
         if (!status?.management?.managed || stale.length === 0) {
-            return {
+            return reverifyTransportIfDegraded({
                 ...base,
                 ok: restarted.blockers.length === 0,
                 repaired: restarted.restarted,
                 warnings: restarted.warnings,
                 blockers: restarted.blockers
-            };
+            }, reverify, statusImpl, executeImpl);
         }
         const attempts = [];
         let syncedAndVerified = false;
@@ -165,7 +127,7 @@ export async function repairDoctorDesktopBridgeCatalog(input, deps = {}) {
             }
             attempts.push(`catalog_sync_attempt_${attempt}:${commandOk ? `still_stale:${stillStale.join(',')}` : (sync?.execution?.blockers || ['failed']).map(String).join(',')}`);
         }
-        return {
+        return reverifyTransportIfDegraded({
             ...base,
             ok: syncedAndVerified && restarted.blockers.length === 0,
             repaired: syncedAndVerified || restarted.restarted,
@@ -174,9 +136,29 @@ export async function repairDoctorDesktopBridgeCatalog(input, deps = {}) {
                 ...(syncedAndVerified ? [] : ['desktop_bridge_catalog_still_stale_after_repair', ...attempts]),
                 ...restarted.blockers
             ]
-        };
+        }, reverify, statusImpl, executeImpl);
     }
     catch (error) {
         return { ...base, ok: false, repaired: false, blockers: [String(error?.message || 'desktop_bridge_catalog_sync_failed')] };
     }
 }
+async function reverifyTransportIfDegraded(result, input, statusImpl, executeImpl) {
+    if (!input.fix)
+        return result;
+    const before = await statusImpl({ home: input.bridgeHome, env: process.env }).catch(() => null);
+    const serving = before?.service?.state === 'ready' || before?.service?.running === true;
+    const degraded = before?.readiness?.state === 'degraded';
+    if (before?.management?.managed !== true || !serving || (!degraded && !input.restarted))
+        return result;
+    await executeImpl({ operation: 'verify', level: 'transport' }, { home: input.bridgeHome, env: process.env }).catch(() => null);
+    const after = await statusImpl({ home: input.bridgeHome, env: process.env }).catch(() => null);
+    const afterState = String(after?.readiness?.state || 'unknown');
+    return {
+        ...result,
+        repaired: result.repaired || (degraded && afterState === 'ready'),
+        warnings: [
+            ...result.warnings,
+            afterState === 'ready' ? 'desktop_bridge_transport_reverified' : `desktop_bridge_transport_reverify_incomplete:${afterState}`
+        ]
+    };
+}

package/dist/core/doctor/doctor-readiness-matrix.js

@@ -1,7 +1,22 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { manualProofRoutesBlockReadiness } from '../verification-profile.js';
 export const DOCTOR_READINESS_MATRIX_SCHEMA = 'sks.doctor-readiness-matrix.v2';
 const OPTIONAL_ROUTE_SCOPES = new Set(['route-computer-use', 'route-chrome-web-review', 'route-app-handoff', 'route-app-screenshot']);
+const MANUAL_PROOF_ROUTE_SCOPES = new Set(['route-image']);
+function optionalRouteScope(scope) {
+    if (OPTIONAL_ROUTE_SCOPES.has(scope))
+        return true;
+    return MANUAL_PROOF_ROUTE_SCOPES.has(scope) && !manualProofRoutesBlockReadiness();
+}
+function desktopBridgeReadinessView(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    if (value.management || value.readiness)
+        return value;
+    const status = value.status;
+    return status && typeof status === 'object' && (status.management || status.readiness) ? status : value;
+}
 export async function writeDoctorReadinessMatrix(root, input = {}) {
     const matrix = buildDoctorReadinessMatrix(input);
     const reportPath = input.reportPath || path.join(root, '.sneakoscope', 'reports', 'doctor-ready-breakdown.json');
@@ -76,13 +91,17 @@ export function buildDoctorReadinessMatrix(input = {}) {
     if (codexAppHarness?.ok === false)
         for (const blocker of normalizeList(codexAppHarness.blockers))
             warnings.add(`codex_app_harness:${blocker}`);
-    const desktopBridge = input.desktop_bridge_status || input.desktop_bridge || null;
+    const desktopBridge = desktopBridgeReadinessView(input.desktop_bridge_status || input.desktop_bridge || null);
     if (desktopBridge?.management?.managed === true && desktopBridge?.readiness?.ready !== true) {
         const bridgeBlockers = normalizeList(desktopBridge?.readiness?.blockers);
         for (const blocker of bridgeBlockers)
             blockers.add(blocker);
-        if (!bridgeBlockers.length)
-            blockers.add('desktop_bridge_not_ready');
+        if (!bridgeBlockers.length) {
+            if (desktopBridge?.readiness?.state === 'degraded')
+                warnings.add('desktop_bridge_readiness_degraded:transport_unverified_for_current_process');
+            else
+                blockers.add('desktop_bridge_not_ready');
+        }
     }
     if (desktopBridge?.management?.managed === true && desktopBridge?.service?.running !== true) {
         warnings.add('desktop_bridge_service_not_running');
@@ -136,7 +155,7 @@ export function buildDoctorReadinessMatrix(input = {}) {
     for (const [scope, list] of Object.entries(routeBlockers)) {
         for (const blocker of Array.isArray(list) ? list : []) {
             const value = `route:${scope}:${String(blocker)}`;
-            if (OPTIONAL_ROUTE_SCOPES.has(String(scope)))
+            if (optionalRouteScope(String(scope)))
                 warnings.add(value);
             else
                 blockers.add(value);

package/dist/core/hooks-runtime/hook-context.js

@@ -6,6 +6,7 @@ import { allowlistedManagedRouteSkillNames, dollarCommand, INVALID_EXPLICIT_MANA
 import { inspectConfinedPath } from '../managed-path-safety.js';
 import { renderAuthoritativeSksSkillContext } from '../codex-native/sks-skill-paths.js';
 import { resolveManagedSkillSourcesForAdmission } from './managed-skill-admission.js';
+import { managedSkillDigestBlocksEnforced } from '../verification-profile.js';
 import { looksLikeActiveContinuationPrompt } from './naruto-decision-gate.js';
 import { extractUserPrompt, looksLikeCodexGitAction, looksLikeCodexUiSettingsEvent } from './payload-signals.js';
 const STANDALONE_PARENT_BASE_SKILLS = [
@@ -59,7 +60,7 @@ export async function attachAuthoritativeSksSkillContext(root, state, payload, r
         return result;
     const admission = await authoritativeSksSkillAdmission(root, skillNames);
     if (admission.blocked)
-        return { ...result, ...admission.blocked };
+        return managedSkillDigestBlocksEnforced(root) ? { ...result, ...admission.blocked } : result;
     const resolution = admission.resolution;
     if (!resolution)
         return result;
@@ -211,7 +212,9 @@ export async function hookActiveSkillContextRefresh(root, state, name) {
         return {
             continue: true,
             ...(spawnCompatibility ? { additionalContext: spawnCompatibility } : {}),
-            systemMessage: 'SKS managed skill refresh could not verify the current installation. Do not use a stale skill location; the next active tool call will be denied until the installation is repaired.'
+            systemMessage: managedSkillDigestBlocksEnforced(root)
+                ? 'SKS managed skill refresh could not verify the current installation. Do not use a stale skill location; the next active tool call will be denied until the installation is repaired.'
+                : 'SKS managed skill refresh could not verify the current installation; continuing without unverified skill context. `sks doctor --fix` repairs the installation when convenient.'
         };
     }
     const additionalContext = [spawnCompatibility, refresh.context].filter(Boolean).join('\n\n');

package/dist/core/hooks-runtime.js

@@ -10,6 +10,7 @@ import { isMadSksRouteState } from './permission-gates.js';
 import { classifyMadSksShellCommand } from './mad-sks/write-guard.js';
 import { activeRouteContext, evaluateStop, prepareRoute, promptPipelineContext as routePipelineContext, recordContext7Evidence, recordSubagentEvidence, routePrompt } from './pipeline.js';
 import { localizedFinalizationReason } from './language-preference.js';
+import { managedSkillDigestBlocksEnforced, postToolEvidenceEnabled, stopFinalizationRitualsEnforced } from './verification-profile.js';
 import { classifyToolError } from './evaluation.js';
 import { dollarCommand, managedSkillNamesForPrompt, stripVisibleDecisionAnswerBlocks } from './routes.js';
 import { coreEngineeringDirectiveReferenceText } from './lean-engineering-policy.js';
@@ -250,19 +251,19 @@ async function hookUserPrompt(root, state, payload, noQuestion, sessionKey = nul
         }).catch(() => toolOutputQuarantine);
     }
     if (submittedPrompt && (detectedMissingCallId || toolOutputQuarantine)) {
-        return {
-            decision: 'block',
-            reason: interruptedToolOutputRecoveryBlockReason({
-                callId: detectedMissingCallId || toolOutputQuarantine?.call_id,
-                missionId: state?.mission_id || toolOutputQuarantine?.mission_id
-            })
-        };
+        const reason = interruptedToolOutputRecoveryBlockReason({
+            callId: detectedMissingCallId || toolOutputQuarantine?.call_id,
+            missionId: state?.mission_id || toolOutputQuarantine?.mission_id
+        });
+        if (stopFinalizationRitualsEnforced(root))
+            return { decision: 'block', reason };
+        return { continue: true, additionalContext: reason, systemMessage: visibleHookMessage('user-prompt-submit', reason) };
     }
     const parentLaunchMissionId = activeNarutoParentLaunchMissionId();
     if (parentLaunchMissionId) {
         const parentSkillNames = await standaloneParentManagedSkillNames(root, parentLaunchMissionId, state);
         const skillAdmission = await authoritativeSksSkillAdmission(root, parentSkillNames);
-        if (skillAdmission.blocked)
+        if (skillAdmission.blocked && managedSkillDigestBlocksEnforced(root))
             return skillAdmission.blocked;
         const parentHostCapability = await claimStandaloneParentHostCapabilityRuntime({
             root,
@@ -339,7 +340,7 @@ async function hookUserPrompt(root, state, payload, noQuestion, sessionKey = nul
         }
         if (!explicitCommand && !clarificationPending && !madConfirmationPrompt && !activeContinuation && lightRoute?.id === 'Answer') {
             const skillAdmission = await authoritativeSksSkillAdmission(root, lightRoute.requiredSkills || ['answer', 'honest-mode']);
-            if (skillAdmission.blocked)
+            if (skillAdmission.blocked && managedSkillDigestBlocksEnforced(root))
                 return skillAdmission.blocked;
             const turnId = hookTurnId(payload);
             if (turnId) {
@@ -413,7 +414,7 @@ async function hookUserPrompt(root, state, payload, noQuestion, sessionKey = nul
             }
             if (!explicitActiveWorkflowReplacement) {
                 const activeSkillAdmission = await authoritativeSksSkillAdmission(root, selectedSksSkillNamesForActiveState(state));
-                if (activeSkillAdmission.blocked)
+                if (activeSkillAdmission.blocked && managedSkillDigestBlocksEnforced(root))
                     return activeSkillAdmission.blocked;
                 const queued = await queueActiveOfficialWorkflowPrompt({
                     root,
@@ -443,7 +444,7 @@ async function hookUserPrompt(root, state, payload, noQuestion, sessionKey = nul
             }
         }
         const skillAdmission = await authoritativeSksSkillAdmission(root, managedSkillNamesForPrompt(route, prompt));
-        if (skillAdmission.blocked)
+        if (skillAdmission.blocked && managedSkillDigestBlocksEnforced(root))
             return skillAdmission.blocked;
         const skillContext = skillAdmission.resolution
             ? renderAuthoritativeSksSkillContext(skillAdmission.resolution)
@@ -594,11 +595,12 @@ async function hookPreTool(root, state, payload, noQuestion, sessionKey = null)
                 skillAvailabilityBlock = await evaluateSkillAvailabilityBlock();
         }
     }
-    if (skillAvailabilityBlock) {
+    const digestBlocks = managedSkillDigestBlocksEnforced(root);
+    if (skillAvailabilityBlock && digestBlocks) {
         return { decision: 'block', permissionDecision: 'deny', reason: skillAvailabilityBlock };
     }
     const skillRefresh = await activeAuthoritativeSksSkillRefresh(root, state);
-    if (skillRefresh.blocked) {
+    if (skillRefresh.blocked && digestBlocks) {
         return {
             decision: 'block',
             permissionDecision: 'deny',
@@ -667,12 +669,13 @@ async function parentWaveGuidanceContext(root, state = {}, sessionKey = null) {
 }
 async function hookPostTool(root, state, payload, noQuestion, sessionKey = null) {
     state = { ...state, _session_key: state?._session_key || sessionKey };
+    const evidence = postToolEvidenceEnabled(root);
     await Promise.all([
         recordHostCapabilityPostTool(root, state, payload, sessionKey).catch(() => null),
         recordMadSksSqlPlanePostToolLifecycle(root, state, payload).catch(() => null),
-        recordContext7Evidence(root, state, payload).catch(() => null),
-        recordSubagentEvidence(root, state, payload).catch(() => null),
-        toolFailed(payload) ? recordToolErrorTaxonomy(root, state, payload).catch(() => null) : Promise.resolve(null)
+        evidence ? recordContext7Evidence(root, state, payload).catch(() => null) : Promise.resolve(null),
+        evidence ? recordSubagentEvidence(root, state, payload).catch(() => null) : Promise.resolve(null),
+        evidence && toolFailed(payload) ? recordToolErrorTaxonomy(root, state, payload).catch(() => null) : Promise.resolve(null)
     ]);
     if (!noQuestion)
         return { continue: true };
@@ -1029,6 +1032,9 @@ async function hookStop(root, state, payload, noQuestion, sessionKey = null) {
     if (state?.subagents_required === true) {
         await refreshOfficialSubagentCompletionArtifacts(root, state, last, sessionKey).catch(() => null);
     }
+    if (!noQuestion && !stopFinalizationRitualsEnforced(root)) {
+        return { continue: true, action: 'essential_profile_stop_accepted' };
+    }
     const routeDecision = await evaluateStop(root, state, payload, { noQuestion });
     if (routeDecision && !successfulAppNarutoStopNeedsVisibleSummary(state, routeDecision)) {
         return routeDecision;

package/dist/core/init/skills.js

@@ -38,7 +38,7 @@ async function installOfficialSkills(root) {
         .trim();
     const skills = {
         'dfix': `---\nname: dfix\ndescription: Direct Fix mode for $DFix or $dfix requests and inferred tiny copy/config/docs/labels/spacing/translation/simple mechanical edits.\n---\n\nUse for tiny copy/config/docs/labels/spacing/translation/simple mechanical edits. List exact micro-edits, inspect only needed files, apply only those edits, and run cheap verification. Keep broad implementation routed to Naruto; for UI/UX micro-edits read \`design.md\` when present and use imagegen for image/logo/raster assets. Bypass broad SKS routing, mission state, TriWiki/TriFix/reflection/state recording, Goal, Research, eval, redesign, and repeated full-route Honest Mode loops. Start the final answer with \`DFix 완료 요약:\` and include one \`DFix 솔직모드:\` line covering verified, not verified, and remaining issues. ${CODEX_IMAGEGEN_REQUIRED_POLICY}\n`,
-        'answer': `---\nname: answer\ndescription: Answer questions with research or docs; never implement.\n---\n\nUse for explanations, comparisons, status, facts, source-backed research, or docs guidance. Use repo/TriWiki first for project-local facts; hydrate low-trust claims from source. Browse or use Context7 for current external package/API/framework/MCP docs. End with a concise answer summary plus Honest Mode; do not create missions, subagents, or file edits.\n`,
+        'answer': `---\nname: answer\ndescription: Answer questions with research or docs; never implement.\n---\n\nUse for explanations, comparisons, status, facts, source-backed research, or docs guidance. Use repo/TriWiki first for project-local facts; hydrate low-trust claims from source. Browse or use Context7 for current external package/API/framework/MCP docs. End with a concise answer that separates what was verified from what was inferred; do not create missions, subagents, or file edits.\n`,
         'sks': `---\nname: sks\ndescription: General Sneakoscope Codex command route for $SKS or $sks usage, setup, status, and workflow help.\n---\n\nUse local SKS commands: bootstrap, deps, commands, quickstart, codex-app, context7, guard, conflicts, reasoning, wiki, pipeline status, pipeline plan, skill-dream. Promote code-changing work to Naruto unless Answer/DFix/Help/Wiki/safety route fits. Surface route/guard/scope, use TriWiki, do not edit installed harness files outside this engine repo, and clear conflicting third-party Codex harness markers via \`sks conflicts cleanup --yes\`. ${skillDreamPolicyText()}\n`,
         'plan': `---\nname: plan\ndescription: Write a plan artifact only; never edit product or source files.\n---\n\nUse when the user invokes $Plan or asks for a plan-only frontdoor. Produce a concrete plan artifact under .sneakoscope/plans/<slug>.md with goal, scope, files to inspect, implementation steps, acceptance checks, and rollback notes. Do not edit product/source files, generated harness files, package metadata, or docs beyond the plan artifact. Keep implementation_allowed=false and hand off execution to $Work only after the user or route explicitly moves from planning to work. Finish with what is planned, what remains unimplemented, and Honest Mode.\n`,
         'work': `---\nname: work\ndescription: Execute the latest plan with evidence-gated completion. 예: $Work\n---\n\nUse when the user invokes $Work or asks to execute the latest SKS plan. Resolve the newest .sneakoscope/plans/*.md, route execution through Naruto evidence gates, keep leases and verification artifacts current, and do not claim completion without machine evidence or explicit blocker evidence. If no plan exists, block with a clear next action: run $Plan first or provide a task.\n`,
@@ -52,7 +52,7 @@ async function installOfficialSkills(root) {
         'from-chat-img': `---\nname: from-chat-img\ndescription: Explicit $From-Chat-IMG Naruto add-on gate for chat screenshot plus attachment analysis.\n---\n\nUse only for From-Chat-IMG/$From-Chat-IMG. It enters the Naruto pipeline with from_chat_img_required=true and an add-on coverage gate. Treat uploads as chat screenshot plus originals. For web/browser/webapp targets use Codex Chrome Extension first; for native Mac/non-web app surfaces use Codex Computer Use visual inspection when available. List requirements first, match regions to attachments with confidence, write ${FROM_CHAT_IMG_COVERAGE_ARTIFACT}, ${FROM_CHAT_IMG_CHECKLIST_ARTIFACT}, ${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT}, and ${FROM_CHAT_IMG_QA_LOOP_ARTIFACT}, then continue Naruto worker proof, review, reflection, and Honest Mode. ${CODEX_WEB_VERIFICATION_POLICY} ${CODEX_COMPUTER_USE_ONLY_POLICY} The ledger must account for every visible customer request, screenshot image region, and separate attachment; ${FROM_CHAT_IMG_CHECKLIST_ARTIFACT} must have a checked item for each request, image-region/attachment match, work item, scoped QA-LOOP, and verification step; ${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT} stores temporary TriWiki-backed session context with expires_after_sessions=${FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS}. ${FROM_CHAT_IMG_QA_LOOP_ARTIFACT} must prove QA-LOOP ran over the exact customer-request work-order range after implementation, with every work item covered, post-fix verification complete, and zero unresolved findings. naruto-gate.json cannot pass From-Chat-IMG completion until from_chat_img_request_coverage=true, unresolved_items is empty, every checklist box is checked, and scoped_qa_loop_completed=true.\n`,
         'qa-loop': `---\nname: qa-loop\ndescription: $QA-LOOP dogfoods UI/API as human proxy with safety gates, Codex Chrome Extension-first web UI evidence, safe fixes, rechecks, and a QA report.\n---\n\nUse only $QA-LOOP. Infer scope, target, mutation policy, and login boundary from the prompt plus TriWiki/current-code defaults; do not surface a prequestion sheet. Credentials are runtime-only; never save secrets. Web/browser/webapp UI-level E2E must run the Codex Chrome Extension readiness gate first; if the extension is missing or disabled, rapidly halt and ask the user to set it up, then resume only after the user confirms installation is complete. Codex Computer Use is reserved for native Mac/non-web surfaces and must not satisfy web UI evidence. Playwright, Selenium, Puppeteer, Browser Use, Chrome MCP, screenshots fabricated from code, and prose-only checks do not satisfy web UI/browser verification. ${CODEX_WEB_VERIFICATION_POLICY} Deployed targets are read-only; destructive removal is forbidden. After answer/run, dogfood real flows, apply safe contract-allowed code/test/docs fixes, recheck, and do not pass qa-gate.json with unresolved findings or without post_fix_verification_complete. Finish qa-ledger, date/version report, gate, completion summary, and Honest Mode.\n`,
         'ppt': `---\nname: ppt\ndescription: $PPT information-first HTML/PDF presentation pipeline with inferred STP, audience, pain-point, format, research, design-system, and verification contract.\n---\n\nUse only when the user invokes $PPT or asks to create a presentation, deck, slides, pitch deck, proposal deck, HTML presentation, or PDF presentation artifact. Before artifact work, auto-seal presentation-specific answers from prompt, TriWiki/current-code defaults, and conservative policy: delivery context, target audience profile including role/average age/job/industry/topic familiarity/decision power, STP strategy, decision context and objections, and 3+ pain-point to solution mappings with expected aha moments. Do not surface a prequestion sheet. Presentation design must be simple, restrained, and information-first: avoid over-designed decoration, ornamental gradients, nested cards, and effects that compete with the message. Design detail should be embedded through typography hierarchy, spacing, alignment, thin rules, source clarity, and subtle accents. ${pptPipelineAllowlistPolicyText()} Use Product Design plugin first for context, ideation, prototype direction, audit, design QA, and share handoff. Use design.md only as an existing project-local cache or fallback SSOT when Product Design is unavailable; if fallback creation is needed, use docs/Design-Sys-Prompt.md plus getdesign-reference and curated DESIGN.md examples from ${AWESOME_DESIGN_MD_REFERENCE.url} only as source inputs, then fuse them into route-local PPT style tokens with a recorded design_ssot instead of treating references as parallel authorities. The $PPT route always loads imagegen as a required skill, checks Codex App imagegen at route start, and runs SKS auto-repair once before any image-dependent build/review work. If repair fails, stop with codex_imagegen_unavailable and do not continue with image-free or API-substituted evidence. When the sealed contract needs a generated raster asset or generated slide visual critique, immediately invoke Codex App \`$imagegen\` with gpt-image-2, move/copy the selected output into the mission assets or review evidence path, and record the real file path in ppt-image-asset-ledger.json or ppt-review-ledger.json before building or passing the gate. Direct API fallback, placeholder files, HTML/CSS stand-ins, and prose-only substitutes do not satisfy the route gate. ${productDesignPluginPolicyText()} ${CODEX_IMAGEGEN_REQUIRED_POLICY} Use web or Context7 evidence only when external facts/libraries/current docs are required by the PPT contract, record verified claims in ppt-fact-ledger.json, record generated image asset plans/results/blockers in ppt-image-asset-ledger.json, then create the PDF plus editable source HTML under source-html/, keep independent strategy/render/file-write phases parallel where inputs allow, record ppt-parallel-report.json, run the bounded ppt-review-policy/ppt-review-ledger/ppt-iteration-report loop, and verify readability, overlap, format fit, source coverage, export state, unsupported-claim status, image-asset completion, review-loop termination, and temporary build files cleanup. Finish with reflection and Honest Mode.\n`,
-        'computer-use-fast': `---\nname: computer-use-fast\ndescription: Alias for the maximum-speed $Computer-Use/$CU native Codex Computer Use lane.\n---\n\nUse the same rules as computer-use: skip Naruto delegation, QA-LOOP clarification, upfront TriWiki refresh, Context7, subagents, and reflection unless explicitly requested. Use Codex Computer Use directly only for native macOS, desktop-app, OS-settings, or non-web visual tasks. Browser, localhost, website, webapp, and web-based app verification must use the Codex Chrome Extension path first and must halt if that extension is not installed/enabled. At the end only, refresh/pack TriWiki, validate it, then provide a concise completion summary plus Honest Mode. ${CODEX_WEB_VERIFICATION_POLICY} ${CODEX_COMPUTER_USE_ONLY_POLICY}\n`,
+        'computer-use-fast': `---\nname: computer-use-fast\ndescription: Alias for the maximum-speed $Computer-Use/$CU native Codex Computer Use lane.\n---\n\nUse the same rules as computer-use: skip Naruto delegation, QA-LOOP clarification, upfront TriWiki refresh, Context7, subagents, and reflection unless explicitly requested. Use Codex Computer Use directly only for native macOS, desktop-app, OS-settings, or non-web visual tasks. Browser, localhost, website, webapp, and web-based app verification must use the Codex Chrome Extension path first and must halt if that extension is not installed/enabled. At the end only, refresh/pack TriWiki, validate it, then provide a concise completion summary that separates what was verified from what was not. ${CODEX_WEB_VERIFICATION_POLICY} ${CODEX_COMPUTER_USE_ONLY_POLICY}\n`,
         'cu': `---\nname: cu\ndescription: Short alias for the maximum-speed native $Computer-Use Codex Computer Use lane.\n---\n\nUse the same rules as computer-use. This is a speed lane for native macOS, desktop-app, OS-settings, and non-web visual tasks requiring Codex Computer Use evidence, with TriWiki refresh/validate and Honest Mode deferred to final closeout. Web/browser/webapp verification must use Codex Chrome Extension first and stop if the extension is not installed/enabled. ${CODEX_WEB_VERIFICATION_POLICY} ${CODEX_COMPUTER_USE_ONLY_POLICY}\n`,
         'goal': `---\nname: goal\ndescription: Codex-native $Goal/$goal control with detailed completion criteria and no SKS-owned Goal state.\n---\n\nUse when the user invokes $Goal/$goal or asks to create, edit, view, pause, resume, or clear a persisted goal. Use only Codex native Goal controls or the callable native goal tool. Do not run sks goal, create an SKS mission, write bridge artifacts, compile a compatibility loop, create fallback Goal state, refresh TriWiki, or open subagents for the Goal control turn. Before create or edit, expand the request into explicit Outcome, Scope, Constraints, Verification, Done when, Stop conditions, and Non-goals. Completion criteria must be measurable and must stop work once satisfied; forbid unrelated refactors, speculative expansion, and open-ended polishing. If native Goal is unavailable, report that limitation instead of substituting an SKS implementation.\n`,
         'release-review': `---\nname: release-review\ndescription: Review release readiness through official Codex subagents.\n---\n\nUse only when the user invokes $Release-Review or asks for a release-readiness review. Run it through \`sks naruto run \"$Release-Review release audit\" --agents <n> --read-only --json\` or the current Codex parent session. The parent owns decomposition, waits for every official worker/expert thread, integrates one structured outcome per thread, and records subagent-plan.json, subagent-events.jsonl, subagent-parent-summary.json, and subagent-evidence.json. No alternate Release-Review runtime is supported. Finish with release-readiness verification and Honest Mode.\n`,
@@ -67,13 +67,13 @@ async function installOfficialSkills(root) {
         'prompt-pipeline': `---\nname: prompt-pipeline\ndescription: Default SKS prompt routing for execution requests; Answer and DFix remain lightweight.\n---\n\nClassify only the route and the constraints that change execution. Answer handles real information requests; DFix handles tiny copy/config/docs/labels/spacing/translation/mechanical edits; general code-changing work uses Naruto with Codex official subagents. Preserve the literal user request; TriWiki may enrich it but never replace an explicit requirement. ${coreEngineeringDirectiveReferenceText()} ${engineeringSanityPolicyText()} For code work, identify the requested outcome, actual code/data flow, exact write scope, acceptance criteria, and the smallest meaningful verification. Load route-specific Design, PPT, image, browser, research, DB, release, or Context7 rules only when that route or external contract requires them. Materialize pipeline-plan.json with route, scopes, verification, and blockers, then finish the requested work instead of stopping at the plan.\n`,
         [SOLUTION_SCOUT_SKILL_NAME]: `---\nname: ${SOLUTION_SCOUT_SKILL_NAME}\ndescription: Optional source scout for fixes that materially depend on external precedent.\n---\n\nUse only when the user asks for similar cases or when a package, API, platform, or externally documented behavior makes outside precedent materially useful. Search with the concrete symptom and current stack, prefer primary sources, and keep the local code path authoritative. Do not add this step to ordinary local bugfixes. If external evidence is unavailable, record that gap instead of inventing a workaround.\n`,
         'reasoning-router': `---\nname: reasoning-router\ndescription: Temporary SKS reasoning-effort routing for every command and pipeline route on the GPT-5.6 family.\n---\n\nGPT-5.6 efforts: none/low/medium/high/xhigh/max. Route medium for simple copy/color/discovery/setup/mechanical edits; high for logic, safety, architecture, DB, orchestration, refactor, multi-file work; xhigh for research, AutoResearch, falsification, benchmarks, SEO/GEO, open-ended discovery, and From-Chat-IMG analysis; max only for hardest quality-first judgment. Prefer gpt-5.6-luna / terra / sol role defaults over legacy model aliases. Routing is temporary; return to default after the gate. Inspect with sks reasoning and sks pipeline status.\n`,
-        'pipeline-runner': `---\nname: pipeline-runner\ndescription: Execute SKS routes with bounded state, evidence, reflection, and Honest Mode.\n---\n\nEvery $ command selects a route. Use current.json, mission artifacts, and pipeline-plan.json as bounded execution state; load only the selected route skill. ${coreEngineeringDirectiveReferenceText()} ${engineeringSanityPolicyText()} Codex native /goal is the only persisted goal owner. Use official Codex subagents only when the route requires independent slices, keep parent-owned integration, use bounded TriWiki context, fetch current external docs only when relevant, record real blockers, refresh and validate evidence, run reflection for full routes, and finish with a completion summary plus Honest Mode.\n`,
+        'pipeline-runner': `---\nname: pipeline-runner\ndescription: Execute SKS routes with bounded state and evidence.\n---\n\nEvery $ command selects a route. Use current.json, mission artifacts, and pipeline-plan.json as bounded execution state; load only the selected route skill. ${coreEngineeringDirectiveReferenceText()} ${engineeringSanityPolicyText()} Codex native /goal is the only persisted goal owner. Use official Codex subagents only when the route requires independent slices, keep parent-owned integration, use bounded TriWiki context, fetch current external docs only when relevant, record real blockers, and finish with a completion summary that states what was verified and what remains. Reflection and Honest Mode sections are strict-profile requirements only.\n`,
         'context7-docs': `---\nname: context7-docs\ndescription: Enforce Context7 MCP documentation evidence for SKS routes that depend on external libraries, frameworks, APIs, MCPs, package managers, DB SDKs, or generated docs.\n---\n\nWhen required, resolve-library-id, then query-docs for the resolved id. Legacy get-library-docs evidence is accepted. Prefer sks context7 tools/resolve/docs/evidence and finish only after both evidence stages exist. Check setup with sks context7 check.\n`,
         'super-search': `---\nname: super-search\ndescription: Dollar-command route for $Super-Search provider-independent source intelligence.\n---\n\nUse when the user invokes $Super-Search or asks for Super-Search source intelligence, source acquisition, X-search-style collection, URL acquisition, source normalization, claim ledgers, or citation proof. Prefer \`sks super-search doctor --json\` for readiness and \`sks super-search run "<query>" --mode balanced --json\` for provider-independent source proof; use \`sks super-search x "<query>" --json\` for X-search intent and \`sks super-search fetch "<url>" --json\` for URL acquisition. Context7 is required only when the query depends on current package/API/framework/MCP/generated documentation behavior. Provider-specific credentials are optional and must not be required for route readiness. Evidence/artifacts remain under \`.sneakoscope/missions/<super-search-* or route mission>/super-search/\`: intent.json, axes.json, query-variants.json, provider-plan.json, source-ledger.json, lead-ledger.json, claim-ledger.json, attempt-ledger.json, synthesis.md, super-search-proof.json, super-search-gate.json, and super-search-result.json. Do not turn weak discovery into supported claims; finish with an Honest Mode summary of verified sources, blockers, and unverified external coverage.\n`,
         'search-visibility-core': `---\nname: search-visibility-core\ndescription: Shared kernel for seo-geo-optimizer audit, plan, explicit apply, rollback, verification, gates, and Completion Proof.\n---\n\nPurpose: keep Search Engine Optimization and Generative Engine Optimization on one typed search-visibility kernel instead of duplicate implementations. Use when $SEO-GEO-OPTIMIZER or \`sks seo-geo-optimizer\` is selected. Workflow: doctor detects package/static/Next evidence; audit writes source-backed inventory and findings; plan compiles safe mutation operations; apply requires explicit \`--apply\`; verify separates source, build, HTTP, browser, production, and measured outcome; rollback only reverses mission-owned operations. Safety: default read-only, never overwrite unmanaged robots.txt, sitemap, llms.txt, metadata, or structured data; do not hard-code customer routes; do not invent prices, reviews, availability, rankings, traffic, or AI citation outcomes. Evidence/artifacts: search-visibility/intake.json, adapter-detection.json, site-inventory.json, route-graph.json, robots-policy.json, structured-data-ledger.json, mutation-plan.json, mutation-journal.jsonl, rollback-manifest.json, verification-report.json, route gate, and completion-proof.json. Failure/recovery: unsupported frameworks stay audit/plan-only; missing production/browser/Search Console evidence remains unverified, not fabricated. CLI entrypoint: \`sks seo-geo-optimizer ... --mode seo|geo\`.\n`,
         'seo-geo-optimizer': `---\nname: seo-geo-optimizer\ndescription: Unified $SEO-GEO-OPTIMIZER route for Search Engine Optimization and Generative Engine Optimization.\n---\n\nPurpose: use one route name for SEO and GEO work while keeping the internal search-visibility mode explicit. Use when: the user asks for SEO audit/fix/verification, package/npm/GitHub search visibility, canonical, sitemap, robots.txt, hreflang, metadata, structured data, AI answer visibility, LLM citation readiness, answerability, entity/claim provenance, crawler policy, OAI-SearchBot/GPTBot/ChatGPT-User, Claude-SearchBot/ClaudeBot/Claude-User, or optional llms.txt planning. GEO means Generative Engine Optimization, not geolocation, GeoIP, maps, CDN geography, location permission, or regional redirect bugs. Workflow: run \`sks seo-geo-optimizer doctor --mode seo|geo\`, then audit, plan, explicit apply, verify, status, and rollback. Use \`--mode seo\` for technical/package search optimization and \`--mode geo\` for entity facts, claim evidence, answerability, crawler policy, and optional llms.txt. Safety: audit and plan must not mutate source; apply checks base hashes, ownership, scope, protected paths, rollback manifest, and post-verify. AI crawler policy must split search, training, user-directed retrieval, and ads/other; never use one allow_ai toggle and never auto-allow training crawlers. Evidence/artifacts: site-inventory.json, route-graph.json, seo-findings.json or geo-findings.json, entity-facts.json, claim-evidence-ledger.json, answerability-report.json, ai-crawler-policy.json, llms-txt-plan.json, mutation-plan.json, verification-report.json, seo-gate.json or geo-gate.json, completion-proof.json. Failure/recovery: unsupported frameworks stay plan-only; browser/production/Search Console/analytics outcomes are marked unverified when not actually run. Forbidden claims: no ranking, indexing, traffic lift, rich-result, answer inclusion, or AI citation guarantee; no keyword stuffing, doorway pages, fake reviews, fake prices, fake availability, fake shipping, fake awards, hidden AI-only text, or scaled spam. CLI entrypoint: \`sks seo-geo-optimizer doctor|audit|plan|apply|verify|status|rollback|fixture --mode seo|geo\`.\n`,
         'reflection': `---\nname: reflection\ndescription: Post-route self-review for full SKS routes that records real misses, gaps, and corrective lessons into TriWiki memory.\n---\n\nUse after full route work/tests and before final. DFix, Answer, Help, Wiki, SKS discovery are exempt. Do not invent faults. Write reflection.md; append real lessons to ${REFLECTION_MEMORY_PATH}; refresh/pack, validate context-pack.json, pass reflection-gate.json.\n\n${reflectionInstructionText()}\n`,
-        'honest-mode': `---\nname: honest-mode\ndescription: Required final SKS verification pass before claiming a task is complete.\n---\n\nBefore final: include a completion summary explaining what was done, what changed for the user/repo, what was verified, and what remains unverified or blocked. Then restate the goal, compare result to evidence, list tests/commands/inspections, state uncertainty or blockers plainly, and do not claim completion beyond evidence. Full routes must pass reflection-gate.json first. Include concise SKS Honest Mode or 솔직모드 when required.\n`,
+        'honest-mode': `---\nname: honest-mode\ndescription: Optional explicit self-audit before a completion claim; run it when asked for $Honest-Mode, or when the strict verification profile requires it.\n---\n\nWhen invoked: restate the goal, compare the result to the evidence actually produced, list the tests/commands/inspections that ran, and state uncertainty or blockers plainly. Do not claim completion beyond evidence. In the essential profile this is a tool the user reaches for, not a gate every finish must pass; in the strict profile full routes still pass reflection-gate.json first and end with a concise SKS Honest Mode (솔직모드) section.\n`,
         'autoresearch-loop': `---\nname: autoresearch-loop\ndescription: Iterative AutoResearch-style loop for open-ended improvement, discovery, prompt, ranking, SEO/GEO, and workflow-quality tasks.\n---\n\nUse for research, ranking, prompt/workflow improvement, benchmark gains, or repeated refinement. Loop: program, hypothesis, smallest falsifying experiment, metric, keep/discard, falsify, next step. Keep a ledger and do not claim improvement without evidence.\n`,
         'hproof-claim-ledger': `---\nname: hproof-claim-ledger\ndescription: Extract atomic claims and classify support status.\n---\n\nEvery factual statement must become an atomic claim. Unsupported critical claims cannot be used for implementation or final answer. Database claims require DB safety evidence.\n`,
         'hproof-evidence-bind': `---\nname: hproof-evidence-bind\ndescription: Bind claims to code, tests, decision contract, vgraph, beta, wiki, or GX render evidence.\n---\n\nEvidence priority: current code/tests, decision-contract.json, vgraph.json, beta.json, GX snapshot/render metadata, LLM Wiki coordinate index, user prompt. Database claims must respect .sneakoscope/db-safety.json. Wiki claims should carry id, hash, source path, and RGBA/trig coordinate anchors so they can be hydrated instead of treated as unsupported summaries.\n`,

package/dist/core/init.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { postToolEvidenceEnabled } from './verification-profile.js';
 import fsp from 'node:fs/promises';
 import { ensureDir, readJson, readText, writeJsonAtomic, writeTextAtomic, mergeManagedBlock, nowIso, PACKAGE_VERSION, exists } from './fsx.js';
 import { DEFAULT_RETENTION_POLICY } from './retention.js';
@@ -144,9 +145,17 @@ const MANAGED_HOOKS = {
     SubagentStop: [{ hooks: [{ type: 'command', command: null, hookName: 'subagent-stop', statusMessage: 'SKS recording subagent stop' }] }],
     Stop: [{ hooks: [{ type: 'command', command: null, hookName: 'stop', statusMessage: 'SKS checking done gate' }] }]
 };
-function buildManagedHooks(commandPrefix) {
+const ESSENTIAL_PROFILE_OMITTED_HOOK_EVENTS = new Set(['PostToolUse']);
+export function managedHookEventNames(root) {
+    const all = Object.keys(MANAGED_HOOKS);
+    return postToolEvidenceEnabled(root) ? all : all.filter((event) => !ESSENTIAL_PROFILE_OMITTED_HOOK_EVENTS.has(event));
+}
+function buildManagedHooks(commandPrefix, root) {
     const hooks = {};
+    const events = new Set(managedHookEventNames(root));
     for (const [eventName, entries] of Object.entries(MANAGED_HOOKS)) {
+        if (!events.has(eventName))
+            continue;
         hooks[eventName] = entries.map((entry) => ({
             ...('matcher' in entry ? { matcher: entry.matcher } : {}),
             hooks: entry.hooks.map(({ hookName, ...hook }) => ({
@@ -160,7 +169,7 @@ function buildManagedHooks(commandPrefix) {
 const CODEX_HOOK_EVENT_KEYS = { ...CODEX_HOOK_EVENT_STATE_KEYS };
 export function buildManagedHookTrustStateToml(root, commandPrefix) {
     const source = path.join(root, '.codex', 'hooks.json');
-    const managed = buildManagedHooks(commandPrefix).hooks;
+    const managed = buildManagedHooks(commandPrefix, root).hooks;
     const blocks = [];
     for (const [eventName, entries] of Object.entries(managed)) {
         const eventKey = CODEX_HOOK_EVENT_KEYS[eventName] || eventName;
@@ -217,7 +226,7 @@ function upsertCodexTrustTomlTable(text, table, block) {
     lines.splice(start, end - start, ...blockLines);
     return lines.join('\n').replace(/\n{3,}/g, '\n\n');
 }
-export function mergeManagedHooksJson(existingContent, commandPrefix) {
+export function mergeManagedHooksJson(existingContent, commandPrefix, projectRootDir) {
     let root = {};
     try {
         root = existingContent?.trim() ? JSON.parse(existingContent) : {};
@@ -227,10 +236,10 @@ export function mergeManagedHooksJson(existingContent, commandPrefix) {
     catch {
         root = {};
     }
-    const managed = buildManagedHooks(commandPrefix);
+    const managed = buildManagedHooks(commandPrefix, projectRootDir);
     const currentHooks = root.hooks && typeof root.hooks === 'object' && !Array.isArray(root.hooks) ? root.hooks : {};
     const nextHooks = { ...currentHooks };
-    for (const [eventName, managedEntries] of Object.entries(managed.hooks)) {
+    for (const eventName of new Set([...Object.keys(currentHooks), ...Object.keys(managed.hooks)])) {
         const existingEntries = Array.isArray(currentHooks[eventName]) ? currentHooks[eventName] : [];
         const preserved = [];
         for (const entry of existingEntries) {
@@ -238,7 +247,12 @@ export function mergeManagedHooksJson(existingContent, commandPrefix) {
             if (stripped)
                 preserved.push(stripped);
         }
-        nextHooks[eventName] = [...preserved, ...managedEntries];
+        const managedEntries = Array.isArray(managed.hooks[eventName]) ? managed.hooks[eventName] : [];
+        const merged = [...preserved, ...managedEntries];
+        if (merged.length)
+            nextHooks[eventName] = merged;
+        else if (eventName in nextHooks)
+            delete nextHooks[eventName];
     }
     return `${JSON.stringify({ ...root, hooks: nextHooks }, null, 2)}\n`;
 }
@@ -282,8 +296,8 @@ const AGENTS_BLOCK = [
     '',
     '- Prefer current code, tests, configuration, contracts, and specifications over memory. Use Context7 or official vendor docs when external APIs, SDKs, packages, MCPs, or versions matter.',
     '- Keep TriWiki recall bounded: read the current context pack before a stage, hydrate risky or stale claims from source, refresh after material changes, and validate before handoff or final.',
-    '- Mock, fixture, synthetic, or capability evidence never proves real execution. Completion claims require relevant checks or an explicit justification for why a check is not useful.',
-    '- Final output must summarize the result, verification, and remaining gaps, then run Honest Mode.',
+    '- Mock, fixture, synthetic, or capability evidence never proves real execution. Say what was actually run.',
+    '- Final output states the result, what was verified, and what remains — plainly, once. No ritual sections.',
     '',
     '## Safety',
     '',

package/dist/core/verification-profile.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const VERIFICATION_PROFILES = ['essential', 'strict'];
+export const DEFAULT_VERIFICATION_PROFILE = 'essential';
+export const VERIFICATION_PROFILE_ENV = 'SKS_VERIFICATION_PROFILE';
+export const VERIFICATION_PROFILE_FILE = 'verification-profile.json';
+const CACHE_TTL_MS = 5_000;
+const cache = new Map();
+export function normalizeVerificationProfile(value) {
+    const text = String(value ?? '').trim().toLowerCase();
+    return text === 'essential' || text === 'strict' ? text : null;
+}
+function globalRootDir(env) {
+    return env.SKS_GLOBAL_ROOT || path.join(env.HOME || os.homedir(), '.sneakoscope-global');
+}
+function readProfileFile(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return normalizeVerificationProfile(parsed?.profile);
+    }
+    catch {
+        return null;
+    }
+}
+export function isVerificationTestHarness(env = process.env) {
+    return env.NODE_TEST_CONTEXT !== undefined || env.SKS_TEST_ISOLATION === '1';
+}
+export function resolveVerificationProfile(root, env = process.env) {
+    const explicit = normalizeVerificationProfile(env[VERIFICATION_PROFILE_ENV]);
+    if (explicit)
+        return explicit;
+    const key = `${root ? path.resolve(root) : ''}|${globalRootDir(env)}|${isVerificationTestHarness(env) ? 't' : 'p'}`;
+    const cached = cache.get(key);
+    if (cached && Date.now() - cached.at < CACHE_TTL_MS)
+        return cached.profile;
+    const profile = (root ? readProfileFile(path.join(path.resolve(root), '.sneakoscope', VERIFICATION_PROFILE_FILE)) : null)
+        ?? readProfileFile(path.join(globalRootDir(env), VERIFICATION_PROFILE_FILE))
+        ?? (isVerificationTestHarness(env) ? 'strict' : DEFAULT_VERIFICATION_PROFILE);
+    cache.set(key, { at: Date.now(), profile });
+    return profile;
+}
+export function resetVerificationProfileCache() {
+    cache.clear();
+}
+export function isStrictVerification(root, env = process.env) {
+    return resolveVerificationProfile(root, env) === 'strict';
+}
+export function stopFinalizationRitualsEnforced(root, env = process.env) {
+    return isStrictVerification(root, env);
+}
+export function managedSkillDigestBlocksEnforced(root, env = process.env) {
+    return isStrictVerification(root, env);
+}
+export function postToolEvidenceEnabled(root, env = process.env) {
+    return isStrictVerification(root, env);
+}
+export function manualProofRoutesBlockReadiness(root, env = process.env) {
+    return isStrictVerification(root, env);
+}
+export function hookDaemonEnabled(env = process.env) {
+    const explicit = String(env.SKS_HOOK_DAEMON ?? '').trim();
+    if (explicit === '1')
+        return true;
+    if (explicit === '0')
+        return false;
+    return !isVerificationTestHarness(env);
+}
+export function verificationProfileSummary(root, env = process.env) {
+    const explicit = normalizeVerificationProfile(env[VERIFICATION_PROFILE_ENV]);
+    const projectFile = root ? readProfileFile(path.join(path.resolve(root), '.sneakoscope', VERIFICATION_PROFILE_FILE)) : null;
+    const globalFile = readProfileFile(path.join(globalRootDir(env), VERIFICATION_PROFILE_FILE));
+    const source = explicit ? 'env'
+        : projectFile ? 'project_file'
+            : globalFile ? 'global_file'
+                : isVerificationTestHarness(env) ? 'harness_default' : 'default';
+    const profile = explicit ?? projectFile ?? globalFile ?? (isVerificationTestHarness(env) ? 'strict' : DEFAULT_VERIFICATION_PROFILE);
+    const strict = profile === 'strict';
+    return {
+        schema: 'sks.verification-profile.v1',
+        profile,
+        source,
+        hook_daemon: hookDaemonEnabled(env),
+        post_tool_evidence: strict,
+        stop_finalization_rituals: strict,
+        managed_skill_digest_blocks: strict,
+        manual_proof_routes_block_readiness: strict,
+    };
+}
+export function writeVerificationProfile(profile, target, env = process.env) {
+    const dir = target.scope === 'project'
+        ? path.join(path.resolve(target.root || process.cwd()), '.sneakoscope')
+        : globalRootDir(env);
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, VERIFICATION_PROFILE_FILE);
+    fs.writeFileSync(file, `${JSON.stringify({ schema: 'sks.verification-profile.v1', profile }, null, 2)}\n`);
+    resetVerificationProfileCache();
+    return file;
+}

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '9.2.6';
+export const PACKAGE_VERSION = '10.0.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "9.2.6",
+  "version": "10.0.0",
   "description": "Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",