sneakoscope 6.2.0 → 6.4.0

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

@@ -0,0 +1,233 @@
+import Cocoa
+
+enum SKSStatusIcon {
+    case healthy, working, attention, updateAvailable, warning
+}
+
+final class StatusItemController: NSObject, NSMenuDelegate {
+    private let processClient: ProcessClient
+    private let operations: OperationCoordinator
+    private let notifications: NotificationCoordinator
+    private let openControlCenter: (SidebarItem) -> Void
+    private let statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
+    private let statusLine = NSMenuItem(title: "Status: Starting", action: nil, keyEquivalent: "")
+    private let pendingLine = NSMenuItem(title: "Pending approvals (0)", action: nil, keyEquivalent: "")
+    private var timer: Timer?
+    private var lastOperationArguments: [String]?
+    private var operationFailed = false
+    private var operationRunning = false
+    private var actionRequired = false
+    private var notificationAuthorizationDenied = false
+    private var updateRefreshInFlight = false
+    private var lastUpdateNotificationFingerprint: String?
+
+    init(processClient: ProcessClient, operations: OperationCoordinator, notifications: NotificationCoordinator, openControlCenter: @escaping (SidebarItem) -> Void) {
+        self.processClient = processClient
+        self.operations = operations
+        self.notifications = notifications
+        self.openControlCenter = openControlCenter
+        super.init()
+    }
+
+    func start() {
+        notificationAuthorizationDenied = notifications.authorizationDenied
+        statusItem.autosaveName = "com.sneakoscope.sks-menubar"
+        statusItem.button?.toolTip = "SKS Control Center"
+        statusItem.button?.setAccessibilityLabel("SKS status")
+        let menu = NSMenu()
+        menu.delegate = self
+        let version = NSMenuItem(title: "SKS \(AppRuntime.packageVersion)", action: nil, keyEquivalent: "")
+        version.isEnabled = false
+        statusLine.isEnabled = false
+        pendingLine.isEnabled = false
+        menu.addItem(version)
+        menu.addItem(statusLine)
+        menu.addItem(NSMenuItem.separator())
+        menu.addItem(item("Open SKS Control Center…", #selector(openCenter)))
+        menu.addItem(item("Open Dashboard", #selector(openDashboardAction)))
+        menu.addItem(pendingLine)
+        menu.addItem(NSMenuItem.separator())
+        menu.addItem(item("Check for Updates", #selector(checkUpdates)))
+        menu.addItem(item("View Last Operation", #selector(viewLastOperation)))
+        menu.addItem(NSMenuItem.separator())
+        menu.addItem(item("Quit SKS Menu", #selector(quit)))
+        statusItem.menu = menu
+        configureCodexLifecycle()
+        refreshLocalState()
+        timer = Timer.scheduledTimer(withTimeInterval: 30, repeats: true) { [weak self] _ in self?.refreshLocalState() }
+    }
+
+    func stop() { timer?.invalidate(); timer = nil }
+
+    func menuWillOpen(_ menu: NSMenu) {
+        refreshLocalState()
+        refreshExpiredUpdateStatusIfNeeded()
+    }
+
+    func setNotificationAuthorizationDenied(_ denied: Bool) {
+        notificationAuthorizationDenied = denied
+        refreshLocalState()
+    }
+
+    func retryLastOperation() {
+        guard let arguments = lastOperationArguments else { openControlCenter(.overview); return }
+        run(arguments, kind: "retry", mutationGroup: nil, summary: "Retry operation")
+    }
+
+    func openDashboard() {
+        do { try processClient.runDetached(["ui"]) }
+        catch { AlertFactory.fatal(title: "Open Dashboard failed", message: String(describing: error)) }
+        if let url = URL(string: "http://127.0.0.1:4477") {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.7) { NSWorkspace.shared.open(url) }
+        }
+    }
+
+    private func refreshLocalState() {
+        let update = readJson(path: FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".sneakoscope-global/cache/update-status.json").path)
+        let sksUpdate = ((update?["sks"] as? [String: Any])?["update_available"] as? Bool) == true
+        let codexUpdate = ((update?["codex_cli"] as? [String: Any])?["update_available"] as? Bool) == true
+        let menuBar = update?["menubar"] as? [String: Any]
+        let signatureBroken = menuBar?["signature_ok"] as? Bool == false
+        let resourcesBroken = menuBar?["resources_ok"] as? Bool == false
+        let integrityBroken = signatureBroken || resourcesBroken || !FileManager.default.fileExists(atPath: AppRuntime.buildStampPath)
+        let icon: SKSStatusIcon
+        let summary: String
+        if integrityBroken { icon = .warning; summary = "Needs attention — Menu Bar integrity" }
+        else if operationFailed { icon = .warning; summary = "Needs attention — last operation failed" }
+        else if actionRequired || notificationAuthorizationDenied { icon = .attention; summary = notificationAuthorizationDenied ? "Notifications require attention" : "Input or approval required" }
+        else if sksUpdate || codexUpdate { icon = .updateAvailable; summary = "Update available" }
+        else if operationRunning { icon = .working; summary = "Working" }
+        else { icon = .healthy; summary = "Healthy" }
+        apply(icon)
+        statusLine.title = "Status: \(summary)"
+    }
+
+    private func refreshExpiredUpdateStatusIfNeeded() {
+        let update = readJson(path: FileManager.default.homeDirectoryForCurrentUser
+            .appendingPathComponent(".sneakoscope-global/cache/update-status.json").path)
+        guard !updateRefreshInFlight, StatusItemController.updateStatusNeedsRefresh(update) else { return }
+        updateRefreshInFlight = true
+        processClient.run(["update", "status", "--json"]) { [weak self] result in
+            guard let self = self else { return }
+            self.updateRefreshInFlight = false
+            let fingerprint = self.updateNotificationFingerprint(result.output)
+            if result.code == 0 && NotificationCoordinator.updateIsAvailable(in: result.output), fingerprint != self.lastUpdateNotificationFingerprint {
+                self.lastUpdateNotificationFingerprint = fingerprint
+                self.notifications.send(PublicNotificationEvent(
+                    category: "SKS_UPDATE_AVAILABLE",
+                    title: "SKS update available",
+                    body: "An expired update snapshot was refreshed and a verified update is ready for review."
+                ))
+            }
+            self.refreshLocalState()
+        }
+    }
+
+    private func updateNotificationFingerprint(_ output: String) -> String? {
+        guard let data = output.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil }
+        let sks = json["sks"] as? [String: Any]
+        let codex = json["codex_cli"] as? [String: Any]
+        let menu = json["menubar"] as? [String: Any]
+        return [
+            json["generated_at"] as? String ?? "",
+            sks?["latest"] as? String ?? "",
+            codex?["latest"] as? String ?? "",
+            menu?["expected_version"] as? String ?? ""
+        ].joined(separator: "|")
+    }
+
+    static func updateStatusNeedsRefresh(_ update: [String: Any]?, now: Date = Date()) -> Bool {
+        guard let update = update else { return true }
+        if update["source"] as? String == "disabled" { return false }
+        guard update["schema"] as? String == "sks.update-status.v3",
+              let expiresAt = update["expires_at"] as? String,
+              let expiry = ISO8601DateFormatter().date(from: expiresAt) else { return true }
+        return expiry <= now
+    }
+
+    private func apply(_ state: SKSStatusIcon) {
+        let pair: (String, String)
+        switch state {
+        case .healthy: pair = ("SKSStatusTemplate", "checkmark.circle")
+        case .working: pair = ("SKSStatusTemplate", "ellipsis.circle")
+        case .attention: pair = ("SKSStatusAttentionTemplate", "exclamationmark.circle")
+        case .updateAvailable: pair = ("SKSStatusUpdateTemplate", "arrow.down.circle")
+        case .warning: pair = ("SKSStatusWarningTemplate", "exclamationmark.triangle")
+        }
+        statusItem.button?.image = AppIdentity.statusImage(resource: pair.0, symbol: pair.1)
+        statusItem.button?.imagePosition = .imageOnly
+    }
+
+    private func run(_ arguments: [String], kind: String, mutationGroup: String?, summary: String) {
+        guard let snapshot = operations.begin(kind: kind, mutationGroup: mutationGroup, summary: summary) else {
+            actionRequired = true
+            notifications.send(PublicNotificationEvent(
+                category: "SKS_ACTION_REQUIRED",
+                title: "SKS action requires attention",
+                body: "Another guarded mutation is already running. Open Control Center to review the active operation."
+            ))
+            refreshLocalState()
+            return
+        }
+        actionRequired = false
+        lastOperationArguments = arguments
+        operationRunning = true
+        operationFailed = false
+        _ = operations.update(snapshot, state: .running, stage: "running", progress: nil, summary: summary)
+        processClient.run(arguments) { [weak self] result in
+            guard let self = self else { return }
+            self.operationRunning = false
+            self.operationFailed = result.code != 0
+            _ = self.operations.update(snapshot, state: result.code == 0 ? .succeeded : .failed, stage: "complete", progress: 1, summary: result.code == 0 ? "Operation completed" : "Operation failed")
+            let updateOutput = kind == "update-status" ? result.output : nil
+            self.notifications.send(PublicNotificationEvent(
+                category: NotificationCoordinator.categoryIdentifier(updateStatusOutput: updateOutput, failed: result.code != 0),
+                title: updateOutput != nil && NotificationCoordinator.updateIsAvailable(in: result.output)
+                    ? "SKS update available"
+                    : result.code == 0 ? "SKS operation completed" : "SKS operation needs attention",
+                body: updateOutput != nil && NotificationCoordinator.updateIsAvailable(in: result.output)
+                    ? "A verified SKS, Codex CLI, or Menu Bar update is ready for review."
+                    : result.code == 0 ? "The requested operation completed." : "The requested operation failed. Open Control Center for redacted details."
+            ))
+            self.refreshLocalState()
+        }
+    }
+
+    private func configureCodexLifecycle() {
+        guard let bundle = AppRuntime.codexBundleId else { return }
+        statusItem.isVisible = NSWorkspace.shared.runningApplications.contains { $0.bundleIdentifier == bundle }
+        let center = NSWorkspace.shared.notificationCenter
+        center.addObserver(forName: NSWorkspace.didLaunchApplicationNotification, object: nil, queue: .main) { [weak self] note in
+            guard let app = note.userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication, app.bundleIdentifier == bundle else { return }
+            self?.statusItem.isVisible = true
+        }
+        center.addObserver(forName: NSWorkspace.didTerminateApplicationNotification, object: nil, queue: .main) { [weak self] note in
+            guard let app = note.userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication, app.bundleIdentifier == bundle else { return }
+            let config = self?.readJson(path: AppRuntime.configPath)
+            if config?["quit_with_codex"] as? Bool == true { NSApplication.shared.terminate(nil) }
+            else { self?.statusItem.isVisible = false }
+        }
+    }
+
+    private func item(_ title: String, _ action: Selector) -> NSMenuItem {
+        let value = NSMenuItem(title: title, action: action, keyEquivalent: "")
+        value.target = self
+        return value
+    }
+
+    private func readJson(path: String) -> [String: Any]? {
+        guard let data = FileManager.default.contents(atPath: path) else { return nil }
+        return try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+    }
+
+    @objc private func openCenter() { openControlCenter(.overview) }
+    @objc private func openDashboardAction() { openDashboard() }
+    @objc private func checkUpdates() { run(["update", "status", "--refresh", "--json"], kind: "update-status", mutationGroup: nil, summary: "Check for updates") }
+    @objc private func viewLastOperation() {
+        if FileManager.default.fileExists(atPath: AppRuntime.lastActionLogPath) { NSWorkspace.shared.open(URL(fileURLWithPath: AppRuntime.lastActionLogPath)) }
+        else { openControlCenter(.overview) }
+    }
+    @objc private func quit() { NSApplication.shared.terminate(nil) }
+}

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

@@ -0,0 +1,237 @@
+import Cocoa
+
+final class UpdatesViewController: NSViewController {
+    private let processClient: ProcessClient
+    private let operations: OperationCoordinator
+    private let notifications: NotificationCoordinator
+    private let status = NativeView.detail("Update status has not been checked yet.")
+    private let stageStatus = NativeView.detail("Update stages: no update receipt recorded yet.")
+    private let remediation = NativeView.detail("Remediation and rollback guidance will appear here when needed.")
+    private let progress = NSProgressIndicator()
+    private var receiptTimer: Timer?
+    private var activeReceiptId: String?
+
+    init(processClient: ProcessClient, operations: OperationCoordinator, notifications: NotificationCoordinator) {
+        self.processClient = processClient; self.operations = operations; self.notifications = notifications
+        super.init(nibName: nil, bundle: nil)
+    }
+    required init?(coder: NSCoder) { nil }
+
+    override func loadView() {
+        progress.isIndeterminate = !NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
+        progress.controlSize = .small
+        progress.isHidden = true
+        let check = NativeView.button("Check Now", target: self, action: #selector(checkNow))
+        let review = NativeView.button("Review and Update", target: self, action: #selector(reviewAndUpdate))
+        let buttons = NSStackView(views: [check, review, progress])
+        buttons.orientation = .horizontal; buttons.spacing = 8
+        view = NativeView.stack([
+            NativeView.title("Updates"),
+            NativeView.detail("SKS, Codex CLI, and Menu Bar status share one local snapshot. Network refresh only runs on demand or after expiry."),
+            status, stageStatus, remediation, buttons,
+            NativeView.detail("Rollback guidance and the previous Menu Bar app remain available if final verification fails. The update receipt records the exact recovery command and stage state.")
+        ])
+        loadCached()
+    }
+
+    deinit { receiptTimer?.invalidate() }
+
+    private func loadCached() {
+        reloadSnapshot()
+    }
+
+    @objc private func checkNow() { run(["update", "status", "--refresh", "--json"], kind: "update-status", group: nil) }
+
+    @objc private func reviewAndUpdate() {
+        run(["update", "review", "--json"], kind: "update-review", group: nil) { [weak self] result in
+            guard result.code == 0, let self = self, let window = self.view.window else { return }
+            AlertFactory.confirmSheet(window: window, title: "Update SKS?", message: "Review completed. Continue with the verified staged update?", destructive: false) { approved in
+                if approved { self.run(["update", "now", "--json"], kind: "update", group: "update") }
+            }
+        }
+    }
+
+    private func run(_ args: [String], kind: String, group: String?, completion: ((ProcessResult) -> Void)? = nil) {
+        guard let operation = operations.begin(kind: kind, mutationGroup: group, summary: kind) else {
+            status.stringValue = "Another update or MCP mutation is already running."
+            notifications.send(PublicNotificationEvent(
+                category: "SKS_ACTION_REQUIRED",
+                title: "SKS update is waiting",
+                body: "Another guarded mutation is already running. Open Control Center to review it before retrying."
+            ))
+            return
+        }
+        progress.isHidden = false
+        if NSWorkspace.shared.accessibilityDisplayShouldReduceMotion {
+            progress.isIndeterminate = false
+            progress.minValue = 0
+            progress.maxValue = 1
+            progress.doubleValue = 0
+        } else {
+            progress.isIndeterminate = true
+            progress.startAnimation(nil)
+        }
+        status.stringValue = "\(kind.replacingOccurrences(of: "-", with: " ").capitalized)…"
+        _ = operations.update(operation, state: .running, stage: "running", progress: nil, summary: status.stringValue)
+        if kind == "update" { startReceiptPolling(for: operation) }
+        processClient.run(args) { [weak self] result in
+            guard let self = self else { return }
+            self.stopReceiptPolling()
+            self.progress.stopAnimation(nil); self.progress.isHidden = true
+            var authoritativeState: OperationState?
+            if kind == "update" {
+                if let receipt = self.operations.updateReceipt(fromProcessOutput: result.output) ?? self.operations.latestUpdateReceipt(),
+                   self.receipt(receipt, belongsTo: operation) {
+                    authoritativeState = OperationCoordinator.authoritativeState(for: receipt, processCompleted: true)
+                    _ = self.operations.synchronize(operation, with: receipt, processCompleted: true)
+                    self.render(receipt: receipt)
+                } else {
+                    authoritativeState = .terminalUncertain
+                    _ = self.operations.update(
+                        operation,
+                        state: .terminalUncertain,
+                        stage: "receipt",
+                        progress: nil,
+                        summary: "Update process ended without a readable update receipt",
+                        retryable: true
+                    )
+                    self.stageStatus.stringValue = "Update stages: receipt unavailable; completion cannot be assumed."
+                    self.remediation.stringValue = "Remediation: open the last operation log and run sks update status --refresh --json before retrying or rolling back."
+                }
+            } else {
+                let state: OperationState = kind == "update-review" && result.code == 0 ? .waitingForConfirmation : result.code == 0 ? .succeeded : .failed
+                _ = self.operations.update(operation, state: state, stage: state == .waitingForConfirmation ? "confirmation" : "complete", progress: 1, summary: state == .waitingForConfirmation ? "Update review is waiting for confirmation" : result.code == 0 ? "Update operation completed" : "Update operation failed")
+            }
+            let updateOutput = kind == "update-status" ? result.output : nil
+            let approvalRequired = kind == "update-review" && result.code == 0
+            let updateAvailable = updateOutput != nil && NotificationCoordinator.updateIsAvailable(in: result.output)
+            let authoritativeFailure = kind == "update" ? authoritativeState != .succeeded : result.code != 0
+            let terminalUncertain = kind == "update" && authoritativeState == .terminalUncertain
+            let notificationTitle: String
+            let notificationBody: String
+            if updateAvailable {
+                notificationTitle = "SKS update available"
+                notificationBody = "A verified SKS, Codex CLI, or Menu Bar update is ready for review."
+            } else if approvalRequired {
+                notificationTitle = "SKS update approval required"
+                notificationBody = "Review completed. Return to Control Center to approve or cancel the staged update."
+            } else if terminalUncertain {
+                notificationTitle = "SKS update outcome is uncertain"
+                notificationBody = "The authoritative update receipt could not confirm completion. Open Control Center before retrying or rolling back."
+            } else if authoritativeFailure {
+                notificationTitle = "SKS update needs attention"
+                notificationBody = "The authoritative update state did not complete successfully. Open Control Center for redacted remediation."
+            } else {
+                notificationTitle = "SKS update operation completed"
+                notificationBody = "The authoritative update receipt confirmed completion."
+            }
+            self.notifications.send(PublicNotificationEvent(
+                category: NotificationCoordinator.categoryIdentifier(updateStatusOutput: updateOutput, failed: authoritativeFailure, actionRequired: approvalRequired),
+                title: notificationTitle,
+                body: notificationBody
+            ))
+            if kind == "update-status" { self.render(statusResult: result) }
+            else if kind == "update" { self.reloadSnapshot() }
+            completion?(result)
+        }
+    }
+
+    private func reloadSnapshot() {
+        processClient.run(["update", "status", "--json"]) { [weak self] result in self?.render(statusResult: result) }
+    }
+
+    private func render(statusResult result: ProcessResult) {
+        let receipt = operations.latestUpdateReceipt()
+        if result.code != 0 {
+            status.stringValue = "Update status unavailable. No success state was assumed."
+            if let receipt = receipt { render(receipt: receipt) }
+            return
+        }
+        guard let data = result.output.data(using: .utf8), let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            status.stringValue = "Update status output was not valid JSON."
+            if let receipt = receipt { render(receipt: receipt) }
+            return
+        }
+        let sks = json["sks"] as? [String: Any]
+        let codex = json["codex_cli"] as? [String: Any]
+        let menu = json["menubar"] as? [String: Any]
+        let generatedAt = json["generated_at"] as? String ?? "unknown"
+        let expiresAt = json["expires_at"] as? String ?? "unknown"
+        let expired = ISO8601DateFormatter().date(from: expiresAt).map { $0 <= Date() } ?? true
+        status.stringValue = [
+            "SKS \(sks?["current"] as? String ?? "unknown") → \(sks?["latest"] as? String ?? "unknown") · Codex CLI \(codex?["current"] as? String ?? "unknown") → \(codex?["latest"] as? String ?? "unknown")",
+            "Menu Bar expected \(menu?["expected_version"] as? String ?? AppRuntime.packageVersion) · installed \(menu?["installed_version"] as? String ?? "unknown") · rebuild \(menu?["rebuild_required"] as? Bool == true ? "required" : "not required")",
+            "Last checked \(formatTimestamp(generatedAt)) · expires \(formatTimestamp(expiresAt))\(expired ? " (expired)" : "") · source \(json["source"] as? String ?? "unknown")"
+        ].joined(separator: "\n")
+        if let receipt = receipt { render(receipt: receipt) }
+        else {
+            stageStatus.stringValue = stageChecklist(receipt: nil)
+            let publicError = json["public_error"] as? String
+            remediation.stringValue = publicError.map { "Remediation: \($0)" } ?? "Rollback: no completed update receipt is available yet."
+        }
+    }
+
+    private func startReceiptPolling(for operation: OperationSnapshot) {
+        stopReceiptPolling()
+        activeReceiptId = nil
+        progress.isIndeterminate = false
+        progress.minValue = 0
+        progress.maxValue = Double(OperationCoordinator.updateStageOrder.count)
+        progress.doubleValue = 0
+        let timer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { [weak self] _ in
+            guard let self = self, let receipt = self.operations.latestUpdateReceipt(), self.receipt(receipt, belongsTo: operation) else { return }
+            if let active = self.activeReceiptId, active != receipt.id { return }
+            self.activeReceiptId = receipt.id
+            _ = self.operations.synchronize(operation, with: receipt)
+            self.render(receipt: receipt)
+        }
+        timer.tolerance = 0.1
+        receiptTimer = timer
+    }
+
+    private func stopReceiptPolling() {
+        receiptTimer?.invalidate()
+        receiptTimer = nil
+    }
+
+    private func receipt(_ receipt: UpdateOperationReceiptSnapshot, belongsTo operation: OperationSnapshot) -> Bool {
+        guard receipt.kind == "update" || receipt.kind == "rollback" else { return false }
+        let parser = ISO8601DateFormatter()
+        guard let receiptDate = parser.date(from: receipt.startedAt), let operationDate = parser.date(from: operation.startedAt) else { return receipt.startedAt >= operation.startedAt }
+        return receiptDate >= operationDate.addingTimeInterval(-1)
+    }
+
+    private func render(receipt: UpdateOperationReceiptSnapshot) {
+        let completed = Set(receipt.stages.map(\.id)).intersection(Set(OperationCoordinator.updateStageOrder)).count
+        progress.isIndeterminate = false
+        progress.minValue = 0
+        progress.maxValue = Double(OperationCoordinator.updateStageOrder.count)
+        progress.doubleValue = Double(completed)
+        progress.isHidden = !["queued", "running"].contains(receipt.state)
+        stageStatus.stringValue = stageChecklist(receipt: receipt)
+        let state = receipt.state.replacingOccurrences(of: "_", with: " ")
+        let current = receipt.currentStage ?? receipt.stages.last?.id ?? "not started"
+        let rollbackState = receipt.sideEffectsStarted ? "available for \(receipt.previousVersion)" : "not armed before side effects"
+        let publicError = receipt.publicError.map { " · \($0)" } ?? ""
+        remediation.stringValue = "Receipt \(receipt.id) · \(state) · current stage \(current) · \(completed)/\(OperationCoordinator.updateStageOrder.count)\nRollback \(rollbackState): \(receipt.rollbackCommand)\(publicError)"
+    }
+
+    private func stageChecklist(receipt: UpdateOperationReceiptSnapshot?) -> String {
+        let byId = Dictionary(uniqueKeysWithValues: (receipt?.stages ?? []).map { ($0.id, $0) })
+        let current = receipt?.currentStage
+        let rows = OperationCoordinator.updateStageOrder.map { id -> String in
+            if let stage = byId[id] { return "\(stage.ok ? "✓" : "✕") \(id) — \(stage.status)" }
+            if id == current { return "● \(id) — running" }
+            return "○ \(id)"
+        }
+        return "Update stages (14):\n" + rows.joined(separator: "\n")
+    }
+
+    private func formatTimestamp(_ value: String) -> String {
+        guard let date = ISO8601DateFormatter().date(from: value) else { return value }
+        let formatter = DateFormatter()
+        formatter.dateStyle = .medium
+        formatter.timeStyle = .medium
+        return formatter.string(from: date)
+    }
+}

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

@@ -0,0 +1,18 @@
+import Cocoa
+import UserNotifications
+
+enum AppRuntime {
+    static let actionScript = __SKS_ACTION_SCRIPT__
+    static let projectRoot = __SKS_PROJECT_ROOT__
+    static let buildStampPath = __SKS_BUILD_STAMP__
+    static let configPath = __SKS_CONFIG_PATH__
+    static let lastActionLogPath = __SKS_LAST_LOG__
+    static let operationDirectory = __SKS_OPERATION_DIR__
+    static let codexBundleId: String? = __SKS_CODEX_BUNDLE_ID__
+    static let packageVersion = __SKS_PACKAGE_VERSION__
+}
+
+let application = NSApplication.shared
+let applicationDelegate = AppDelegate()
+application.delegate = applicationDelegate
+application.run()

package/dist/scripts/agent-message-bus-reader-check.js

@@ -16,4 +16,3 @@ assertGate(rows.length === 2, 'message bus reader must read jsonl entries', rows
 assertGate(rows[0].event_type === 'worker_completed' && rows[1].event_type === 'worker_failed', 'message bus reader must normalize event types', rows);
 assertGate(rows[1].level === 'error', 'worker_failed message must normalize to error level', rows[1]);
 emitGate('agent:message-bus-reader', { rows });
-//# sourceMappingURL=agent-message-bus-reader-check.js.map

package/dist/scripts/all-feature-deep-completion-check.js

@@ -38,4 +38,3 @@ const report = runSksJson(['features', 'complete', '--json']);
 assertGate(report.schema === 'sks.all-feature-completion.v1', 'all-feature completion schema mismatch', report);
 assertGate(Array.isArray(report.features) && report.features.length > 0, 'all-feature completion rows missing', report);
 emitGate('all-features:deep-completion', { version: report.version, features: report.features.length, status: report.status });
-//# sourceMappingURL=all-feature-deep-completion-check.js.map

package/dist/scripts/appshots-thread-attachment-discovery-check.js

@@ -84,4 +84,3 @@ function writeAppshotFixture() {
         }
     };
 }
-//# sourceMappingURL=appshots-thread-attachment-discovery-check.js.map

package/dist/scripts/architecture-guard-check.js

@@ -21,6 +21,7 @@ function assertScript(name, expected) {
         issues.push(`package script ${name} must include ${expected}`);
 }
 const pkg = readJson('package.json');
+const architectureBudgets = readJson('config/architecture-budgets.v1.json');
 const releaseManifest = readJson('release-gates.v2.json');
 const releaseGateIds = new Set((Array.isArray(releaseManifest?.gates) ? releaseManifest.gates : [])
     .filter((gate) => Array.isArray(gate?.preset) && gate.preset.includes('release'))
@@ -28,6 +29,33 @@ const releaseGateIds = new Set((Array.isArray(releaseManifest?.gates) ? releaseM
 assertScript('architecture:guard', 'node ./dist/scripts/architecture-guard-check.js');
 if (!releaseGateIds.has('architecture:guard'))
     issues.push('release-gates.v2.json release preset missing architecture:guard');
+if (architectureBudgets.schema !== 'sks.architecture-budgets.v1')
+    issues.push('architecture budget schema must be sks.architecture-budgets.v1');
+if (architectureBudgets.waiver_policy?.mode !== 'shrink-only')
+    issues.push('architecture waivers must be shrink-only');
+for (const [id, maxLines] of [
+    ['menubar-facade', 80],
+    ['menubar-typescript', 450],
+    ['menubar-swift', 500],
+    ['menubar-app-delegate', 250],
+    ['pipeline-trust-evidence-proof', 1200],
+    ['command-module', 900],
+    ['default-handwritten-source', 1800]
+]) {
+    const rule = architectureBudgets.budgets?.find((candidate) => candidate?.id === id);
+    if (rule?.max_lines !== maxLines)
+        issues.push(`architecture budget ${id} must be ${maxLines}`);
+}
+if (architectureBudgets.split_review_lines !== 3000)
+    issues.push('architecture split-review threshold must be 3000');
+assertIncludes('src/scripts/check-architecture.ts', "git', ['merge-base'", 'architecture check must use git merge-base');
+assertIncludes('src/scripts/check-architecture.ts', "args.includes('--strict-all')", 'architecture check must expose strict-all mode');
+assertIncludes('src/scripts/check-architecture.ts', "'config', 'architecture-budgets.v1.json'", 'architecture check must load the budget SSOT');
+assertIncludes('src/scripts/check-architecture.ts', 'shrink-only ceiling', 'architecture check must enforce shrink-only waivers');
+assertIncludes('docs/architecture.md', '`config/architecture-budgets.v1.json`', 'architecture docs must name the budget SSOT');
+for (const token of ['`80`', '`250`', '`450`', '`500`', '`900`', '`1200`', '`1800`', '`3000`', '`--strict-all`', 'shrink-only']) {
+    assertIncludes('docs/architecture.md', token, `architecture docs missing ${token}`);
+}
 assertIncludes('src/core/safety/ssot-guard.ts', 'solid_principles');
 assertIncludes('src/core/safety/ssot-guard.ts', 'single_responsibility');
 assertIncludes('src/core/safety/ssot-guard.ts', 'open_closed');
@@ -39,7 +67,8 @@ assertIncludes('src/core/pipeline-internals/runtime-core.ts', 'buildSsotGuard');
 assertIncludes('src/core/pipeline-internals/runtime-core.ts', 'ssotGuardPolicyText');
 assertIncludes('src/core/pipeline-internals/runtime-gates.ts', 'validateSsotGuardArtifact');
 assertIncludes('src/core/pipeline-internals/runtime-gates.ts', "'ssot_guard'");
-assertIncludes('src/core/commands/team-command.ts', 'SSOT_GUARD_ARTIFACT');
+assertIncludes('src/core/subagents/official-subagent-preparation.ts', 'SSOT_GUARD_ARTIFACT');
+assertIncludes('src/core/subagents/official-subagent-preparation.ts', 'validateSsotGuardArtifact');
 assertIncludes('src/scripts/release-parallel-check.ts', 'release-gate-dag-runner.js');
 assertIncludes('src/scripts/release-parallel-check.ts', "'--preset', 'release', '--full'");
 assertIncludes('src/core/release/gate-manifest.ts', "'architecture:guard'");
@@ -50,7 +79,7 @@ const report = {
     schema: 'sks.architecture-guard-check.v1',
     ok: issues.length === 0,
     gate: 'architecture:guard',
-    guarantees: ['ssot', 'solid'],
+    guarantees: ['ssot', 'solid', 'merge-base', 'shrink-only'],
     issues
 };
 const reportDir = path.join(root, '.sneakoscope', 'reports');
@@ -59,4 +88,3 @@ fs.writeFileSync(path.join(reportDir, 'architecture-guard.json'), `${JSON.string
 console.log(JSON.stringify(report, null, 2));
 if (!report.ok)
     process.exitCode = 1;
-//# sourceMappingURL=architecture-guard-check.js.map

package/dist/scripts/build-dist.js

@@ -11,6 +11,7 @@ const distRoot = path.join(root, 'dist');
 await fsp.mkdir(distRoot, { recursive: true });
 await removeDistMjs(distRoot);
 await copyRuntimeConfigFiles();
+await copyNativeMenuBarSources();
 await writeSkillsManifest();
 await removeDistNonRuntimeArtifacts(distRoot);
 await writeCommonJsBinScope();
@@ -50,6 +51,9 @@ async function copyRuntimeConfigFiles() {
     }
     await copyDirIfPresent(path.join(srcRoot, 'vendor', 'openai-codex'), path.join(distRoot, 'vendor', 'openai-codex'));
 }
+async function copyNativeMenuBarSources() {
+    await copyDirIfPresent(new URL('../../native/sks-menubar', import.meta.url), path.join(distRoot, 'native', 'sks-menubar'));
+}
 async function writeSkillsManifest() {
     const { generatePackagedSkillsManifest } = await import('../core/init/skills.js');
     const manifest = await generatePackagedSkillsManifest();
@@ -63,7 +67,7 @@ async function writeCommonJsBinScope() {
         return;
     await writeTextAtomic(path.join(binDir, 'package.json'), '{"type":"commonjs"}\n');
     await rewriteIfPresent(path.join(binDir, 'sks.js'), (text) => stripSourceMap(text)
-        .replace(/^import \{ PACKAGE_VERSION \} from '\.\.\/core\/version\.js';$/m, "const { PACKAGE_VERSION } = require('../core/version.js');")
+        .replace(/^import \{ PACKAGE_VERSION \} from '\.\.\/core\/version\.js';$/m, "const { version: PACKAGE_VERSION } = require('../../package.json');")
         .replace(/\nexport \{\};\n?/, '\n'));
     await rewriteIfPresent(path.join(binDir, 'sks-dispatch.js'), (text) => {
         const next = stripGeneratedCommonJsExports(stripSourceMap(text).replace(/^export async function runSks/m, 'async function runSks'), ['runSks']);
@@ -102,6 +106,7 @@ function stripGeneratedCommonJsExports(text, names) {
         .trimEnd();
 }
 async function copyDirIfPresent(from, to) {
+    from = fileURLToPathIfNeeded(from);
     if (!fs.existsSync(from))
         return;
     await fsp.rm(to, { recursive: true, force: true });
@@ -115,4 +120,6 @@ async function copyDirIfPresent(from, to) {
             await fsp.copyFile(source, target);
     }
 }
-//# sourceMappingURL=build-dist.js.map
+function fileURLToPathIfNeeded(value) {
+    return value instanceof URL ? fileURLToPath(value) : value;
+}

package/dist/scripts/build-once-runner-check.js

@@ -5,4 +5,3 @@ assertGate(src.includes('.sks-build-proof.json') && src.includes('build:incremen
 const mod = await importDist('core/build/build-once-runner.js');
 assertGate(mod.BUILD_ONCE_PROOF_SCHEMA === 'sks.build-once-proof.v1', 'build-once proof schema missing');
 emitGate('build-once:runner');
-//# sourceMappingURL=build-once-runner-check.js.map

package/dist/scripts/canonical-test-runner.js

@@ -191,4 +191,3 @@ function discover(dir, accept) {
     }
     return out;
 }
-//# sourceMappingURL=canonical-test-runner.js.map

package/dist/scripts/certificate-sla-check.js

@@ -6,4 +6,3 @@ const graph = graphMod.computeTriWikiAffectedGraph({ root, changedFiles: ['src/c
 const cert = certMod.buildTriWikiSlaCertificate({ graph, slaMs: 300000, estimatedCriticalPathMs: 1000, estimatedSequentialMs: 5000 });
 assertGate(cert.schema === 'sks.triwiki-sla-certificate.v1' && cert.ok === true && cert.release_equivalent_within_scope === true, 'SLA certificate must pass for in-budget affected graph', cert);
 emitGate('certificate:sla', { reduction_ratio: cert.reduction_ratio });
-//# sourceMappingURL=certificate-sla-check.js.map

package/dist/scripts/changelog-check.js

@@ -44,4 +44,3 @@ if (!versionSection)
 if (!hasReleaseEntry(versionSection))
     fail(`CHANGELOG.md [${version}] section must include at least one categorized bullet.`);
 console.log(`Changelog check passed: ${version}`);
-//# sourceMappingURL=changelog-check.js.map