vigthoria-cli 1.13.20 → 1.13.23

package/dist/utils/auth-session.d.ts

@@ -0,0 +1,41 @@
+import { Config } from './config.js';
+export interface TokenClaims {
+    issuer: string;
+    audience: string[];
+    expiresAt: number;
+    subject?: string;
+}
+export interface ValidatedToken {
+    token: string;
+    type: 'jwt' | 'opaque';
+    claims?: TokenClaims;
+}
+export interface AuthIdentity {
+    userId?: string | null;
+    email?: string | null;
+}
+export interface AuthSessionOptions {
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+}
+type AuthInvalidationListener = () => void;
+export declare function subscribeAuthInvalidation(listener: AuthInvalidationListener): () => void;
+export declare function validateTokenStructure(token: string, endpoint: string, now?: number): ValidatedToken;
+export declare class AuthSessionService {
+    private readonly config;
+    private readonly fetchImpl;
+    private readonly now;
+    constructor(config: Config, options?: AuthSessionOptions);
+    getAccessToken(): string | null;
+    validateServerAcceptance(token: string, endpoint?: string): Promise<AuthIdentity>;
+    validateAndPersistToken(token: string, options?: {
+        apiUrl?: string;
+        refreshToken?: string | null;
+        identity?: AuthIdentity;
+        v3ServiceKey?: string | null;
+    }): Promise<ValidatedToken>;
+    refresh(): Promise<boolean>;
+    private refreshOnce;
+    clearLocalCredentials(): void;
+}
+export {};

package/dist/utils/auth-session.js

@@ -0,0 +1,224 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { clearGatewayPreflightCache } from './cli-state.js';
+import { assertTrustedEndpoint, guardedFetch } from './network-policy.js';
+const invalidationListeners = new Set();
+const refreshes = new Map();
+export function subscribeAuthInvalidation(listener) {
+    invalidationListeners.add(listener);
+    return () => invalidationListeners.delete(listener);
+}
+function notifyAuthInvalidation() {
+    for (const listener of [...invalidationListeners]) {
+        try {
+            listener();
+        }
+        catch { /* one client must not block credential clearing */ }
+    }
+}
+function decodeBase64UrlJson(segment) {
+    if (!/^[A-Za-z0-9_-]+$/.test(segment))
+        throw new Error('JWT contains invalid base64url characters.');
+    const decoded = Buffer.from(segment, 'base64url').toString('utf8');
+    const value = JSON.parse(decoded);
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('JWT segment is not an object.');
+    return value;
+}
+function normalizeAudience(value) {
+    if (typeof value === 'string' && value.trim())
+        return [value.trim()];
+    if (Array.isArray(value))
+        return value.filter((item) => typeof item === 'string' && Boolean(item.trim())).map((item) => item.trim());
+    return [];
+}
+export function validateTokenStructure(token, endpoint, now = Date.now()) {
+    const normalized = String(token || '').trim();
+    if (!normalized || normalized.length > 16_384 || /[\s\u0000-\u001f\u007f]/.test(normalized)) {
+        throw new Error('Token is empty or contains invalid characters.');
+    }
+    const trustedEndpoint = assertTrustedEndpoint(endpoint, { audience: 'coder', credentialBearing: true, ignoreOffline: true });
+    const segments = normalized.split('.');
+    if (segments.length !== 3) {
+        if (normalized.length < 20)
+            throw new Error('Opaque token is too short.');
+        return { token: normalized, type: 'opaque' };
+    }
+    const header = decodeBase64UrlJson(segments[0]);
+    const payload = decodeBase64UrlJson(segments[1]);
+    if (!segments[2] || String(header.alg || '').toLowerCase() === 'none')
+        throw new Error('Unsigned JWTs are not accepted.');
+    const issuer = typeof payload.iss === 'string' ? payload.iss.trim().replace(/\/$/, '') : '';
+    const audience = normalizeAudience(payload.aud);
+    const expiresAt = typeof payload.exp === 'number' && Number.isFinite(payload.exp) ? payload.exp * 1000 : Number.NaN;
+    const notBefore = typeof payload.nbf === 'number' && Number.isFinite(payload.nbf) ? payload.nbf * 1000 : null;
+    if (!issuer)
+        throw new Error('JWT issuer claim is required.');
+    if (audience.length === 0)
+        throw new Error('JWT audience claim is required.');
+    if (!Number.isFinite(expiresAt))
+        throw new Error('JWT expiry claim is required.');
+    if (expiresAt <= now + 30_000)
+        throw new Error('Token is expired or too close to expiry.');
+    if (notBefore !== null && notBefore > now + 30_000)
+        throw new Error('Token is not active yet.');
+    const allowedIssuers = new Set([
+        trustedEndpoint.origin,
+        'https://coder.vigthoria.io',
+        'https://api.vigthoria.io',
+    ]);
+    if (!allowedIssuers.has(issuer))
+        throw new Error('Token issuer does not belong to the configured Vigthoria endpoint.');
+    const allowedAudiences = new Set([
+        'vigthoria-cli',
+        'vigthoria-coder',
+        'coder',
+        trustedEndpoint.hostname,
+        trustedEndpoint.origin,
+    ]);
+    if (!audience.some((entry) => allowedAudiences.has(entry)))
+        throw new Error('Token audience is not valid for the Vigthoria CLI.');
+    return {
+        token: normalized,
+        type: 'jwt',
+        claims: {
+            issuer,
+            audience,
+            expiresAt,
+            subject: typeof payload.sub === 'string' ? payload.sub : undefined,
+        },
+    };
+}
+function extractIdentity(payload) {
+    if (!payload || typeof payload !== 'object')
+        return {};
+    const root = payload;
+    const user = root.user && typeof root.user === 'object' ? root.user : root;
+    return {
+        userId: user.id === undefined ? undefined : String(user.id),
+        email: typeof user.email === 'string' ? user.email : undefined,
+    };
+}
+export class AuthSessionService {
+    config;
+    fetchImpl;
+    now;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.fetchImpl = options.fetchImpl || globalThis.fetch;
+        this.now = options.now || Date.now;
+    }
+    getAccessToken() {
+        return process.env.VIGTHORIA_TOKEN
+            || process.env.VIGTHORIA_AUTH_TOKEN
+            || this.config.get('authToken')
+            || null;
+    }
+    async validateServerAcceptance(token, endpoint = String(this.config.get('apiUrl'))) {
+        const base = assertTrustedEndpoint(endpoint, { audience: 'coder', credentialBearing: true }).origin;
+        validateTokenStructure(token, base, this.now());
+        const headers = {
+            Authorization: `Bearer ${token}`,
+            Cookie: `vigthoria-auth-token=${token}`,
+            Accept: 'application/json',
+        };
+        const probes = [
+            { path: '/api/auth/me', method: 'GET' },
+            { path: '/api/user/profile', method: 'GET' },
+            { path: '/api/user/info', method: 'GET' },
+            { path: '/api/user/subscription', method: 'GET' },
+            { path: '/api/auth/verify', method: 'POST' },
+        ];
+        let lastStatus = 0;
+        for (const probe of probes) {
+            const response = await guardedFetch(`${base}${probe.path}`, {
+                method: probe.method,
+                headers: probe.method === 'POST' ? { ...headers, 'Content-Type': 'application/json' } : headers,
+                body: probe.method === 'POST' ? JSON.stringify({ token }) : undefined,
+                signal: AbortSignal.timeout(8000),
+            }, { audience: 'coder', fetchImpl: this.fetchImpl });
+            lastStatus = response.status;
+            if (response.ok) {
+                const payload = await response.json().catch(() => ({}));
+                return extractIdentity(payload);
+            }
+            if (response.status === 401 || response.status === 403)
+                break;
+            if (response.status !== 404 && response.status !== 405)
+                break;
+        }
+        throw new Error(`Token was rejected by the configured Vigthoria endpoint${lastStatus ? ` (HTTP ${lastStatus})` : ''}.`);
+    }
+    async validateAndPersistToken(token, options = {}) {
+        const apiUrl = String(options.apiUrl || this.config.get('apiUrl'));
+        const validated = validateTokenStructure(token, apiUrl, this.now());
+        const acceptedIdentity = await this.validateServerAcceptance(validated.token, apiUrl);
+        this.config.setAuth({
+            token: validated.token,
+            refreshToken: options.refreshToken,
+            userId: acceptedIdentity.userId ?? options.identity?.userId,
+            email: acceptedIdentity.email ?? options.identity?.email,
+            apiUrl,
+            v3ServiceKey: options.v3ServiceKey,
+        });
+        clearGatewayPreflightCache();
+        notifyAuthInvalidation();
+        return validated;
+    }
+    async refresh() {
+        const key = this.config.getConfigPath();
+        const active = refreshes.get(key);
+        if (active)
+            return active;
+        const operation = this.refreshOnce().finally(() => refreshes.delete(key));
+        refreshes.set(key, operation);
+        return operation;
+    }
+    async refreshOnce() {
+        const refreshToken = this.config.get('refreshToken');
+        if (!refreshToken)
+            return false;
+        const base = assertTrustedEndpoint(String(this.config.get('apiUrl')), { audience: 'coder' }).origin;
+        try {
+            const response = await guardedFetch(`${base}/api/token/refresh`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ refresh_token: refreshToken }),
+                signal: AbortSignal.timeout(8000),
+            }, { audience: 'coder', fetchImpl: this.fetchImpl });
+            if (!response.ok) {
+                if (response.status === 401 || response.status === 403)
+                    this.clearLocalCredentials();
+                return false;
+            }
+            const payload = await response.json();
+            const nextToken = payload.token || payload.access_token;
+            if (!nextToken)
+                return false;
+            validateTokenStructure(nextToken, base, this.now());
+            this.config.setAuth({ token: nextToken, refreshToken: payload.refresh_token || refreshToken });
+            clearGatewayPreflightCache();
+            notifyAuthInvalidation();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    clearLocalCredentials() {
+        this.config.clearAuth();
+        clearGatewayPreflightCache();
+        const compatibilityDir = path.dirname(this.config.getConfigPath());
+        for (const fileName of ['auth.json', 'session.json']) {
+            const candidate = path.join(compatibilityDir, fileName);
+            try {
+                fs.unlinkSync(candidate);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        notifyAuthInvalidation();
+    }
+}

package/dist/utils/brain-hub-client.d.ts

@@ -1,7 +1,3 @@
-/**
- * Brain Hub client — sync workspace index + fetch account brain context
- * via coder.vigthoria.io (JWT-authenticated).
- */
 export type BrainSyncPayload = {
     workspaceName: string;
     workspacePath: string;

package/dist/utils/brain-hub-client.js

@@ -2,6 +2,8 @@
  * Brain Hub client — sync workspace index + fetch account brain context
  * via coder.vigthoria.io (JWT-authenticated).
  */
+import { assertTrustedEndpoint } from './network-policy.js';
+import { redactSensitiveText, scanOutboundContext } from './secret-policy.js';
 // Brain Hub calls are an optional personalization enhancement to an agent
 // turn, not on the critical path. Native `fetch()` has NO default timeout,
 // so a slow/unresponsive coder.vigthoria.io backend previously caused the
@@ -23,6 +25,7 @@ export class BrainHubClient {
     getAuthToken;
     constructor(options) {
         this.apiBase = (options.apiBase || 'https://coder.vigthoria.io').replace(/\/$/, '');
+        assertTrustedEndpoint(this.apiBase, { audience: 'brain-hub' });
         this.getAuthToken = options.getAuthToken;
     }
     async headers() {
@@ -42,7 +45,7 @@ export class BrainHubClient {
             const resp = await fetchWithTimeout(`${this.apiBase}/api/brain/sync-index`, {
                 method: 'POST',
                 headers,
-                body: JSON.stringify(payload),
+                body: JSON.stringify(scanOutboundContext(payload).value),
             });
             const data = await resp.json().catch(() => ({}));
             if (!resp.ok) {
@@ -52,7 +55,7 @@ export class BrainHubClient {
         }
         catch (error) {
             const timedOut = error instanceof Error && error.name === 'AbortError';
-            return { ok: false, error: timedOut ? `timeout after ${BRAIN_HUB_TIMEOUT_MS}ms` : String(error) };
+            return { ok: false, error: timedOut ? `timeout after ${BRAIN_HUB_TIMEOUT_MS}ms` : redactSensitiveText(String(error)) };
         }
     }
     async fetchAccountContext(limit = 25) {
@@ -70,7 +73,7 @@ export class BrainHubClient {
         }
         catch (error) {
             const timedOut = error instanceof Error && error.name === 'AbortError';
-            return { ok: false, formattedText: '', error: timedOut ? `timeout after ${BRAIN_HUB_TIMEOUT_MS}ms` : String(error) };
+            return { ok: false, formattedText: '', error: timedOut ? `timeout after ${BRAIN_HUB_TIMEOUT_MS}ms` : redactSensitiveText(String(error)) };
         }
     }
 }

package/dist/utils/bridge-client.js

@@ -15,6 +15,7 @@ import WebSocket from 'ws';
 import * as os from 'os';
 import chalk from 'chalk';
 import { CH } from './logger.js';
+import { assertTrustedWebSocketEndpoint } from './network-policy.js';
 // ── Singleton accessor ───────────────────────────────────────────────
 let _instance = null;
 /** Get the active bridge client (may be null if --bridge was not used). */
@@ -41,6 +42,7 @@ export class BridgeClient {
         if (!this.url.includes('/ws')) {
             this.url = this.url.replace(/^http/, 'ws') + '/ws';
         }
+        assertTrustedWebSocketEndpoint(this.url, 'bridge', Boolean(opts.apiKey));
         this.apiKey = opts.apiKey;
         this.machineLabel = opts.machineLabel || os.hostname();
         this.clientId = `cli-${this.machineLabel}-${Date.now().toString(36)}`;

package/dist/utils/capability-health-service.d.ts

@@ -0,0 +1,48 @@
+export interface EndpointHealthStatus {
+    name: string;
+    endpoint: string;
+    ok: boolean;
+    error?: string;
+    details?: Record<string, unknown>;
+}
+export interface APIHealthStatus {
+    overallOk: boolean;
+    coder: EndpointHealthStatus;
+    models: EndpointHealthStatus;
+    selfHosted: EndpointHealthStatus | null;
+}
+export interface CapabilityTruthStatus {
+    overallOk: boolean;
+    v3Agent: EndpointHealthStatus;
+    hyperLoop: EndpointHealthStatus;
+    repoMemory: EndpointHealthStatus;
+    devtoolsBridge: EndpointHealthStatus;
+}
+export type ModelPreflightStatus = {
+    healthy: boolean;
+    endpoint: string;
+    error?: string;
+    routes: Array<{
+        name: string;
+        ok: boolean;
+        error?: string;
+    }>;
+};
+export interface CapabilityHealthDependencies {
+    getCoderHealth(): Promise<EndpointHealthStatus>;
+    getModelsHealth(): Promise<EndpointHealthStatus>;
+    getSelfHostedHealth(): Promise<EndpointHealthStatus | null>;
+    getV3Health(): Promise<EndpointHealthStatus>;
+    getHyperLoopHealth(): Promise<EndpointHealthStatus>;
+    getRepoMemoryHealth(context: Record<string, any>): Promise<EndpointHealthStatus>;
+    getDevtoolsBridgeHealth(): Promise<EndpointHealthStatus>;
+    modelUsesV3(requestedModel: string): boolean;
+}
+export declare class CapabilityHealthService {
+    private readonly dependencies;
+    constructor(dependencies: CapabilityHealthDependencies);
+    runModelPreflight(requestedModel?: string): Promise<ModelPreflightStatus>;
+    mapPreflightEndpoint(endpoint: string): 'coder' | 'models' | 'selfhosted' | null;
+    getCapabilityTruth(context?: Record<string, any>): Promise<CapabilityTruthStatus>;
+    getHealth(): Promise<APIHealthStatus>;
+}

package/dist/utils/capability-health-service.js

@@ -0,0 +1,64 @@
+export class CapabilityHealthService {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async runModelPreflight(requestedModel = 'agent') {
+        const probes = [
+            { name: 'Vigthoria Coder API', run: () => this.dependencies.getCoderHealth() },
+            { name: 'Vigthoria Models API', run: () => this.dependencies.getModelsHealth() },
+        ];
+        const selfHosted = await this.dependencies.getSelfHostedHealth();
+        if (selfHosted)
+            probes.unshift({ name: selfHosted.name || 'Dedicated Models API', run: async () => selfHosted });
+        if (this.dependencies.modelUsesV3(requestedModel))
+            probes.push({ name: 'V3 Agent API', run: () => this.dependencies.getV3Health() });
+        const routes = await Promise.all(probes.map(async (probe) => {
+            try {
+                const status = await probe.run();
+                return { name: probe.name, ok: status.ok, error: status.error };
+            }
+            catch (error) {
+                return { name: probe.name, ok: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        }));
+        const healthy = routes.some((route) => route.ok);
+        const inferenceRoutes = routes.filter((route) => route.name !== 'V3 Agent API');
+        const firstHealthy = inferenceRoutes.find((route) => route.ok) || routes.find((route) => route.ok);
+        return {
+            healthy,
+            endpoint: firstHealthy?.name || 'api.vigthoria.io',
+            error: healthy ? undefined : 'No Vigthoria model backend responded during preflight. Run `vigthoria login` and check your internet connection.',
+            routes,
+        };
+    }
+    mapPreflightEndpoint(endpoint) {
+        const normalized = String(endpoint || '').toLowerCase();
+        if (normalized.includes('coder'))
+            return 'coder';
+        if (normalized.includes('models') && !normalized.includes('dedicated'))
+            return 'models';
+        if (normalized.includes('dedicated') || normalized.includes('self-hosted') || normalized.includes('selfhosted'))
+            return 'selfhosted';
+        return null;
+    }
+    async getCapabilityTruth(context = {}) {
+        const withTimeout = (promise, name) => Promise.race([
+            promise,
+            new Promise((resolve) => setTimeout(() => resolve({ name, endpoint: '', ok: false, error: 'Service not reachable (15 s timeout)' }), 15000)),
+        ]);
+        const [v3Agent, hyperLoop, repoMemory, devtoolsBridge] = await Promise.all([
+            withTimeout(this.dependencies.getV3Health(), 'V3 Agent'),
+            withTimeout(this.dependencies.getHyperLoopHealth(), 'Hyper Loop'),
+            withTimeout(this.dependencies.getRepoMemoryHealth(context), 'Repo Memory'),
+            withTimeout(this.dependencies.getDevtoolsBridgeHealth(), 'DevTools Bridge'),
+        ]);
+        return { overallOk: v3Agent.ok && (hyperLoop.ok || repoMemory.ok), v3Agent, hyperLoop, repoMemory, devtoolsBridge };
+    }
+    async getHealth() {
+        const [coder, models, selfHosted] = await Promise.all([
+            this.dependencies.getCoderHealth(), this.dependencies.getModelsHealth(), this.dependencies.getSelfHostedHealth(),
+        ]);
+        return { overallOk: coder.ok && models.ok, coder, models, selfHosted };
+    }
+}

package/dist/utils/chat-prompt-policy.d.ts

@@ -0,0 +1,18 @@
+export interface ChatRuntimeEnvironment {
+    platform: 'windows' | 'macos' | 'linux' | 'unknown';
+    shell?: string;
+    pathStyle?: 'windows' | 'posix';
+    cwd?: string;
+    [key: string]: unknown;
+}
+export declare class ChatPromptPolicy {
+    private readonly getRuntime;
+    constructor(getRuntime: () => ChatRuntimeEnvironment);
+    isDiagnostic(prompt: string): boolean;
+    isAnalysisLookup(prompt: string): boolean;
+    isBrowserTask(prompt: string): boolean;
+    isRepoGrounded(prompt: string): boolean;
+    isOperatorDirectAnswerable(prompt: string): boolean;
+    buildShapingInstructions(prompt: string): string;
+    buildExecutionPrompt(prompt: string): string;
+}

package/dist/utils/chat-prompt-policy.js

@@ -0,0 +1,61 @@
+import { taskRequiresWorkspaceChanges } from './requestIntent.js';
+export class ChatPromptPolicy {
+    getRuntime;
+    constructor(getRuntime) {
+        this.getRuntime = getRuntime;
+    }
+    isDiagnostic(prompt) {
+        if (taskRequiresWorkspaceChanges(prompt))
+            return false;
+        return /(startup|start up|won'?t start|doesn'?t start|crash|crashes|error|errors|failing|fails|issue|issues|bug|bugs|diagnos|debug|runtime|log|logs|exception|traceback|stack trace|yaml|blocking|blocker)/i.test(prompt);
+    }
+    isAnalysisLookup(prompt) {
+        if (taskRequiresWorkspaceChanges(prompt))
+            return false;
+        const text = prompt.trim();
+        return /^(what|which|where|how many|who|find|list|show|check|inspect|analyze|analyse|audit|explain|describe|summarize|summarise|review|overview|count|read|look at|tell me|locate|search for|does .* exist)/i.test(text)
+            || /\b(where\s+(?:is|are)|what\s+(?:is|are|have|did|was|were)|how\s+(?:do|does|is|are)|what\s+(?:have\s+)?you\s+(?:done|changed|built)|what\s+(?:is|was)\s+(?:your|the)\s+answer)\b/i.test(text);
+    }
+    isBrowserTask(prompt) {
+        return /(\bbrowser\b|\bchrome\b|\bdevtools\b|\bconsole\b|\bdom\b|network tab|network request|frontend runtime|client-side|client side|rendering|page load|\bwebsocket\b|ui bug|inspect element)/i.test(prompt);
+    }
+    isRepoGrounded(prompt) {
+        const text = prompt.trim();
+        return /\b(src\/|\.js\b|\.ts\b|\.py\b|\.jsx\b|\.tsx\b|\.css\b|\.html\b|\.json\b|\.yaml\b|\.yml\b)/i.test(text)
+            || /\b(file|folder|directory|module|class|function|method|variable|handler|listener|binding|conflict|bug|issue|error)\b/i.test(text)
+            || /\b(inspect|analyze|analyse|audit|review|find|diagnose|debug|trace|compare|diff|check|investigate)\b/i.test(text)
+            || /\b(Camera|InputManager|keydown|KeyS|KeyA|KeyW|stopPropagation|addEventListener|handleKeyDown)\b/.test(text)
+            || /\/[a-zA-Z]/.test(text)
+            || /[A-Z][a-z]+\.[a-z_][a-zA-Z]+/.test(text)
+            || /\b(key\s*code|keydown|keyup|key\s*bind|event\s*listener|event\s*handler|addEventListener|handleKey|onKey)\b/i.test(text);
+    }
+    isOperatorDirectAnswerable(prompt) {
+        const text = prompt.trim();
+        if (/^(status(\s+check)?|health(\s+check)?|ping)$/i.test(text))
+            return true;
+        if (this.isRepoGrounded(text))
+            return false;
+        return text.length < 120 && /^(reply with|say|echo|respond with|return|ping|hello|hi|test|status|what is \d|how much is)\b/i.test(text);
+    }
+    buildShapingInstructions(prompt) {
+        const instructions = [];
+        const runtime = this.getRuntime();
+        if (runtime.platform === 'windows')
+            instructions.push('Platform: Windows. Use list_dir, glob, read_file, and the grep tool for searching.', 'The grep tool handles Windows automatically — do not use bash to call grep, findstr, or Select-String manually.', 'Do not use bash for Unix commands (cat, head, tail, awk, sed, wc).', 'Use read_file to inspect file contents instead of shell commands.', 'All file paths use forward slashes internally.');
+        else if (runtime.platform === 'macos')
+            instructions.push('Platform: macOS. Prefer list_dir, grep, and read_file tools for deterministic results.', 'Use workspace-relative paths and verify file existence before claiming a file is missing.');
+        else if (runtime.platform === 'linux')
+            instructions.push('Platform: Linux. Prefer list_dir, grep, and read_file for grounded repository inspection.', 'Use exact file paths from tool output when reporting findings or fixes.');
+        if (this.isAnalysisLookup(prompt))
+            instructions.push('Read-only analysis mode is active.', 'Inspect the workspace with tools and produce a grounded report of findings, gaps, and blockers.', 'Do not create, modify, or delete files unless the user explicitly asked for changes.');
+        if (this.isDiagnostic(prompt))
+            instructions.push('Diagnostic mode is active.', 'Treat this as a debugging task, not a generic code review or feature request.', 'Start with concrete evidence: logs, runtime errors, config, launch files, and exact symbol references.', 'If log files exist, inspect them before proposing fixes.', 'Do not claim a file, definition, asset, or symbol is missing until you verify that with tools.', 'Prefer grep plus read_file around the exact references involved in the failure.', 'Separate your reasoning into: Evidence, Confirmed Cause, and Remaining Hypotheses.', 'CRITICAL GROUNDING RULE: Every key name, variable name, symbol, or identifier in the final answer must appear verbatim in tool evidence.', 'CROSS-FILE ATTRIBUTION: Report a key or symbol as conflicting only when tool evidence shows it in both files.', 'Cite exact file, line, and string evidence for each reported conflict.');
+        if (this.isBrowserTask(prompt))
+            instructions.push('Browser-debug mode is active.', 'Prefer concrete browser evidence such as console errors, network failures, DOM state, and websocket behavior.', 'Use the DevTools Bridge only when the user explicitly enabled it for this run.');
+        return instructions.join('\n');
+    }
+    buildExecutionPrompt(prompt) {
+        const shaping = this.buildShapingInstructions(prompt);
+        return shaping ? `${prompt}\n\n${shaping}` : prompt;
+    }
+}

package/dist/utils/chat-tool-call-parser.d.ts

@@ -0,0 +1,11 @@
+export interface ParsedToolCall {
+    tool: string;
+    args: Record<string, string>;
+}
+export declare class ChatToolCallParser {
+    extract(message: string): ParsedToolCall[];
+    normalizeName(name: string): string;
+    parseLegacy(message: string): ParsedToolCall[];
+    parsePayload(payload: string): ParsedToolCall | null;
+    strip(message: string): string;
+}

package/dist/utils/chat-tool-call-parser.js

@@ -0,0 +1,71 @@
+export class ChatToolCallParser {
+    extract(message) {
+        const calls = [];
+        const seen = new Set();
+        const add = (call) => {
+            if (!call)
+                return;
+            const key = `${call.tool}::${JSON.stringify(call.args)}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                calls.push(call);
+            }
+        };
+        for (const match of message.matchAll(/<tool_call>([\s\S]*?)<\/tool_call>/g))
+            add(this.parsePayload(match[1] || ''));
+        for (const call of this.parseLegacy(message))
+            add(call);
+        return calls;
+    }
+    normalizeName(name) {
+        const normalized = name.trim().toLowerCase();
+        const aliases = {
+            list_directory: 'list_dir', listdirectory: 'list_dir', ls: 'list_dir', dir: 'list_dir',
+            readfile: 'read_file', writefile: 'write_file', editfile: 'edit_file',
+            shell: 'bash', command: 'bash', run_command: 'bash',
+        };
+        return aliases[normalized] || normalized;
+    }
+    parseLegacy(message) {
+        const calls = [];
+        const functionRegex = /<function\s*=\s*["']?([A-Za-z0-9_-]+)["']?>\s*([\s\S]*?)(?:<\/function>|$)/gi;
+        for (const match of message.matchAll(functionRegex)) {
+            const tool = this.normalizeName(match[1] || '');
+            if (!tool)
+                continue;
+            const args = {};
+            const parameterRegex = /<parameter\s*=\s*["']?([A-Za-z0-9_-]+)["']?>\s*([\s\S]*?)(?=<parameter\s*=|<\/function>|<\/parameter>|$)/gi;
+            for (const parameter of (match[2] || '').matchAll(parameterRegex)) {
+                if (parameter[1])
+                    args[parameter[1]] = (parameter[2] || '').replace(/<\/parameter>\s*$/i, '').trim();
+            }
+            calls.push({ tool, args });
+        }
+        return calls;
+    }
+    parsePayload(payload) {
+        const normalized = payload.trim();
+        if (!normalized)
+            return null;
+        try {
+            const parsed = JSON.parse(normalized);
+            if (typeof parsed.tool !== 'string')
+                return null;
+            const args = {};
+            if (parsed.args && typeof parsed.args === 'object') {
+                for (const [key, value] of Object.entries(parsed.args))
+                    args[key] = typeof value === 'string' ? value : JSON.stringify(value);
+            }
+            return { tool: this.normalizeName(parsed.tool), args };
+        }
+        catch {
+            return null;
+        }
+    }
+    strip(message) {
+        return message
+            .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '')
+            .replace(/<function\s*=\s*["']?[A-Za-z0-9_-]+["']?>[\s\S]*?(?:<\/function>|$)/gi, '')
+            .trim();
+    }
+}

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

@@ -21,13 +21,30 @@ export interface CliStateShape {
         latestVersion: string;
         notifiedFor?: string;
     };
-    gatewayPreflight?: {
+    gatewayPreflight?: Record<string, {
         checkedAt: number;
         valid: boolean;
-    };
+        endpoint: string;
+        credentialFingerprint: string;
+        capability: string;
+        configurationFingerprint: string;
+    }>;
     /** Last-seen version — used to render release notes on upgrade. */
     lastSeenVersion?: string;
 }
+export interface GatewayPreflightCacheKeyInput {
+    endpoint: string;
+    credential: string;
+    capability: string;
+    relevantConfiguration?: unknown;
+}
+export interface GatewayPreflightCacheKey {
+    id: string;
+    endpoint: string;
+    credentialFingerprint: string;
+    capability: string;
+    configurationFingerprint: string;
+}
 export declare function ensureStateDir(): void;
 /** Best-effort lock-down: `0o600` on POSIX, no-op on Windows (NTFS ACL ≠ chmod). */
 export declare function secureFileMode(filePath: string): void;
@@ -49,8 +66,9 @@ export declare function isUpdateCheckSuppressed(): boolean;
 /** Cached read for the latest known version — null when stale or absent. */
 export declare function readCachedLatestVersion(maxAgeMs?: number): string | null;
 export declare function writeCachedLatestVersion(latestVersion: string, notifiedFor?: string): void;
-export declare function readGatewayPreflightCache(maxAgeMs?: number): boolean | null;
-export declare function writeGatewayPreflightCache(valid: boolean): void;
+export declare function createGatewayPreflightCacheKey(input: GatewayPreflightCacheKeyInput): GatewayPreflightCacheKey;
+export declare function readGatewayPreflightCache(key: GatewayPreflightCacheKey, maxAgeMs?: number): boolean | null;
+export declare function writeGatewayPreflightCache(key: GatewayPreflightCacheKey, valid: boolean): void;
 /**
  * Invalidate any cached gateway-preflight result.  Must be called on
  * every login/logout/token change so a stale cached `false` from a