sneakoscope 7.1.0 → 7.3.0

package/dist/core/telegram/service.js

@@ -0,0 +1,181 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { ensureDir, exists, globalSksRoot, runProcess, writeTextAtomic } from '../fsx.js';
+export const TELEGRAM_HUB_LAUNCH_LABEL = 'com.sneakoscope.telegram-hub';
+export function telegramHubServicePaths(globalRoot = globalSksRoot(), home = process.env.HOME || os.homedir()) {
+    const root = path.resolve(globalRoot);
+    const logs = path.join(root, 'telegram', 'logs');
+    return {
+        global_root: root,
+        launch_agent_path: path.join(path.resolve(home), 'Library', 'LaunchAgents', `${TELEGRAM_HUB_LAUNCH_LABEL}.plist`),
+        stdout_log_path: path.join(logs, 'hub.out.log'),
+        stderr_log_path: path.join(logs, 'hub.err.log')
+    };
+}
+export function telegramHubLaunchAgentSource(input) {
+    const args = [
+        '/usr/bin/caffeinate',
+        '-i',
+        input.nodeBin,
+        input.sksEntry,
+        'telegram',
+        'hub',
+        'run',
+        '--project-root',
+        path.resolve(input.projectRoot),
+        '--json'
+    ];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${TELEGRAM_HUB_LAUNCH_LABEL}</string>
+<key>ProgramArguments</key><array>${args.map((value) => `<string>${xml(value)}</string>`).join('')}</array>
+<key>RunAtLoad</key><true/>
+<key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+<key>ProcessType</key><string>Background</string>
+<key>ThrottleInterval</key><integer>5</integer>
+<key>StandardOutPath</key><string>${xml(input.paths.stdout_log_path)}</string>
+<key>StandardErrorPath</key><string>${xml(input.paths.stderr_log_path)}</string>
+</dict></plist>
+`;
+}
+export async function installAndStartTelegramHubService(options) {
+    const platform = options.platform ?? process.platform;
+    const paths = telegramHubServicePaths(options.globalRoot, options.home);
+    if (platform !== 'darwin')
+        return unsupportedStatus(paths, 'telegram_launch_agent_requires_macos', options.uid);
+    const nodeBin = path.resolve(options.nodeBin ?? process.execPath);
+    const sksEntry = path.resolve(options.sksEntry ?? process.argv[1] ?? '');
+    if (!await exists(nodeBin) || !await exists(sksEntry))
+        throw new Error('telegram_launch_agent_runtime_missing');
+    await ensureDir(path.dirname(paths.launch_agent_path));
+    await ensureDir(path.dirname(paths.stdout_log_path));
+    const plist = telegramHubLaunchAgentSource({
+        nodeBin,
+        sksEntry,
+        projectRoot: options.projectRoot,
+        paths
+    });
+    await writeTextAtomic(paths.launch_agent_path, plist, { mode: 0o644 });
+    const run = options.run ?? runProcess;
+    const launchctl = options.launchctl ?? '/bin/launchctl';
+    const domain = launchDomain(options.uid);
+    const service = `${domain}/${TELEGRAM_HUB_LAUNCH_LABEL}`;
+    await run(launchctl, ['bootout', service], { timeoutMs: 5_000, maxOutputBytes: 16 * 1024 }).catch(() => undefined);
+    const bootstrap = await run(launchctl, ['bootstrap', domain, paths.launch_agent_path], {
+        timeoutMs: 10_000,
+        maxOutputBytes: 32 * 1024
+    });
+    if (bootstrap.code !== 0 && !bootstrap.timedOut) {
+        return {
+            ...(await telegramHubServiceStatus({ ...options, run, launchctl })),
+            ok: false,
+            error: boundedError(bootstrap.stderr || bootstrap.stdout || 'launchctl_bootstrap_failed')
+        };
+    }
+    await run(launchctl, ['kickstart', '-k', service], { timeoutMs: 10_000, maxOutputBytes: 32 * 1024 }).catch(() => undefined);
+    return waitForTelegramHubService({ ...options, run, launchctl });
+}
+export async function stopTelegramHubService(options) {
+    const paths = telegramHubServicePaths(options.globalRoot, options.home);
+    const platform = options.platform ?? process.platform;
+    if (platform !== 'darwin')
+        return unsupportedStatus(paths, 'telegram_launch_agent_requires_macos', options.uid);
+    const run = options.run ?? runProcess;
+    const launchctl = options.launchctl ?? '/bin/launchctl';
+    const service = `${launchDomain(options.uid)}/${TELEGRAM_HUB_LAUNCH_LABEL}`;
+    const stopped = await run(launchctl, ['bootout', service], { timeoutMs: 8_000, maxOutputBytes: 32 * 1024 });
+    const status = await telegramHubServiceStatus({ ...options, run, launchctl });
+    if (!status.running)
+        return { ...status, ok: true, loaded: false, error: null };
+    return {
+        ...status,
+        ok: false,
+        error: boundedError(stopped.stderr || stopped.stdout || 'launchctl_bootout_failed')
+    };
+}
+export async function restartTelegramHubService(options) {
+    await stopTelegramHubService(options).catch(() => undefined);
+    return installAndStartTelegramHubService(options);
+}
+export async function telegramHubServiceStatus(options) {
+    const paths = telegramHubServicePaths(options.globalRoot, options.home);
+    const service = `${launchDomain(options.uid)}/${TELEGRAM_HUB_LAUNCH_LABEL}`;
+    if ((options.platform ?? process.platform) !== 'darwin') {
+        return unsupportedStatus(paths, 'telegram_launch_agent_requires_macos', options.uid);
+    }
+    const installed = await exists(paths.launch_agent_path);
+    const run = options.run ?? runProcess;
+    const launchctl = options.launchctl ?? '/bin/launchctl';
+    const result = await run(launchctl, ['print', service], { timeoutMs: 3_000, maxOutputBytes: 32 * 1024 })
+        .catch((error) => ({
+        code: 1,
+        stdout: '',
+        stderr: error instanceof Error ? error.message : String(error),
+        timedOut: false
+    }));
+    const text = `${result.stdout || ''}\n${result.stderr || ''}`;
+    const state = text.match(/^[ \t]*state = ([^\n]+)/m)?.[1]?.trim() ?? null;
+    const pidText = text.match(/^[ \t]*pid = (\d+)/m)?.[1] ?? null;
+    const pid = pidText ? Number(pidText) : null;
+    const loaded = result.code === 0;
+    const running = loaded && state === 'running' && Boolean(pid);
+    return {
+        schema: 'sks.telegram-hub-service.v1',
+        ok: running,
+        supported: true,
+        installed,
+        loaded,
+        running,
+        state,
+        pid,
+        service,
+        launch_agent_path: paths.launch_agent_path,
+        error: running ? null : loaded ? 'telegram_hub_not_running' : boundedError(result.stderr || result.stdout || 'telegram_hub_not_loaded')
+    };
+}
+export async function removeTelegramHubService(options) {
+    await stopTelegramHubService(options).catch(() => undefined);
+    const paths = telegramHubServicePaths(options.globalRoot, options.home);
+    await fsp.unlink(paths.launch_agent_path).catch(() => undefined);
+    const status = await telegramHubServiceStatus(options);
+    return { ...status, installed: false, ok: !status.running };
+}
+function unsupportedStatus(paths, error, uid) {
+    return {
+        schema: 'sks.telegram-hub-service.v1',
+        ok: false,
+        supported: false,
+        installed: false,
+        loaded: false,
+        running: false,
+        state: null,
+        pid: null,
+        service: `${launchDomain(uid)}/${TELEGRAM_HUB_LAUNCH_LABEL}`,
+        launch_agent_path: paths.launch_agent_path,
+        error
+    };
+}
+async function waitForTelegramHubService(options) {
+    let status = await telegramHubServiceStatus(options);
+    for (let attempt = 0; attempt < 25 && !status.running; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        status = await telegramHubServiceStatus(options);
+    }
+    return status;
+}
+function launchDomain(uid = typeof process.getuid === 'function' ? process.getuid() : 0) {
+    return `gui/${uid}`;
+}
+function boundedError(value) {
+    return String(value || '').replace(/(?:\/Users|\/home)\/[^\s]+/g, '[path-redacted]').slice(0, 500);
+}
+function xml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}

package/dist/core/telegram/setup.js

@@ -0,0 +1,220 @@
+import os from 'node:os';
+import path from 'node:path';
+import { ensureDir, globalSksRoot, nowIso, readJson, runProcess, sha256, which, writeJsonAtomic } from '../fsx.js';
+import { REMOTE_MACHINE_REGISTRY_SCHEMA, REMOTE_SESSION_INDEX_SCHEMA, RemoteCodexSessionBindingStore, remoteCodexSessionBindingsPath, remoteMachineRegistryPath, remoteSessionIndexPath, validateAllowedRoot, validateRemoteMachineRegistry, validateRemoteSessionIndex } from '../remote/index.js';
+import { TelegramBotApiClient } from './bot-api.js';
+import { isPositiveTelegramId, validateTelegramBotToken } from './config.js';
+import { telegramHubPaths } from './hub.js';
+const KEYCHAIN_SERVICE = 'com.sneakoscope.telegram.bot';
+const KEYCHAIN_WRITER_SWIFT = `import Foundation
+import Security
+let a=CommandLine.arguments[1],s=CommandLine.arguments[2]
+guard let k=String(data:FileHandle.standardInput.readDataToEndOfFile(),encoding:.utf8)?.trimmingCharacters(in:.whitespacesAndNewlines),!k.isEmpty else{exit(64)}
+let q:[String:Any]=[kSecClass as String:kSecClassGenericPassword,kSecAttrAccount as String:a,kSecAttrService as String:s]
+let v:[String:Any]=[kSecValueData as String:Data(k.utf8)]
+var r=SecItemUpdate(q as CFDictionary,v as CFDictionary)
+if r==errSecItemNotFound{var n=q;n[kSecValueData as String]=Data(k.utf8);r=SecItemAdd(n as CFDictionary,nil)}
+if r != errSecSuccess{FileHandle.standardError.write(Data("keychain_status=\\(r)\\n".utf8));exit(1)}`;
+export async function setupTelegramLocalCoding(input) {
+    const token = validateTelegramBotToken(input.token.trim());
+    const explicitPair = normalizeExplicitPair(input.pairedChatId, input.pairedUserId);
+    const projectRoot = await canonicalProjectRoot(input.projectRoot);
+    const rootIssue = validateAllowedRoot(projectRoot);
+    if (rootIssue)
+        throw new Error(`telegram_project_root_invalid:${rootIssue}`);
+    const globalRoot = path.resolve(input.globalRoot ?? globalSksRoot());
+    const api = input.api ?? new TelegramBotApiClient(token, { timeoutMs: 12_000, maxRetries: 0 });
+    const bot = await api.call('getMe', {});
+    const pairing = explicitPair ?? await detectPrivateStart(api);
+    const account = input.account?.trim() || process.env.USER || os.userInfo().username || 'sks';
+    await (input.keychainWriter ?? writeTelegramKeychain)(token, KEYCHAIN_SERVICE, account);
+    const hostname = input.hostname ?? os.hostname();
+    const machineId = `local-${sha256(hostname).slice(0, 12)}`;
+    const projectId = `project-${sha256(projectRoot).slice(0, 12)}`;
+    const sessionId = `telegram-${sha256(`${machineId}:${projectId}`).slice(0, 12)}`;
+    const bindingStore = new RemoteCodexSessionBindingStore(remoteCodexSessionBindingsPath(projectRoot));
+    const existingBinding = await bindingStore.find(sessionId);
+    const binding = existingBinding && input.resetSession !== true
+        ? existingBinding
+        : await bindingStore.upsert({
+            session_id: sessionId,
+            machine_id: machineId,
+            project_id: projectId,
+            project_root: projectRoot,
+            codex_thread_id: null,
+            last_turn_id: null,
+            last_turn_status: null
+        });
+    const machinePath = remoteMachineRegistryPath(globalRoot);
+    const registry = await upsertLocalMachine(machinePath, {
+        id: machineId,
+        display_name: `This Mac (${hostname})`.slice(0, 120),
+        transport: 'local',
+        allowed_roots: [projectRoot],
+        enabled: true
+    });
+    const indexPath = remoteSessionIndexPath(projectRoot);
+    await upsertLocalTarget(indexPath, registry, {
+        machine_id: machineId,
+        project_id: projectId,
+        project_root: projectRoot
+    });
+    const config = {
+        schema: 'sks.telegram-config.v1',
+        bot_token_ref: { type: 'keychain', service: KEYCHAIN_SERVICE, account },
+        paired_chat_ids: [pairing.chatId],
+        paired_user_ids: [pairing.userId],
+        long_poll_timeout_sec: 25,
+        owner_stale_ms: 60_000,
+        protect_content: true,
+        silent_notifications: false
+    };
+    const configPath = telegramHubPaths(globalRoot).config;
+    await writeJsonAtomic(configPath, config);
+    return {
+        schema: 'sks.telegram-setup.v1',
+        ok: true,
+        bot: {
+            id: bot?.id === undefined ? null : String(bot.id),
+            username: bot?.username ? String(bot.username) : null
+        },
+        pairing: {
+            chat_id: pairing.chatId,
+            user_id: pairing.userId,
+            detected: explicitPair === null
+        },
+        machine_id: machineId,
+        project_id: projectId,
+        project_root: projectRoot,
+        session_id: sessionId,
+        codex_thread_id: binding.codex_thread_id,
+        codex_thread_state: binding.codex_thread_id ? 'ready' : 'pending_first_turn',
+        token_storage: 'macos-keychain',
+        config_path: configPath,
+        machine_registry_path: machinePath,
+        session_index_path: indexPath
+    };
+}
+export async function detectPrivateStart(api) {
+    const updates = await api.getUpdates({ timeout: 0, allowed_updates: ['message'] });
+    const match = [...updates].reverse().find(isPrivateStart);
+    if (!match?.message?.from) {
+        throw new Error('telegram_pairing_start_not_found:send_/start_to_the_bot_then_retry');
+    }
+    await api.getUpdates({
+        offset: match.update_id + 1,
+        timeout: 0,
+        allowed_updates: ['message']
+    });
+    return {
+        chatId: String(match.message.chat.id),
+        userId: String(match.message.from.id)
+    };
+}
+export async function writeTelegramKeychain(token, service, account) {
+    if (process.platform !== 'darwin')
+        throw new Error('telegram_keychain_requires_macos');
+    const swift = await which('swift').catch(() => null) || '/usr/bin/swift';
+    const result = await runProcess(swift, ['-e', KEYCHAIN_WRITER_SWIFT, account, service], {
+        input: `${token}\n`,
+        timeoutMs: 30_000,
+        maxOutputBytes: 8 * 1024
+    });
+    if (result.code !== 0 || result.timedOut)
+        throw new Error('telegram_keychain_store_failed');
+}
+async function upsertLocalMachine(file, machine) {
+    await ensureDir(path.dirname(file));
+    const raw = await readJson(file, null);
+    let registry;
+    if (raw === null) {
+        registry = { schema: REMOTE_MACHINE_REGISTRY_SCHEMA, machines: [] };
+    }
+    else {
+        const validated = validateRemoteMachineRegistry(raw);
+        if (!validated.ok || !validated.registry) {
+            throw new Error(`remote_machine_registry_invalid:${validated.issues.join(',')}`);
+        }
+        registry = validated.registry;
+    }
+    const machines = [...registry.machines];
+    const index = machines.findIndex((candidate) => candidate.id === machine.id);
+    if (index >= 0) {
+        const current = machines[index];
+        if (current.transport !== 'local')
+            throw new Error('remote_local_machine_id_conflict');
+        machines[index] = {
+            ...machine,
+            allowed_roots: [...new Set([...current.allowed_roots, ...machine.allowed_roots])]
+        };
+    }
+    else
+        machines.push(machine);
+    const next = { schema: REMOTE_MACHINE_REGISTRY_SCHEMA, machines };
+    const validation = validateRemoteMachineRegistry(next);
+    if (!validation.ok || !validation.registry)
+        throw new Error(`remote_machine_registry_invalid:${validation.issues.join(',')}`);
+    await writeJsonAtomic(file, validation.registry);
+    return validation.registry;
+}
+async function upsertLocalTarget(file, registry, target) {
+    await ensureDir(path.dirname(file));
+    const raw = await readJson(file, null);
+    let index;
+    if (raw === null) {
+        index = { schema: REMOTE_SESSION_INDEX_SCHEMA, targets: [] };
+    }
+    else {
+        const validated = validateRemoteSessionIndex(raw, registry);
+        if (!validated.ok || !validated.index) {
+            throw new Error(`remote_session_index_invalid:${validated.issues.join(',')}`);
+        }
+        index = validated.index;
+    }
+    const targets = [...index.targets];
+    const found = targets.findIndex((candidate) => candidate.machine_id === target.machine_id && candidate.project_id === target.project_id);
+    if (found >= 0)
+        targets[found] = target;
+    else
+        targets.push(target);
+    const next = { schema: REMOTE_SESSION_INDEX_SCHEMA, targets };
+    const validation = validateRemoteSessionIndex(next, registry);
+    if (!validation.ok || !validation.index)
+        throw new Error(`remote_session_index_invalid:${validation.issues.join(',')}`);
+    await writeJsonAtomic(file, validation.index);
+    return validation.index;
+}
+async function canonicalProjectRoot(value) {
+    if (!path.isAbsolute(value))
+        throw new Error('telegram_project_root_must_be_absolute');
+    const fsp = await import('node:fs/promises');
+    const resolved = await fsp.realpath(path.resolve(value)).catch(() => null);
+    if (!resolved)
+        throw new Error('telegram_project_root_unreadable');
+    const stat = await fsp.stat(resolved).catch(() => null);
+    if (!stat?.isDirectory())
+        throw new Error('telegram_project_root_not_directory');
+    return resolved;
+}
+function normalizeExplicitPair(chatId, userId) {
+    const chat = String(chatId ?? '').trim();
+    const user = String(userId ?? '').trim();
+    if (!chat && !user)
+        return null;
+    if (!isPositiveTelegramId(chat) || !isPositiveTelegramId(user)) {
+        throw new Error('telegram_pairing_ids_must_be_positive_private_ids');
+    }
+    return { chatId: chat, userId: user };
+}
+function isPrivateStart(update) {
+    const message = update.message;
+    if (!message || message.chat.type !== 'private' || !message.from)
+        return false;
+    return /^\/start(?:@\w+)?(?:\s|$)/i.test(String(message.text || '').trim());
+}
+export function telegramSetupKeychainReference(account = process.env.USER || os.userInfo().username || 'sks') {
+    return { type: 'keychain', service: KEYCHAIN_SERVICE, account };
+}
+export function telegramSetupTimestamp() {
+    return nowIso();
+}

package/dist/core/text/regex.js

@@ -0,0 +1,3 @@
+export function escapeRegExp(value) {
+    return String(value ?? '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/core/text/strings.js

@@ -0,0 +1,6 @@
+export function uniqueStrings(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
+}
+export function uniqueStringsSorted(values) {
+    return uniqueStrings(values).sort();
+}

package/dist/core/triwiki-wrongness/image-wrongness.js

@@ -3,6 +3,7 @@ import { ensureDir, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 import { missionDir } from '../mission.js';
 import { addWrongnessRecord } from './wrongness-ledger.js';
 import { deterministicWrongnessId } from './wrongness-schema.js';
+import { asRecordOrEmpty as asRecord } from '../json/records.js';
 export const IMAGE_WRONGNESS_RECORD_SCHEMA = 'sks.image-wrongness.v1';
 export const IMAGE_WRONGNESS_INDEX_SCHEMA = 'sks.image-wrongness-index.v1';
 export function imageWrongnessIndexPath(root) {
@@ -133,9 +134,6 @@ function anchorIdFromIssue(issue) {
     const match = issue.match(/anchor(?:_id|_bbox|_image_ref)?:([^:\s]+)/i);
     return match?.[1] || null;
 }
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
 function stringOrNull(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : null;
 }

package/dist/core/triwiki-wrongness/wrongness-ledger.js

@@ -6,6 +6,7 @@ import { withFileLock } from '../locks/file-lock.js';
 import { findLatestMission, missionsDir } from '../mission.js';
 import { codexSchemaPath, runCodexExecResumeWithOutputSchema } from '../codex-exec-output-schema.js';
 import { WRONGNESS_INDEX_SCHEMA, WRONGNESS_LEDGER_SCHEMA, createWrongnessRecord, deterministicWrongnessId, emptyWrongnessLedger, normalizeRootCauseKind, normalizeSeverity, normalizeWrongnessKind, severityForRecord, validateWrongnessLedger } from './wrongness-schema.js';
+import { asRecordOrEmpty as asRecord } from '../json/records.js';
 const CANONICAL_MISSION_ID_RE = /^M-[A-Za-z0-9][A-Za-z0-9._-]*$/;
 export function projectWrongnessLedgerPath(root) {
     return path.join(safeWrongnessWikiDir(root), 'wrongness-ledger.json');
@@ -588,9 +589,6 @@ function countBy(records, key) {
         out[key(record)] = Number(out[key(record)] || 0) + 1;
     return out;
 }
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
 export function highSeverityActive(records) {
     return records.filter((record) => record.status === 'active' && ['high', 'critical'].includes(severityForRecord(record)));
 }

package/dist/core/triwiki-wrongness/wrongness-proof-linker.js

@@ -1,5 +1,6 @@
 import { nowIso } from '../fsx.js';
 import { readCombinedWrongnessRecords, summarizeWrongnessRecords } from './wrongness-ledger.js';
+import { asRecordOrEmpty as asRecord } from '../json/records.js';
 export async function wrongnessProofEvidence(root, missionId = null, opts = {}) {
     const records = await readCombinedWrongnessRecords(root, missionId);
     const summary = summarizeWrongnessRecords(records);
@@ -43,9 +44,6 @@ export function claimReferencesActiveWrongness(claim, evidence) {
         return false;
     return asStringList(wrongness).some((id) => ids.has(id));
 }
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
 function asStringList(value) {
     return Array.isArray(value) ? value.map((item) => String(item || '')).filter(Boolean) : [];
 }

package/dist/core/triwiki-wrongness/wrongness-retrieval.js

@@ -1,6 +1,7 @@
 import { nowIso } from '../fsx.js';
 import { readCombinedWrongnessRecords, summarizeWrongnessRecords } from './wrongness-ledger.js';
 import { WRONGNESS_CONTEXT_SCHEMA } from './wrongness-schema.js';
+import { asRecordOrEmpty as asRecord } from '../json/records.js';
 export async function wrongnessContextForRoute(root, opts = {}) {
     const missionId = opts.missionId ?? null;
     const route = opts.route ?? null;
@@ -75,6 +76,3 @@ function severityRank(value) {
         return 2;
     return 1;
 }
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}

package/dist/core/triwiki-wrongness/wrongness-schema.js

@@ -1,5 +1,6 @@
 import { nowIso, randomId, sha256 } from '../fsx.js';
 import { moduleIdsForPath } from '../triwiki/triwiki-module-card.js';
+import { asRecordOrEmpty as asRecord } from '../json/records.js';
 export const WRONGNESS_RECORD_SCHEMA = 'sks.triwiki-wrongness.v1';
 export const WRONGNESS_LEDGER_SCHEMA = 'sks.triwiki-wrongness-ledger.v1';
 export const WRONGNESS_INDEX_SCHEMA = 'sks.triwiki-wrongness-index.v1';
@@ -378,9 +379,6 @@ function severityForKind(kind) {
         return 'medium';
     return 'medium';
 }
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
 function asList(value) {
     return Array.isArray(value) ? value : [];
 }

package/dist/core/triwiki-wrongness/wrongness-trust-policy.js

@@ -1,3 +1,4 @@
+import { asRecordOrEmpty as asRecord } from '../json/records.js';
 export function evaluateWrongnessTrust(input = {}) {
     const row = asRecord(input);
     const proof = asRecord(row.proof ?? input);
@@ -71,9 +72,6 @@ function claimLinksActiveWrongness(proof, evidence) {
         return wrongness.some((id) => activeIds.has(id));
     });
 }
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
 function asStringList(value) {
     return Array.isArray(value) ? value.map((item) => String(item || '')).filter(Boolean) : [];
 }

package/dist/core/trust-kernel/completion-contract.js

@@ -1,8 +1,6 @@
 import { validateCompletionProof } from '../proof/validation.js';
 import { rootCauseAnalysisIssue } from '../proof/root-cause-policy.js';
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
+import { asRecordOrEmpty as asRecord } from '../json/records.js';
 function asList(value) {
     return Array.isArray(value) ? value : [];
 }

package/dist/core/trust-kernel/route-contract.js

@@ -5,9 +5,7 @@ import { routeRequiresCompletionProof, routeRequiresImageVoxelAnchors } from '..
 import { rootCauseAnalysisRequired } from '../proof/root-cause-policy.js';
 import { ROUTE_COMPLETION_CONTRACT_SCHEMA, normalizeTrustStatus, trustKernelMetadata } from './trust-kernel-schema.js';
 import { validateCompletionContract } from './completion-contract.js';
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
+import { asRecordOrEmpty as asRecord } from '../json/records.js';
 function asList(value) {
     return Array.isArray(value) ? value : [];
 }

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

@@ -9,6 +9,7 @@ import { reconcileSkills } from '../init/skills.js';
 import { codexHookTrustDoctor } from '../codex-hooks/codex-hook-trust-doctor.js';
 import { writeCodexConfigGuarded } from '../codex/codex-config-guard.js';
 import { compareSemVer } from './semver.js';
+import { escapeRegExp } from '../text/regex.js';
 export const UPDATE_MIGRATION_SCHEMA = 'sks.project-migration-receipt.v2';
 export const INSTALLATION_EPOCH_SCHEMA = 'sks.installation-epoch.v1';
 export function installationEpochPath() {
@@ -715,9 +716,6 @@ function tomlLineKey(line) {
 function ensureTrailingNewline(text) {
     return `${String(text || '').trim()}\n`;
 }
-function escapeRegExp(value) {
-    return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 export async function ensureCurrentMigrationBeforeCommand(input) {
     const env = input.env || process.env;
     const command = input.command;

package/dist/core/update-check.js

@@ -5,7 +5,7 @@ import { PACKAGE_VERSION, packageRoot, readJson, runProcess, throttleLines, whic
 import { createRequestedScopeContract } from './safety/requested-scope-contract.js';
 import { guardedPackageInstall, guardContextForRoute } from './safety/mutation-guard.js';
 import { isUpdateMigrationReceiptCurrent, projectUpdateMigrationReceiptPath, resolveInstalledSksEntrypoint, runPackageLocalDoctor, writeProjectUpdateMigrationReceipt } from './update/update-migration-state.js';
-import { inspectSksMenuBarStatus, installSksMenuBar, sksMenuBarPaths } from './codex-app/sks-menubar.js';
+import { inspectSksMenuBarStatus, installSksMenuBar, sksMenuBarPaths } from './codex-app/menubar/index.js';
 import { inspectCodexCliUpdate } from './codex/codex-cli-update.js';
 import { reconcileSkills } from './init/skills.js';
 import { codexHookTrustDoctor } from './codex-hooks/codex-hook-trust-doctor.js';
@@ -234,6 +234,7 @@ export const UPDATE_STAGE_ORDER = [
     'version_probe',
     'new_version_doctor',
     'hook_trust_repair',
+    'project_receipt',
     'global_skills_reconcile',
     'native_capability_setup',
     'menubar_rebuild',
@@ -241,6 +242,13 @@ export const UPDATE_STAGE_ORDER = [
     'final_self_verification',
     'snapshot_refresh'
 ];
+export function updateNestedProcessEnvironment(env) {
+    return {
+        ...env,
+        SKS_UPDATE_DEFER_MENUBAR_RESTART: '1',
+        SKS_SKIP_SKS_MENUBAR_LAUNCH: '1'
+    };
+}
 export async function runSksUpdateReview(options = {}) {
     const packageName = options.packageName || 'sneakoscope';
     const registry = options.registry || DEFAULT_REGISTRY;
@@ -323,6 +331,7 @@ export async function runSksUpdateNow(options = {}) {
     const packageName = options.packageName || 'sneakoscope';
     const registry = options.registry || DEFAULT_REGISTRY;
     const env = options.env || process.env;
+    const nestedProcessEnv = updateNestedProcessEnvironment(env);
     const npmBin = options.npmBin === undefined ? await which('npm') : options.npmBin;
     const cwd = env.HOME || os.homedir();
     const check = await runSksUpdateCheck({
@@ -472,6 +481,10 @@ export async function runSksUpdateNow(options = {}) {
         recordRegistryStage();
         stage('temporary_install_smoke', true, 'skipped_current', { current: check.current });
         stage('global_install', true, 'skipped_current', { current: check.current });
+        stage('resolve_new_binary', true, 'skipped_current', { current: check.current });
+        stage('version_probe', true, 'skipped_current', { current: check.current });
+        stage('new_version_doctor', true, 'skipped_current', { current: check.current });
+        stage('hook_trust_repair', true, 'skipped_current', { current: check.current });
         const receipt = await writeProjectUpdateMigrationReceipt({
             root: projectReceiptRoot,
             source: 'update-now-current',
@@ -482,6 +495,7 @@ export async function runSksUpdateNow(options = {}) {
         const migrationCurrent = isUpdateMigrationReceiptCurrent(receipt);
         stage('project_receipt', migrationCurrent, migrationCurrent ? 'current' : 'failed', { root: projectReceiptRoot });
         await runUpdateGlobalSkillsReconcile(stage, { quiet: machineOutput, env });
+        stage('native_capability_setup', true, 'skipped_current', { reason: 'package_already_current' });
         const sksMenuBar = migrationCurrent
             ? await installUpdateSksMenuBar({ root: projectReceiptRoot, env, stage, quiet: machineOutput })
             : null;
@@ -543,7 +557,7 @@ export async function runSksUpdateNow(options = {}) {
             root: projectReceiptRoot,
             args: ['doctor', '--fix', '--yes', '--profile', 'migration', '--machine-only', '--report-file', path.join(projectReceiptRoot, '.sneakoscope', 'update', 'old-version-doctor.json')],
             env: {
-                ...env,
+                ...nestedProcessEnv,
                 ...(env.SKS_TEST_OLD_DOCTOR_FAIL === '1' ? { SKS_TEST_DOCTOR_FAIL: '1' } : {})
             },
             timeoutMs: oldDoctorTimeoutMs,
@@ -563,7 +577,7 @@ export async function runSksUpdateNow(options = {}) {
         packageName,
         version: installVersion,
         registry,
-        env,
+        env: nestedProcessEnv,
         ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
         ...(options.maxOutputBytes === undefined ? {} : { maxOutputBytes: options.maxOutputBytes })
     });
@@ -615,7 +629,7 @@ export async function runSksUpdateNow(options = {}) {
         command: npmBin,
         args: npmArgs,
         cwd,
-        env,
+        env: nestedProcessEnv,
         timeoutMs: options.timeoutMs ?? 10 * 60 * 1000,
         maxOutputBytes: options.maxOutputBytes ?? 128 * 1024
     };
@@ -660,7 +674,7 @@ export async function runSksUpdateNow(options = {}) {
                 root: projectReceiptRoot,
                 entrypoint: newBinary,
                 args: ['doctor', '--fix', '--yes', '--profile', 'migration', '--machine-only', '--report-file', path.join(projectReceiptRoot, '.sneakoscope', 'update', 'new-version-doctor.json')],
-                env,
+                env: nestedProcessEnv,
                 timeoutMs: updateDoctorTimeoutMs(env),
                 maxOutputBytes: 32 * 1024
             }), 60_000);
@@ -683,7 +697,7 @@ export async function runSksUpdateNow(options = {}) {
                 doctor: newVersionDoctor,
                 updateStages: stages,
                 fromVersion: check.current,
-                env
+                env: nestedProcessEnv
             });
             projectReceipt = receiptResult.receipt;
             migrationCurrent = isUpdateMigrationReceiptCurrent(projectReceipt, installVersion);