sneakoscope 10.2.0 → 10.3.0

package/dist/core/update/update-migration-state/retired-local-decision.js

@@ -0,0 +1,203 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { runProcess } from '../../fsx.js';
+import { inspectConfinedPath, ManagedPathSafetyError } from '../../managed-path-safety.js';
+const RUNTIME_DIRNAME = 'local-decision';
+const MAX_MARKER_BYTES = 256 * 1024;
+export async function runRetiredLocalDecisionStage(env = process.env) {
+    const cleanup = await removeRetiredLocalDecisionRuntime(env);
+    return {
+        ok: cleanup.ok,
+        status: cleanup.ok ? 'ok' : 'failed',
+        actions: cleanup.actions,
+        blockers: cleanup.blockers,
+        warnings: cleanup.warnings,
+        detail: cleanup.detail
+    };
+}
+export async function removeRetiredLocalDecisionRuntime(env = process.env, opts = {}) {
+    const sksHome = path.resolve(env.SKS_HOME || path.join(env.HOME || os.homedir(), '.sneakoscope'));
+    const runtimeRoot = path.join(sksHome, RUNTIME_DIRNAME);
+    const actions = [];
+    const blockers = [];
+    const warnings = [];
+    const detail = {
+        runtime_root: runtimeRoot,
+        removed_runtime: false,
+        removed_socket_dir: false,
+        stopped_worker: false
+    };
+    if (sksHome === path.parse(sksHome).root) {
+        blockers.push('retired_local_decision_home_root_refused');
+        return { ok: false, actions, blockers, warnings, detail };
+    }
+    const stopped = await stopRecordedWorker(runtimeRoot).catch(() => 'unreadable');
+    if (stopped === 'stopped') {
+        detail.stopped_worker = true;
+        actions.push('stopped_retired_local_decision_worker');
+    }
+    else if (stopped === 'not_ours') {
+        warnings.push('retired_local_decision_worker_pid_not_owned');
+    }
+    const removedDefault = await removeConfinedTree(sksHome, runtimeRoot);
+    if (removedDefault === 'removed') {
+        detail.removed_runtime = true;
+        actions.push('removed_retired_local_decision_runtime');
+    }
+    else if (removedDefault === 'absent') {
+        actions.push('retired_local_decision_runtime_absent');
+    }
+    else {
+        blockers.push(`retired_local_decision_runtime_${removedDefault}`);
+    }
+    const explicit = explicitRuntimeRoot(env, runtimeRoot);
+    if (explicit) {
+        const removedExplicit = await removeMarkedExplicitRoot(explicit);
+        if (removedExplicit === 'removed')
+            actions.push('removed_explicit_retired_local_decision_root');
+        else if (removedExplicit === 'preserved')
+            warnings.push('retired_local_decision_explicit_root_preserved');
+        else if (removedExplicit !== 'absent')
+            blockers.push(`retired_local_decision_explicit_root_${removedExplicit}`);
+    }
+    const socketDir = opts.socketDir || defaultSocketDir();
+    const removedSocket = await removeSocketDir(socketDir, Boolean(opts.socketDir));
+    if (removedSocket === 'removed') {
+        detail.removed_socket_dir = true;
+        actions.push('removed_retired_local_decision_socket_dir');
+    }
+    else if (removedSocket !== 'absent') {
+        blockers.push(`retired_local_decision_socket_${removedSocket}`);
+    }
+    return { ok: blockers.length === 0, actions, blockers, warnings, detail };
+}
+function explicitRuntimeRoot(env, defaultRoot) {
+    const raw = String(env.SKS_LOCAL_DECISION_ROOT || '').trim();
+    if (!raw)
+        return null;
+    const resolved = path.resolve(raw);
+    if (resolved === defaultRoot)
+        return null;
+    return resolved;
+}
+async function removeMarkedExplicitRoot(target) {
+    const parent = path.dirname(target);
+    if (parent === target || parent === path.parse(parent).root)
+        return 'preserved';
+    const marked = await isRetiredRuntimeMarker(target);
+    if (marked === 'absent')
+        return 'absent';
+    if (marked !== 'marked')
+        return 'preserved';
+    return removeConfinedTree(parent, target);
+}
+async function isRetiredRuntimeMarker(root) {
+    const configPath = path.join(root, 'config.json');
+    const receiptPath = path.join(root, 'install-receipt.json');
+    const configStat = await fsp.lstat(configPath).catch(() => null);
+    const receiptStat = await fsp.lstat(receiptPath).catch(() => null);
+    if (!configStat && !receiptStat)
+        return 'absent';
+    if (!configStat?.isFile() || configStat.isSymbolicLink() || !receiptStat?.isFile() || receiptStat.isSymbolicLink())
+        return 'unmarked';
+    if (configStat.size > MAX_MARKER_BYTES || receiptStat.size > MAX_MARKER_BYTES)
+        return 'unmarked';
+    try {
+        const config = JSON.parse(await fsp.readFile(configPath, 'utf8'));
+        if (config.schemaVersion !== 1)
+            return 'unmarked';
+        return 'marked';
+    }
+    catch {
+        return 'unmarked';
+    }
+}
+async function removeConfinedTree(boundary, target) {
+    try {
+        const inspected = await inspectConfinedPath(boundary, target);
+        if (!inspected.exists)
+            return 'absent';
+        await removeExistingTree(inspected.path);
+        const after = await inspectConfinedPath(boundary, target);
+        return after.exists ? 'refused' : 'removed';
+    }
+    catch (error) {
+        if (error instanceof ManagedPathSafetyError)
+            return 'refused';
+        return 'refused';
+    }
+}
+async function removeSocketDir(socketDir, trustedParent) {
+    const resolved = path.resolve(socketDir);
+    const parent = path.dirname(resolved);
+    const name = path.basename(resolved);
+    if (!/^sks-ld-\d+$/.test(name))
+        return 'refused';
+    const stat = await fsp.lstat(resolved).catch((error) => error.code === 'ENOENT' ? null : Promise.reject(error));
+    if (!stat)
+        return 'absent';
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+        return 'refused';
+    if (!trustedParent && !(await parentIsTemp(parent)))
+        return 'refused';
+    await removeExistingTree(resolved);
+    return 'removed';
+}
+async function parentIsTemp(parent) {
+    const parentReal = await fsp.realpath(parent).catch(() => null);
+    const tempReal = await fsp.realpath('/tmp').catch(() => null);
+    return Boolean(parentReal && tempReal && parentReal === tempReal);
+}
+async function removeExistingTree(target) {
+    await fsp.rm(target, { recursive: true, force: false });
+}
+function defaultSocketDir() {
+    const uid = typeof process.getuid === 'function' ? process.getuid() : 0;
+    const base = process.platform === 'win32' ? os.tmpdir() : '/tmp';
+    return path.join(base, `sks-ld-${uid}`);
+}
+async function stopRecordedWorker(runtimeRoot) {
+    const file = path.join(runtimeRoot, 'runtime', 'service.json');
+    const stat = await fsp.lstat(file).catch(() => null);
+    if (!stat)
+        return 'absent';
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_MARKER_BYTES)
+        return 'unreadable';
+    let pid = null;
+    try {
+        const parsed = JSON.parse(await fsp.readFile(file, 'utf8'));
+        pid = typeof parsed.pid === 'number' && Number.isInteger(parsed.pid) ? parsed.pid : null;
+    }
+    catch {
+        return 'unreadable';
+    }
+    if (!pid || pid === process.pid || pid <= 1)
+        return 'unreadable';
+    const command = await processCommand(pid);
+    if (!command)
+        return 'absent';
+    if (!command.includes('sks_local_decision'))
+        return 'not_ours';
+    if (!signal(pid, 'SIGTERM'))
+        return 'absent';
+    return 'stopped';
+}
+async function processCommand(pid) {
+    const result = await runProcess('ps', ['-p', String(pid), '-o', 'command='], {
+        timeoutMs: 2_000,
+        maxOutputBytes: 16 * 1024
+    }).catch(() => null);
+    if (!result || result.code !== 0)
+        return null;
+    return String(result.stdout || '').trim() || null;
+}
+function signal(pid, sig) {
+    try {
+        process.kill(pid, sig);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/update/update-migration-state.js

@@ -14,6 +14,7 @@ import { runCurrentPublicSurfaceReconcileStage } from './update-migration-state/
 import { runDesktopBridgeCatalogRepairStage } from './update-migration-state/desktop-bridge-catalog-repair-stage.js';
 import { runDesktopBridgeRestageStage } from './update-migration-state/desktop-bridge-restage.js';
 import { runSessionStateSplitStage } from './update-migration-state/session-state-split.js';
+import { runRetiredLocalDecisionStage } from './update-migration-state/retired-local-decision.js';
 import { runHookTrustRefreshStage, runOtherHarnessCleanupStage } from './update-migration-state/simple-stages.js';
 import { compareSemVer } from './semver.js';
 export const UPDATE_MIGRATION_SCHEMA = 'sks.project-migration-receipt.v2';
@@ -227,6 +228,11 @@ const UPDATE_MIGRATION_STAGES = [
         min_from_version: '0.0.0',
         run: runOtherHarnessCleanupStage
     },
+    {
+        id: 'retired-local-decision',
+        min_from_version: '0.0.0',
+        run: () => runRetiredLocalDecisionStage()
+    },
     {
         id: 'skills-reconcile',
         min_from_version: '0.0.0',

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '10.2.0';
+export const PACKAGE_VERSION = '10.3.0';

package/dist/native/sks-menubar/Sources/ControlCenterWindowController.swift

@@ -16,12 +16,14 @@ final class ControlCenterWindowController: NSWindowController, NSTableViewDataSo
         let overview = OverviewViewController(processClient: processClient, operations: operations)
         overviewController = overview
         defer {
-            // Overview quick navigation: section names only, so the standalone
-            // Overview compile harness never needs the SidebarItem type.
-            overview.openSection = { [weak self] name in
+            // Overview / Decisions quick navigation: section names only, so the
+            // standalone Overview compile harness never needs the SidebarItem type.
+            let open: (String) -> Void = { [weak self] name in
                 guard let item = SidebarItem.allCases.first(where: { $0.rawValue == name }) else { return }
                 self?.show(section: item)
             }
+            overview.openSection = open
+            (controllers[.localDecision] as? LocalDecisionViewController)?.openSection = open
         }
         controllers = [
             .overview: overview,
@@ -29,6 +31,7 @@ final class ControlCenterWindowController: NSWindowController, NSTableViewDataSo
             .mcpServers: MCPServersViewController(processClient: processClient, operations: operations, notifications: notifications),
             .providers: ProvidersViewController(processClient: processClient, operations: operations),
             .remoteCoding: RemoteCodingViewController(),
+            .localDecision: LocalDecisionViewController(processClient: processClient, operations: operations),
             .diagnostics: DiagnosticsViewController(processClient: processClient, operations: operations),
             .settings: SettingsViewController(processClient: processClient, operations: operations, notifications: notifications)
         ]

package/dist/native/sks-menubar/Sources/LocalDecisionModels.swift

@@ -0,0 +1,166 @@
+import Foundation
+
+/// Exact `sks decision` argv the Control Center page runs. Tests lock this
+/// against the CLI contract so enable/disable cannot silently drift.
+enum LocalDecisionCommand {
+    static let provider = "openrouter"
+    static let pinnedModel = "typesafe/jev-1.13"
+    static let statusSchema = "sks.jev-decision-status.v1"
+    static let enableSchema = "sks.jev-decision-enable.v1"
+    static let disableSchema = "sks.jev-decision-disable.v1"
+
+    static var status: [String] { ["decision", "status", "--json"] }
+    static var enable: [String] {
+        [
+            "decision", "enable",
+            "--provider", provider,
+            "--model", pinnedModel,
+            "--consent-cloud",
+            "--json"
+        ]
+    }
+    static var disable: [String] { ["decision", "disable", "--json"] }
+
+    static func mutationSucceeded(_ payload: [String: Any]?, schema: String) -> Bool {
+        payload?["ok"] as? Bool == true && payload?["schema"] as? String == schema
+    }
+}
+
+/// stdout+stderr are merged by ProcessClient. Prefer the first complete object
+/// whose schema is a Jev decision payload, not the last nested `{`.
+enum LocalDecisionJSON {
+    static func object(from text: String) -> [String: Any]? {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let object = parseEntire(trimmed) { return object }
+        var search = trimmed.startIndex
+        var fallback: [String: Any]?
+        while search < trimmed.endIndex, let start = trimmed[search...].firstIndex(of: "{") {
+            if let slice = completeObject(in: trimmed, from: start), let object = parseEntire(slice) {
+                if let schema = object["schema"] as? String, schema.hasPrefix("sks.jev-decision") {
+                    return object
+                }
+                if fallback == nil, object["ok"] != nil { fallback = object }
+            }
+            search = trimmed.index(after: start)
+        }
+        return fallback
+    }
+
+    static func statusFailureReason(code: Int32, output: String) -> String {
+        let text = output.lowercased()
+        if code == 127 || text.contains("sks command not found") {
+            return "SKS is not on this Menu Bar path. Update SKS, then reopen Decisions."
+        }
+        if text.contains("unknown subcommand") || text.contains("unknown command")
+            || (text.contains("usage: sks") && !text.contains("jev-decision") && !text.contains("sks decision")) {
+            return "This SKS build does not include `decision`. Update SKS, then reopen Decisions."
+        }
+        return "Status unavailable · update SKS, then reopen this page."
+    }
+
+    private static func parseEntire(_ text: String) -> [String: Any]? {
+        guard let data = text.data(using: .utf8) else { return nil }
+        return try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+    }
+
+    private static func completeObject(in text: String, from start: String.Index) -> String? {
+        var depth = 0
+        var inString = false
+        var escape = false
+        var index = start
+        while index < text.endIndex {
+            let ch = text[index]
+            if inString {
+                if escape { escape = false }
+                else if ch == "\\" { escape = true }
+                else if ch == "\"" { inString = false }
+            } else if ch == "\"" {
+                inString = true
+            } else if ch == "{" {
+                depth += 1
+            } else if ch == "}" {
+                depth -= 1
+                if depth == 0 { return String(text[start...index]) }
+            }
+            index = text.index(after: index)
+        }
+        return nil
+    }
+}
+
+/// Public projection of `sks decision status --json`. Pure parsing so the
+/// Control Center page and its tests share one reading of the CLI contract.
+struct LocalDecisionStatus: Equatable {
+    enum NextStep: String { case missingKey = "missing_key", enable, ready }
+
+    let mode: String
+    let provider: String
+    let model: String
+    let consentCloud: Bool
+    let credentialPresent: Bool
+    let credentialSource: String?
+    let recoverySupported: Bool
+    let recoveryReason: String?
+    let nextStep: NextStep
+
+    static let schema = LocalDecisionCommand.statusSchema
+
+    static func decode(from payload: [String: Any]) -> LocalDecisionStatus? {
+        guard payload["schema"] as? String == schema, payload["ok"] as? Bool == true,
+              let mode = payload["mode"] as? String,
+              let provider = payload["provider"] as? String,
+              let model = payload["model"] as? String,
+              let consentCloud = payload["consentCloud"] as? Bool,
+              let credential = payload["credential"] as? [String: Any],
+              let present = credential["present"] as? Bool else { return nil }
+        let recovery = payload["recovery"] as? [String: Any]
+        let step = NextStep(rawValue: payload["nextStep"] as? String ?? "") ?? .enable
+        return LocalDecisionStatus(
+            mode: mode,
+            provider: provider,
+            model: model,
+            consentCloud: consentCloud,
+            credentialPresent: present,
+            credentialSource: credential["source"] as? String,
+            recoverySupported: recovery?["supported"] as? Bool == true,
+            recoveryReason: recovery?["reason"] as? String,
+            nextStep: step
+        )
+    }
+
+    var modeTitle: String { mode == "jev" ? "Jev" : "Off" }
+    var canEnable: Bool { mode != "jev" }
+    var canDisable: Bool { mode == "jev" }
+
+    var badgeText: String {
+        if mode == "jev", consentCloud {
+            return credentialPresent ? "Ready · Jev via OpenRouter" : "Jev on · add OpenRouter key"
+        }
+        return "Off · deterministic baseline"
+    }
+
+    var badgeReady: Bool { mode == "jev" && consentCloud && credentialPresent }
+
+    var modelLabel: String {
+        let credential = credentialPresent ? (credentialSource ?? "present") : "missing"
+        return "\(model) via \(provider) · credential \(credential)"
+    }
+
+    var guidance: String {
+        switch nextStep {
+        case .missingKey:
+            return "Add an OpenRouter key in Connections first. SKS reuses that credential; there is no Jev-specific secret. You can still turn the mode on from this page; preparation stays on the deterministic baseline until a key is present."
+        case .enable:
+            return "Turn Jev on here to use it in official-subagent preparation. Off makes no network call. Jev may choose an automatic plan variant or optional context; recovery is unsupported."
+        case .ready:
+            return "Jev is on. Eligible Naruto/official preparation may send one bounded Decisions request and compile the answer into the SKS plan. Recovery remains unsupported, and a saved plan is not proof that Codex spawned a child."
+        }
+    }
+
+    static let enableConsentBody = "SKS will send bounded task evidence to OpenRouter's Decisions endpoint using your existing OpenRouter credential. A valid answer is compiled into an existing plan or context selection. This is not a measured performance claim, and recovery stays unsupported."
+
+    var enableConsentMessage: String {
+        if credentialPresent { return Self.enableConsentBody }
+        return "\(Self.enableConsentBody) No OpenRouter key is saved yet — add one in Connections or Jev stays on the deterministic baseline."
+    }
+}

package/dist/native/sks-menubar/Sources/LocalDecisionViewController.swift

@@ -0,0 +1,200 @@
+import Cocoa
+
+/// Control Center page for optional Jev decisions. Every action is an explicit
+/// `sks decision …` call. Status never contacts OpenRouter.
+final class LocalDecisionViewController: NSViewController, ControlCenterPage {
+    private let processClient: ProcessClient
+    private let operations: OperationCoordinator
+    private let badge = NativeView.badge("Checking…", color: .secondaryLabelColor)
+    private let modelDetail = NativeView.detail("Checking configuration…")
+    private let guidance = NativeView.detail("")
+    private let actionStatus = NativeView.detail("")
+    private let modePopup = NSPopUpButton()
+    private let modeStatus = NativeView.detail("Jev compiles a typed Choice into SKS-owned plan or context selection.")
+    private var enableButton: NSButton!
+    private var disableButton: NSButton!
+    private var refreshButton: NSButton!
+    private var connectionsButton: NSButton!
+    private var status: LocalDecisionStatus?
+    private var pendingMode: String?
+    private var busy = false
+    private var generation = 0
+    /// Section navigation by sidebar title, wired by ControlCenterWindowController.
+    var openSection: ((String) -> Void)?
+
+    init(processClient: ProcessClient, operations: OperationCoordinator) {
+        self.processClient = processClient
+        self.operations = operations
+        super.init(nibName: nil, bundle: nil)
+    }
+    required init?(coder: NSCoder) { nil }
+
+    override func loadView() {
+        enableButton = NativeView.button("Enable Jev…", target: self, action: #selector(enableJev))
+        disableButton = NativeView.button("Disable", target: self, action: #selector(disableJev))
+        refreshButton = NativeView.button("Refresh", target: self, action: #selector(refresh))
+        connectionsButton = NativeView.button("Connections…", target: self, action: #selector(openConnections))
+        connectionsButton.setAccessibilityIdentifier("sks-decision-connections")
+        enableButton.isEnabled = false
+        disableButton.isEnabled = false
+        modePopup.addItems(withTitles: ["Off", "Jev"])
+        modePopup.target = self
+        modePopup.action = #selector(applyMode)
+        modePopup.isEnabled = false
+        modePopup.setAccessibilityLabel("Decision mode")
+        modePopup.setAccessibilityIdentifier("sks-decision-mode")
+        badge.setAccessibilityIdentifier("sks-decision-badge")
+        actionStatus.setAccessibilityIdentifier("sks-decision-action-status")
+        let statusCard = NativeView.card(
+            title: "Decisions",
+            subtitle: "Optional Jev judgments through the existing OpenRouter credential. Off by default. A valid answer is compiled into an existing SKS candidate; there is no advisory text and no second LLM judge.",
+            views: [badge, modelDetail, guidance, NativeView.row([refreshButton, connectionsButton])]
+        )
+        let modeCard = NativeView.card(
+            title: "Mode",
+            subtitle: "Off: no network call. Jev: send bounded evidence to OpenRouter after explicit cloud consent. Recovery is unsupported.",
+            views: [NativeView.row([modePopup, enableButton, disableButton]), modeStatus, actionStatus]
+        )
+        view = NativeView.page([
+            ControlKit.header("Decisions", "Optional Jev selection through OpenRouter."),
+            statusCard, modeCard
+        ])
+    }
+
+    func refreshOnAppear() { refresh() }
+
+    @objc private func openConnections() { openSection?("Providers") }
+
+    @objc private func refresh() {
+        guard !busy else { return }
+        generation += 1
+        let requestGeneration = generation
+        processClient.run(LocalDecisionCommand.status, timeout: NativeView.statusTimeout) { [weak self] result in
+            guard let self, requestGeneration == self.generation, !self.busy else { return }
+            guard result.code == 0, let payload = LocalDecisionJSON.object(from: result.output),
+                  let status = LocalDecisionStatus.decode(from: payload) else {
+                self.status = nil
+                self.render(failure: LocalDecisionJSON.statusFailureReason(code: result.code, output: result.output))
+                return
+            }
+            self.status = status
+            self.pendingMode = nil
+            self.render(failure: nil)
+        }
+    }
+
+    private func render(failure: String?) {
+        let mode = pendingMode ?? status?.mode
+        if let status {
+            let color: NSColor = status.badgeReady ? .systemGreen : (status.mode == "jev" ? .systemOrange : .secondaryLabelColor)
+            NativeView.setBadge(badge, text: status.badgeText, color: color)
+            modelDetail.stringValue = status.modelLabel
+            guidance.stringValue = status.guidance
+            if !status.recoverySupported {
+                modeStatus.stringValue = "Recovery is unsupported: no SKS-owned ambiguous-failure handler exists."
+                modeStatus.textColor = .secondaryLabelColor
+            }
+        } else {
+            NativeView.setBadge(badge, text: failure ?? "Unavailable", color: .systemOrange)
+            modelDetail.stringValue = ""
+            guidance.stringValue = "Enable and Disable still call `sks decision` so a stale status read cannot trap this page."
+        }
+        enableButton.isEnabled = mode != "jev" || mode == nil
+        disableButton.isEnabled = mode == "jev" || mode == nil
+        connectionsButton.isEnabled = true
+        modePopup.isEnabled = true
+        if let mode { modePopup.selectItem(withTitle: mode == "jev" ? "Jev" : "Off") }
+    }
+
+    @objc private func applyMode() {
+        guard !busy else { return }
+        let desired = modePopup.titleOfSelectedItem == "Jev" ? "jev" : "off"
+        let current = pendingMode ?? status?.mode
+        guard desired != current else { return }
+        if desired == "jev" {
+            enableJev()
+            return
+        }
+        disableJev()
+    }
+
+    @objc private func enableJev() {
+        guard !busy else { return }
+        guard let window = hostWindow() else {
+            revertModePopup()
+            actionStatus.stringValue = "Open SKS Control Center to confirm cloud consent."
+            return
+        }
+        AlertFactory.confirmSheet(
+            window: window,
+            title: "Enable Jev through OpenRouter?",
+            message: status?.enableConsentMessage ?? LocalDecisionStatus.enableConsentBody,
+            destructive: false,
+            actionTitle: "Consent and Enable"
+        ) { [weak self] confirmed in
+            guard let self, confirmed else {
+                self?.revertModePopup()
+                return
+            }
+            guard let operation = self.operations.begin(kind: "decision-enable", mutationGroup: "decision", summary: "Enable Jev via OpenRouter") else {
+                self.revertModePopup()
+                self.actionStatus.stringValue = "Another configuration change is running. Try again when it finishes."
+                return
+            }
+            self.setBusy(true, message: "Enabling Jev…")
+            self.processClient.run(LocalDecisionCommand.enable, timeout: NativeView.mutationTimeout) { [weak self] result in
+                guard let self else { return }
+                let payload = LocalDecisionJSON.object(from: result.output)
+                let ok = result.code == 0 && LocalDecisionCommand.mutationSucceeded(payload, schema: LocalDecisionCommand.enableSchema)
+                if ok { self.pendingMode = "jev" }
+                else { self.revertModePopup() }
+                let summary = ok ? "Jev enabled through OpenRouter." : "Enable failed · \(NativeView.redactPreview(result.output))"
+                _ = self.operations.update(operation, state: ok ? .succeeded : .failed, stage: "complete", progress: 1, summary: summary)
+                self.setBusy(false, message: summary)
+            }
+        }
+    }
+
+    @objc private func disableJev() {
+        guard !busy else { return }
+        guard let operation = operations.begin(kind: "decision-disable", mutationGroup: "decision", summary: "Disable Jev") else {
+            revertModePopup()
+            actionStatus.stringValue = "Another configuration change is running. Try again when it finishes."
+            return
+        }
+        setBusy(true, message: "Returning to the deterministic baseline…")
+        processClient.run(LocalDecisionCommand.disable, timeout: NativeView.mutationTimeout) { [weak self] result in
+            guard let self else { return }
+            let payload = LocalDecisionJSON.object(from: result.output)
+            let ok = result.code == 0 && LocalDecisionCommand.mutationSucceeded(payload, schema: LocalDecisionCommand.disableSchema)
+            if ok { self.pendingMode = "off" }
+            else { self.revertModePopup() }
+            let summary = ok ? "Mode set to off." : "Disable could not be confirmed · \(NativeView.redactPreview(result.output))"
+            _ = self.operations.update(operation, state: ok ? .succeeded : .failed, stage: "complete", progress: 1, summary: summary)
+            self.setBusy(false, message: summary)
+        }
+    }
+
+    private func setBusy(_ value: Bool, message: String) {
+        busy = value
+        actionStatus.stringValue = message
+        actionStatus.textColor = value ? .secondaryLabelColor : .labelColor
+        if value {
+            for button in [enableButton, disableButton, refreshButton, connectionsButton] { button?.isEnabled = false }
+            modePopup.isEnabled = false
+        } else {
+            refreshButton.isEnabled = true
+            connectionsButton.isEnabled = true
+            refresh()
+        }
+    }
+
+    private func revertModePopup() {
+        let mode = pendingMode ?? status?.mode
+        modePopup.selectItem(withTitle: mode == "jev" ? "Jev" : "Off")
+    }
+
+    private func hostWindow() -> NSWindow? {
+        view.window ?? NSApp.keyWindow ?? NSApp.windows.first(where: { $0.title == "SKS Control Center" })
+    }
+}

package/dist/native/sks-menubar/Sources/OverviewViewController.swift

@@ -38,6 +38,7 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
         let shortcuts = NativeView.row([
             NativeView.button("Remote Coding…", target: self, action: #selector(openRemoteCoding)),
             connectionsShortcut(),
+            NativeView.button("Decisions…", target: self, action: #selector(openDecisions)),
             NativeView.button("Updates…", target: self, action: #selector(openUpdates)),
             NativeView.button("Diagnostics…", target: self, action: #selector(openDiagnostics))
         ])
@@ -73,6 +74,7 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
 
     @objc private func openRemoteCoding() { openSection?("Remote Coding") }
     @objc private func openProviders() { openSection?("Providers") }
+    @objc private func openDecisions() { openSection?("Decisions") }
     @objc private func openUpdates() { openSection?("Updates") }
     @objc private func openDiagnostics() { openSection?("Diagnostics") }
 
@@ -89,6 +91,8 @@ final class OverviewViewController: NSViewController, ControlCenterPage {
             || operation.kind.localizedCaseInsensitiveContains("openrouter")
             || operation.kind.localizedCaseInsensitiveContains("codex-lb") {
             section = "Providers"
+        } else if operation.kind.localizedCaseInsensitiveContains("decision") {
+            section = "Decisions"
         } else if operation.kind.localizedCaseInsensitiveContains("update") {
             section = "Updates"
         } else {

package/dist/native/sks-menubar/Sources/SidebarItem.swift

@@ -8,6 +8,7 @@ enum SidebarItem: String, CaseIterable {
     case remoteCoding = "Remote Coding"
     case updates = "Updates"
     case mcpServers = "MCP Servers"
+    case localDecision = "Decisions"
     case diagnostics = "Diagnostics"
     case settings = "Settings"
 
@@ -19,6 +20,7 @@ enum SidebarItem: String, CaseIterable {
         case .providers: return "network"
         case .updates: return "arrow.down.circle"
         case .mcpServers: return "server.rack"
+        case .localDecision: return "cpu"
         case .remoteCoding: return "laptopcomputer.and.iphone"
         case .diagnostics: return "stethoscope"
         case .settings: return "gearshape"

package/dist/scripts/current-surface-update-e2e-check.js

@@ -9,6 +9,7 @@ import { runSksUpdateNow } from '../core/update-check.js';
 import { ensureCurrentMigrationBeforeCommand, projectUpdateMigrationReceiptPath, runPackageLocalDoctor } from '../core/update/update-migration-state.js';
 const REQUIRED_MIGRATION_STAGES = [
     'other-harness-cleanup',
+    'retired-local-decision',
     'current-public-surface-reconcile',
     'session-state-split',
     'skills-reconcile',