sneakoscope 8.3.2 → 8.4.0

package/dist/core/codex-lb/desktop-controller-v3/catalog.js

@@ -1,4 +1,6 @@
-import { readText } from '../../fsx.js';
+import { readText, writeJsonAtomic } from '../../fsx.js';
+import { readTopLevelTomlString } from '../../codex-app/codex-model-catalog.js';
+import { BRIDGE_MODEL_SELECTION_SCHEMA, MAX_SELECTED_OPENROUTER_MODELS, bridgeAvailableModelsPath, pruneSelection, readBridgeModelSelectionState, writeBridgeModelSelection } from '../combined-catalog/model-selection.js';
 import { listOpenRouterModels } from '../../providers/openrouter/openrouter-account.js';
 import { buildCombinedBridgeCatalog, readActiveCombinedBridgeCatalog, stageCombinedBridgeCatalog } from '../combined-catalog.js';
 import { codexLbEnvPath, codexLbMetadataPath, loadCodexLbEnv, readCodexLbModelCatalog } from '../codex-lb-env.js';
@@ -40,7 +42,21 @@ export async function syncCatalogInternal(options) {
     const catalogs = await fetchProviderCatalogs(initialRegistry, rawCredentials, paths, options);
     const credentials = await resolveValidatedCredentials(options, paths);
     const registry = await resolveBridgeProviderRegistry({ home: paths.home, credentials, storedRegistry });
-    const build = buildCombinedBridgeCatalog(registry, { catalogs, created_at: nowIso(options) });
+    const selectionState = await readBridgeModelSelectionState(paths.home, nowIso(options));
+    const selection = selectionState.stored
+        ? selectionState.selection
+        : seedSelectionFromConfiguredModel(selectionState.selection, await readText(paths.configPath, ''));
+    const build = buildCombinedBridgeCatalog(registry, { catalogs, created_at: nowIso(options), selection });
+    if (!selectionState.stored)
+        await writeBridgeModelSelection(paths.home, selection).catch(() => undefined);
+    await writeJsonAtomic(bridgeAvailableModelsPath(paths.home), {
+        schema: 'sks.bridge-available-models.v1',
+        updated_at: nowIso(options),
+        openrouter: build.available_openrouter_models
+    }, { mode: 0o600 }).catch(() => undefined);
+    const pruned = pruneSelection(selection, build.available_openrouter_models);
+    if (pruned !== selection)
+        await writeBridgeModelSelection(paths.home, pruned).catch(() => undefined);
     const staging = await stageCombinedBridgeCatalog({
         build,
         catalogPath: paths.catalogPath,
@@ -200,11 +216,12 @@ async function fetchProviderCatalogs(registry, credentials, paths, options) {
                 home: paths.home,
                 validationPath: paths.validationPath
             });
+            const codexLbModels = result.model_rows.length > 0 ? result.model_rows : result.models;
             return [providerId, {
                     provider_id: providerId,
                     state: result.ok ? 'verified' : 'failed',
-                    generation: result.ok ? sha256Stable({ provider_id: providerId, models: result.models }) : null,
-                    models: { models: result.models },
+                    generation: result.ok ? sha256Stable({ provider_id: providerId, models: codexLbModels }) : null,
+                    models: { models: codexLbModels },
                     checked_at: checkedAt,
                     expires_at: expiresAt,
                     blockers: result.blockers,
@@ -255,3 +272,57 @@ function validationFailureState(blockers) {
     return blockers.some((blocker) => /(?:401|403|auth|rejected|invalid_key|unauthorized)/i.test(blocker))
         ? 'rejected' : 'unavailable';
 }
+export async function listSelectableModels(options) {
+    const paths = controllerPaths(options);
+    const selection = (await readBridgeModelSelectionState(paths.home, nowIso(options))).selection;
+    const available = await readText(bridgeAvailableModelsPath(paths.home), '');
+    let rows = [];
+    try {
+        const parsed = available ? JSON.parse(available) : null;
+        if (parsed && Array.isArray(parsed.openrouter))
+            rows = parsed.openrouter;
+    }
+    catch {
+        rows = [];
+    }
+    const selected = new Set(selection.openrouter.public_ids);
+    const status = await desktopBridgeStatusV3(options);
+    return commandResult('models.list', true, status, {
+        codex_lb_exposure: 'all',
+        openrouter: {
+            mode: 'selected',
+            selected_count: selection.openrouter.public_ids.length,
+            max_selected: MAX_SELECTED_OPENROUTER_MODELS,
+            available_count: rows.length,
+            models: rows.map((row) => ({
+                public_id: String(row?.public_id || ''),
+                display_name: String(row?.display_name || row?.public_id || ''),
+                selected: selected.has(String(row?.public_id || ''))
+            })).filter((row) => row.public_id)
+        }
+    }, rows.length === 0 ? ['bridge_available_models_unknown'] : [], options);
+}
+export async function selectExposedModels(publicIds, options) {
+    const paths = controllerPaths(options);
+    const requested = [...new Set(publicIds.map((id) => String(id || '').trim()).filter(Boolean))].sort();
+    if (requested.length > MAX_SELECTED_OPENROUTER_MODELS) {
+        throw new Error('bridge_model_selection_limit_exceeded');
+    }
+    await writeBridgeModelSelection(paths.home, {
+        schema: BRIDGE_MODEL_SELECTION_SCHEMA,
+        updated_at: nowIso(options),
+        openrouter: { mode: 'selected', public_ids: requested }
+    });
+    const sync = await syncCatalogInternal(options);
+    const status = await desktopBridgeStatusV3(options);
+    const activation = sync.activation && typeof sync.activation === 'object'
+        ? sync.activation
+        : {};
+    return commandResult('models.select', sync.ok === true, status, { selected_count: requested.length, catalog_sync: sync }, sync.ok === true ? [] : stringArray(activation.blockers), options);
+}
+function seedSelectionFromConfiguredModel(selection, configText) {
+    const configured = readTopLevelTomlString(configText, 'model');
+    if (!configured || !configured.includes('/'))
+        return selection;
+    return { ...selection, openrouter: { mode: 'selected', public_ids: [configured] } };
+}

package/dist/core/codex-lb/desktop-controller-v3.js

@@ -1,4 +1,4 @@
-import { syncCatalog } from './desktop-controller-v3/catalog.js';
+import { listSelectableModels, selectExposedModels, syncCatalog } from './desktop-controller-v3/catalog.js';
 import { explainRoute, ensureDesktopBridge, repairDesktopBridge, rollbackDesktopBridge, setDefaultProvider, unmanageDesktopBridge } from './desktop-controller-v3/lifecycle-commands.js';
 import { configureProvider, removeCredential, setProviderState, validateProvider } from './desktop-controller-v3/provider-commands.js';
 import { commandResult, safeCode } from './desktop-controller-v3/shared.js';
@@ -40,6 +40,10 @@ export async function executeDesktopBridgeCommandV3(request, options = {}) {
             if (request.operation === 'provider.remove-credential') {
                 return removeCredential(request.provider_id, options);
             }
+            if (request.operation === 'models.list')
+                return listSelectableModels(options);
+            if (request.operation === 'models.select')
+                return selectExposedModels(request.public_ids, options);
             if (request.operation === 'catalog.sync')
                 return syncCatalog(options);
             if (request.operation === 'catalog.status') {

package/dist/core/commands/triwiki-atlas-command.js

@@ -0,0 +1,372 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { flag, readOption } from '../../cli/args.js';
+import { ARCHITECTURE_MAP_MANIFEST_SCHEMA, ARCHITECTURE_MAP_VIEW_IDS, GLOBAL_ARCHITECTURE_MAP_VIEW_IDS } from '../triwiki/context-graph/architecture/contracts.js';
+import { ARCHITECTURE_MAP_DIR_REL } from '../triwiki/context-graph/store/architecture-map-store.js';
+export const TRIWIKI_ATLAS_SUBCOMMANDS = [
+    'atlas-status',
+    'atlas-lint',
+    'atlas-list',
+    'atlas-show',
+    'atlas-why'
+];
+const REPAIR_COMMAND = 'sks align run';
+const VIEW_ID_SET = new Set(ARCHITECTURE_MAP_VIEW_IDS);
+const GLOBAL_VIEW_ID_SET = new Set(GLOBAL_ARCHITECTURE_MAP_VIEW_IDS);
+export function isTriWikiAtlasSubcommand(value) {
+    return typeof value === 'string' && TRIWIKI_ATLAS_SUBCOMMANDS.includes(value);
+}
+function mapRoot(root) {
+    return path.join(root, ...ARCHITECTURE_MAP_DIR_REL.split('/'));
+}
+function missionMapRoot(root, missionId) {
+    return path.join(root, '.sneakoscope', 'missions', missionId, 'architecture-map');
+}
+function resolveMapDir(root, args) {
+    const missionId = readOption(args, '--mission', '') || null;
+    if (missionId) {
+        return { dir: missionMapRoot(root, missionId), mode: 'mission', missionId };
+    }
+    return { dir: mapRoot(root), mode: 'global', missionId: null };
+}
+function readJsonFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function loadManifest(dir) {
+    const file = path.join(dir, 'manifest.json');
+    if (!fs.existsSync(file))
+        return { ok: false, manifest: null, path: file };
+    const manifest = readJsonFile(file);
+    return { ok: Boolean(manifest && manifest.schema === ARCHITECTURE_MAP_MANIFEST_SCHEMA), manifest, path: file };
+}
+function loadFindings(dir) {
+    const file = path.join(dir, 'findings.json');
+    const doc = readJsonFile(file);
+    return Array.isArray(doc?.findings) ? doc.findings : [];
+}
+function countBySeverity(findings) {
+    let blocking = 0;
+    let warning = 0;
+    let info = 0;
+    for (const finding of findings) {
+        if (finding.severity === 'blocking')
+            blocking += 1;
+        else if (finding.severity === 'warning')
+            warning += 1;
+        else
+            info += 1;
+    }
+    return { blocking, warning, info };
+}
+function graphFreshness(root, manifest) {
+    if (!manifest)
+        return 'missing';
+    const graphPath = path.join(root, '.sneakoscope', 'wiki', 'context-graph.json');
+    if (!fs.existsSync(graphPath))
+        return 'missing';
+    const graph = readJsonFile(graphPath);
+    const expected = String(graph?.snapshotHash || '');
+    const observed = String(manifest.graphHash || manifest.sourceBinding?.graphHash || '');
+    if (!expected || !observed)
+        return 'missing';
+    return expected === observed ? 'fresh' : 'stale';
+}
+async function atlasStatus(root, args) {
+    const resolved = resolveMapDir(root, args);
+    const loaded = loadManifest(resolved.dir);
+    const findings = loaded.manifest ? loadFindings(resolved.dir) : [];
+    const severity = countBySeverity(findings);
+    const freshness = graphFreshness(root, loaded.manifest);
+    const ok = loaded.ok && freshness === 'fresh' && severity.blocking === 0;
+    const result = {
+        schema: 'sks.triwiki-atlas-status.v1',
+        ok,
+        mode: resolved.mode,
+        mission_id: resolved.missionId,
+        manifest_schema: loaded.manifest?.schema ?? null,
+        graph_hash: loaded.manifest?.graphHash ?? null,
+        policy_hash: loaded.manifest?.policyHash ?? null,
+        generated_from: loaded.manifest?.canonicalHash ?? null,
+        freshness,
+        view_count: loaded.manifest?.views?.length ?? 0,
+        blocking_count: severity.blocking,
+        warning_count: severity.warning,
+        projection_accounting: loaded.manifest?.projectionAccounting ?? null,
+        next_action: ok ? null : REPAIR_COMMAND,
+        repair_command: REPAIR_COMMAND
+    };
+    const lines = [
+        `Architecture map (${resolved.mode}): ${ok ? 'ok' : 'blocked'}`,
+        `Freshness: ${freshness}`,
+        `Views: ${result.view_count}; blocking=${severity.blocking} warning=${severity.warning}`,
+        ...(ok ? [] : [`Repair: ${REPAIR_COMMAND}`])
+    ];
+    return { result, ok, lines };
+}
+async function atlasLint(root, args) {
+    const resolved = resolveMapDir(root, args);
+    const loaded = loadManifest(resolved.dir);
+    const errors = [];
+    if (!loaded.manifest)
+        errors.push('manifest_missing');
+    else {
+        if (loaded.manifest.schema !== ARCHITECTURE_MAP_MANIFEST_SCHEMA)
+            errors.push('schema');
+        if (!loaded.manifest.graphHash)
+            errors.push('graph_hash');
+        if (!loaded.manifest.policyHash)
+            errors.push('policy_hash');
+        if (!Array.isArray(loaded.manifest.views) || loaded.manifest.views.length === 0)
+            errors.push('views');
+        if (!loaded.manifest.projectionAccounting)
+            errors.push('projection_accounting');
+        for (const view of loaded.manifest.views ?? []) {
+            if (!VIEW_ID_SET.has(view.viewId))
+                errors.push(`unknown_view:${view.viewId}`);
+            const viewPath = path.join(resolved.dir, 'views', `${view.viewId}.mmd`);
+            if (!fs.existsSync(viewPath)) {
+                errors.push(`missing_view_file:${view.viewId}`);
+                continue;
+            }
+            const text = fs.readFileSync(viewPath, 'utf8');
+            if (!text.startsWith('%% GENERATED BY SKS'))
+                errors.push(`header:${view.viewId}`);
+            if (!/\bflowchart (TD|LR)\b/.test(text))
+                errors.push(`grammar:${view.viewId}`);
+            if (/\/Users\/|\/home\/|C:\\\\/.test(text))
+                errors.push(`absolute_path:${view.viewId}`);
+            const rel = path.relative(resolved.dir, viewPath);
+            if (rel.startsWith('..') || path.isAbsolute(rel))
+                errors.push(`path_escape:${view.viewId}`);
+        }
+    }
+    const freshness = graphFreshness(root, loaded.manifest);
+    if (freshness !== 'fresh')
+        errors.push(`freshness_${freshness}`);
+    const ok = errors.length === 0;
+    const result = {
+        schema: 'sks.triwiki-atlas-lint.v1',
+        ok,
+        mode: resolved.mode,
+        mission_id: resolved.missionId,
+        error_count: errors.length,
+        errors,
+        repair_command: REPAIR_COMMAND
+    };
+    return {
+        result,
+        ok,
+        lines: [
+            `Architecture map lint: ${ok ? 'ok' : 'blocked'} (${errors.length} errors)`,
+            ...errors.slice(0, 20).map((error) => `- ${error}`),
+            ...(ok ? [] : [`Repair: ${REPAIR_COMMAND}`])
+        ]
+    };
+}
+async function atlasList(root, args) {
+    const resolved = resolveMapDir(root, args);
+    const loaded = loadManifest(resolved.dir);
+    if (!loaded.manifest) {
+        return {
+            result: {
+                schema: 'sks.triwiki-atlas-list.v1',
+                ok: false,
+                error_code: 'manifest_missing',
+                repair_command: REPAIR_COMMAND
+            },
+            ok: false,
+            lines: ['Architecture map list: manifest_missing', `Repair: ${REPAIR_COMMAND}`]
+        };
+    }
+    const views = (loaded.manifest.views ?? []).map((view) => {
+        const rel = `${ARCHITECTURE_MAP_DIR_REL}/views/${view.viewId}.mmd`;
+        const abs = path.join(resolved.dir, 'views', `${view.viewId}.mmd`);
+        let direction = null;
+        let nodeCount = 0;
+        let edgeCount = 0;
+        if (fs.existsSync(abs)) {
+            const text = fs.readFileSync(abs, 'utf8');
+            direction = text.match(/\bflowchart (TD|LR)\b/)?.[1] ?? null;
+            nodeCount = [...text.matchAll(/^\s*[A-Za-z0-9_]+\[/gm)].length;
+            edgeCount = [...text.matchAll(/-->/g)].length;
+        }
+        return {
+            view_id: view.viewId,
+            path: rel,
+            direction,
+            node_count: nodeCount,
+            edge_count: edgeCount,
+            byte_count: view.byteLength,
+            hash: view.contentHash
+        };
+    });
+    const result = {
+        schema: 'sks.triwiki-atlas-list.v1',
+        ok: true,
+        mode: resolved.mode,
+        mission_id: resolved.missionId,
+        views
+    };
+    return {
+        result,
+        ok: true,
+        lines: views.map((view) => `${view.view_id}  ${view.direction ?? '?'}  nodes=${view.node_count} edges=${view.edge_count} bytes=${view.byte_count} ${view.hash.slice(0, 12)}`)
+    };
+}
+async function atlasShow(root, args) {
+    const viewId = args.find((arg) => !arg.startsWith('-')) ?? '';
+    if (!viewId || !VIEW_ID_SET.has(viewId)) {
+        return {
+            result: {
+                schema: 'sks.triwiki-atlas-show.v1',
+                ok: false,
+                error_code: 'invalid_view_id',
+                allowed: [...ARCHITECTURE_MAP_VIEW_IDS]
+            },
+            ok: false,
+            lines: [
+                'Usage: sks triwiki atlas-show <view-id> [--mission <id>] [--format mermaid|json]',
+                `Allowed: ${ARCHITECTURE_MAP_VIEW_IDS.join(', ')}`
+            ]
+        };
+    }
+    if (!GLOBAL_VIEW_ID_SET.has(viewId) && !readOption(args, '--mission', '')) {
+        return {
+            result: {
+                schema: 'sks.triwiki-atlas-show.v1',
+                ok: false,
+                error_code: 'mission_view_requires_mission',
+                view_id: viewId
+            },
+            ok: false,
+            lines: [`View ${viewId} is mission-scoped; pass --mission <id>`]
+        };
+    }
+    const format = readOption(args, '--format', 'mermaid') || 'mermaid';
+    const resolved = resolveMapDir(root, args);
+    const viewPath = path.join(resolved.dir, 'views', `${viewId}.mmd`);
+    const confined = path.relative(resolved.dir, viewPath);
+    if (confined.startsWith('..') || path.isAbsolute(confined)) {
+        return {
+            result: { schema: 'sks.triwiki-atlas-show.v1', ok: false, error_code: 'path_escape' },
+            ok: false,
+            lines: ['Architecture map show blocked: path_escape']
+        };
+    }
+    if (!fs.existsSync(viewPath)) {
+        return {
+            result: {
+                schema: 'sks.triwiki-atlas-show.v1',
+                ok: false,
+                error_code: 'view_missing',
+                view_id: viewId,
+                repair_command: REPAIR_COMMAND
+            },
+            ok: false,
+            lines: [`Architecture map show: view_missing (${viewId})`, `Repair: ${REPAIR_COMMAND}`]
+        };
+    }
+    const text = fs.readFileSync(viewPath, 'utf8');
+    if (format === 'json') {
+        const result = {
+            schema: 'sks.triwiki-atlas-show.v1',
+            ok: true,
+            view_id: viewId,
+            format: 'json',
+            path: `${ARCHITECTURE_MAP_DIR_REL}/views/${viewId}.mmd`,
+            text
+        };
+        return { result, ok: true, lines: [JSON.stringify(result, null, 2)] };
+    }
+    return {
+        result: {
+            schema: 'sks.triwiki-atlas-show.v1',
+            ok: true,
+            view_id: viewId,
+            format: 'mermaid',
+            path: `${ARCHITECTURE_MAP_DIR_REL}/views/${viewId}.mmd`,
+            text
+        },
+        ok: true,
+        lines: [text.trimEnd()]
+    };
+}
+async function atlasWhy(root, args) {
+    const findingId = args.find((arg) => !arg.startsWith('-')) ?? '';
+    const missionId = readOption(args, '--mission', '');
+    if (!findingId || !missionId) {
+        return {
+            result: { schema: 'sks.triwiki-atlas-why.v1', ok: false, error_code: 'usage' },
+            ok: false,
+            lines: ['Usage: sks triwiki atlas-why <finding-id> --mission <id> [--json]']
+        };
+    }
+    const resolved = resolveMapDir(root, [`--mission`, missionId]);
+    const findings = loadFindings(resolved.dir);
+    const finding = findings.find((entry) => entry.id === findingId) ?? null;
+    if (!finding) {
+        return {
+            result: {
+                schema: 'sks.triwiki-atlas-why.v1',
+                ok: false,
+                error_code: 'finding_not_found',
+                finding_id: findingId,
+                mission_id: missionId
+            },
+            ok: false,
+            lines: [`Architecture map why: finding_not_found (${findingId})`]
+        };
+    }
+    const result = {
+        schema: 'sks.triwiki-atlas-why.v1',
+        ok: true,
+        finding_id: finding.id,
+        code: finding.code ?? null,
+        severity: finding.severity ?? null,
+        subject: finding.subjectIds ?? [],
+        evidence_path: finding.evidenceIds ?? [],
+        before: null,
+        after: null,
+        policy_rule: finding.ruleId ?? null,
+        exception: finding.disposition ?? null,
+        inspect_nodes: finding.subjectIds ?? [],
+        message: finding.message ?? null
+    };
+    return {
+        result,
+        ok: true,
+        lines: [
+            `${finding.id}: ${finding.code ?? 'unknown'} (${finding.severity ?? 'info'})`,
+            ...(finding.subjectIds?.length ? [`Subject: ${finding.subjectIds.join(', ')}`] : []),
+            ...(finding.message ? [finding.message] : [])
+        ]
+    };
+}
+export async function triwikiAtlasCommand(root, sub, args) {
+    let answer;
+    if (sub === 'atlas-status')
+        answer = await atlasStatus(root, args);
+    else if (sub === 'atlas-lint')
+        answer = await atlasLint(root, args);
+    else if (sub === 'atlas-list')
+        answer = await atlasList(root, args);
+    else if (sub === 'atlas-show')
+        answer = await atlasShow(root, args);
+    else
+        answer = await atlasWhy(root, args);
+    const usageFailed = typeof answer.result === 'object' &&
+        answer.result !== null &&
+        'error_code' in answer.result &&
+        answer.result.error_code === 'usage';
+    const invalidView = typeof answer.result === 'object' &&
+        answer.result !== null &&
+        'error_code' in answer.result &&
+        answer.result.error_code === 'invalid_view_id';
+    const exitCode = answer.ok ? 0 : usageFailed || invalidView ? 2 : 1;
+    return { ...answer, exitCode };
+}

package/dist/core/commands/triwiki-command.js

@@ -5,6 +5,7 @@ import { computeTriWikiAffectedGraph } from '../triwiki/triwiki-affected-graph.j
 import { buildTriWikiGateImpactMap } from '../triwiki/triwiki-gate-impact-map.js';
 import { DEFAULT_TRIWIKI_MODULE_CARDS } from '../triwiki/triwiki-module-card.js';
 import { summarizeTriWikiProofBank } from '../triwiki/triwiki-proof-bank.js';
+import { isTriWikiAtlasSubcommand, triwikiAtlasCommand } from './triwiki-atlas-command.js';
 import { isTriWikiGraphSubcommand, triwikiGraphCommand } from './triwiki-graph-command.js';
 export async function triwikiCommand(args = []) {
     const root = await projectRoot();
@@ -20,6 +21,16 @@ export async function triwikiCommand(args = []) {
             console.log(line);
         return answer.result;
     }
+    if (isTriWikiAtlasSubcommand(sub)) {
+        const answer = await triwikiAtlasCommand(root, sub, args.slice(1));
+        process.exitCode = answer.exitCode;
+        if (json)
+            return printJson(answer.result);
+        const stream = answer.ok ? console.log : console.error;
+        for (const line of answer.lines)
+            stream(line);
+        return answer.result;
+    }
     if (sub === 'index') {
         result = {
             schema: 'sks.triwiki-index.v1',
@@ -36,7 +47,7 @@ export async function triwikiCommand(args = []) {
         result = summarizeTriWikiProofBank(root);
     }
     else {
-        console.error('Usage: sks triwiki index|affected|proof-bank|graph-status|graph-lint|graph-query [--json]');
+        console.error('Usage: sks triwiki index|affected|proof-bank|graph-status|graph-lint|graph-query|atlas-status|atlas-lint|atlas-list|atlas-show|atlas-why [--json]');
         process.exitCode = 1;
         return null;
     }

package/dist/core/fsx.js

@@ -65,6 +65,20 @@ export async function canonicalFilesystemPath(p) {
     const resolved = path.resolve(p);
     return fsp.realpath(resolved).catch(() => resolved);
 }
+export function canonicalFilesystemPathSync(value) {
+    const resolved = path.resolve(value);
+    try {
+        return fs.realpathSync.native(resolved);
+    }
+    catch {
+        if (process.platform === 'darwin' && resolved.startsWith('/var/'))
+            return `/private${resolved}`;
+        return resolved;
+    }
+}
+export function sameFilesystemPathSync(left, right) {
+    return Boolean(left && right && canonicalFilesystemPathSync(left) === canonicalFilesystemPathSync(right));
+}
 export async function sameFilesystemPath(left, right) {
     const [leftCanonical, rightCanonical] = await Promise.all([
         canonicalFilesystemPath(left),

package/dist/core/git-hygiene/git-policy.js

@@ -17,6 +17,8 @@ export const SHARED_MEMORY_TRACK = [
 export const GENERATED_INDEX_IGNORE = [
     '.sneakoscope/wiki/indexes/**/*.json',
     '.sneakoscope/wiki/context-packs/**/*.json',
+    '.sneakoscope/wiki/architecture-map/**',
+    '.sneakoscope/wiki/architecture-map/**/*.mmd',
     '.sneakoscope/wiki/tmp/**'
 ];
 export const LOCAL_RUNTIME_IGNORE = [
@@ -53,6 +55,8 @@ export const LOCAL_RUNTIME_IGNORE = [
     '.sneakoscope/wiki/image-wrongness-index.json',
     '.sneakoscope/wiki/visual-anchors.json',
     '.sneakoscope/wiki/last-sweep-report.json',
+    '.sneakoscope/wiki/architecture-map/**',
+    '.sneakoscope/wiki/architecture-map/**/*.mmd',
     '.sneakoscope/**/*.log'
 ];
 export const SHARED_MEMORY_DIRS = [

package/dist/core/git-hygiene/gitignore-writer.js

@@ -32,6 +32,8 @@ export const GITIGNORE_BLOCK = `# BEGIN ${GIT_HYGIENE_BLOCK}
 # Generated TriWiki indexes and transient context packs
 .sneakoscope/wiki/indexes/
 .sneakoscope/wiki/context-packs/
+.sneakoscope/wiki/architecture-map/
+.sneakoscope/wiki/architecture-map/**
 .sneakoscope/wiki/tmp/
 .sneakoscope/wiki/context-pack.json
 .sneakoscope/wiki/image-assets.json

package/dist/core/gx-renderer.js

@@ -78,7 +78,8 @@ export function normalizeVGraph(vgraph = {}) {
         edges,
         invariants: Array.isArray(vgraph.invariants) ? vgraph.invariants : [],
         tests: Array.isArray(vgraph.tests) ? vgraph.tests : [],
-        risks: Array.isArray(vgraph.risks) ? vgraph.risks : []
+        risks: Array.isArray(vgraph.risks) ? vgraph.risks : [],
+        ...(vgraph.atlas && typeof vgraph.atlas === 'object' && !Array.isArray(vgraph.atlas) ? { atlas: vgraph.atlas } : {})
     };
 }
 export function vgraphHash(vgraph = {}) {

package/dist/core/managed-paths.js

@@ -29,6 +29,7 @@ export function defaultManagedPaths() {
         row('.sneakoscope/wiki/summaries', 'tracked shared markdown summaries', false, 'shared_memory', 'tracked'),
         row('.sneakoscope/wiki/indexes', 'ignored regenerated shared-memory indexes', true, 'generated_index', 'ignored'),
         row('.sneakoscope/wiki/context-packs', 'ignored regenerated context-pack snapshots', true, 'generated_index', 'ignored'),
+        row('.sneakoscope/wiki/architecture-map', 'ignored regenerated Architecture Map views', true, 'generated_index', 'ignored'),
         row('.sneakoscope/missions', 'local runtime mission state and proof artifacts', true, 'local_runtime', 'ignored'),
         row('.sneakoscope/reports', 'local runtime reports', true, 'local_runtime', 'ignored'),
         row('.sneakoscope/tmp', 'local temporary runtime files', true, 'local_runtime', 'ignored'),