sneakoscope 10.2.0 → 10.3.0

package/README.md

@@ -16,7 +16,7 @@
 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 -->
 
-Current package: **SKS 10.2.0**. Install the latest stable release from npm.
+Current package: **SKS 10.3.0**. Install the latest stable release from npm.
 
 [Quick start](#install-in-one-command) · [Commands](#everyday-commands) · [SKS Center](#sks-center-macos) · [Documentation](#documentation) · [Changelog](CHANGELOG.md)
 
@@ -92,6 +92,11 @@ in your terminal.
 ## SKS Center (macOS)
 
 Open **SKS Control Center** from the SKS menu bar.
+The Menu Bar app (with the Control Center) is built from source on macOS when you run
+`npm i -g sneakoscope` interactively in a terminal, and by `sks install`, `sks doctor --fix`,
+`sks update`, or `sks menubar install`. Dependency, CI, and piped installs never touch your
+home directory; set `SKS_POSTINSTALL_MENUBAR=1` to force the build in a script, or
+`SKS_POSTINSTALL_NO_MENUBAR=1` to skip it.
 
 | Page | Use it to |
 | --- | --- |

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/cli/command-manifest-lite.js

@@ -95,7 +95,8 @@ const COMMAND_MANIFEST_LITE_BASE = [
     { name: 'perf', summary: 'Run performance checks', maturity: 'beta' },
     { name: 'bench', summary: 'Run core trust-kernel benchmark budgets', maturity: 'beta' },
     { name: 'mcp-server', summary: 'Run a stdio MCP server exposing SKS commands as tools for MCP-capable agent hosts', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true },
-    { name: 'agent-bridge', summary: 'Register SKS tools or run read-only tools with native Astra async calling', maturity: 'beta', readonly: true, diagnostic: true }
+    { name: 'agent-bridge', summary: 'Register SKS tools or run read-only tools with native Astra async calling', maturity: 'beta', readonly: true, diagnostic: true },
+    { name: 'decision', summary: 'Manage optional Jev decisions through OpenRouter: status, enable, disable, probe, evaluate', maturity: 'labs', skipMigrationGate: true, allowedDuringActiveRoute: true }
 ];
 const SAFE_COMMAND_CONTRACT_LITE = {
     risk: 'R2',
@@ -107,6 +108,7 @@ const SAFE_COMMAND_CONTRACT_LITE = {
 };
 const COMMAND_CONTRACT_OVERRIDES_LITE = {
     align: { latency: 'long', supportsJson: true, inputProfile: 'json-only' },
+    decision: { risk: 'R2', latency: 'long', supportsJson: true, remoteAllowed: false, inputProfile: 'json-only' },
     cleanup: { risk: 'R3', latency: 'long', supportsJson: true, remoteAllowed: false, inputProfile: 'json-only' },
     autoresearch: { latency: 'long' },
     bench: { latency: 'long' },

package/dist/cli/command-registry.js

@@ -247,10 +247,18 @@ const COMMAND_DEFINITIONS = {
         allowedDuringActiveRoute: true,
         activeRoutePolicy: 'always'
     }),
-    'agent-bridge': readOnly(entry('beta', 'Register SKS tools or run read-only tools with native Astra async calling', 'dist/core/commands/agent-bridge-command.js', subcommand(() => import('../core/commands/agent-bridge-command.js'), 'agentBridgeCommand', 'dist/core/commands/agent-bridge-command.js', 'setup')))
+    'agent-bridge': readOnly(entry('beta', 'Register SKS tools or run read-only tools with native Astra async calling', 'dist/core/commands/agent-bridge-command.js', subcommand(() => import('../core/commands/agent-bridge-command.js'), 'agentBridgeCommand', 'dist/core/commands/agent-bridge-command.js', 'setup'))),
+    decision: {
+        ...skipMigrationGate(entry('labs', 'Manage optional Jev decisions through OpenRouter: status, enable, disable, probe, evaluate', 'dist/commands/decision.js', directCommand(() => import('../commands/decision.js'), 'dist/commands/decision.js'), {
+            allowedDuringActiveRoute: true,
+            activeRoutePolicy: 'always'
+        })),
+        packageRequiredFiles: ['dist/commands/decision.js']
+    }
 };
 const COMMANDS_WITH_LEGACY_CONTRACT_OVERRIDES = applyCommandContractOverrides(COMMAND_DEFINITIONS, {
     align: { latency: 'long', supportsJson: true, inputProfile: 'json-only' },
+    decision: { risk: 'R2', latency: 'long', supportsJson: true, remoteAllowed: false, inputProfile: 'json-only' },
     cleanup: { risk: 'R3', latency: 'long', supportsJson: true, remoteAllowed: false, inputProfile: 'json-only' },
     autoresearch: { latency: 'long' },
     bench: { latency: 'long' },

package/dist/cli/install-helpers-menubar.js

@@ -0,0 +1,57 @@
+import { stdin as input, stdout as output } from 'node:process';
+import { globalSksRoot } from '../core/fsx.js';
+import { installSksMenuBar, sksMenuBarRestartDeferred } from '../core/codex-app/menubar/installer.js';
+export function postinstallMenuBarPolicy(env, io, platform = process.platform) {
+    const launch = !sksMenuBarRestartDeferred(env);
+    if (env.SKS_POSTINSTALL_NO_BOOTSTRAP === '1')
+        return { install: false, launch: false, reason: 'SKS_POSTINSTALL_NO_BOOTSTRAP=1' };
+    if (env.SKS_POSTINSTALL_NO_MENUBAR === '1')
+        return { install: false, launch: false, reason: 'SKS_POSTINSTALL_NO_MENUBAR=1' };
+    if (platform !== 'darwin')
+        return { install: false, launch: false, reason: `platform:${platform}` };
+    if (env.SKS_POSTINSTALL_MENUBAR === '1')
+        return { install: true, launch, reason: 'forced by SKS_POSTINSTALL_MENUBAR=1' };
+    if (env.npm_config_global !== 'true')
+        return { install: false, launch: false, reason: 'not a global npm install' };
+    if (env.CI === 'true' || env.CI === '1')
+        return { install: false, launch: false, reason: 'CI' };
+    if (!io.stdinTTY || !io.stdoutTTY)
+        return { install: false, launch: false, reason: 'non-interactive install' };
+    return { install: true, launch, reason: 'interactive global npm install on macOS' };
+}
+export async function ensureSksMenuBarDuringPostinstall(env = process.env, io = { stdinTTY: Boolean(input.isTTY), stdoutTTY: Boolean(output.isTTY) }, installer = installSksMenuBar) {
+    const policy = postinstallMenuBarPolicy(env, io);
+    if (!policy.install)
+        return { status: 'skipped', reason: policy.reason, app_path: null, launched: false, blockers: [] };
+    try {
+        const result = await installer({ root: globalSksRoot(), apply: true, launch: policy.launch, env, quiet: true });
+        const blockers = Array.isArray(result.blockers) ? result.blockers.map(String) : [];
+        if (!result.ok)
+            return { status: 'blocked', reason: policy.reason, app_path: result.app_path ?? null, launched: false, blockers };
+        const upToDate = Array.isArray(result.actions) && result.actions.includes('menubar_up_to_date');
+        return {
+            status: upToDate ? 'up_to_date' : 'installed',
+            reason: policy.reason,
+            app_path: result.app_path ?? null,
+            launched: result.launch?.ok === true && result.launch?.requested === true,
+            blockers
+        };
+    }
+    catch (error) {
+        return { status: 'failed', reason: policy.reason, app_path: null, launched: false, blockers: [error instanceof Error ? error.message : String(error)] };
+    }
+}
+export function describePostinstallMenuBar(outcome) {
+    switch (outcome.status) {
+        case 'installed':
+            return `SKS Menu Bar + Control Center: installed at ${outcome.app_path ?? 'unknown path'}${outcome.launched ? ' and started' : ' (start it with `sks menubar restart`)'} (${outcome.reason}).`;
+        case 'up_to_date':
+            return `SKS Menu Bar + Control Center: already current at ${outcome.app_path ?? 'unknown path'}.`;
+        case 'blocked':
+            return `SKS Menu Bar + Control Center: not installed (${outcome.blockers.join(', ') || 'blocked'}). Run \`sks menubar install\` after fixing the blocker.`;
+        case 'failed':
+            return `SKS Menu Bar + Control Center: install failed (${outcome.blockers.join(', ')}). Run \`sks menubar install\`.`;
+        default:
+            return `SKS Menu Bar + Control Center: not installed during npm install (${outcome.reason}). Run \`sks install\` or \`sks menubar install\` to add it.`;
+    }
+}

package/dist/cli/install-helpers.js

@@ -7,14 +7,23 @@ import { formatHarnessConflictReport, llmHarnessCleanupPrompt, scanHarnessConfli
 import { reconcileCodexAppUpgradeProcesses } from '../core/codex-app.js';
 import { runPostinstallGlobalDoctorAndMarkPending } from '../core/update/update-migration-state.js';
 import { isProjectSetupCandidate } from './install-tool-helpers.js';
+import { describePostinstallMenuBar, ensureSksMenuBarDuringPostinstall } from './install-helpers-menubar.js';
 import { ensureCodexImagegenDuringInstall, ensureGlobalCodexSkillsDuringInstall, ensureGlobalContext7DuringInstall, ensureGlobalGetdesignSkillDuringInstall, ensureSksCommandDuringInstall } from './install-helpers-install-support.js';
 const doctorFixCommand = ['sks doctor', '--fix'].join(' ');
 export async function postinstall({ bootstrap }) {
     const installRoot = path.resolve(process.env.INIT_CWD || process.cwd());
     console.log('\nSKS installed.');
     await restoreInstalledPackageBuildStamp();
+    const menuBar = await ensureSksMenuBarDuringPostinstall(process.env);
+    if (menuBar.status !== 'skipped')
+        console.log(describePostinstallMenuBar(menuBar));
     if (!postinstallExternalMutationsAllowed(process.env)) {
-        console.log('Automatic bootstrap was not run; npm install leaves project, HOME, Codex, and global SKS state unchanged by default.');
+        const menuBarTouchedHome = menuBar.status === 'installed' || menuBar.status === 'up_to_date';
+        console.log(menuBarTouchedHome
+            ? 'Automatic bootstrap was not run; apart from the SKS Menu Bar app above, npm install leaves project, HOME, Codex, and global SKS state unchanged.'
+            : 'Automatic bootstrap was not run; npm install leaves project, HOME, Codex, and global SKS state unchanged by default.');
+        if (menuBar.status === 'skipped')
+            console.log(describePostinstallMenuBar(menuBar));
         console.log('Next: run `sks bootstrap` when you are ready to initialize SKS.');
         console.log('Dependency diagnostics remain explicit: sks deps check');
         console.log('Explicit lifecycle opt-in: SKS_POSTINSTALL_BOOTSTRAP=1 npm i -g sneakoscope');

package/dist/commands/decision.js

@@ -0,0 +1,7 @@
+import { runDecisionCommand, usage, UsageError } from '../core/decisions/cli.js';
+export { UsageError, parseDecisionArgs, runDecisionCommand, usage } from '../core/decisions/cli.js';
+export async function run(_command, args = []) {
+    const code = await runDecisionCommand(args);
+    if (code !== 0)
+        process.exitCode = code;
+}

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "10.2.0",
+  "package_version": "10.3.0",
   "skills": [
     {
       "canonical_name": "sks",

package/dist/core/agents/native-worker-backend-router.js

@@ -245,6 +245,11 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
         && input.agent?.routed_model === ASTRA_SUBAGENT_MODEL
         ? normalizeModelReasoning(input.agent?.routed_model_reasoning_effort)
         : null;
+    const jevModel = !explicitModel && input.agent?.routed_model_policy === 'jev_sealed_routing'
+        ? String(input.agent.routed_model || '').trim()
+        : '';
+    const jevEffort = jevModel ? normalizeModelReasoning(input.agent?.routed_model_reasoning_effort) : null;
+    const selectedModel = explicitModel || jevModel;
     const taskPolicy = decideSubagentModel({ title: taskKindText, description: riskText, role: input.agent?.role });
     const routed = narutoOnly
         ? await routeModel(category, {
@@ -252,10 +257,10 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
             narutoOnly: true,
             taskText: taskKindText,
             riskText,
-            reasoningEffort: savedAstraEffort,
+            reasoningEffort: jevEffort || savedAstraEffort,
             availableModels: lbCatalog?.models || [],
             availableModelEfforts: lbCatalog?.model_efforts || {},
-            ...(explicitModel ? { model: explicitModel } : {})
+            ...(selectedModel ? { model: selectedModel } : {})
         })
         : {
             model: ASTRA_SUBAGENT_MODEL,

package/dist/core/codex-app/menubar/constants.js

@@ -32,6 +32,8 @@ export const NATIVE_SOURCE_FILES = [
     'RemoteCodingViewController.swift',
     'DiagnosticsViewController.swift',
     'SettingsViewController.swift',
+    'LocalDecisionModels.swift',
+    'LocalDecisionViewController.swift',
     'OperationModels.swift',
     'ProviderRouteExplanation.swift',
     'OperationCoordinator.swift',

package/dist/core/decisions/cli.js

@@ -0,0 +1,324 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { printJson } from '../../cli/output.js';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
+import { jevEnabled, readDecisionConfig, writeDecisionConfig } from './config.js';
+import { buildEvaluationReport } from './evaluation.js';
+import { OPENROUTER_DECISIONS_ENDPOINT, OPENROUTER_DECISIONS_MODEL, requestOpenRouterDecision } from './openrouter.js';
+import { buildDecisionBundle } from './questions.js';
+import { RECOVERY_CAPABILITY } from './recovery.js';
+import { DESIGN_DEFAULTS } from './types.js';
+export const EXIT_USAGE = 2;
+export const EXIT_FAILURE = 1;
+export class UsageError extends Error {
+}
+export const SUBCOMMANDS = ['status', 'enable', 'disable', 'probe', 'evaluate'];
+const OPTION_SPEC = {
+    status: { booleans: ['--json'], values: [] },
+    enable: { booleans: ['--json', '--consent-cloud'], values: ['--provider', '--model'] },
+    disable: { booleans: ['--json'], values: [] },
+    probe: { booleans: ['--json'], values: [] },
+    evaluate: { booleans: ['--json'], values: ['--dataset', '--output'] }
+};
+export function parseDecisionArgs(args) {
+    const [first, ...rest] = args.map(String);
+    if (!first || first === '--help' || first === '-h' || first === 'help')
+        throw new UsageError('help');
+    if (!SUBCOMMANDS.includes(first))
+        throw new UsageError(`unknown subcommand: ${first}`);
+    const subcommand = first;
+    const spec = OPTION_SPEC[subcommand];
+    const flags = new Set();
+    const values = new Map();
+    for (let index = 0; index < rest.length; index += 1) {
+        const arg = rest[index];
+        if (!arg.startsWith('--'))
+            throw new UsageError(`unexpected argument: ${arg}`);
+        const [name, inline] = arg.includes('=') ? [arg.slice(0, arg.indexOf('=')), arg.slice(arg.indexOf('=') + 1)] : [arg, undefined];
+        if (spec.booleans.includes(name)) {
+            if (inline !== undefined)
+                throw new UsageError(`flag takes no value: ${name}`);
+            flags.add(name);
+            continue;
+        }
+        if (spec.values.includes(name)) {
+            const value = inline !== undefined ? inline : rest[index + 1];
+            if (value === undefined || value.startsWith('--'))
+                throw new UsageError(`missing value for ${name}`);
+            if (values.has(name))
+                throw new UsageError(`duplicate option: ${name}`);
+            values.set(name, value);
+            if (inline === undefined)
+                index += 1;
+            continue;
+        }
+        throw new UsageError(`unknown option for ${subcommand}: ${name}`);
+    }
+    return { subcommand, flags, values };
+}
+export function usage() {
+    return [
+        'Usage: sks decision <subcommand> [options]',
+        '',
+        'Optional Jev decisions through OpenRouter. Default mode is off: no network',
+        'call, no model load, and no source hydration solely for Jev. A valid Jev',
+        'answer is compiled into an existing SKS plan or context selection. There is',
+        'no advisory mode and no second LLM judge.',
+        '',
+        '  status [--json]     local, non-billable readiness',
+        '  enable --provider openrouter --model typesafe/jev-1.13 --consent-cloud [--json]',
+        '  disable [--json]    return to the deterministic baseline',
+        '  probe [--json]      explicit tiny synthetic Decisions request',
+        '  evaluate --dataset <path> --output <path> [--json]',
+        '',
+        'Exit codes: 0 ok, 1 unavailable or failed, 2 usage error.'
+    ].join('\n');
+}
+function output(result, json, textLines) {
+    if (json) {
+        printJson(result, { failureExitCode: false });
+        return;
+    }
+    for (const line of textLines())
+        console.log(line);
+}
+export async function runDecisionCommand(args, env = process.env) {
+    let parsed;
+    try {
+        parsed = parseDecisionArgs(args);
+    }
+    catch (error) {
+        const message = error instanceof UsageError ? error.message : String(error);
+        if (message !== 'help')
+            console.error(`error: ${message}\n`);
+        console.log(usage());
+        return message === 'help' ? 0 : EXIT_USAGE;
+    }
+    const json = parsed.flags.has('--json');
+    try {
+        switch (parsed.subcommand) {
+            case 'status': {
+                const report = await statusReport(env);
+                output(report, json, () => [
+                    `mode: ${report.mode}  consent: ${report.consentCloud}  credential: ${report.credential.present ? report.credential.source : 'missing'}`,
+                    `model: ${report.model}  endpoint: ${report.endpoint}`,
+                    `capabilities: context=${report.capabilities.context.ready ? 'ready' : 'off'} plan=${report.capabilities.plan.ready ? 'ready' : 'off'} recovery=${report.capabilities.recovery.reason}`
+                ]);
+                return 0;
+            }
+            case 'enable':
+                return await runEnable(parsed, env);
+            case 'disable':
+                return await runDisable(env, json);
+            case 'probe':
+                return await runProbe(env, json);
+            case 'evaluate':
+                return await runEvaluate(parsed, env);
+        }
+    }
+    catch (error) {
+        if (error instanceof UsageError) {
+            console.error(`error: ${error.message}\n`);
+            console.log(usage());
+            return EXIT_USAGE;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        if (json)
+            printJson({ ok: false, error: message }, { failureExitCode: false });
+        else
+            console.error(`error: ${message}`);
+        return EXIT_FAILURE;
+    }
+}
+export async function statusReport(env) {
+    const config = await readDecisionConfig(env);
+    const resolved = await resolveOpenRouterApiKey({ env });
+    const nextStep = !resolved.key
+        ? 'missing_key'
+        : !jevEnabled(config)
+            ? 'enable'
+            : 'ready';
+    return {
+        schema: 'sks.jev-decision-status.v1',
+        ok: true,
+        mode: config.mode,
+        provider: config.provider,
+        model: config.model,
+        endpoint: OPENROUTER_DECISIONS_ENDPOINT,
+        consentCloud: config.consentCloud,
+        credential: {
+            present: Boolean(resolved.key),
+            source: resolved.source,
+            preview: resolved.key_preview
+        },
+        capabilities: config.capabilities,
+        recovery: RECOVERY_CAPABILITY,
+        nextStep,
+        notes: [
+            'status never calls OpenRouter and never starts a service',
+            'enabled Jev is consumed by official-subagent preparation: automatic plan variants and optional context',
+            'recovery is unsupported: no SKS-owned ambiguous-failure handler exists'
+        ],
+        utilization: {
+            officialSubagentPreparation: jevEnabled(config),
+            planSelection: 'automatic_only',
+            recovery: false
+        }
+    };
+}
+async function runEnable(parsed, env) {
+    const provider = parsed.values.get('--provider');
+    const model = parsed.values.get('--model');
+    if (provider !== 'openrouter')
+        throw new UsageError('--provider must be openrouter');
+    if (model !== OPENROUTER_DECISIONS_MODEL)
+        throw new UsageError(`--model must be ${OPENROUTER_DECISIONS_MODEL}`);
+    if (!parsed.flags.has('--consent-cloud'))
+        throw new UsageError('--consent-cloud is required to send bounded evidence to OpenRouter');
+    const json = parsed.flags.has('--json');
+    const config = await writeDecisionConfig({
+        mode: 'jev',
+        model,
+        consentCloud: true,
+        consentAt: nowIso(),
+        capabilities: {
+            context: { ready: true, promoted: false, reason: 'implementation_ready_not_workload_promoted' },
+            plan: { ready: true, promoted: false, reason: 'implementation_ready_host_dispatch_unverified' },
+            recovery: { ready: false, promoted: false, reason: RECOVERY_CAPABILITY.reason }
+        }
+    }, env);
+    output({ schema: 'sks.jev-decision-enable.v1', ok: true, config }, json, () => [
+        `enabled Jev via OpenRouter (${config.model})`,
+        'context and SKS-owned plan selection are ready; recovery remains unsupported',
+        'this is not a measured performance claim'
+    ]);
+    return 0;
+}
+async function runDisable(env, json) {
+    const config = await writeDecisionConfig({
+        mode: 'off',
+        consentCloud: false,
+        consentAt: null,
+        capabilities: {
+            context: { ready: false, promoted: false, reason: 'not_enabled' },
+            plan: { ready: false, promoted: false, reason: 'not_enabled' },
+            recovery: { ready: false, promoted: false, reason: RECOVERY_CAPABILITY.reason }
+        }
+    }, env);
+    output({ schema: 'sks.jev-decision-disable.v1', ok: true, config }, json, () => [
+        'mode: off'
+    ]);
+    return 0;
+}
+async function runProbe(env, json) {
+    const resolved = await resolveOpenRouterApiKey({ env });
+    if (!resolved.key) {
+        output({ schema: 'sks.jev-decision-probe.v1', ok: false, error: 'missing_key', live: false }, json, () => [
+            'probe skipped: OpenRouter key is missing'
+        ]);
+        return EXIT_FAILURE;
+    }
+    const bundle = buildDecisionBundle({
+        projectId: 'probe',
+        workflowRunId: 'probe',
+        workflowRevision: 'probe',
+        sourceDigest: 'probe',
+        graphDigest: null,
+        goal: 'Synthetic connectivity probe only. No repository or personal data.',
+        facts: { notice: 'synthetic_probe' },
+        recoveryCandidates: [{
+                id: 'failed',
+                summary: 'The recorded status is failed.',
+                handlerId: 'none',
+                authorized: true,
+                readOnly: true
+            }, {
+                id: 'passed',
+                summary: 'The recorded status is passed.',
+                handlerId: 'none',
+                authorized: true,
+                readOnly: true
+            }],
+        recoveryDiagnostic: 'A synthetic test failed.'
+    });
+    bundle.request.state = {
+        notice: 'Synthetic connectivity probe only. No repository or personal data.',
+        status: 'failed',
+        diagnostic: 'A synthetic test failed.'
+    };
+    bundle.request.questions = {
+        status: {
+            type: 'choice',
+            instructions: 'Which status is explicitly recorded in state.status?',
+            criteria: {
+                passed: 'The recorded status is passed.',
+                failed: 'The recorded status is failed.'
+            }
+        },
+        has_failure: {
+            type: 'noul',
+            instructions: 'Does state.diagnostic explicitly describe a failure?'
+        },
+        severity: {
+            type: 'score',
+            instructions: 'How directly does state.diagnostic state a failure?',
+            criteria: [
+                'No failure is stated.',
+                'A failure is implied but not explicit.',
+                'A failure is explicitly stated.'
+            ]
+        }
+    };
+    const started = Date.now();
+    const result = await requestOpenRouterDecision(bundle, { env, deadlineMs: DESIGN_DEFAULTS.deadlineMs });
+    const receipt = {
+        schema: 'sks.jev-decision-probe.v1',
+        live: result.ok,
+        ok: result.ok,
+        endpoint: OPENROUTER_DECISIONS_ENDPOINT,
+        requestedModel: OPENROUTER_DECISIONS_MODEL,
+        responseModel: result.ok ? result.resolvedModel : null,
+        timestamp: nowIso(),
+        httpStatus: result.ok ? 200 : result.status,
+        reason: result.ok ? 'connected' : result.reason,
+        usage: result.ok ? result.usage : result.usage,
+        elapsedMs: Date.now() - started,
+        evidenceLevel: result.ok ? 'live_protocol' : 'failed_probe',
+        note: 'A 200 response is connectivity evidence, not SKS task accuracy or a privacy audit.'
+    };
+    output(receipt, json, () => [
+        result.ok
+            ? `probe ok · model ${receipt.responseModel} · ${receipt.elapsedMs}ms`
+            : `probe failed · ${receipt.reason}`
+    ]);
+    return result.ok ? 0 : EXIT_FAILURE;
+}
+async function runEvaluate(parsed, env) {
+    const dataset = parsed.values.get('--dataset');
+    const outputPath = parsed.values.get('--output');
+    if (!dataset || !outputPath)
+        throw new UsageError('--dataset and --output are required');
+    const json = parsed.flags.has('--json');
+    let rows = [];
+    try {
+        const raw = JSON.parse(await fsp.readFile(dataset, 'utf8'));
+        rows = Array.isArray(raw) ? raw : Array.isArray(raw.rows) ? raw.rows : [];
+    }
+    catch {
+        throw new UsageError('invalid JSON dataset');
+    }
+    const report = buildEvaluationReport({
+        rows,
+        evidenceLevel: 'synthetic',
+        live: false
+    });
+    await fsp.mkdir(path.dirname(path.resolve(outputPath)), { recursive: true });
+    await writeJsonAtomic(path.resolve(outputPath), report, { mode: 0o600 });
+    output({ schema: 'sks.jev-decision-evaluate.v1', ok: true, reportPath: outputPath, report }, json, () => [
+        `wrote ${outputPath}`,
+        `tasks: ${report.taskCount}  live: ${report.live}`,
+        ...(report.unavailableReasons.length ? [`unavailable: ${report.unavailableReasons.join(', ')}`] : [])
+    ]);
+    return 0;
+}

package/dist/core/decisions/config.js

@@ -0,0 +1,109 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { ensureConfinedDirectory, inspectConfinedPath, ManagedPathSafetyError } from '../managed-path-safety.js';
+import { DESIGN_DEFAULTS } from './types.js';
+export const DECISION_CONFIG_SCHEMA = 'sks.jev-decision-config.v1';
+const CONFIG_DIRNAME = 'decisions';
+export function decisionPaths(env = process.env) {
+    const sksHome = path.resolve(env.SKS_HOME || path.join(env.HOME || os.homedir(), '.sneakoscope'));
+    const configDir = path.join(sksHome, CONFIG_DIRNAME);
+    return {
+        sksHome,
+        configDir,
+        configPath: path.join(configDir, 'config.json')
+    };
+}
+export function defaultDecisionConfig() {
+    return {
+        schema: DECISION_CONFIG_SCHEMA,
+        mode: DESIGN_DEFAULTS.mode,
+        provider: 'openrouter',
+        model: DESIGN_DEFAULTS.model,
+        consentCloud: false,
+        consentAt: null,
+        capabilities: {
+            context: capability(false, false, 'not_enabled'),
+            plan: capability(false, false, 'not_enabled'),
+            recovery: capability(false, false, 'unsupported_no_sks_handler')
+        },
+        updatedAt: null
+    };
+}
+export async function readDecisionConfig(env = process.env) {
+    const paths = decisionPaths(env);
+    const current = await readJson(paths.configPath, null).catch(() => null);
+    return current ? normalizeConfig(current) : defaultDecisionConfig();
+}
+export async function writeDecisionConfig(patch, env = process.env) {
+    const paths = decisionPaths(env);
+    const current = await readDecisionConfig(env);
+    const next = {
+        ...current,
+        ...(patch.mode === undefined ? {} : { mode: patch.mode }),
+        ...(patch.model === undefined ? {} : { model: patch.model }),
+        ...(patch.consentCloud === undefined ? {} : { consentCloud: patch.consentCloud }),
+        ...(patch.consentAt === undefined ? {} : { consentAt: patch.consentAt }),
+        capabilities: {
+            context: patch.capabilities?.context || current.capabilities.context,
+            plan: patch.capabilities?.plan || current.capabilities.plan,
+            recovery: current.capabilities.recovery
+        },
+        updatedAt: nowIso()
+    };
+    if (next.mode !== 'off' && next.mode !== 'jev')
+        throw new Error(`invalid_decision_mode:${String(next.mode)}`);
+    if (next.mode === 'jev' && next.consentCloud !== true)
+        throw new Error('jev_cloud_consent_required');
+    if (next.model !== DESIGN_DEFAULTS.model)
+        throw new Error(`unsupported_decision_model:${next.model}`);
+    await fsp.mkdir(paths.sksHome, { recursive: true });
+    await ensureConfinedDirectory(paths.sksHome, paths.configDir);
+    const inspected = await inspectConfinedPath(paths.sksHome, paths.configPath);
+    if (inspected.leafSymlink) {
+        throw new ManagedPathSafetyError('managed_path_leaf_symlink_refused', inspected.path);
+    }
+    await writeJsonAtomic(inspected.path, next, { mode: 0o600 });
+    return next;
+}
+export function jevEnabled(config) {
+    return config.mode === 'jev' && config.consentCloud === true;
+}
+function normalizeConfig(raw) {
+    const fallback = defaultDecisionConfig();
+    if (!isRecord(raw) || raw.schema !== DECISION_CONFIG_SCHEMA)
+        return fallback;
+    const mode = raw.mode === 'jev' ? 'jev' : 'off';
+    const consentCloud = raw.consentCloud === true;
+    return {
+        schema: DECISION_CONFIG_SCHEMA,
+        mode: mode === 'jev' && consentCloud ? 'jev' : 'off',
+        provider: 'openrouter',
+        model: typeof raw.model === 'string' && raw.model.trim() ? raw.model.trim() : DESIGN_DEFAULTS.model,
+        consentCloud,
+        consentAt: typeof raw.consentAt === 'string' ? raw.consentAt : null,
+        capabilities: {
+            context: normalizeCapability(raw.capabilities, 'context', fallback.capabilities.context),
+            plan: normalizeCapability(raw.capabilities, 'plan', fallback.capabilities.plan),
+            recovery: capability(false, false, 'unsupported_no_sks_handler')
+        },
+        updatedAt: typeof raw.updatedAt === 'string' ? raw.updatedAt : null
+    };
+}
+function normalizeCapability(raw, key, fallback) {
+    if (!isRecord(raw) || !isRecord(raw[key]))
+        return fallback;
+    const row = raw[key];
+    return {
+        ready: row.ready === true,
+        promoted: row.promoted === true,
+        reason: typeof row.reason === 'string' ? row.reason : fallback.reason
+    };
+}
+function capability(ready, promoted, reason) {
+    return { ready, promoted, reason };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}