vigthoria-cli 1.13.20 → 1.13.22

package/dist/utils/config.js

@@ -2,7 +2,12 @@
  * Configuration Manager for Vigthoria CLI
  */
 import Conf from 'conf';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
 import { secureFileMode } from './cli-state.js';
+import { DurableJsonStore } from './durable-json.js';
+import { assertTrustedEndpoint, assertTrustedWebSocketEndpoint, guardedFetch } from './network-policy.js';
 const defaultConfig = {
     apiUrl: 'https://coder.vigthoria.io',
     modelsApiUrl: 'https://api.vigthoria.io', // Direct AI Models API - no proxying through Coder
@@ -43,95 +48,213 @@ const defaultConfig = {
         ],
     },
 };
+function cloneDefaultConfig() {
+    return JSON.parse(JSON.stringify(defaultConfig));
+}
+function readJsonObject(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function normalizeConfigValue(value, base = cloneDefaultConfig()) {
+    const raw = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    const next = JSON.parse(JSON.stringify(base));
+    const legacyUser = raw.user && typeof raw.user === 'object' ? raw.user : {};
+    for (const key of ['apiUrl', 'modelsApiUrl', 'musicApiUrl', 'wsUrl']) {
+        if (typeof raw[key] === 'string' && raw[key])
+            next[key] = String(raw[key]);
+    }
+    if (raw.selfHostedModelsApiUrl === null || typeof raw.selfHostedModelsApiUrl === 'string')
+        next.selfHostedModelsApiUrl = raw.selfHostedModelsApiUrl;
+    next.authToken = optionalString(raw.authToken ?? raw.token) ?? next.authToken;
+    next.refreshToken = optionalString(raw.refreshToken) ?? next.refreshToken;
+    next.userId = optionalString(raw.userId ?? legacyUser.id) ?? next.userId;
+    next.email = optionalString(raw.email ?? legacyUser.email) ?? next.email;
+    next.v3ServiceKey = optionalString(raw.v3ServiceKey) ?? next.v3ServiceKey;
+    if (raw.subscription && typeof raw.subscription === 'object' && !Array.isArray(raw.subscription)) {
+        const subscription = raw.subscription;
+        next.subscription = {
+            plan: optionalString(subscription.plan),
+            status: optionalString(subscription.status),
+            expiresAt: optionalString(subscription.expiresAt ?? subscription.expires_at),
+        };
+    }
+    if (raw.preferences && typeof raw.preferences === 'object' && !Array.isArray(raw.preferences)) {
+        next.preferences = { ...next.preferences, ...raw.preferences };
+    }
+    if (raw.project && typeof raw.project === 'object' && !Array.isArray(raw.project)) {
+        const project = raw.project;
+        next.project = {
+            rootPath: project.rootPath === null ? null : optionalString(project.rootPath) ?? next.project.rootPath,
+            ignorePatterns: Array.isArray(project.ignorePatterns)
+                ? project.ignorePatterns.filter((entry) => typeof entry === 'string')
+                : next.project.ignorePatterns,
+        };
+    }
+    if (raw.persona === 'default' || raw.persona === 'wiener_grant')
+        next.persona = raw.persona;
+    if (raw.hubModelPrefs && typeof raw.hubModelPrefs === 'object' && !Array.isArray(raw.hubModelPrefs)) {
+        const prefs = raw.hubModelPrefs;
+        next.hubModelPrefs = {
+            enabledCloudModels: Array.isArray(prefs.enabledCloudModels)
+                ? prefs.enabledCloudModels.filter((entry) => typeof entry === 'string')
+                : [],
+            defaultCloudModel: optionalString(prefs.defaultCloudModel) || undefined,
+            defaultLocalModel: optionalString(prefs.defaultLocalModel) || undefined,
+            balance: typeof prefs.balance === 'number' && Number.isFinite(prefs.balance) ? prefs.balance : undefined,
+            fetchedAt: optionalString(prefs.fetchedAt) || undefined,
+        };
+    }
+    return next;
+}
+function isConfigValue(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const candidate = value;
+    return typeof candidate.apiUrl === 'string'
+        && typeof candidate.modelsApiUrl === 'string'
+        && typeof candidate.musicApiUrl === 'string'
+        && typeof candidate.wsUrl === 'string'
+        && Boolean(candidate.subscription && typeof candidate.subscription === 'object')
+        && Boolean(candidate.preferences && typeof candidate.preferences === 'object')
+        && Boolean(candidate.project && typeof candidate.project === 'object')
+        && Array.isArray(candidate.project.ignorePatterns);
+}
 export class Config {
     store;
     static OPERATOR_PLANS = new Set(['enterprise', 'admin', 'master_admin']);
-    static CLOUD_PLANS = new Set(['pro', 'professional', 'ultra', 'enterprise', 'master_admin', 'admin']);
-    constructor() {
-        // `Conf` defaults to 0o644 on POSIX which would leave auth tokens
-        // readable by every local user.  We post-process the file in
-        // `secureOnDisk()` to enforce 0o600 ownership.  The `fileMode`
-        // option exists on newer `conf` releases — supply it via a cast so
-        // older type-defs do not reject the field.
-        this.store = new Conf({
-            projectName: 'vigthoria-cli',
-            defaults: defaultConfig,
-            ...{ fileMode: 0o600 },
-            schema: {
-                apiUrl: { type: 'string' },
-                modelsApiUrl: { type: 'string' },
-                musicApiUrl: { type: 'string' },
-                wsUrl: { type: 'string' },
-                selfHostedModelsApiUrl: { type: ['string', 'null'] },
-                authToken: { type: ['string', 'null'] },
-                refreshToken: { type: ['string', 'null'] },
-                userId: { type: ['string', 'null'] },
-                email: { type: ['string', 'null'] },
-                v3ServiceKey: { type: ['string', 'null'] },
-                subscription: {
-                    type: 'object',
-                    properties: {
-                        plan: { type: ['string', 'null'] },
-                        status: { type: ['string', 'null'] },
-                        expiresAt: { type: ['string', 'null'] },
-                    },
-                },
-                preferences: {
-                    type: 'object',
-                    properties: {
-                        defaultModel: { type: 'string' },
-                        theme: { type: 'string', enum: ['dark', 'light'] },
-                        autoApplyFixes: { type: 'boolean' },
-                        showDiffs: { type: 'boolean' },
-                        contextLines: { type: 'number' },
-                        maxTokens: { type: 'number' },
-                    },
-                },
-                persona: { type: 'string', enum: ['default', 'wiener_grant'] },
-                project: {
-                    type: 'object',
-                    properties: {
-                        rootPath: { type: ['string', 'null'] },
-                        ignorePatterns: { type: 'array', items: { type: 'string' } },
-                    },
-                },
+    constructor(options = {}) {
+        const stateRoot = path.resolve(options.stateRoot || os.homedir());
+        const canonicalPath = path.join(stateRoot, '.vigthoria', 'config.json');
+        const legacyConfPath = options.legacyConfPath
+            ? path.resolve(options.legacyConfPath)
+            : options.stateRoot
+                ? path.join(stateRoot, '.legacy-conf', 'config.json')
+                : new Conf({ projectName: 'vigthoria-cli' }).path;
+        const legacyCandidate = path.resolve(legacyConfPath) === path.resolve(canonicalPath) ? null : readJsonObject(legacyConfPath);
+        const legacyEnvelopeData = legacyCandidate?.data && typeof legacyCandidate.data === 'object'
+            ? legacyCandidate.data
+            : null;
+        const legacyConf = legacyEnvelopeData?.credentialsRetired === true ? null : legacyCandidate;
+        const legacyMtime = legacyConf ? fs.statSync(legacyConfPath).mtimeMs : 0;
+        const canonicalMtime = fs.existsSync(canonicalPath) ? fs.statSync(canonicalPath).mtimeMs : 0;
+        this.store = new DurableJsonStore({
+            filePath: canonicalPath,
+            schemaVersion: 2,
+            defaultValue: cloneDefaultConfig,
+            validate: isConfigValue,
+            migrate: (value) => {
+                const fromConf = legacyConf ? normalizeConfigValue(legacyConf) : cloneDefaultConfig();
+                const merged = normalizeConfigValue(value, fromConf);
+                // During the one-time collision resolution, preserve the most
+                // recently written credential bundle. Non-auth preferences use
+                // canonical-file precedence.
+                if (legacyConf && legacyMtime > canonicalMtime) {
+                    const legacyCredentials = normalizeConfigValue(legacyConf);
+                    merged.authToken = legacyCredentials.authToken;
+                    merged.refreshToken = legacyCredentials.refreshToken;
+                    merged.userId = legacyCredentials.userId;
+                    merged.email = legacyCredentials.email;
+                    merged.v3ServiceKey = legacyCredentials.v3ServiceKey;
+                    merged.subscription = legacyCredentials.subscription;
+                }
+                return merged;
             },
         });
-        // Defence-in-depth: re-apply 0600 every time we instantiate Config so
-        // that an older install which created the file with 0644 gets locked
-        // down on next startup.
-        try {
-            secureFileMode(this.store.path);
+        const canonicalExisted = fs.existsSync(canonicalPath);
+        if (!canonicalExisted && legacyConf) {
+            this.store.write(normalizeConfigValue(legacyConf));
+        }
+        else {
+            // Triggers legacy-flat migration and corruption recovery before any
+            // command can observe configuration.
+            this.store.read();
         }
-        catch { /* best-effort */ }
+        if (legacyConf)
+            this.retireLegacyConfStore(legacyConfPath, canonicalPath);
+        this.secureOnDisk();
+    }
+    retireLegacyConfStore(legacyPath, canonicalPath) {
+        const retired = new DurableJsonStore({
+            filePath: legacyPath,
+            schemaVersion: 1,
+            defaultValue: () => ({ migratedTo: canonicalPath, credentialsRetired: true }),
+            validate: (value) => Boolean(value && typeof value === 'object'
+                && typeof value.migratedTo === 'string'
+                && value.credentialsRetired === true),
+            migrate: () => ({ migratedTo: canonicalPath, credentialsRetired: true }),
+        });
+        retired.write({ migratedTo: canonicalPath, credentialsRetired: true });
     }
     /**
      * Re-apply secure POSIX permissions to the on-disk config file.  Safe
      * to call repeatedly; no-op on Windows.
      */
     secureOnDisk() {
-        try {
-            secureFileMode(this.store.path);
-        }
-        catch { /* best-effort */ }
+        secureFileMode(this.store.filePath);
+    }
+    validateEndpointValue(key, value) {
+        if (typeof value !== 'string')
+            return value;
+        if (key === 'apiUrl')
+            assertTrustedEndpoint(value, { audience: 'coder', ignoreOffline: true });
+        else if (key === 'modelsApiUrl' || key === 'selfHostedModelsApiUrl')
+            assertTrustedEndpoint(value, { audience: 'models', ignoreOffline: true });
+        else if (key === 'musicApiUrl')
+            assertTrustedEndpoint(value, { audience: 'music', ignoreOffline: true });
+        else if (key === 'wsUrl')
+            assertTrustedWebSocketEndpoint(value, 'coder', false, true);
+        return value;
     }
     get(key) {
-        return this.store.get(key);
+        return this.validateEndpointValue(key, this.store.read()[key]);
     }
     set(key, value) {
-        this.store.set(key, value);
+        const validated = this.validateEndpointValue(key, value);
+        this.store.update((current) => ({ ...current, [key]: validated }));
+        this.secureOnDisk();
     }
     getAll() {
-        return this.store.store;
+        const current = this.store.read();
+        return {
+            ...current,
+            apiUrl: this.validateEndpointValue('apiUrl', current.apiUrl),
+            modelsApiUrl: this.validateEndpointValue('modelsApiUrl', current.modelsApiUrl),
+            musicApiUrl: this.validateEndpointValue('musicApiUrl', current.musicApiUrl),
+            wsUrl: this.validateEndpointValue('wsUrl', current.wsUrl),
+            selfHostedModelsApiUrl: current.selfHostedModelsApiUrl
+                ? this.validateEndpointValue('selfHostedModelsApiUrl', current.selfHostedModelsApiUrl)
+                : null,
+        };
     }
     reset() {
-        this.store.clear();
+        this.store.write(cloneDefaultConfig());
+    }
+    resetPreservingAuth() {
+        this.store.update((current) => {
+            const next = cloneDefaultConfig();
+            next.authToken = current.authToken;
+            next.refreshToken = current.refreshToken;
+            next.userId = current.userId;
+            next.email = current.email;
+            next.v3ServiceKey = current.v3ServiceKey;
+            next.subscription = { ...current.subscription };
+            return next;
+        });
+        this.secureOnDisk();
     }
     isAuthenticated() {
-        return this.store.get('authToken') !== null;
+        return Boolean(this.get('authToken'));
     }
     hasValidSubscription() {
-        const sub = this.store.get('subscription');
+        const sub = this.get('subscription');
         if (!sub.status || sub.status !== 'active')
             return false;
         if (sub.expiresAt) {
@@ -141,7 +264,7 @@ export class Config {
         return true;
     }
     getNormalizedPlan() {
-        return (this.store.get('subscription').plan || '').trim().toLowerCase();
+        return (this.get('subscription').plan || '').trim().toLowerCase();
     }
     hasOperatorAccess() {
         return Config.OPERATOR_PLANS.has(this.getNormalizedPlan());
@@ -153,42 +276,45 @@ export class Config {
         return this.isAuthenticated();
     }
     getConfigPath() {
-        return this.store.path;
+        return this.store.filePath;
     }
     // Auth helpers
     setAuth(data) {
-        this.store.set('authToken', data.token);
-        if (data.refreshToken) {
-            this.store.set('refreshToken', data.refreshToken);
-        }
-        this.store.set('userId', data.userId);
-        this.store.set('email', data.email);
+        this.store.update((current) => ({
+            ...current,
+            authToken: data.token,
+            refreshToken: data.refreshToken === undefined ? current.refreshToken : data.refreshToken,
+            userId: data.userId === undefined ? current.userId : data.userId,
+            email: data.email === undefined ? current.email : data.email,
+            apiUrl: data.apiUrl ? this.validateEndpointValue('apiUrl', data.apiUrl) : current.apiUrl,
+            v3ServiceKey: data.v3ServiceKey === undefined ? current.v3ServiceKey : data.v3ServiceKey,
+        }));
         // Tighten permissions whenever the token rotates so a brand-new
         // install (which may have created the file under a previous default
         // umask) becomes 0600 immediately after first login.
         this.secureOnDisk();
     }
     clearAuth() {
-        this.store.set('authToken', null);
-        this.store.set('refreshToken', null);
-        this.store.set('userId', null);
-        this.store.set('email', null);
-        this.store.set('subscription', {
-            plan: null,
-            status: null,
-            expiresAt: null,
-        });
+        this.store.update((current) => ({
+            ...current,
+            authToken: null,
+            refreshToken: null,
+            userId: null,
+            email: null,
+            v3ServiceKey: null,
+            hubModelPrefs: undefined,
+            subscription: { plan: null, status: null, expiresAt: null },
+        }));
     }
     setSubscription(data) {
-        this.store.set('subscription', {
-            plan: data.plan,
-            status: data.status,
-            expiresAt: data.expiresAt || null,
-        });
+        this.store.update((current) => ({
+            ...current,
+            subscription: { plan: data.plan, status: data.status, expiresAt: data.expiresAt || null },
+        }));
     }
     // Model selection - Vigthoria Models (internal routing IDs only)
     getAvailableModels() {
-        const sub = this.store.get('subscription');
+        const sub = this.get('subscription');
         const plan = (sub.plan || '').toLowerCase();
         void plan;
         // ═══════════════════════════════════════════════════════════════
@@ -208,28 +334,28 @@ export class Config {
             // Legacy aliases
             { id: 'cloud', name: 'Vigthoria Cloud Balanced', description: 'Legacy alias for cloud-balanced', tier: 'cloud', backendModel: 'vigthoria-cloud-balanced' }, { id: 'cloud-reason', name: 'Vigthoria Cloud Balanced', description: 'Legacy alias for cloud-balanced', tier: 'cloud', backendModel: 'vigthoria-cloud-balanced' }, { id: 'ultra', name: 'Vigthoria Cloud Maximum', description: 'Legacy alias for cloud-maximum', tier: 'cloud', backendModel: 'vigthoria-cloud-maximum' });
         }
-        const hubPrefs = this.store.get('hubModelPrefs');
+        const hubPrefs = this.get('hubModelPrefs');
         if (hubPrefs?.enabledCloudModels?.length) {
             return this.filterModelsByHubPreferences(models, hubPrefs.enabledCloudModels);
         }
         return models;
     }
     async refreshHubModelPreferences() {
-        const token = this.store.get('authToken');
-        const apiUrl = String(this.store.get('apiUrl') || '').replace(/\/$/, '');
+        const token = this.get('authToken');
+        const apiUrl = String(this.get('apiUrl') || '').replace(/\/$/, '');
         if (!token || !apiUrl)
             return;
         try {
-            const response = await fetch(`${apiUrl}/api/user/credits/model-preferences`, {
+            const response = await guardedFetch(`${apiUrl}/api/user/credits/model-preferences`, {
                 headers: { Authorization: `Bearer ${token}` },
                 signal: AbortSignal.timeout(8000),
-            });
+            }, { audience: 'coder' });
             if (!response.ok)
                 return;
             const prefs = await response.json();
             if (prefs?.success === false)
                 return;
-            this.store.set('hubModelPrefs', {
+            this.set('hubModelPrefs', {
                 enabledCloudModels: Array.isArray(prefs.enabledCloudModels) ? prefs.enabledCloudModels : [],
                 defaultCloudModel: typeof prefs.defaultCloudModel === 'string' ? prefs.defaultCloudModel : undefined,
                 defaultLocalModel: typeof prefs.defaultLocalModel === 'string' ? prefs.defaultLocalModel : undefined,

package/dist/utils/context-ranker.js

@@ -9,6 +9,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { containsHighConfidenceSecret, isSensitivePath } from './secret-policy.js';
 const IGNORED_DIRS = new Set([
     '.git', 'node_modules', 'dist', '.next', '__pycache__',
     '.vigthoria', 'coverage', '.cache', '.turbo', 'build', 'out',
@@ -16,7 +17,7 @@ const IGNORED_DIRS = new Set([
 const TEXT_EXTENSIONS = new Set([
     '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
     '.py', '.go', '.rs', '.java', '.c', '.cpp', '.h', '.cs', '.php', '.rb',
-    '.json', '.yaml', '.yml', '.toml', '.env', '.sh', '.bash',
+    '.json', '.yaml', '.yml', '.toml', '.sh', '.bash',
     '.html', '.css', '.scss', '.sass', '.less',
     '.md', '.txt', '.xml', '.svg',
 ]);
@@ -86,6 +87,9 @@ function walkWorkspace(dir, maxFiles = 800) {
             if (IGNORED_DIRS.has(entry.name))
                 continue;
             const fullPath = path.join(current, entry.name);
+            const relativePath = path.relative(workspaceRoot, fullPath).replace(/\\/g, '/');
+            if (isSensitivePath(relativePath))
+                continue;
             // Security: skip symlinks that escape workspace root (fixes 8.2)
             if (entry.isSymbolicLink()) {
                 try {
@@ -101,7 +105,12 @@ function walkWorkspace(dir, maxFiles = 800) {
                 stack.push(fullPath);
             }
             else if (entry.isFile() && TEXT_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
-                results.push(fullPath);
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf8').slice(0, 300000);
+                    if (!containsHighConfidenceSecret(content))
+                        results.push(fullPath);
+                }
+                catch { /* unreadable files are not context */ }
             }
         }
     }

package/dist/utils/context-state.d.ts

@@ -0,0 +1,39 @@
+export type ContextStateSource = 'workflow-memory' | 'session-memory' | 'project-memory' | 'codebase-index' | 'mcp-context' | 'account-brain' | 'workspace-hashes';
+export interface ContextOwnershipRule {
+    owner: string;
+    schema: string;
+    precedence: number;
+    privacy: 'local-only' | 'account-remote' | 'execution-remote' | 'metadata-only';
+    retention: string;
+    conflictPolicy: string;
+}
+export declare const CONTEXT_STATE_OWNERSHIP: Readonly<Record<ContextStateSource, ContextOwnershipRule>>;
+export interface ContextStateLayer {
+    source: ContextStateSource;
+    schema: string;
+    precedence: number;
+    privacy: ContextOwnershipRule['privacy'];
+    content?: string;
+    metadata?: Record<string, unknown>;
+    contentHash?: string;
+}
+export interface ContextStateEnvelope {
+    schema: 'vigthoria.context-state.v1';
+    precedence: ContextStateSource[];
+    layers: ContextStateLayer[];
+    compatibilityAdapters: {
+        projectMemory: 'project-memory';
+        codebaseContext: 'codebase-index';
+        accountBrainContext: 'account-brain';
+        vigthoriaBrain: 'project-memory-metadata';
+    };
+}
+export declare function assembleContextState(input: Partial<Record<ContextStateSource, {
+    content?: string;
+    metadata?: Record<string, unknown>;
+}>>): ContextStateEnvelope;
+export declare function contextLayer(envelope: ContextStateEnvelope, source: ContextStateSource): ContextStateLayer | undefined;
+export declare function appendContextLayer(envelope: ContextStateEnvelope | undefined, source: ContextStateSource, value: {
+    content?: string;
+    metadata?: Record<string, unknown>;
+}): ContextStateEnvelope;

package/dist/utils/context-state.js

@@ -0,0 +1,52 @@
+import { createHash } from 'crypto';
+import { scanOutboundContext } from './secret-policy.js';
+export const CONTEXT_STATE_OWNERSHIP = Object.freeze({
+    'workflow-memory': { owner: 'VigFlow target adapter', schema: 'vigthoria.context.workflow.v1', precedence: 90, privacy: 'execution-remote', retention: 'remote workflow policy', conflictPolicy: 'explicit workflow inputs override remembered context' },
+    'session-memory': { owner: 'SessionManager', schema: 'vigthoria.context.session.v1', precedence: 80, privacy: 'local-only', retention: '90 days / 200 sessions', conflictPolicy: 'latest project-bound checkpoint wins' },
+    'project-memory': { owner: 'ProjectMemoryService', schema: 'vigthoria.context.project-memory.v2', precedence: 70, privacy: 'local-only', retention: '240 bounded items', conflictPolicy: 'newer explicit decisions/preferences win by item identity' },
+    'codebase-index': { owner: 'CodebaseIndexer', schema: 'vigthoria.context.codebase-index.v1', precedence: 60, privacy: 'local-only', retention: 'content-addressed until reindex', conflictPolicy: 'current workspace bytes are authoritative' },
+    'mcp-context': { owner: 'MCP execution binding', schema: 'vigthoria.context.mcp.v1', precedence: 50, privacy: 'execution-remote', retention: 'remote execution lifetime', conflictPolicy: 'scoped tool evidence is additive and cannot override local files' },
+    'account-brain': { owner: 'BrainHubClient', schema: 'vigthoria.context.account-brain.v1', precedence: 40, privacy: 'account-remote', retention: 'account Brain policy', conflictPolicy: 'account facts yield to project/session evidence' },
+    'workspace-hashes': { owner: 'WorkspaceHashCache', schema: 'vigthoria.context.workspace-hashes.v1', precedence: 10, privacy: 'metadata-only', retention: 'latest successful workspace observation', conflictPolicy: 'routing metadata only; never semantic authority' },
+});
+export function assembleContextState(input) {
+    const layers = Object.entries(input)
+        .filter((entry) => Boolean(entry[1]))
+        .map(([source, value]) => {
+        const rule = CONTEXT_STATE_OWNERSHIP[source];
+        const scanned = scanOutboundContext(value).value;
+        const content = String(scanned.content || '').trim();
+        const contentHash = content ? createHash('sha256').update(content).digest('hex') : undefined;
+        return {
+            source,
+            schema: rule.schema,
+            precedence: rule.precedence,
+            privacy: rule.privacy,
+            ...(content ? { content, contentHash } : {}),
+            ...(scanned.metadata ? { metadata: scanned.metadata } : {}),
+        };
+    })
+        .sort((left, right) => right.precedence - left.precedence)
+        .filter((layer, _index, all) => !layer.contentHash
+        || all.findIndex((candidate) => candidate.contentHash === layer.contentHash) === all.indexOf(layer));
+    return {
+        schema: 'vigthoria.context-state.v1',
+        precedence: layers.map((layer) => layer.source),
+        layers,
+        compatibilityAdapters: {
+            projectMemory: 'project-memory',
+            codebaseContext: 'codebase-index',
+            accountBrainContext: 'account-brain',
+            vigthoriaBrain: 'project-memory-metadata',
+        },
+    };
+}
+export function contextLayer(envelope, source) {
+    return envelope.layers.find((layer) => layer.source === source);
+}
+export function appendContextLayer(envelope, source, value) {
+    const existing = envelope?.layers || [];
+    const input = Object.fromEntries(existing.map((layer) => [layer.source, { content: layer.content, metadata: layer.metadata }]));
+    input[source] = value;
+    return assembleContextState(input);
+}

package/dist/utils/deckEvents.d.ts

@@ -1,8 +1,3 @@
-/**
- * Structured events for Vigthoria Workbench (VIGTHORIA_DECK_MODE=1).
- * Emitted as single lines: @vigthoria-deck:{json}
- * Workbench strips these from terminal display and updates UI panels.
- */
 export type DeckEventType = 'agent_start' | 'tool_start' | 'tool_end' | 'report_ready' | 'run_complete' | 'run_summary';
 export interface DeckEvent {
     type: DeckEventType;

package/dist/utils/deckEvents.js

@@ -3,6 +3,7 @@
  * Emitted as single lines: @vigthoria-deck:{json}
  * Workbench strips these from terminal display and updates UI panels.
  */
+import { scanOutboundContext } from './secret-policy.js';
 const DECK_PREFIX = '@vigthoria-deck:';
 export function isDeckModeEnabled() {
     return /^(1|true|yes)$/i.test(String(process.env.VIGTHORIA_DECK_MODE || ''));
@@ -10,10 +11,10 @@ export function isDeckModeEnabled() {
 export function emitDeckEvent(event) {
     if (!isDeckModeEnabled())
         return;
-    const payload = {
+    const payload = scanOutboundContext({
         ...event,
         ts: event.ts ?? Date.now(),
-    };
+    }).value;
     // Force the marker onto its own fresh line. Callers may have just updated an
     // in-place spinner (e.g. ora) which redraws via "\r" and never emits a
     // trailing "\n", so without this leading newline the marker can land stuck

package/dist/utils/desktop-bridge-client.js

@@ -1,9 +1,11 @@
+import { assertTrustedEndpoint } from './network-policy.js';
 export async function getDesktopBridgeStatus(options = {}) {
     const endpoint = options.url
         || process.env.VIGTHORIA_DESKTOP_BRIDGE_URL
         || `http://${process.env.VIGTHORIA_DESKTOP_HOST || '127.0.0.1'}:${process.env.VIGTHORIA_DESKTOP_PORT || '49160'}`;
     const timeoutMs = options.timeoutMs ?? 5000;
     try {
+        assertTrustedEndpoint(endpoint, { audience: 'bridge' });
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), timeoutMs);
         const response = await fetch(`${endpoint.replace(/\/$/, '')}/health`, {

package/dist/utils/direct-output-policy.d.ts

@@ -0,0 +1,3 @@
+export declare function stripHiddenThoughtBlocks(text: string): string;
+export declare function sanitizeDirectModeOutput(text: string): string;
+export declare function isDirectModeFollowUpQuestion(text: string): boolean;