sneakoscope 9.0.3 → 9.0.6

package/README.md

@@ -22,7 +22,7 @@ Proof-first orchestration for Codex CLI, ChatGPT Desktop, AI coding agents, mult
 Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-This README documents package **SKS 9.0.3** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
+This README documents package **SKS 9.0.6** — its own identity, read from `package.json` and subject to release-gate verification, not advice about what to install.
 
 Use the official latest stable SKS and Codex CLI releases. The Codex compatibility SSOT is always the **current latest stable** host; capability probes measure what that host can actually do. Product docs do not crown a fixed `0.x.y` string as SSOT (release pins and schema directories are measured artifacts for the current package, not a permanent product version claim). Menu Bar / Center induce updates to the latest stable build. Run `sks update-check` for what is installed and read the capability report for what is supported. Install SSOT is npm `sneakoscope@latest`; PATH `sks` and Menu Bar stamped generation must match that version or gates fail. It resolves managed SKS skills from the authoritative global install, preserves a runnable Naruto child slot when `max_threads=2`, and keeps Menu Bar repair transactional so stamped generations remain verifiable. Naruto uses stable opt-in multi-agent V2 when the host exposes it (Codex official multi-agent wrap-only; SKS does not reimplement a parallel runtime). Local code search is mode-separated (`sks search files|text|structure|symbol|context`); `context` is answered by the compiled TriWiki Context Graph (`context-graph.json` is exhaustive authority; `context-pack.json` and managed `AGENTS.md` are bounded projections) — see [docs/architecture/context-graph.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/architecture/context-graph.md) and [docs/PRODUCT-CONTRACT.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/docs/PRODUCT-CONTRACT.md). See [CHANGELOG.md](https://github.com/mandarange/Sneakoscope-Codex/blob/main/CHANGELOG.md).
 

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

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

package/dist/commands/doctor.js

@@ -7,10 +7,8 @@ import { ui as cliUi } from '../cli/cli-theme.js';
 import { getCodexInfo } from '../core/codex-adapter.js';
 import { rustInfo } from '../core/rust-accelerator.js';
 import { codexAppIntegrationStatus } from '../core/codex-app.js';
-import { desktopBridgeStatusV3, executeDesktopBridgeCommandV3 } from '../core/codex-lb/desktop-controller-v3.js';
-import { bootstrapExistingDesktopBridgeService, desktopBridgeServiceStatus } from '../core/codex-lb/desktop-service.js';
-import { desktopBridgeRuntimeVersion, desktopBridgeRuntimeVersionStale } from '../core/codex-lb/desktop-bridge/state.js';
-import { PACKAGE_VERSION } from '../core/version.js';
+import { desktopBridgeStatusV3 } from '../core/codex-lb/desktop-controller-v3.js';
+import { repairDoctorDesktopBridgeCatalog } from '../core/doctor/desktop-bridge-catalog-repair.js';
 import { inspectCodexConfigReadability } from '../core/codex/codex-config-readability.js';
 import { inspectOAuthCallbackPortConflict, oauthCallbackDoctorGuidance } from '../core/codex/oauth-callback-port-diagnostic.js';
 import { inventoryCodexPermissionProfiles } from '../core/codex/codex-permission-profiles.js';
@@ -37,29 +35,7 @@ export { buildCodexAppUiDiagnosticFailure, buildRuntimeReadiness, formatCodexDoc
 export function doctorArgWarnings(args = []) {
     return baseDoctorArgWarnings(args);
 }
-export async function restartStaleDesktopBridgeRuntime(input) {
-    if (process.env.SKS_TEST_ISOLATION === '1' || process.env.SKS_RELEASE_UPGRADE_SMOKE === '1') {
-        return { restarted: false, warnings: [], blockers: [] };
-    }
-    const service = await desktopBridgeServiceStatus({ home: input.home }).catch(() => null);
-    if (!service?.running || !desktopBridgeRuntimeVersionStale(service.state)) {
-        return { restarted: false, warnings: [], blockers: [] };
-    }
-    const running = desktopBridgeRuntimeVersion(service.state) || 'pre-8.6.2';
-    if (!input.fix) {
-        return {
-            restarted: false,
-            warnings: [],
-            blockers: [`desktop_bridge_runtime_version_stale:${running}:${PACKAGE_VERSION}`]
-        };
-    }
-    const restarted = await bootstrapExistingDesktopBridgeService({ home: input.home }).catch(() => null);
-    const nowRunning = restarted?.running === true && !desktopBridgeRuntimeVersionStale(restarted.state);
-    return nowRunning
-        ? { restarted: true, warnings: [`desktop_bridge_runtime_restarted:${running}:${PACKAGE_VERSION}`], blockers: [] }
-        : { restarted: false, warnings: [], blockers: [`desktop_bridge_runtime_version_stale:${running}:${PACKAGE_VERSION}`] };
-}
-export const CATALOG_REPAIR_MAX_ATTEMPTS = 2;
+export { CATALOG_REPAIR_MAX_ATTEMPTS, repairDoctorDesktopBridgeCatalog, restartStaleDesktopBridgeRuntime } from '../core/doctor/desktop-bridge-catalog-repair.js';
 export function deferCommandAliasCleanupToMigrationReceipt(result) {
     const observedBlockers = Array.isArray(result?.blockers)
         ? result.blockers.map(String).filter(Boolean)
@@ -214,19 +190,41 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         status: 'failed',
         error: err?.message || String(err)
     }));
-    const menuBar = await installMenuBarImpl({
-        home,
-        root: home,
-        apply: true,
-        launch: !sksMenuBarRestartDeferred(doctorEnv),
-        env: doctorEnv,
-        quiet: flag(args, '--json') || flag(args, '--machine-only')
-    }).catch((err) => ({
-        schema: 'sks.codex-app-sks-menubar.v1',
+    const doctorProfile = doctorProfileFromArgs(args, true);
+    const menuBarPolicy = doctorMenuBarInstallPolicy(args, true, doctorEnv);
+    const menuBar = menuBarPolicy.phase_enabled
+        ? await installMenuBarImpl({
+            home,
+            root: home,
+            apply: true,
+            launch: !sksMenuBarRestartDeferred(doctorEnv),
+            env: doctorEnv,
+            quiet: flag(args, '--json') || flag(args, '--machine-only')
+        }).catch((err) => ({
+            schema: 'sks.codex-app-sks-menubar.v1',
+            ok: false,
+            status: 'blocked',
+            blockers: [err?.message || String(err)],
+            warnings: []
+        }))
+        : {
+            schema: 'sks.codex-app-sks-menubar.v1',
+            ok: true,
+            status: 'skipped_by_profile',
+            skipped: true,
+            blockers: [],
+            warnings: [`sks_menubar_phase_skipped_for_profile:${doctorProfile}`]
+        };
+    const desktopBridgeRepairImpl = deps.desktopBridgeRepairImpl || repairDoctorDesktopBridgeCatalog;
+    const desktopBridgeRepair = await desktopBridgeRepairImpl({ fix: true }).catch((err) => ({
+        id: 'desktop_bridge_catalog_repair',
         ok: false,
-        status: 'blocked',
-        blockers: [err?.message || String(err)],
-        warnings: []
+        repaired: false,
+        required_for_ready: false,
+        manual_required: false,
+        warnings: [],
+        blockers: [`desktop_bridge_catalog_repair_failed:${err?.message || String(err)}`],
+        rollback_evidence: 'combined_catalog_previous_generation_preserved'
     }));
     const desktopBridge = await inspectDoctorDesktopBridgeStatus({
         home,
@@ -238,15 +236,54 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
     const globalFastModeReady = globalFastMode?.status !== 'failed'
         && globalFastMode?.ok !== false;
     const menuBarReady = menuBar?.ok !== false;
-    const blockers = [...new Set([
+    const migrationScopeBlockers = [...new Set([
             ...(!globalSkillsReady ? [`global_skills_reconcile_failed:${globalSkills?.error || 'core_skill_integrity'}`] : []),
             ...(currentSurface?.ok !== true ? (currentSurface?.blockers || ['global_current_surface_reconcile_failed']) : []),
-            ...(!globalFastModeReady ? [`global_fast_mode_repair_failed:${globalFastMode?.error || globalFastMode?.status || 'unknown'}`] : []),
-            ...(!menuBarReady ? (menuBar?.blockers || ['sks_menubar_repair_failed']) : []),
+            ...(!globalFastModeReady ? [`global_fast_mode_repair_failed:${globalFastMode?.error || globalFastMode?.status || 'unknown'}`] : [])
+        ].map(String).filter(Boolean))];
+    const bridgeBlockers = [...new Set([
+            ...(desktopBridgeRepair?.ok === false
+                ? (desktopBridgeRepair?.blockers?.length ? desktopBridgeRepair.blockers : ['desktop_bridge_catalog_repair_failed'])
+                : []),
             ...(desktopBridge.ok === false
                 ? (desktopBridge.blockers || ['desktop_bridge_unavailable'])
                 : [])
         ].map(String).filter(Boolean))];
+    const bridgeReadinessRequired = doctorProfileRequiresDesktopBridgeReadiness(doctorProfile);
+    let migrationReceipt = null;
+    if (doctorProfile === 'migration') {
+        const writeReceiptImpl = deps.writeProjectUpdateMigrationReceiptImpl || writeProjectUpdateMigrationReceipt;
+        migrationReceipt = await writeReceiptImpl({
+            root: home,
+            source: `doctor-${doctorProfile}`,
+            blockers: migrationScopeBlockers,
+            warnings: ['global_only_home_scope_migration_receipt'],
+            ...(migrationScopeBlockers.length ? { status: 'blocked' } : {})
+        }).catch((err) => ({
+            schema: 'sks.project-migration-receipt.v2',
+            status: 'blocked',
+            sks_version: null,
+            root: home,
+            source: `doctor-${doctorProfile}`,
+            generated_at: new Date().toISOString(),
+            blockers: [`migration_receipt_failed:${err?.message || String(err)}`],
+            warnings: []
+        }));
+    }
+    const migrationReceiptBlockers = migrationReceipt && !isUpdateMigrationReceiptCurrent(migrationReceipt)
+        ? ((migrationReceipt.blockers || []).length ? migrationReceipt.blockers : ['global_migration_receipt_not_current'])
+        : [];
+    const blockers = [...new Set([
+            ...migrationScopeBlockers,
+            ...(!menuBarReady ? (menuBar?.blockers || ['sks_menubar_repair_failed']) : []),
+            ...(bridgeReadinessRequired ? bridgeBlockers : []),
+            ...migrationReceiptBlockers
+        ].map(String).filter(Boolean))];
+    const warnings = [...new Set([
+            ...(!bridgeReadinessRequired ? bridgeBlockers.map((blocker) => `migration_optional_blocker:${blocker}`) : []),
+            ...(desktopBridgeRepair?.warnings || []),
+            ...(desktopBridge?.warnings || [])
+        ].map(String).filter(Boolean))];
     const ok = blockers.length === 0;
     const projectRootAliasDetected = path.resolve(root) === home;
     return {
@@ -257,6 +294,7 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         diagnostic_depth: 'global-only',
         global_only: true,
         install_scope: 'global',
+        doctor_profile: doctorProfile,
         root,
         home,
         project_root_alias_detected: projectRootAliasDetected,
@@ -268,20 +306,26 @@ export async function executeDoctorGlobalOnlyFix(args = [], root, deps = {}) {
             'project_supabase_mcp_repair',
             'project_hook_trust_repair',
             'project_command_alias_cleanup',
-            'project_migration_receipt'
+            ...(migrationReceipt ? [] : ['project_migration_receipt'])
         ],
         skills: { global: globalSkills, project: { skipped: true, reason: 'global_only_doctor' } },
         current_public_surface: currentSurface,
         codex_app_fast_mode: globalFastMode,
         openrouter_provider: desktopBridge.providers?.openrouter || null,
         sks_menubar: menuBar,
+        desktop_bridge_repair: desktopBridgeRepair,
         desktop_bridge: desktopBridge,
+        ...(migrationReceipt ? { migration_receipt: migrationReceipt } : {}),
         blockers,
+        warnings,
         next_actions: [
             ...(projectRootAliasDetected
                 ? ['Project checks were skipped because this directory is your home folder. Run them from your project: cd <your-project> && sks doctor --fix']
                 : []),
             ...(desktopBridge.ok === false ? desktopBridge.recovery_actions || [] : []),
+            ...(!bridgeReadinessRequired && bridgeBlockers.length
+                ? ['Desktop Bridge still reports blockers: run `sks doctor --fix` to repair the bridge catalog.']
+                : []),
             'Run `sks doctor --fix --json` from a specific project directory when project-scoped repair is required.'
         ]
     };
@@ -300,10 +344,19 @@ async function runDoctorGlobalOnlyFix(args = [], root, deps = {}) {
         printJson(result);
     }
     else {
+        const bridgeRepair = result.desktop_bridge_repair;
         console.log(`SKS Doctor global repair: ${result.ok ? 'ok' : 'blocked'}`);
         console.log(`Global skills: ${result.skills.global?.error ? 'blocked' : 'reconciled'}`);
         console.log(`SKS menu bar: ${result.sks_menubar?.status || (result.sks_menubar?.ok ? 'ok' : 'blocked')}`);
+        console.log(`Desktop Bridge repair: ${bridgeRepair?.skipped_reason
+            ? bridgeRepair.skipped_reason
+            : bridgeRepair?.repaired
+                ? 'repaired'
+                : bridgeRepair?.ok === false ? 'failed' : 'nothing_to_repair'}`);
         console.log(`Desktop Bridge: ${result.desktop_bridge.ok ? 'ready' : 'blocked'} (${result.desktop_bridge.status?.readiness?.state || 'unavailable'})`);
+        if (result.migration_receipt) {
+            console.log(`Migration receipt: ${result.migration_receipt.status} (${result.home})`);
+        }
         for (const blocker of result.blockers)
             console.log(`- blocker: ${blocker}`);
         for (const action of result.next_actions)
@@ -1027,61 +1080,7 @@ async function runDoctor(args = [], root, doctorFix, deps = {}) {
                 {
                     id: 'desktop_bridge_catalog_repair',
                     required_for_ready: false,
-                    run: async () => {
-                        const base = {
-                            id: 'desktop_bridge_catalog_repair',
-                            required_for_ready: false,
-                            manual_required: false,
-                            warnings: [],
-                            rollback_evidence: 'combined_catalog_previous_generation_preserved'
-                        };
-                        try {
-                            const bridgeHome = path.resolve(process.env.HOME || os.homedir());
-                            const restarted = await restartStaleDesktopBridgeRuntime({
-                                home: bridgeHome,
-                                fix: doctorFix,
-                            });
-                            const status = await desktopBridgeStatusV3({ home: bridgeHome, env: process.env });
-                            const blockers = (status?.readiness?.blockers || []).map(String);
-                            const stale = blockers.filter((blocker) => blocker.endsWith('_catalog_stale'));
-                            if (!status?.management?.managed || stale.length === 0) {
-                                return {
-                                    ...base,
-                                    ok: restarted.blockers.length === 0,
-                                    repaired: restarted.restarted,
-                                    warnings: restarted.warnings,
-                                    blockers: restarted.blockers
-                                };
-                            }
-                            const attempts = [];
-                            let syncedAndVerified = false;
-                            for (let attempt = 1; attempt <= CATALOG_REPAIR_MAX_ATTEMPTS; attempt += 1) {
-                                const sync = await executeDesktopBridgeCommandV3({ operation: 'catalog.sync' }, { home: bridgeHome, env: process.env });
-                                const commandOk = sync?.ok === true && sync?.execution?.ok === true;
-                                const after = await desktopBridgeStatusV3({ home: bridgeHome, env: process.env });
-                                const stillStale = (after?.readiness?.blockers || [])
-                                    .map(String).filter((blocker) => blocker.endsWith('_catalog_stale'));
-                                if (commandOk && stillStale.length === 0) {
-                                    syncedAndVerified = true;
-                                    break;
-                                }
-                                attempts.push(`catalog_sync_attempt_${attempt}:${commandOk ? `still_stale:${stillStale.join(',')}` : (sync?.execution?.blockers || ['failed']).map(String).join(',')}`);
-                            }
-                            return {
-                                ...base,
-                                ok: syncedAndVerified && restarted.blockers.length === 0,
-                                repaired: syncedAndVerified || restarted.restarted,
-                                warnings: [...restarted.warnings, ...(syncedAndVerified ? attempts : [])],
-                                blockers: [
-                                    ...(syncedAndVerified ? [] : ['desktop_bridge_catalog_still_stale_after_repair', ...attempts]),
-                                    ...restarted.blockers
-                                ]
-                            };
-                        }
-                        catch (error) {
-                            return { ...base, ok: false, repaired: false, blockers: [String(error?.message || 'desktop_bridge_catalog_sync_failed')] };
-                        }
-                    }
+                    run: async () => repairDoctorDesktopBridgeCatalog({ fix: doctorFix })
                 }
             ].filter((phase) => doctorPhaseIds.includes(phase.id))
         }).catch((err) => ({

package/dist/config/skills-manifest.json

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

package/dist/core/codex-lb/desktop-bridge/http-forward.js

@@ -273,13 +273,23 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
             upstream.once('response', (response) => {
                 const statusCode = response.statusCode || 502;
                 if (statusCode >= 400) {
-                    void readRedactedUpstreamError(response).then(({ body, upstreamCode }) => {
+                    void readRedactedUpstreamError(response).then(({ body, upstreamCode, upstreamType }) => {
+                        const transientMislabel = statusCode === 404
+                            && (upstreamType === 'upstream_error' || upstreamCode === 'upstream_error');
+                        if (transientMislabel && replayable && !useFreshConnection) {
+                            responseStarted = true;
+                            finish(new StalePooledSocketFailure(new DesktopBridgeError('bridge_upstream_transient_mislabel')));
+                            return;
+                        }
+                        const clientStatus = transientMislabel ? 503 : statusCode;
                         logHttpRejection({
-                            code: upstreamCode ? `bridge_upstream_status_${statusCode}:${upstreamCode}` : `bridge_upstream_status_${statusCode}`,
+                            code: transientMislabel
+                                ? `bridge_upstream_status_${statusCode}_translated_503`
+                                : upstreamCode ? `bridge_upstream_status_${statusCode}:${upstreamCode}` : `bridge_upstream_status_${statusCode}`,
                             transport: 'http',
                             ...(req.method === undefined ? {} : { method: req.method }),
                             ...(req.url === undefined ? {} : { url: req.url }),
-                            status: statusCode,
+                            status: clientStatus,
                             provider_id: provider.provider_id,
                             public_model: request.route.public_model,
                         });
@@ -287,7 +297,9 @@ export async function forwardHttp(req, res, config, prepared, authenticatedLocal
                         const responseHeaders = rewriteResponseHeaders(response.headers, provider.base_url, authenticatedLocalBaseUrl);
                         responseHeaders['content-length'] = String(body.length);
                         delete responseHeaders['transfer-encoding'];
-                        res.writeHead(statusCode, responseHeaders);
+                        if (transientMislabel)
+                            responseHeaders['retry-after'] = '10';
+                        res.writeHead(clientStatus, responseHeaders);
                         res.end(body, () => finish());
                     }).catch(finish);
                     return;

package/dist/core/commands/basic-cli.js

@@ -255,6 +255,11 @@ export async function updateCommand(sub = 'now', args = []) {
         console.log(`New version: ${result.new_version}`);
     if (result.project_receipt)
         console.log(`Migration receipt: ${result.project_receipt.root} (${result.migration_current ? 'current' : 'not current'})`);
+    for (const warning of (result.project_receipt?.optional_warnings || [])
+        .filter((entry) => String(entry).includes('sks doctor --fix'))
+        .slice(0, 3)) {
+        console.log(`Follow-up: ${warning}`);
+    }
     if (result.sks_menubar)
         console.log(`SKS menu bar: ${result.sks_menubar.status}${result.sks_menubar.app_path ? ` (${result.sks_menubar.app_path})` : ''}`);
     if (result.operation_receipt_path)

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

@@ -0,0 +1,102 @@
+import os from 'node:os';
+import path from 'node:path';
+import { desktopBridgeStatusV3, executeDesktopBridgeCommandV3 } from '../codex-lb/desktop-controller-v3.js';
+import { bootstrapExistingDesktopBridgeService, desktopBridgeServiceStatus } from '../codex-lb/desktop-service.js';
+import { desktopBridgeRuntimeVersion, desktopBridgeRuntimeVersionStale } from '../codex-lb/desktop-bridge/state.js';
+import { PACKAGE_VERSION } from '../version.js';
+export async function restartStaleDesktopBridgeRuntime(input) {
+    if (process.env.SKS_TEST_ISOLATION === '1' || process.env.SKS_RELEASE_UPGRADE_SMOKE === '1') {
+        return { restarted: false, warnings: [], blockers: [] };
+    }
+    const service = await desktopBridgeServiceStatus({ home: input.home }).catch(() => null);
+    if (!service?.running || !desktopBridgeRuntimeVersionStale(service.state)) {
+        return { restarted: false, warnings: [], blockers: [] };
+    }
+    const running = desktopBridgeRuntimeVersion(service.state) || 'pre-8.6.2';
+    if (!input.fix) {
+        return {
+            restarted: false,
+            warnings: [],
+            blockers: [`desktop_bridge_runtime_version_stale:${running}:${PACKAGE_VERSION}`]
+        };
+    }
+    const restarted = await bootstrapExistingDesktopBridgeService({ home: input.home }).catch(() => null);
+    const nowRunning = restarted?.running === true && !desktopBridgeRuntimeVersionStale(restarted.state);
+    return nowRunning
+        ? { restarted: true, warnings: [`desktop_bridge_runtime_restarted:${running}:${PACKAGE_VERSION}`], blockers: [] }
+        : { restarted: false, warnings: [], blockers: [`desktop_bridge_runtime_version_stale:${running}:${PACKAGE_VERSION}`] };
+}
+export const CATALOG_REPAIR_MAX_ATTEMPTS = 2;
+export async function repairDoctorDesktopBridgeCatalog(input, deps = {}) {
+    const base = {
+        id: 'desktop_bridge_catalog_repair',
+        required_for_ready: false,
+        manual_required: false,
+        warnings: [],
+        rollback_evidence: 'combined_catalog_previous_generation_preserved'
+    };
+    const usingRealImpls = !deps.restartStaleDesktopBridgeRuntimeImpl
+        && !deps.desktopBridgeStatusImpl
+        && !deps.executeDesktopBridgeCommandImpl;
+    if (usingRealImpls
+        && (process.env.NODE_TEST_CONTEXT !== undefined
+            || process.env.SKS_TEST_ISOLATION === '1'
+            || process.env.SKS_RELEASE_UPGRADE_SMOKE === '1')) {
+        return {
+            ...base,
+            ok: true,
+            repaired: false,
+            blockers: [],
+            skipped_reason: 'desktop_bridge_catalog_repair_skipped_under_tests'
+        };
+    }
+    const restartImpl = deps.restartStaleDesktopBridgeRuntimeImpl || restartStaleDesktopBridgeRuntime;
+    const statusImpl = deps.desktopBridgeStatusImpl || desktopBridgeStatusV3;
+    const executeImpl = deps.executeDesktopBridgeCommandImpl || executeDesktopBridgeCommandV3;
+    try {
+        const bridgeHome = path.resolve(process.env.HOME || os.homedir());
+        const restarted = await restartImpl({
+            home: bridgeHome,
+            fix: input.fix
+        });
+        const status = await statusImpl({ home: bridgeHome, env: process.env });
+        const blockers = (status?.readiness?.blockers || []).map(String);
+        const stale = blockers.filter((blocker) => blocker.endsWith('_catalog_stale'));
+        if (!status?.management?.managed || stale.length === 0) {
+            return {
+                ...base,
+                ok: restarted.blockers.length === 0,
+                repaired: restarted.restarted,
+                warnings: restarted.warnings,
+                blockers: restarted.blockers
+            };
+        }
+        const attempts = [];
+        let syncedAndVerified = false;
+        for (let attempt = 1; attempt <= CATALOG_REPAIR_MAX_ATTEMPTS; attempt += 1) {
+            const sync = await executeImpl({ operation: 'catalog.sync' }, { home: bridgeHome, env: process.env });
+            const commandOk = sync?.ok === true && sync?.execution?.ok === true;
+            const after = await statusImpl({ home: bridgeHome, env: process.env });
+            const stillStale = (after?.readiness?.blockers || [])
+                .map(String).filter((blocker) => blocker.endsWith('_catalog_stale'));
+            if (commandOk && stillStale.length === 0) {
+                syncedAndVerified = true;
+                break;
+            }
+            attempts.push(`catalog_sync_attempt_${attempt}:${commandOk ? `still_stale:${stillStale.join(',')}` : (sync?.execution?.blockers || ['failed']).map(String).join(',')}`);
+        }
+        return {
+            ...base,
+            ok: syncedAndVerified && restarted.blockers.length === 0,
+            repaired: syncedAndVerified || restarted.restarted,
+            warnings: [...restarted.warnings, ...(syncedAndVerified ? attempts : [])],
+            blockers: [
+                ...(syncedAndVerified ? [] : ['desktop_bridge_catalog_still_stale_after_repair', ...attempts]),
+                ...restarted.blockers
+            ]
+        };
+    }
+    catch (error) {
+        return { ...base, ok: false, repaired: false, blockers: [String(error?.message || 'desktop_bridge_catalog_sync_failed')] };
+    }
+}

package/dist/core/triwiki/context-graph/extractors/code/index.js

@@ -33,17 +33,21 @@ function sortedHashes(hashes) {
 }
 export class CodeGraphExtractor {
     preparedInventory;
+    sourceInventory;
     id = CODE_GRAPH_EXTRACTOR_ID;
     revision = CODE_GRAPH_EXTRACTOR_REVISION;
-    constructor(preparedInventory = null) {
+    constructor(preparedInventory = null, sourceInventory = null) {
         this.preparedInventory = preparedInventory;
+        this.sourceInventory = sourceInventory;
     }
     async extract(input) {
         const startedAt = Date.now();
         const deadline = startedAt + Math.max(1, input.limits.timeoutMs);
         const root = realRoot(input.root);
         const sink = new CodeGraphSink(input.limits, input.observedAt);
-        const inventory = this.preparedInventory ?? walkCodeInventory(root, input.limits);
+        const inventory = this.preparedInventory
+            ?? this.sourceInventory?.inventory(root, input.limits)
+            ?? walkCodeInventory(root, input.limits);
         for (const skip of inventory.skipped)
             sink.addSkip(skip);
         const hashes = new Map();
@@ -273,6 +277,6 @@ function collectNodeRels(factsByRel, parsedByRel, inventory, selectedRels) {
     return [...rels].sort();
 }
 export function createCodeGraphExtractor(options = {}) {
-    return new CodeGraphExtractor(options.preparedInventory ?? null);
+    return new CodeGraphExtractor(options.preparedInventory ?? null, options.sourceInventory ?? null);
 }
 export { CODE_GRAPH_EXTRACTOR_ID, CODE_GRAPH_EXTRACTOR_REVISION } from './types.js';

package/dist/core/triwiki/context-graph/extractors/evidence/index.js

@@ -2,15 +2,25 @@ import { lintWarning } from '../../contracts.js';
 import { extractContextPackEvidence } from './claims.js';
 import { extractProofEvidence } from './proofs.js';
 import { sanitizeEvidenceFragment } from './redaction.js';
+import { createSharedSourceInventory } from '../source-inventory.js';
 import { CONTEXT_PACK_REL, EVIDENCE_EXTRACTOR_ID, EVIDENCE_EXTRACTOR_REVISION, EvidenceFragmentBuilder, PROOF_BANK_REL, RiskDomainRegistry, evidenceContext, finalizeEvidenceFragment } from './shared.js';
 export { CONTEXT_PACK_REL, EVIDENCE_EXTRACTOR_ID, EVIDENCE_EXTRACTOR_REVISION, PROOF_BANK_REL, PROOF_INDEX_REL } from './shared.js';
 export { TRIWIKI_PROOF_INDEX_SCHEMA } from './proof-index.js';
 const MIN_FAN_IN_FOR_VERIFICATION_WARNING = 3;
 export class EvidenceGraphExtractor {
+    sourceInventory;
     id = EVIDENCE_EXTRACTOR_ID;
     revision = EVIDENCE_EXTRACTOR_REVISION;
+    constructor(sourceInventory = createSharedSourceInventory()) {
+        this.sourceInventory = sourceInventory;
+    }
     async extract(input) {
-        const ctx = evidenceContext({ root: input.root, observedAt: input.observedAt, limits: input.limits });
+        const ctx = evidenceContext({
+            root: input.root,
+            observedAt: input.observedAt,
+            limits: input.limits,
+            sourcePaths: this.sourceInventory.sourcePaths(input.root, input.limits)
+        });
         const builder = new EvidenceFragmentBuilder(input.limits, input.observedAt);
         const risks = new RiskDomainRegistry();
         const pack = extractContextPackEvidence(builder, ctx, risks);
@@ -26,8 +36,8 @@ export class EvidenceGraphExtractor {
         return finalizeEvidenceFragment(sanitizeEvidenceFragment(builder.fragment));
     }
 }
-export function createEvidenceGraphExtractor() {
-    return new EvidenceGraphExtractor();
+export function createEvidenceGraphExtractor(options = {}) {
+    return new EvidenceGraphExtractor(options.sourceInventory ?? createSharedSourceInventory());
 }
 function noteUnverifiedFanIn(builder) {
     const incoming = new Map();

package/dist/core/triwiki/context-graph/extractors/evidence/proof-index.js

@@ -3,7 +3,7 @@ import { sha256 } from '../../../../fsx.js';
 import { resolveInsideWorkspace, tryNormalizeGraphPath } from '../../paths.js';
 import { PROOF_BANK_REL, PROOF_INDEX_REL, asArray, asRecord, asString, asStringList, readWorkspaceFile, statWorkspaceEntry } from './shared.js';
 export const TRIWIKI_PROOF_INDEX_SCHEMA = 'sks.triwiki-proof-index.v1';
-const MAX_PROOF_RECORDS = 512;
+const MAX_PROOF_RECORDS = 4096;
 const MAX_SCAN_DEPTH = 4;
 const SCAN_EXCLUDED_DIRS = new Set(['.locks', 'node_modules', '.git']);
 export function discoverProofRecords(ctx) {

package/dist/core/triwiki/context-graph/extractors/evidence/proofs.js

@@ -7,10 +7,6 @@ import { EvidenceFragmentBuilder, PROOF_BANK_REL, RiskDomainRegistry, asRecord,
 import { discoverProofRecords } from './proof-index.js';
 const MAX_DERIVED_INPUTS = 12;
 const PLACEHOLDER_HASHES = new Set(['', 'unknown', 'legacy-missing', 'none', 'null']);
-const HASH_PINNED_INPUTS = [
-    { field: 'package_lock_hash', rel: 'package-lock.json' },
-    { field: 'release_gates_hash', rel: 'release-gates.v2.json' }
-];
 export function extractProofEvidence(builder, ctx, risks) {
     const discovery = discoverProofRecords(ctx);
     for (const skip of discovery.skipped)
@@ -220,15 +216,7 @@ function linkSubject(builder, record, health, proofNodeId, mode) {
 }
 function linkDerivedInputs(builder, ctx, record, proofNodeId) {
     const raw = record.card;
-    const candidates = [];
-    if (raw) {
-        for (const pinned of HASH_PINNED_INPUTS) {
-            const hash = asString(raw[pinned.field]);
-            if (hash && !PLACEHOLDER_HASHES.has(hash))
-                candidates.push(pinned.rel);
-        }
-        candidates.push(...asStringList(raw.input_paths), ...asStringList(raw.source_paths));
-    }
+    const candidates = raw ? [...asStringList(raw.input_paths), ...asStringList(raw.source_paths)] : [];
     const seen = new Set();
     for (const candidate of candidates) {
         if (seen.size >= MAX_DERIVED_INPUTS)
@@ -236,6 +224,8 @@ function linkDerivedInputs(builder, ctx, record, proofNodeId) {
         const rel = tryNormalizeGraphPath(ctx.root, candidate);
         if (!rel || seen.has(rel))
             continue;
+        if (!ctx.sourcePaths.has(rel))
+            continue;
         const stat = statWorkspaceEntry(ctx.root, rel);
         if (!stat || !stat.isFile())
             continue;

package/dist/core/triwiki/context-graph/extractors/evidence/redaction.js

@@ -1,5 +1,6 @@
 import { REDACTION_MARKER, containsPlaintextSecret, redactString } from '../../../../secret-redaction.js';
 import { lintError } from '../../contracts.js';
+import { isStructuralValue } from '../../lint/rules.js';
 import { isWorkspaceRelativePosixPath } from '../../paths.js';
 export const EVIDENCE_REDACTED_PATH = '[redacted-path]';
 export const EVIDENCE_MAX_META_STRING = 160;
@@ -134,8 +135,11 @@ function sanitizeMetadataValue(value) {
     }
     return { value, changed: false };
 }
+function identityLooksSecret(value) {
+    return !isStructuralValue(value) && containsPlaintextSecret(value);
+}
 function guardNode(node, extractor) {
-    if (containsPlaintextSecret(node.id) || containsPlaintextSecret(node.label)) {
+    if (identityLooksSecret(node.id) || identityLooksSecret(node.label)) {
         return {
             node: null,
             issue: lintError('secret_like_value', 'evidence node identity looks secret-like and was refused', {
@@ -144,7 +148,7 @@ function guardNode(node, extractor) {
             })
         };
     }
-    if (node.path !== undefined && containsPlaintextSecret(node.path)) {
+    if (node.path !== undefined && identityLooksSecret(node.path)) {
         return {
             node: null,
             issue: lintError('secret_like_value', 'evidence node path looks secret-like and was refused', {

package/dist/core/triwiki/context-graph/extractors/evidence/sources.js

@@ -95,8 +95,9 @@ export class EvidenceSourceGraph {
             tokenCost: tokenEstimate(rel.length, 64),
             metadata
         }, CONTEXT_PACK_REL);
-        if (!isDirectory && (diskHash || manifestHash))
+        if (!isDirectory && (diskHash || manifestHash) && this.ctx.sourcePaths.has(rel)) {
             this.linkBackingFile(id, rel, stat, diskHash, manifestHash);
+        }
         const state = { id, freshness };
         this.states.set(rel, state);
         return state;

package/dist/core/triwiki/context-graph/extractors/index.js

@@ -1,14 +1,25 @@
 import { createCodeGraphExtractor } from './code/index.js';
 import { createEvidenceGraphExtractor } from './evidence/index.js';
+import { createSharedSourceInventory } from './source-inventory.js';
 import { createTopologyGraphExtractor } from './topology/index.js';
 export function contextGraphExtractors() {
-    return [createCodeGraphExtractor(), createTopologyGraphExtractor(), createEvidenceGraphExtractor()];
+    const sourceInventory = createSharedSourceInventory();
+    return [
+        createCodeGraphExtractor({ sourceInventory }),
+        createTopologyGraphExtractor({ sourceInventory }),
+        createEvidenceGraphExtractor({ sourceInventory })
+    ];
 }
 export function codeNavigationGraphExtractors(options = {}) {
     return [createCodeGraphExtractor(options)];
 }
 export function architectureMapGraphExtractors(options = {}) {
-    return [createCodeGraphExtractor(options), createTopologyGraphExtractor(), createEvidenceGraphExtractor()];
+    const sourceInventory = createSharedSourceInventory(options.preparedInventory ?? null);
+    return [
+        createCodeGraphExtractor({ sourceInventory }),
+        createTopologyGraphExtractor({ sourceInventory }),
+        createEvidenceGraphExtractor({ sourceInventory })
+    ];
 }
 export const ARCHITECTURE_MAP_EXTRACTOR_IDS = Object.freeze(['code', 'topology', 'triwiki-evidence']);
 export { createCodeGraphExtractor, createEvidenceGraphExtractor, createTopologyGraphExtractor };

package/dist/core/triwiki/context-graph/extractors/source-inventory.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { walkCodeInventory } from './code/inventory.js';
+function canonicalRoot(root) {
+    const absolute = path.resolve(root);
+    try {
+        return fs.realpathSync(absolute);
+    }
+    catch {
+        return absolute;
+    }
+}
+export function createSharedSourceInventory(prepared = null) {
+    let cachedRoot = null;
+    let cachedInventory = prepared;
+    let cachedSet = null;
+    const inventory = (root, limits) => {
+        if (prepared)
+            return prepared;
+        const canonical = canonicalRoot(root);
+        if (!cachedInventory || cachedRoot !== canonical) {
+            cachedInventory = walkCodeInventory(canonical, limits);
+            cachedRoot = canonical;
+        }
+        return cachedInventory;
+    };
+    const sourcePaths = (root, limits) => {
+        const current = inventory(root, limits);
+        if (!cachedSet || cachedSet.inventory !== current) {
+            cachedSet = { inventory: current, set: new Set(current.files.map((file) => file.rel)) };
+        }
+        return cachedSet.set;
+    };
+    return { inventory, sourcePaths };
+}

package/dist/core/triwiki/context-graph/extractors/topology/gate-edges.js

@@ -50,22 +50,26 @@ export function buildGateVerificationEdges(ctx, gates) {
     const verified = new Set();
     for (const gate of gates) {
         let emitted = 0;
+        let capped = false;
         for (const candidate of gateCheckCandidates(gate.command)) {
-            if (emitted >= TOPOLOGY_GATE_VERIFIED_CAP)
-                break;
             const expansion = expandGlob(ctx.files, candidate, TOPOLOGY_GLOB_MATCH_CAP);
-            if (expansion.capped) {
-                recordSkip(ctx, gate.manifestPath, 'cap_reached', `check pattern ${candidate} matched ${expansion.total} files`);
+            if (!expansion.total) {
+                recordSkip(ctx, gate.manifestPath, 'excluded', `check implementation ${candidate} is not in this workspace`);
                 continue;
             }
-            if (!expansion.matches.length) {
-                recordSkip(ctx, gate.manifestPath, 'excluded', `check implementation ${candidate} is not in this workspace`);
+            verified.add(gate.id);
+            if (expansion.capped) {
+                recordSkip(ctx, gate.manifestPath, 'excluded', `check pattern ${candidate} matched ${expansion.total} files; kept whole as checkScripts metadata on the gate node`);
                 continue;
             }
             const confidence = isGlobPattern(candidate) ? 'derived' : 'manifest';
             for (const match of expansion.matches) {
-                if (emitted >= TOPOLOGY_GATE_VERIFIED_CAP)
+                if (!ctx.sourcePaths.has(match))
+                    continue;
+                if (emitted >= TOPOLOGY_GATE_VERIFIED_CAP) {
+                    capped = true;
                     break;
+                }
                 const fileId = ensureFileNode(ctx, match, 'gate_check', gate.manifestPath);
                 if (!fileId)
                     continue;
@@ -78,11 +82,14 @@ export function buildGateVerificationEdges(ctx, gates) {
                     hash: gate.manifestHash,
                     line: gate.line
                 });
-                if (added) {
+                if (added)
                     emitted += 1;
-                    verified.add(gate.id);
-                }
             }
+            if (capped)
+                break;
+        }
+        if (capped) {
+            recordSkip(ctx, gate.manifestPath, 'cap_reached', `gate ${gate.id} hit the verified_by edge cap (${TOPOLOGY_GATE_VERIFIED_CAP}); check relations are missing`);
         }
     }
     return verified;
@@ -91,21 +98,26 @@ export function buildGateAffectedEdges(ctx, gates) {
     const affected = new Set();
     for (const gate of gates) {
         let emitted = 0;
+        let capped = false;
         const seen = new Set();
         for (const input of gate.cacheInputs) {
-            if (emitted >= TOPOLOGY_GATE_AFFECTED_CAP)
-                break;
             const expansion = expandGlob(ctx.files, input, TOPOLOGY_GLOB_MATCH_CAP);
+            if (expansion.total > 0)
+                affected.add(gate.id);
             if (expansion.capped) {
-                recordSkip(ctx, gate.manifestPath, 'cap_reached', `cache input ${input} matched ${expansion.total} files`);
+                recordSkip(ctx, gate.manifestPath, 'excluded', `cache input ${input} matched ${expansion.total} files; kept whole as cacheInputs metadata on the gate node`);
                 continue;
             }
             for (const match of expansion.matches) {
-                if (emitted >= TOPOLOGY_GATE_AFFECTED_CAP)
-                    break;
                 if (seen.has(match))
                     continue;
                 seen.add(match);
+                if (!ctx.sourcePaths.has(match))
+                    continue;
+                if (emitted >= TOPOLOGY_GATE_AFFECTED_CAP) {
+                    capped = true;
+                    break;
+                }
                 const fileId = ensureFileNode(ctx, match, 'gate_cache_input', gate.manifestPath);
                 if (!fileId)
                     continue;
@@ -118,11 +130,14 @@ export function buildGateAffectedEdges(ctx, gates) {
                     hash: gate.manifestHash,
                     line: gate.line
                 });
-                if (added) {
+                if (added)
                     emitted += 1;
-                    affected.add(gate.id);
-                }
             }
+            if (capped)
+                break;
+        }
+        if (capped) {
+            recordSkip(ctx, gate.manifestPath, 'cap_reached', `gate ${gate.id} hit the affected_by edge cap (${TOPOLOGY_GATE_AFFECTED_CAP}); cache-input relations are missing`);
         }
     }
     return affected;

package/dist/core/triwiki/context-graph/extractors/topology/index.js

@@ -4,6 +4,7 @@ import { buildCommandGraph, collectRuntimeManifest } from './commands.js';
 import { buildGateAffectedEdges, buildGateDependencyEdges, buildGatePresetPipelines, buildGateVerificationEdges, reportUnbackedProtectedGates } from './gate-edges.js';
 import { buildGateNodes, collectTopologyGates } from './gates.js';
 import { buildFileInventory } from './globs.js';
+import { createSharedSourceInventory } from '../source-inventory.js';
 import { buildRouteGraph } from './routes.js';
 import { TOPOLOGY_EXTRACTOR_ID, TOPOLOGY_EXTRACTOR_REVISION, createTopologyContext, recordSkip, topologyExpired } from './shared.js';
 const INVENTORY_SKIP_PATH = 'release-gates.v2.json';
@@ -45,8 +46,12 @@ function finalize(ctx) {
     return fragment;
 }
 export class TopologyGraphExtractor {
+    sourceInventory;
     id = TOPOLOGY_EXTRACTOR_ID;
     revision = TOPOLOGY_EXTRACTOR_REVISION;
+    constructor(sourceInventory = createSharedSourceInventory()) {
+        this.sourceInventory = sourceInventory;
+    }
     async extract(input) {
         const startedAt = Date.now();
         const files = buildFileInventory(input.root, input.limits.maxFiles);
@@ -55,6 +60,7 @@ export class TopologyGraphExtractor {
             observedAt: input.observedAt,
             limits: input.limits,
             files,
+            sourcePaths: this.sourceInventory.sourcePaths(input.root, input.limits),
             startedAt
         });
         if (files.truncated) {
@@ -83,8 +89,8 @@ export class TopologyGraphExtractor {
         return finalize(ctx);
     }
 }
-export function createTopologyGraphExtractor() {
-    return new TopologyGraphExtractor();
+export function createTopologyGraphExtractor(options = {}) {
+    return new TopologyGraphExtractor(options.sourceInventory ?? createSharedSourceInventory());
 }
 export { TOPOLOGY_EXTRACTOR_ID, TOPOLOGY_EXTRACTOR_REVISION } from './shared.js';
 export { TOPOLOGY_GATE_MANIFESTS } from './gates.js';

package/dist/core/triwiki/context-graph/extractors/topology/shared.js

@@ -4,10 +4,10 @@ import { lintError } from '../../contracts.js';
 import { contextGraphEdgeId, contextGraphNodeId } from '../../ids.js';
 import { ContextGraphPathError, isWorkspaceRelativePosixPath, resolveInsideWorkspace } from '../../paths.js';
 export const TOPOLOGY_EXTRACTOR_ID = 'topology';
-export const TOPOLOGY_EXTRACTOR_REVISION = '1.0.0';
+export const TOPOLOGY_EXTRACTOR_REVISION = '1.1.0';
 export const TOPOLOGY_GLOB_MATCH_CAP = 48;
-export const TOPOLOGY_GATE_AFFECTED_CAP = 96;
-export const TOPOLOGY_GATE_VERIFIED_CAP = 24;
+export const TOPOLOGY_GATE_AFFECTED_CAP = 256;
+export const TOPOLOGY_GATE_VERIFIED_CAP = 96;
 export function createTopologyContext(params) {
     const timeout = Number.isFinite(params.limits.timeoutMs) && params.limits.timeoutMs > 0 ? params.limits.timeoutMs : 0;
     return {
@@ -16,6 +16,7 @@ export function createTopologyContext(params) {
         limits: params.limits,
         deadline: params.startedAt + timeout,
         files: params.files,
+        sourcePaths: params.sourcePaths,
         nodes: new Map(),
         edges: new Map(),
         issues: [],
@@ -114,6 +115,8 @@ export function addEdge(ctx, input) {
 export function ensureFileNode(ctx, relativePath, role, sourcePath) {
     if (!isWorkspaceRelativePosixPath(relativePath))
         return null;
+    if (!ctx.sourcePaths.has(relativePath))
+        return null;
     const id = contextGraphNodeId({ kind: 'file', path: relativePath });
     const classification = ctx.fileClassification.get(relativePath);
     const metadata = {

package/dist/core/triwiki/context-graph/lint/rules.js

@@ -82,7 +82,7 @@ function looksHighEntropy(token) {
         return true;
     return /[A-Z]/.test(token) && /[a-z]/.test(token) && /[0-9]/.test(token);
 }
-function isStructuralValue(value) {
+export function isStructuralValue(value) {
     if (value.length > 512)
         return false;
     for (const run of value.match(HIGH_ENTROPY_RUN_RE) ?? []) {

package/dist/core/update/update-migration-state/current-public-surface-stage.js

@@ -0,0 +1,67 @@
+import os from 'node:os';
+import path from 'node:path';
+export async function runCurrentPublicSurfaceReconcileStage(root) {
+    const [{ runDoctorCommandAliasCleanup }, { migrateSksProfilesToPerFile }, { cleanupRetiredRemoteBridgeLaunchAgent, quarantineRetiredRemoteBridgeBindings }] = await Promise.all([
+        import('../../doctor/command-alias-cleanup.js'),
+        import('../../auto-review.js'),
+        import('../../codex-app/menubar/migration.js')
+    ]);
+    const home = path.resolve(process.env.HOME || os.homedir());
+    const globalRuntimeRoot = path.resolve(process.env.SKS_GLOBAL_ROOT || path.join(home, '.sneakoscope-global'));
+    const publicSurface = await runDoctorCommandAliasCleanup({
+        root,
+        home,
+        globalRuntimeRoot,
+        fix: true,
+        managedGenerationAlreadyConverged: true
+    });
+    const profileMigration = await migrateSksProfilesToPerFile({ env: process.env }).catch((err) => ({
+        error: err?.message || String(err),
+        retired_profile_table_count: 0,
+        retired_profile_file_removed_count: 0
+    }));
+    const retiredLaunchAgent = await cleanupRetiredRemoteBridgeLaunchAgent({ home, env: process.env });
+    const retiredBindings = await quarantineRetiredRemoteBridgeBindings(root);
+    const remainingCount = Number(publicSurface.cleanup?.remaining_count || 0)
+        + Number(publicSurface.cleanup?.managed_runtime?.remaining_managed_artifact_count || 0)
+        + Number(publicSurface.cleanup?.project_guidance?.remaining_count || 0);
+    const blockers = [
+        ...(publicSurface.ok === true ? [] : ['public_surface_reconcile_failed']),
+        ...(retiredLaunchAgent.ok ? [] : retiredLaunchAgent.blockers),
+        ...(retiredBindings.ok ? [] : retiredBindings.blockers),
+        ...(profileMigration.error ? [`retired_profile_migration_failed:${profileMigration.error}`] : []),
+        ...(remainingCount > 0 ? [`public_surface_remaining:${remainingCount}`] : [])
+    ];
+    return {
+        ok: blockers.length === 0,
+        status: blockers.length ? 'failed' : 'ok',
+        actions: [
+            'reconciled_current_public_surface',
+            ...(retiredLaunchAgent.status === 'removed' ? ['retired_remote_bridge_launch_agent_removed'] : []),
+            ...(retiredBindings.status === 'quarantined' ? ['retired_remote_bridge_bindings_quarantined'] : [])
+        ],
+        blockers,
+        warnings: [
+            ...(publicSurface.warnings || []),
+            ...retiredLaunchAgent.warnings,
+            ...retiredBindings.warnings
+        ],
+        detail: {
+            removed_skill_count: Number(publicSurface.cleanup?.removed_count || 0),
+            quarantined_skill_collision_count: Number(publicSurface.cleanup?.preserved_user_collision_count || 0),
+            removed_runtime_artifact_count: Number(publicSurface.cleanup?.managed_runtime?.removed_managed_artifact_count || 0),
+            quarantined_runtime_collision_count: Number(publicSurface.cleanup?.managed_runtime?.preserved_user_file_count || 0),
+            reconciled_guidance_count: Number(publicSurface.cleanup?.project_guidance?.reconciled_count || 0),
+            quarantined_guidance_collision_count: Number(publicSurface.cleanup?.project_guidance?.preserved_user_file_count || 0),
+            removed_retired_role_count: 0,
+            quarantined_retired_role_collision_count: 0,
+            retired_profile_table_count: Number(profileMigration.retired_profile_table_count || 0),
+            retired_profile_file_removed_count: Number(profileMigration.retired_profile_file_removed_count || 0),
+            retired_remote_bridge_launch_agent_status: retiredLaunchAgent.status,
+            retired_remote_bridge_binding_status: retiredBindings.status,
+            retired_remote_bridge_binding_count: retiredBindings.retired_binding_count,
+            retired_remote_bridge_binding_quarantine_path: retiredBindings.quarantine_path,
+            remaining_count: remainingCount
+        }
+    };
+}

package/dist/core/update/update-migration-state/desktop-bridge-catalog-repair-stage.js

@@ -0,0 +1,45 @@
+import os from 'node:os';
+import path from 'node:path';
+import { exists } from '../../fsx.js';
+import { desktopBridgeServicePaths } from '../../codex-lb/desktop-service.js';
+import { repairDoctorDesktopBridgeCatalog } from '../../doctor/desktop-bridge-catalog-repair.js';
+export async function runDesktopBridgeCatalogRepairStage() {
+    const skip = (reason) => ({ ok: true, status: 'ok', actions: [reason], blockers: [], warnings: [] });
+    if (process.platform !== 'darwin')
+        return skip('desktop_bridge_catalog_repair_not_macos');
+    if (process.env.NODE_TEST_CONTEXT !== undefined)
+        return skip('desktop_bridge_catalog_repair_skipped_under_tests');
+    if (process.env.SKS_TEST_ISOLATION === '1')
+        return skip('desktop_bridge_catalog_repair_skipped_under_tests');
+    if (process.env.SKS_SKIP_BRIDGE_CATALOG_REPAIR === '1')
+        return skip('desktop_bridge_catalog_repair_disabled');
+    const home = path.resolve(process.env.HOME || os.homedir());
+    if (!(await exists(desktopBridgeServicePaths(home).settings_path))) {
+        return skip('desktop_bridge_catalog_repair_no_managed_bridge');
+    }
+    const repair = await repairDoctorDesktopBridgeCatalog({ fix: true }).catch((error) => ({
+        ok: false,
+        repaired: false,
+        warnings: [],
+        blockers: [`desktop_bridge_catalog_repair_failed:${error?.message || String(error)}`]
+    }));
+    if (repair.ok) {
+        return {
+            ok: true,
+            status: 'ok',
+            actions: [repair.repaired ? 'desktop_bridge_catalog_repaired' : 'desktop_bridge_catalog_clean'],
+            blockers: [],
+            warnings: repair.warnings || []
+        };
+    }
+    return {
+        ok: true,
+        status: 'ok',
+        actions: [],
+        blockers: [],
+        warnings: [
+            ...(repair.blockers || []).map((blocker) => `desktop_bridge_catalog_repair_incomplete:${blocker}`),
+            'Desktop Bridge catalog still needs repair: run `sks doctor --fix`'
+        ]
+    };
+}

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

@@ -10,6 +10,8 @@ import { enforceRetention } from '../retention.js';
 import { COMMANDS } from '../../cli/command-registry.js';
 import { reconcileLegacyManagedGeneration } from '../init/legacy-generation-convergence.js';
 import { runConfigFastModeNormalizeStage } from './update-migration-state/fast-mode-config.js';
+import { runCurrentPublicSurfaceReconcileStage } from './update-migration-state/current-public-surface-stage.js';
+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 { runHookTrustRefreshStage, runOtherHarnessCleanupStage } from './update-migration-state/simple-stages.js';
@@ -264,73 +266,13 @@ const UPDATE_MIGRATION_STAGES = [
         id: 'desktop-bridge-restage',
         min_from_version: '0.0.0',
         run: runDesktopBridgeRestageStage
+    },
+    {
+        id: 'desktop-bridge-catalog-repair',
+        min_from_version: '0.0.0',
+        run: runDesktopBridgeCatalogRepairStage
     }
 ];
-async function runCurrentPublicSurfaceReconcileStage(root) {
-    const [{ runDoctorCommandAliasCleanup }, { migrateSksProfilesToPerFile }, { cleanupRetiredRemoteBridgeLaunchAgent, quarantineRetiredRemoteBridgeBindings }] = await Promise.all([
-        import('../doctor/command-alias-cleanup.js'),
-        import('../auto-review.js'),
-        import('../codex-app/menubar/migration.js')
-    ]);
-    const home = path.resolve(process.env.HOME || os.homedir());
-    const globalRuntimeRoot = path.resolve(process.env.SKS_GLOBAL_ROOT || path.join(home, '.sneakoscope-global'));
-    const publicSurface = await runDoctorCommandAliasCleanup({
-        root,
-        home,
-        globalRuntimeRoot,
-        fix: true,
-        managedGenerationAlreadyConverged: true
-    });
-    const profileMigration = await migrateSksProfilesToPerFile({ env: process.env }).catch((err) => ({
-        error: err?.message || String(err),
-        retired_profile_table_count: 0,
-        retired_profile_file_removed_count: 0
-    }));
-    const retiredLaunchAgent = await cleanupRetiredRemoteBridgeLaunchAgent({ home, env: process.env });
-    const retiredBindings = await quarantineRetiredRemoteBridgeBindings(root);
-    const remainingCount = Number(publicSurface.cleanup?.remaining_count || 0)
-        + Number(publicSurface.cleanup?.managed_runtime?.remaining_managed_artifact_count || 0)
-        + Number(publicSurface.cleanup?.project_guidance?.remaining_count || 0);
-    const blockers = [
-        ...(publicSurface.ok === true ? [] : ['public_surface_reconcile_failed']),
-        ...(retiredLaunchAgent.ok ? [] : retiredLaunchAgent.blockers),
-        ...(retiredBindings.ok ? [] : retiredBindings.blockers),
-        ...(profileMigration.error ? [`retired_profile_migration_failed:${profileMigration.error}`] : []),
-        ...(remainingCount > 0 ? [`public_surface_remaining:${remainingCount}`] : [])
-    ];
-    return {
-        ok: blockers.length === 0,
-        status: blockers.length ? 'failed' : 'ok',
-        actions: [
-            'reconciled_current_public_surface',
-            ...(retiredLaunchAgent.status === 'removed' ? ['retired_remote_bridge_launch_agent_removed'] : []),
-            ...(retiredBindings.status === 'quarantined' ? ['retired_remote_bridge_bindings_quarantined'] : [])
-        ],
-        blockers,
-        warnings: [
-            ...(publicSurface.warnings || []),
-            ...retiredLaunchAgent.warnings,
-            ...retiredBindings.warnings
-        ],
-        detail: {
-            removed_skill_count: Number(publicSurface.cleanup?.removed_count || 0),
-            quarantined_skill_collision_count: Number(publicSurface.cleanup?.preserved_user_collision_count || 0),
-            removed_runtime_artifact_count: Number(publicSurface.cleanup?.managed_runtime?.removed_managed_artifact_count || 0),
-            quarantined_runtime_collision_count: Number(publicSurface.cleanup?.managed_runtime?.preserved_user_file_count || 0),
-            reconciled_guidance_count: Number(publicSurface.cleanup?.project_guidance?.reconciled_count || 0),
-            quarantined_guidance_collision_count: Number(publicSurface.cleanup?.project_guidance?.preserved_user_file_count || 0),
-            removed_retired_role_count: 0,
-            quarantined_retired_role_collision_count: 0,
-            retired_profile_table_count: Number(profileMigration.retired_profile_table_count || 0),
-            retired_profile_file_removed_count: Number(profileMigration.retired_profile_file_removed_count || 0),
-            retired_remote_bridge_launch_agent_status: retiredLaunchAgent.status,
-            retired_remote_bridge_binding_status: retiredBindings.status,
-            retired_remote_bridge_binding_count: retiredBindings.retired_binding_count,
-            retired_remote_bridge_binding_quarantine_path: retiredBindings.quarantine_path,
-            remaining_count: remainingCount
-        }
-    };
-}
 export async function runUpdateMigrationStages(root, opts = {}) {
     const fromVersion = opts.fromVersion || null;
     const runs = [];

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '9.0.3';
+export const PACKAGE_VERSION = '9.0.6';

package/package.json

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