vigthoria-cli 1.10.48 → 1.10.49

package/dist/utils/api.js

@@ -254,33 +254,15 @@ export function propagateError(err) {
 const DEFAULT_V3_AGENT_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_AGENT_TIMEOUT_MS || process.env.V3_AGENT_TIMEOUT_MS;
     if (!rawValue) {
-        return 0;
+        return 300000;
     }
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 300000;
 })();
 const DEFAULT_V3_AGENT_IDLE_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_AGENT_IDLE_TIMEOUT_MS || process.env.V3_AGENT_IDLE_TIMEOUT_MS;
-    if (!rawValue) {
-        return 0;
-    }
-    const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
-})();
-const DEFAULT_MCP_BIND_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_MCP_BIND_TIMEOUT_MS || process.env.MCP_BIND_TIMEOUT_MS || '5000';
+    const rawValue = process.env.VIGTHORIA_AGENT_IDLE_TIMEOUT_MS || process.env.V3_AGENT_IDLE_TIMEOUT_MS || '90000';
     const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 5000;
-})();
-const DEFAULT_WORKSPACE_SCAN_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_WORKSPACE_SCAN_TIMEOUT_MS || '2500';
-    const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 2500;
-})();
-const DEFAULT_WORKSPACE_SCAN_MAX_FILES = (() => {
-    const rawValue = process.env.VIGTHORIA_WORKSPACE_SCAN_MAX_FILES || '1800';
-    const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 1800;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 90000;
 })();
 const DEFAULT_OPERATOR_TIMEOUT_MS = (() => {
     const rawValue = process.env.VIGTHORIA_OPERATOR_TIMEOUT_MS || process.env.OPERATOR_TIMEOUT_MS;
@@ -290,16 +272,6 @@ const DEFAULT_OPERATOR_TIMEOUT_MS = (() => {
     const parsed = Number.parseInt(rawValue, 10);
     return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
 })();
-const DEFAULT_CHAT_CONNECT_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_CHAT_CONNECT_TIMEOUT_MS || '20000';
-    const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 20000;
-})();
-const DEFAULT_CHAT_IDLE_TIMEOUT_MS = (() => {
-    const rawValue = process.env.VIGTHORIA_CHAT_IDLE_TIMEOUT_MS || '120000';
-    const parsed = Number.parseInt(rawValue, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 120000;
-})();
 export class APIClient {
     client;
     modelRouterClient;
@@ -1143,76 +1115,13 @@ export class APIClient {
             // Non-fatal: fall through; the health check will surface the auth error.
         }
     }
-    /**
-     * Fast preflight for local agent loop — probes model backends in parallel
-     * so users see a clear pass/fail before "Planning..." hangs on slow routes.
-     */
-    async runChatModelPreflight(requestedModel = 'agent') {
-        const routes = [];
-        const probes = [
-            {
-                name: 'Vigthoria Coder API',
-                run: async () => {
-                    const health = await this.getCoderHealth();
-                    return { ok: health.ok, error: health.error };
-                },
-            },
-            {
-                name: 'Vigthoria Models API',
-                run: async () => {
-                    const health = await this.getModelsHealth();
-                    return { ok: health.ok, error: health.error };
-                },
-            },
-        ];
-        const selfHostedHealth = await this.getSelfHostedHealth();
-        if (selfHostedHealth) {
-            probes.unshift({
-                name: selfHostedHealth.name || 'Dedicated Models API',
-                run: async () => ({ ok: selfHostedHealth.ok, error: selfHostedHealth.error }),
-            });
-        }
-        if (this.isSelfHostedPreferredModel(this.resolveModelId(requestedModel), requestedModel)) {
-            // Agent/code models should also accept V3 health as a usable inference path.
-            probes.push({
-                name: 'V3 Agent API',
-                run: async () => {
-                    const v3 = await this.runV3HealthCheck();
-                    return { ok: v3.healthy, error: v3.error };
-                },
-            });
-        }
-        const results = await Promise.all(probes.map(async (probe) => {
-            try {
-                const result = await probe.run();
-                routes.push({ name: probe.name, ok: result.ok, error: result.error });
-                return result.ok;
-            }
-            catch (error) {
-                const message = error.message || String(error);
-                routes.push({ name: probe.name, ok: false, error: message });
-                return false;
-            }
-        }));
-        const healthy = results.some(Boolean);
-        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,
-        };
-    }
-    async runV3HealthCheck(options = {}) {
-        await this.ensureV3ServiceKey();
+    async runV3HealthCheck() {
         const endpoints = this.getV3AgentBaseUrls(false);
         const headers = await this.getV3AgentHeaders();
-        const perEndpointTimeoutMs = 8000;
-        const probe = async (baseUrl) => {
+        for (const baseUrl of endpoints) {
             const runUrl = this.getV3AgentRunUrl(baseUrl);
+            // Use the lightweight GET /health endpoint — no LLM invocation, responds instantly.
+            // For local 8030 the path is /health directly; for remote it's /api/v3-agent/health via proxy.
             const healthUrl = /127\.0\.0\.1:8030|localhost:8030/.test(baseUrl)
                 ? `${baseUrl}/health`
                 : `${baseUrl}/api/v3-agent/health`;
@@ -1220,198 +1129,29 @@ export class APIClient {
                 const response = await fetch(healthUrl, {
                     method: 'GET',
                     headers,
-                    signal: AbortSignal.timeout(perEndpointTimeoutMs),
+                    signal: AbortSignal.timeout(8000),
                 });
                 if (response.status === 401 || response.status === 403) {
                     return {
                         healthy: false,
                         endpoint: runUrl,
-                        error: 'V3 service rejected authentication. Run: vigthoria login',
+                        error: 'V3 service rejected authentication. Please re-login to refresh your token.',
                     };
                 }
+                // 200 OK or 405 Method Not Allowed both mean V3 is reachable
                 if (response.ok || response.status === 405) {
                     return { healthy: true, endpoint: runUrl };
                 }
-                if (response.status === 502 || response.status === 503 || response.status === 504) {
-                    return {
-                        healthy: false,
-                        endpoint: runUrl,
-                        error: `V3 agent proxy returned ${response.status}. The V3 Code Agent service may be restarting or overloaded.`,
-                    };
-                }
-                return {
-                    healthy: false,
-                    endpoint: runUrl,
-                    error: `V3 agent health returned ${response.status}`,
-                };
             }
-            catch (error) {
-                const reason = error?.message || String(error);
-                if (/timeout|aborted|timed out/i.test(reason)) {
-                    return {
-                        healthy: false,
-                        endpoint: runUrl,
-                        error: options.soft
-                            ? 'V3 health probe timed out; continuing with agent stream.'
-                            : 'V3 agent health check timed out. The service may be busy with another run or temporarily overloaded.',
-                    };
-                }
-                return {
-                    healthy: false,
-                    endpoint: runUrl,
-                    error: reason,
-                };
+            catch {
+                continue;
             }
-        };
-        const results = await Promise.all(endpoints.map((baseUrl) => probe(baseUrl)));
-        const healthy = results.find((entry) => entry.healthy);
-        if (healthy) {
-            return healthy;
         }
-        const timedOut = results.find((entry) => /timed out/i.test(entry.error || ''));
-        if (timedOut) {
-            return timedOut;
-        }
-        return results[0] || {
+        return {
             healthy: false,
-            endpoint: this.getV3AgentRunUrl(endpoints[0] || 'https://coder.vigthoria.io'),
-            error: 'V3 agent service is not responding.',
-        };
-    }
-    resolveChatConnectTimeoutMs(options = {}) {
-        if (options.connectTimeoutMs && options.connectTimeoutMs > 0) {
-            return options.connectTimeoutMs;
-        }
-        if (options.timeoutMs && options.timeoutMs > 0 && options.timeoutMs <= 60000) {
-            return options.timeoutMs;
-        }
-        return DEFAULT_CHAT_CONNECT_TIMEOUT_MS;
-    }
-    resolveChatIdleTimeoutMs(options = {}) {
-        if (options.idleTimeoutMs && options.idleTimeoutMs > 0) {
-            return options.idleTimeoutMs;
-        }
-        if (options.timeoutMs && options.timeoutMs > 60000) {
-            return options.timeoutMs;
-        }
-        return DEFAULT_CHAT_IDLE_TIMEOUT_MS;
-    }
-    mapPreflightEndpointToRoute(endpoint) {
-        const normalized = String(endpoint || '').toLowerCase();
-        if (normalized.includes('coder'))
-            return 'coder';
-        if (normalized.includes('models'))
-            return 'models';
-        if (normalized.includes('dedicated') || normalized.includes('self-hosted') || normalized.includes('selfhosted')) {
-            return 'selfhosted';
-        }
-        return null;
-    }
-    isCanonicalCoderDuplicate() {
-        const apiUrl = String(this.config.get('apiUrl') || '').replace(/\/$/, '').toLowerCase();
-        return apiUrl === 'https://coder.vigthoria.io';
-    }
-    async consumeOpenAIStreamResponse(response, idleTimeoutMs, onDelta) {
-        if (!response.body) {
-            throw new Error('Streaming response had no body');
-        }
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = '';
-        let content = '';
-        let lastActivity = Date.now();
-        const waitForChunk = async () => {
-            const remainingIdle = idleTimeoutMs - (Date.now() - lastActivity);
-            if (idleTimeoutMs > 0 && remainingIdle <= 0) {
-                throw new Error('Model stream stalled (no output)');
-            }
-            const readPromise = reader.read();
-            if (idleTimeoutMs <= 0) {
-                return readPromise;
-            }
-            return Promise.race([
-                readPromise,
-                new Promise((_, reject) => {
-                    setTimeout(() => reject(new Error('Model stream stalled (no output)')), Math.max(1000, remainingIdle));
-                }),
-            ]);
+            endpoint: endpoints[0] ? this.getV3AgentRunUrl(endpoints[0]) : 'unknown',
+            error: 'V3 service is not reachable during startup preflight. Check if V3 Code Agent is online and reachable.',
         };
-        while (true) {
-            const { done, value } = await waitForChunk();
-            if (done) {
-                break;
-            }
-            lastActivity = Date.now();
-            buffer += decoder.decode(value, { stream: true });
-            const frames = buffer.split(/\r?\n\r?\n/);
-            buffer = frames.pop() || '';
-            for (const frame of frames) {
-                const dataLines = frame
-                    .split(/\r?\n/)
-                    .filter((line) => line.startsWith('data:'))
-                    .map((line) => line.slice(5).trimStart());
-                const payload = dataLines.join('\n').trim();
-                if (!payload || payload === '[DONE]') {
-                    continue;
-                }
-                try {
-                    const parsed = JSON.parse(payload);
-                    const delta = parsed?.choices?.[0]?.delta?.content
-                        || parsed?.choices?.[0]?.message?.content
-                        || parsed?.choices?.[0]?.text
-                        || '';
-                    if (typeof delta === 'string' && delta) {
-                        content += delta;
-                        onDelta?.(delta);
-                        lastActivity = Date.now();
-                    }
-                }
-                catch {
-                    // Ignore malformed stream frames.
-                }
-            }
-        }
-        return content.trim();
-    }
-    async tryStreamingModelRouterChat(baseURL, messages, resolvedModel, requestedModel, headers, options) {
-        const connectTimeoutMs = this.resolveChatConnectTimeoutMs(options);
-        const idleTimeoutMs = this.resolveChatIdleTimeoutMs(options);
-        const controller = new AbortController();
-        const connectTimer = setTimeout(() => controller.abort(), connectTimeoutMs);
-        try {
-            const response = await fetch(`${baseURL.replace(/\/$/, '')}/v1/chat/completions`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...headers,
-                },
-                body: JSON.stringify({
-                    model: resolvedModel,
-                    messages,
-                    max_tokens: this.config.get('preferences').maxTokens,
-                    temperature: 0.7,
-                    stream: true,
-                }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                return null;
-            }
-            clearTimeout(connectTimer);
-            const content = await this.consumeOpenAIStreamResponse(response, idleTimeoutMs, options.onStreamDelta);
-            if (!content) {
-                return null;
-            }
-            return {
-                id: `vigthoria-stream-${Date.now()}`,
-                message: content,
-                model: resolvedModel || requestedModel,
-            };
-        }
-        catch (error) {
-            clearTimeout(connectTimer);
-            throw error;
-        }
     }
     async runV3AgentAuthPreflight(baseUrl, body, executionContext) {
         const endpoint = this.getV3AgentRunUrl(baseUrl);
@@ -1670,11 +1410,10 @@ export class APIClient {
         const targetPath = resolvedContext.targetPath || resolvedContext.projectPath || resolvedContext.workspacePath || resolvedContext.projectRoot || process.cwd();
         const localWorkspacePath = this.resolveAgentTargetPath(resolvedContext);
         const serverWorkspacePath = this.resolveServerBindableWorkspacePath(resolvedContext);
-        const prompt = String(resolvedContext.rawPrompt || resolvedContext.contextualPrompt || '').trim();
-        const localWorkspaceSummary = this.buildLocalWorkspaceSummary(localWorkspacePath, { prompt });
+        const localWorkspaceSummary = this.buildLocalWorkspaceSummary(localWorkspacePath);
         const requestedModel = String(resolvedContext.model || resolvedContext.requestedModel || 'agent');
         const resolvedModel = this.resolvePermittedModelId(requestedModel);
-        const localWorkspaceName = localWorkspacePath ? path.basename(localWorkspacePath) : null;
+        const localWorkspaceName = this.getDisplayWorkspaceName(localWorkspacePath);
         const localWorkspaceRef = localWorkspaceName ? `vigthoria://local-workspace/${localWorkspaceName}` : null;
         const publicRuntimeEnvironment = this.buildPublicRuntimeEnvironment(resolvedContext.agentRuntime, {
             localWorkspacePath,
@@ -1723,50 +1462,6 @@ export class APIClient {
             requestStartedAt: resolvedContext.requestStartedAt,
             subscriptionPlan: this.config.getNormalizedPlan() || null,
             email: this.config.get('email') || null,
-            rawPrompt: prompt || null,
-            promptFocusTerms: prompt ? this.extractPromptFocusTerms(prompt) : [],
-            vigthoriaBrain: resolvedContext.vigthoriaBrain
-                ? this.trimVigthoriaBrainForTransport(resolvedContext.vigthoriaBrain)
-                : null,
-            clientToolExecution: resolvedContext.clientToolExecution === true
-                || (resolvedContext.localMachineCapable !== false
-                    && (resolvedContext.executionSurface === 'cli' || resolvedContext.clientSurface === 'cli')
-                    && !!localWorkspacePath
-                    && !serverWorkspacePath),
-            approvalLevel: resolvedContext.autoApprove === true ? 'auto' : (resolvedContext.approvalLevel || 'confirm'),
-            allowedCommands: Array.isArray(resolvedContext.allowedCommands) ? resolvedContext.allowedCommands : [],
-            clientToolPathRules: (resolvedContext.clientToolExecution === true || (resolvedContext.localMachineCapable !== false
-                && (resolvedContext.executionSurface === 'cli' || resolvedContext.clientSurface === 'cli')
-                && !!localWorkspacePath
-                && !serverWorkspacePath))
-                ? [
-                    'Client-side read tools execute on the user real machine via the CLI.',
-                    'Use paths relative to the workspace root only.',
-                    'Never prefix tool paths with workspace/ or vigthoria://workspace/.',
-                    `The workspace root folder name is "${localWorkspaceName || 'project'}". Do not repeat it in paths.`,
-                    'Examples: ".", "Vigthoria-dominion/README.md", "vigthoria-dominion-win/".',
-                ].join(' ')
-                : null,
-            executionHints: {
-                ...(resolvedContext.agentTaskType === 'analysis'
-                    ? {
-                        max_iterations: Number.parseInt(process.env.VIGTHORIA_ANALYSIS_MAX_ITERATIONS || '15', 10) || 15,
-                        task_kind: 'analysis',
-                        requires_file_changes: false,
-                        analysis_guidance: this.buildAnalysisGuidance(Array.isArray(localWorkspaceSummary?.promptFocusDirectories)
-                            ? localWorkspaceSummary.promptFocusDirectories
-                            : [], Array.isArray(localWorkspaceSummary?.mandatoryReadPaths)
-                            ? localWorkspaceSummary.mandatoryReadPaths
-                            : []),
-                    }
-                    : {}),
-                ...(['implementation', 'game-build', 'web-build', 'build', 'fix'].includes(String(resolvedContext.agentTaskType || '').toLowerCase())
-                    ? {
-                        requires_file_changes: true,
-                        task_kind: String(resolvedContext.agentTaskType || 'implementation').toLowerCase(),
-                    }
-                    : {}),
-            },
         };
         return this.compactV3Context(payload);
     }
@@ -1794,15 +1489,9 @@ export class APIClient {
             const overhead = json.length - JSON.stringify(summary.workspaceFiles).length;
             const budget = LIMIT - overhead - 512; // reserve a little headroom
             if (budget > 0) {
-                const focusTerms = Array.isArray(payload.promptFocusTerms) ? payload.promptFocusTerms : [];
-                const focusDirectories = Array.isArray(payload.localWorkspaceSummary?.promptFocusDirectories)
-                    ? payload.localWorkspaceSummary.promptFocusDirectories
-                    : [];
-                const sortedEntries = [...fileEntries].sort((a, b) => this.scoreWorkspacePathForHydration(b[0], focusTerms, focusDirectories)
-                    - this.scoreWorkspacePathForHydration(a[0], focusTerms, focusDirectories));
                 const trimmed = {};
                 let used = 2; // {}
-                for (const [k, v] of sortedEntries) {
+                for (const [k, v] of fileEntries) {
                     const entryLen = JSON.stringify(k).length + 1 + JSON.stringify(v).length + 1;
                     if (used + entryLen > budget)
                         break;
@@ -1869,7 +1558,7 @@ export class APIClient {
             || resolvedContext.projectRoot
             || process.cwd();
         const serverWorkspacePath = this.resolveServerBindableWorkspacePath(resolvedContext);
-        const localWorkspaceName = targetPath ? path.basename(targetPath) : null;
+        const localWorkspaceName = this.getDisplayWorkspaceName(targetPath);
         const localWorkspaceRef = localWorkspaceName ? `vigthoria://local-workspace/${localWorkspaceName}` : null;
         return JSON.stringify({
             workspace: this.buildPublicWorkspaceDescriptor(resolvedContext.workspace, {
@@ -2368,8 +2057,7 @@ menu {
         const headers = await this.getMcpHeaders();
         const localWorkspacePath = this.resolveAgentTargetPath(executionContext);
         const workspacePath = this.resolveServerBindableWorkspacePath(executionContext);
-        const prompt = String(executionContext.rawPrompt || executionContext.contextualPrompt || '').trim();
-        const localWorkspaceSummary = this.buildLocalWorkspaceSummary(localWorkspacePath, { prompt });
+        const localWorkspaceSummary = this.buildLocalWorkspaceSummary(localWorkspacePath);
         const metadata = {
             source: 'vigthoria-cli',
             sharedContextId: executionContext.contextId,
@@ -2405,7 +2093,6 @@ menu {
                 method: 'PUT',
                 headers,
                 body: JSON.stringify({ data }),
-                signal: AbortSignal.timeout(DEFAULT_MCP_BIND_TIMEOUT_MS),
             });
             if (!response.ok) {
                 const errorText = await response.text().catch(() => '');
@@ -2437,7 +2124,6 @@ menu {
                         userId: this.config.get('userId') || this.config.get('email') || 'vigthoria-cli',
                         metadata,
                     }),
-                    signal: AbortSignal.timeout(DEFAULT_MCP_BIND_TIMEOUT_MS),
                 });
                 if (!createResponse.ok) {
                     const errorText = await createResponse.text().catch(() => '');
@@ -2467,7 +2153,7 @@ menu {
         if (!candidate || !path.isAbsolute(candidate) || !fs.existsSync(candidate)) {
             return '';
         }
-        const configuredRoots = (process.env.VIGTHORIA_SERVER_WORKSPACE_ROOTS || '/var/www,/var/www/vigthoria-user-workspaces,/var/lib/vigthoria-workspaces')
+        const configuredRoots = (process.env.VIGTHORIA_SERVER_WORKSPACE_ROOTS || '/var/www/vigthoria-user-workspaces,/var/lib/vigthoria-workspaces')
             .split(',')
             .map((entry) => entry.trim())
             .filter(Boolean);
@@ -2488,8 +2174,16 @@ menu {
         }
         return '';
     }
+    getDisplayWorkspaceName(workspacePath) {
+        const cleaned = String(workspacePath || '').trim().replace(/[\\/]+$/g, '');
+        if (!cleaned) {
+            return null;
+        }
+        const parts = cleaned.split(/[\\/]+/).filter(Boolean);
+        return parts.length > 0 ? parts[parts.length - 1] : cleaned;
+    }
     buildPublicWorkspaceDescriptor(workspace, paths = {}) {
-        const localName = paths.localWorkspacePath ? path.basename(paths.localWorkspacePath) : null;
+        const localName = this.getDisplayWorkspaceName(paths.localWorkspacePath || '');
         const isServerBindable = !!paths.serverWorkspacePath;
         const descriptor = {
             name: localName,
@@ -2510,9 +2204,8 @@ menu {
         if (!runtime || typeof runtime !== 'object') {
             return null;
         }
-        const localName = paths.localWorkspacePath ? path.basename(paths.localWorkspacePath) : null;
+        const localName = this.getDisplayWorkspaceName(paths.localWorkspacePath || '');
         const serverBindableWorkspace = !!paths.serverWorkspacePath || runtime.serverBindableWorkspace === true;
-        const isLocalMachine = !serverBindableWorkspace;
         return {
             osPlatform: runtime.osPlatform || null,
             platform: runtime.platform || null,
@@ -2523,273 +2216,17 @@ menu {
             workspaceName: localName,
             workspacePath: serverBindableWorkspace ? paths.serverWorkspacePath || null : (localName ? `vigthoria://local-workspace/${localName}` : null),
             cwd: serverBindableWorkspace ? paths.serverWorkspacePath || null : (localName ? `vigthoria://local-workspace/${localName}` : null),
-            localExecutionRequired: isLocalMachine,
-            toolExecutionSurface: isLocalMachine ? 'cli-local' : 'server-workspace',
-            executionGuidance: isLocalMachine
-                ? 'The user runs Vigthoria CLI on their local machine. Real files and folders live on the client filesystem. Server workspace tools only see a partial hydrated copy — read `.vigthoria-workspace-index.md` and `promptFocusDirectories` before guessing root-level README.md. Prefer localWorkspaceSummary for structure and tell the user when live local tool execution is required.'
-                : null,
-        };
-    }
-    extractPromptFocusTerms(prompt) {
-        const terms = new Set();
-        const normalized = String(prompt || '').trim();
-        if (!normalized) {
-            return [];
-        }
-        for (const match of normalized.matchAll(/["'`]([^"'`]{2,120})["'`]/g)) {
-            terms.add(match[1].trim());
-        }
-        for (const match of normalized.matchAll(/(?:project|game|folder|directory|path|repo(?:sitory)?)\s+([A-Za-z0-9][\w ._-]{2,80})/gi)) {
-            terms.add(match[1].trim());
-        }
-        for (const match of normalized.matchAll(/(?:investigate|find|explore|look at|check|inspect|analyse|analyze)\s+(?:the\s+)?([A-Za-z0-9][\w ._-]{2,80}?)(?:\s+(?:folder|directory|foulder|dir|project|game))?\b/gi)) {
-            terms.add(match[1].trim());
-        }
-        for (const match of normalized.matchAll(/\b([A-Z][a-z0-9]+(?:\s+[A-Z][a-z0-9]+)+)\b/g)) {
-            const phrase = match[1].trim();
-            if (phrase.length <= 48) {
-                terms.add(phrase);
-            }
-        }
-        for (const match of normalized.matchAll(/\/([\w .-]{2,80})/g)) {
-            const segment = match[1].trim();
-            if (!/^(users|home|desktop|documents|var|www|c)$/i.test(segment)) {
-                terms.add(segment);
-            }
-        }
-        return [...terms].filter((term) => term.length >= 3 && term.length <= 48).slice(0, 8);
-    }
-    buildTopLevelWorkspaceLayout(rootPath) {
-        const skipDirs = new Set(['.git', 'node_modules', '.next', 'dist', 'build', 'coverage', '.cache', '__pycache__', '.venv', 'venv']);
-        const layout = { directories: [], files: [] };
-        try {
-            for (const entry of fs.readdirSync(rootPath, { withFileTypes: true })) {
-                if (entry.name.startsWith('.')) {
-                    continue;
-                }
-                if (entry.isDirectory()) {
-                    if (!skipDirs.has(entry.name)) {
-                        layout.directories.push(entry.name);
-                    }
-                }
-                else if (entry.isFile()) {
-                    layout.files.push(entry.name);
-                }
-            }
-        }
-        catch {
-            return layout;
-        }
-        layout.directories.sort((a, b) => a.localeCompare(b));
-        layout.files.sort((a, b) => a.localeCompare(b));
-        return layout;
-    }
-    normalizeFocusPathKey(value) {
-        return String(value || '').toLowerCase().replace(/[\s_./\\-]+/g, '');
-    }
-    resolvePromptFocusDirectories(rootPath, focusTerms) {
-        const layout = this.buildTopLevelWorkspaceLayout(rootPath);
-        const matches = new Set();
-        const normalizedTerms = focusTerms.map((term) => term.toLowerCase());
-        const normalizedTermKeys = focusTerms.map((term) => this.normalizeFocusPathKey(term));
-        for (const dir of layout.directories) {
-            const dirLower = dir.toLowerCase();
-            const dirKey = this.normalizeFocusPathKey(dir);
-            for (let index = 0; index < normalizedTerms.length; index += 1) {
-                const term = normalizedTerms[index];
-                const termKey = normalizedTermKeys[index];
-                if (dirLower === term
-                    || dirLower.includes(term)
-                    || term.includes(dirLower)
-                    || (termKey && (dirKey === termKey || dirKey.includes(termKey) || termKey.includes(dirKey)))) {
-                    matches.add(`${dir.replace(/\\/g, '/')}/`);
-                }
-            }
-        }
-        for (const term of focusTerms) {
-            const candidate = path.join(rootPath, term);
-            if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
-                matches.add(`${term.replace(/\\/g, '/')}/`);
-            }
-        }
-        return [...matches];
-    }
-    buildMandatoryFocusReadPaths(rootPath, focusDirectories) {
-        const candidates = [];
-        const pushIfExists = (relativePath) => {
-            const normalized = relativePath.replace(/\\/g, '/');
-            const absolutePath = path.join(rootPath, normalized);
-            if (fs.existsSync(absolutePath)) {
-                candidates.push(normalized);
-            }
         };
-        for (const focusDir of focusDirectories) {
-            const base = focusDir.replace(/\\/g, '/').replace(/\/$/, '');
-            pushIfExists(`${base}/package.json`);
-            pushIfExists(`${base}/game.js`);
-            pushIfExists(`${base}/src/Game.js`);
-            pushIfExists(`${base}/src/factions/FactionModels.js`);
-            pushIfExists(`${base}/GAME_DESIGN_DOCUMENT.md`);
-        }
-        const layout = this.buildTopLevelWorkspaceLayout(rootPath);
-        for (const dir of layout.directories) {
-            if (/dominion/i.test(dir) && /-win|desktop|electron/i.test(dir)) {
-                pushIfExists(`${dir.replace(/\\/g, '/')}/`);
-            }
-        }
-        return [...new Set(candidates)];
-    }
-    buildAnalysisGuidance(focusDirectories, mandatoryReadPaths) {
-        const focusLabel = focusDirectories.length > 0
-            ? focusDirectories.map((entry) => entry.replace(/\/$/, '')).join(', ')
-            : 'the requested project folder';
-        const reads = mandatoryReadPaths.length > 0
-            ? mandatoryReadPaths.slice(0, 12).map((entry) => `- \`${entry}\``).join('\n')
-            : '- package.json\n- game.js\n- src/Game.js\n- src/factions/\n- GAME_DESIGN_DOCUMENT.md';
-        return [
-            `The user asked for a grounded overview of ${focusLabel}.`,
-            'Do NOT summarize from root README.md, PRODUCTION_ROADMAP.md, or PROJECT_STATUS_REPORT.md alone — they may be stale or AI-generated.',
-            'Read these code-first paths before writing your final answer:',
-            reads,
-            'MANDATORY: Compare README claims against package.json, game.js, and src/. If they disagree, your final answer MUST:',
-            '1) State what the game actually is based on code,',
-            '2) Quote what README incorrectly claims,',
-            '3) Explicitly say "README is inconsistent with the codebase" and recommend fixing it.',
-            'List `vigthoria-dominion-win/` (or similar) if present to confirm desktop/Electron distribution.',
-        ].join('\n');
-    }
-    collectFocusDirectoryFilePaths(rootPath, focusDirRelative, maxFiles = 250) {
-        const focusRoot = path.join(rootPath, focusDirRelative);
-        if (!fs.existsSync(focusRoot)) {
-            return [];
-        }
-        const skipDirs = new Set(['.git', 'node_modules', '.next', 'dist', 'build', 'coverage', '.cache', '__pycache__', '.venv', 'venv']);
-        const results = [];
-        const stack = [{ abs: focusRoot, rel: focusDirRelative.replace(/\\/g, '/') }];
-        while (stack.length > 0 && results.length < maxFiles) {
-            const current = stack.pop();
-            if (!current) {
-                continue;
-            }
-            let entries;
-            try {
-                entries = fs.readdirSync(current.abs, { withFileTypes: true });
-            }
-            catch {
-                continue;
-            }
-            for (const entry of entries) {
-                if (results.length >= maxFiles) {
-                    break;
-                }
-                const rel = `${current.rel}${current.rel.endsWith('/') ? '' : '/'}${entry.name}`.replace(/\\/g, '/');
-                const abs = path.join(current.abs, entry.name);
-                if (entry.isDirectory()) {
-                    if (!skipDirs.has(entry.name) && !entry.name.startsWith('.')) {
-                        stack.push({ abs, rel: `${rel}/` });
-                    }
-                }
-                else if (entry.isFile()) {
-                    results.push(rel);
-                }
-            }
-        }
-        return results;
-    }
-    mergeWorkspacePathCandidates(primary, extras) {
-        const seen = new Set();
-        const merged = [];
-        for (const candidate of [...extras, ...primary]) {
-            const normalized = candidate.replace(/\\/g, '/');
-            if (!normalized || seen.has(normalized)) {
-                continue;
-            }
-            seen.add(normalized);
-            merged.push(normalized);
-        }
-        return merged;
-    }
-    scoreWorkspacePathForHydration(filePath, focusTerms, focusDirectories = []) {
-        const normalized = filePath.replace(/\\/g, '/').toLowerCase();
-        let score = 0;
-        if (normalized === '.vigthoria-workspace-index.md') {
-            score += 1000;
-        }
-        if (normalized.endsWith('package.json')) {
-            score += 360;
-        }
-        if (/(^|\/)game\.js$/i.test(normalized) || /\/src\/game\.js$/i.test(normalized)) {
-            score += 350;
-        }
-        if (/\/src\/factions\//i.test(normalized) || /factionmodels\.js/i.test(normalized)) {
-            score += 340;
-        }
-        if (/game_design_document\.md/i.test(normalized)) {
-            score += 320;
-        }
-        if (normalized.endsWith('readme.md')) {
-            score += focusDirectories.some((dir) => normalized.startsWith(dir.toLowerCase())) ? 120 : 40;
-        }
-        if (/production_roadmap|project_status_report|status_report|roadmap\.md/i.test(normalized)) {
-            score += 20;
-        }
-        if (/\.(js|ts|tsx|jsx|mjs|cjs)$/i.test(normalized)) {
-            score += 100;
-        }
-        if (/\.(md|txt|json|yaml|yml|toml)$/i.test(normalized)) {
-            score += 40;
-        }
-        for (const dir of focusDirectories.map((entry) => entry.toLowerCase())) {
-            if (normalized.startsWith(dir)) {
-                score += 250;
-            }
-        }
-        for (const term of focusTerms) {
-            const termLower = term.toLowerCase();
-            const termKey = this.normalizeFocusPathKey(term);
-            if (normalized.includes(termLower) || (termKey && normalized.replace(/[\s_./\\-]+/g, '').includes(termKey))) {
-                score += 80;
-            }
-        }
-        return score;
     }
-    sortWorkspacePathsForHydration(filePaths, focusTerms, focusDirectories) {
-        return [...filePaths].sort((a, b) => this.scoreWorkspacePathForHydration(b, focusTerms, focusDirectories)
-            - this.scoreWorkspacePathForHydration(a, focusTerms, focusDirectories));
-    }
-    trimVigthoriaBrainForTransport(brain, maxChars = 12000) {
-        try {
-            const serialized = typeof brain === 'string' ? brain : JSON.stringify(brain);
-            if (serialized.length <= maxChars) {
-                return typeof brain === 'string' ? brain : JSON.parse(serialized);
-            }
-            return {
-                truncated: true,
-                excerpt: serialized.slice(0, maxChars),
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    buildLocalWorkspaceSummary(rootPath, options = {}) {
+    buildLocalWorkspaceSummary(rootPath) {
         if (!rootPath || !fs.existsSync(rootPath)) {
             return null;
         }
         try {
-            const prompt = String(options.prompt || '').trim();
-            const focusTerms = prompt ? this.extractPromptFocusTerms(prompt) : [];
-            const topLevelLayout = this.buildTopLevelWorkspaceLayout(rootPath);
-            const focusDirectories = this.resolvePromptFocusDirectories(rootPath, focusTerms);
-            const mandatoryReadPaths = this.buildMandatoryFocusReadPaths(rootPath, focusDirectories);
             const summary = {
                 path: 'vigthoria://workspace/',
-                name: path.basename(rootPath),
+                name: this.getDisplayWorkspaceName(rootPath) || path.basename(rootPath),
                 files: [],
-                topLevelLayout,
-                promptFocusTerms: focusTerms,
-                promptFocusDirectories: focusDirectories,
-                mandatoryReadPaths,
             };
             const snapshot = this.getAgentWorkspaceSnapshot(rootPath);
             summary.fileCount = snapshot.fileCount;
@@ -2806,34 +2243,12 @@ menu {
                 };
             }
             const readmePath = path.join(rootPath, 'README.md');
-            if (focusDirectories.length === 0 && fs.existsSync(readmePath)) {
+            if (fs.existsSync(readmePath)) {
                 summary.readmeExcerpt = fs.readFileSync(readmePath, 'utf8').slice(0, 2500);
             }
-            else if (focusDirectories.length > 0) {
-                summary.readmeWarning = 'Root README and planning docs are often stale or agent-generated. Prefer package.json, game.js, src/, and GAME_DESIGN_DOCUMENT.md inside the focus folder.';
-            }
-            for (const focusDir of focusDirectories) {
-                const focusReadme = path.join(rootPath, focusDir, 'README.md');
-                if (fs.existsSync(focusReadme)) {
-                    summary.focusReadmeWarning = summary.focusReadmeWarning || {};
-                    summary.focusReadmeWarning[`${focusDir}README.md`.replace(/\\/g, '/')] =
-                        'Subfolder README may be stale or wrong. Prefer package.json, game.js, src/, and GAME_DESIGN_DOCUMENT.md.';
-                }
-            }
-            const focusPaths = [
-                ...mandatoryReadPaths,
-                ...focusDirectories.flatMap((focusDir) => this.collectFocusDirectoryFilePaths(rootPath, focusDir)),
-            ];
-            const hydrationPaths = this.sortWorkspacePathsForHydration(this.mergeWorkspacePathCandidates(snapshot.paths, focusPaths), focusTerms, focusDirectories);
             // Hydrate workspace: include actual file contents so the V3 server
             // can populate the remote workspace before the agent starts.
-            summary.workspaceFiles = this.collectWorkspaceFileContents(rootPath, hydrationPaths);
-            summary.workspaceFiles['.vigthoria-workspace-index.md'] = this.buildWorkspaceIndexFile(rootPath, snapshot, {
-                focusTerms,
-                focusDirectories,
-                topLevelLayout,
-                mandatoryReadPaths,
-            });
+            summary.workspaceFiles = this.collectWorkspaceFileContents(rootPath, snapshot.paths);
             return summary;
         }
         catch (error) {
@@ -2841,68 +2256,13 @@ menu {
             return null;
         }
     }
-    buildWorkspaceIndexFile(rootPath, snapshot, options = {}) {
-        const workspaceName = path.basename(rootPath);
-        const listedPaths = snapshot.paths.slice(0, 1800);
-        const focusTerms = options.focusTerms || [];
-        const focusDirectories = options.focusDirectories || [];
-        const mandatoryReadPaths = options.mandatoryReadPaths || [];
-        const topLevelLayout = options.topLevelLayout || this.buildTopLevelWorkspaceLayout(rootPath);
-        const lines = [
-            '# Vigthoria Local Workspace Index',
-            '',
-            'This file is generated by the Vigthoria CLI so the remote V3 agent can search and understand the local workspace layout without seeing private machine paths.',
-            'Read this file before guessing paths like README.md at the workspace root.',
-            'README.md, PRODUCTION_ROADMAP.md, and PROJECT_STATUS_REPORT.md may be stale or AI-generated. Trust package.json, game.js, src/, and GAME_DESIGN_DOCUMENT.md instead.',
-            '',
-            '## Path rules for client-side tools',
-            '- The workspace root is already bound to the user folder below.',
-            '- Use relative paths from that root: `.`, `Vigthoria-dominion/`, `README.md`.',
-            '- NEVER prefix paths with `workspace/` — that alias does not exist on the user machine.',
-            '- Do NOT repeat the workspace folder name in paths.',
-            '',
-            `Workspace name: ${workspaceName}`,
-            `Indexed files: ${snapshot.fileCount}`,
-            '',
-            '## Top-level layout',
-            ...(topLevelLayout.directories.length > 0
-                ? topLevelLayout.directories.map((dir) => `- ${dir}/`)
-                : ['- (no subdirectories listed)']),
-            ...(topLevelLayout.files.length > 0
-                ? ['', '## Top-level files', ...topLevelLayout.files.map((file) => `- ${file}`)]
-                : []),
-        ];
-        if (focusTerms.length > 0 || focusDirectories.length > 0) {
-            lines.push('', '## Prompt focus');
-            if (focusTerms.length > 0) {
-                lines.push(`User focus terms: ${focusTerms.join(', ')}`);
-            }
-            if (focusDirectories.length > 0) {
-                lines.push('Likely project folders:');
-                for (const focusDir of focusDirectories) {
-                    lines.push(`- ${focusDir}`);
-                }
-            }
-            if (mandatoryReadPaths.length > 0) {
-                lines.push('', '## Mandatory code-first reads (before summarizing)');
-                for (const readPath of mandatoryReadPaths.slice(0, 12)) {
-                    lines.push(`- ${readPath}`);
-                }
-            }
-        }
-        lines.push('', '## Files', ...listedPaths.map((filePath) => `- ${filePath.replace(/\\/g, '/')}`));
-        if (snapshot.fileCount > listedPaths.length) {
-            lines.push('', `Index truncated: ${snapshot.fileCount - listedPaths.length} additional files were not listed.`);
-        }
-        return `${lines.join('\n')}\n`;
-    }
     /**
      * Collect text file contents from the workspace for V3 agent hydration.
      * Budget: up to ~2 MB total, per-file cap 200 KB, skip binary extensions.
      */
     collectWorkspaceFileContents(rootPath, filePaths) {
-        const MAX_TOTAL_BYTES = Number.parseInt(process.env.VIGTHORIA_WORKSPACE_HYDRATION_MAX_BYTES || '', 10) || (8 * 1024 * 1024);
-        const MAX_FILE_BYTES = Number.parseInt(process.env.VIGTHORIA_WORKSPACE_HYDRATION_MAX_FILE_BYTES || '', 10) || (512 * 1024);
+        const MAX_TOTAL_BYTES = 2 * 1024 * 1024;
+        const MAX_FILE_BYTES = 200 * 1024;
         const BINARY_EXTENSIONS = new Set([
             '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg', '.webp', '.avif',
             '.mp3', '.mp4', '.wav', '.ogg', '.webm', '.flac', '.aac',
@@ -2948,24 +2308,14 @@ menu {
             if (!root || !fs.existsSync(root)) {
                 return false;
             }
-            const skipDirs = new Set(['.git', 'node_modules', '.next', 'dist', 'build', 'coverage', '.cache', '__pycache__', '.venv', 'venv']);
-            const startedAt = Date.now();
             const stack = [root];
-            let scannedDirs = 0;
             while (stack.length > 0) {
-                if (Date.now() - startedAt > DEFAULT_WORKSPACE_SCAN_TIMEOUT_MS) {
-                    return false;
-                }
                 const current = stack.pop();
                 if (!current)
                     continue;
-                scannedDirs += 1;
-                if (scannedDirs > DEFAULT_WORKSPACE_SCAN_MAX_FILES) {
-                    return false;
-                }
                 const entries = fs.readdirSync(current, { withFileTypes: true });
                 for (const entry of entries) {
-                    if (skipDirs.has(entry.name)) {
+                    if (entry.name === '.git' || entry.name === 'node_modules') {
                         continue;
                     }
                     const fullPath = path.join(current, entry.name);
@@ -2984,24 +2334,16 @@ menu {
         return false;
     }
     getAgentWorkspaceSnapshot(rootPath) {
-        const skipDirs = new Set(['.git', 'node_modules', '.next', 'dist', 'build', 'coverage', '.cache', '__pycache__', '.venv', 'venv']);
         const stack = [rootPath];
-        const startedAt = Date.now();
         let fileCount = 0;
         const entries = [];
         while (stack.length > 0) {
-            if (Date.now() - startedAt > DEFAULT_WORKSPACE_SCAN_TIMEOUT_MS) {
-                break;
-            }
-            if (entries.length >= DEFAULT_WORKSPACE_SCAN_MAX_FILES) {
-                break;
-            }
             const current = stack.pop();
             if (!current) {
                 continue;
             }
             for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-                if (skipDirs.has(entry.name)) {
+                if (entry.name === '.git' || entry.name === 'node_modules') {
                     continue;
                 }
                 const fullPath = path.join(current, entry.name);
@@ -3015,9 +2357,6 @@ menu {
                 fileCount += 1;
                 const stat = fs.statSync(fullPath);
                 entries.push(`${path.relative(rootPath, fullPath)}:${stat.size}:${stat.mtimeMs}`);
-                if (entries.length >= DEFAULT_WORKSPACE_SCAN_MAX_FILES) {
-                    break;
-                }
             }
         }
         entries.sort();
@@ -3136,16 +2475,11 @@ menu {
                 streamedFiles[filePath] = args.content;
                 return;
             }
-            if (event.name === 'edit_file') {
-                const oldString = args.old_string ?? args.old_text;
-                const newString = args.new_string ?? args.new_text;
-                if (typeof oldString === 'string' && typeof newString === 'string') {
-                    const existing = streamedFiles[filePath];
-                    if (typeof existing === 'string' && existing.includes(oldString)) {
-                        streamedFiles[filePath] = existing.replace(oldString, newString);
-                    }
+            if (event.name === 'edit_file' && typeof args.old_string === 'string' && typeof args.new_string === 'string') {
+                const existing = streamedFiles[filePath];
+                if (typeof existing === 'string' && existing.includes(args.old_string)) {
+                    streamedFiles[filePath] = existing.replace(args.old_string, args.new_string);
                 }
-                return;
             }
         }
     }
@@ -3663,32 +2997,26 @@ document.addEventListener('DOMContentLoaded', () => {
     formatV3AgentResponse(data) {
         const result = data?.result || {};
         if (typeof result === 'string') {
-            return sanitizeUserFacingPathText(result);
+            return this.sanitizeV3AgentResponseText(result);
         }
-        if (typeof result?.summary === 'string' && result.summary.trim() && !this.isGenericV3AgentSummary(result.summary)) {
-            return sanitizeUserFacingPathText(result.summary);
+        if (typeof result?.summary === 'string' && result.summary.trim()) {
+            return this.sanitizeV3AgentResponseText(result.summary);
         }
-        if (typeof result?.message === 'string' && result.message.trim() && !this.isGenericV3AgentSummary(result.message)) {
-            return sanitizeUserFacingPathText(result.message);
+        if (typeof result?.message === 'string' && result.message.trim()) {
+            return this.sanitizeV3AgentResponseText(result.message);
         }
         if (Array.isArray(data?.events)) {
-            const completionEvent = [...data.events].reverse().find((event) => event && event.type === 'complete' && typeof event.summary === 'string' && event.summary.trim() && !this.isGenericV3AgentSummary(event.summary));
+            const completionEvent = [...data.events].reverse().find((event) => event && event.type === 'complete' && typeof event.summary === 'string' && event.summary.trim());
             if (completionEvent) {
                 return sanitizeUserFacingPathText(completionEvent.summary);
             }
             const messageEvent = [...data.events].reverse().find((event) => event && event.type === 'message' && typeof event.content === 'string' && event.content.trim());
             if (messageEvent) {
-                return sanitizeUserFacingPathText(messageEvent.content);
+                return this.sanitizeV3AgentResponseText(messageEvent.content);
             }
             // Synthesize a grounded answer from the tool-call evidence the
             // agent produced, rather than dumping the raw event trace.
-            const answer = this.synthesizeAnswerFromV3Events(data.events, data.liveToolEvidence);
-            if (answer) {
-                return answer;
-            }
-        }
-        if (Array.isArray(data?.liveToolEvidence) && data.liveToolEvidence.length > 0) {
-            const answer = this.synthesizeAnswerFromV3Events([], data.liveToolEvidence);
+            const answer = this.synthesizeAnswerFromV3Events(data.events);
             if (answer) {
                 return answer;
             }
@@ -3701,444 +3029,85 @@ document.addEventListener('DOMContentLoaded', () => {
         const text = sanitizeUserFacingPathText(JSON.stringify(data, null, 2));
         return text.length > 12000 ? `${text.slice(0, 12000)}\n\n[V3 agent output truncated]` : text;
     }
-    isGenericV3AgentSummary(value) {
-        const text = String(value || '').trim();
-        if (!text)
-            return true;
-        return /^(task completed|v3 agent workflow completed\.?|agent run finished|workflow completed\.?|max iterations \(\d+\) reached after\b)/i.test(text);
-    }
-    isV3StreamStatusMessage(value) {
-        const text = String(value || '').trim();
-        if (!text)
-            return true;
-        return /^(the agent produced an in-progress note|continuing to finish cleanly|a previous tool call failed|max iterations \(\d+\) reached)/i.test(text)
-            || /pending blocker|not been resolved|instead of a final report/i.test(text);
-    }
-    scoreEvidenceFilePath(filePath) {
-        const normalized = String(filePath || '').replace(/\\/g, '/').toLowerCase();
-        let score = 0;
-        if (normalized.endsWith('package.json'))
-            score += 100;
-        if (/(^|\/)game\.js$/i.test(normalized) || /\/src\/game\.js$/i.test(normalized))
-            score += 95;
-        if (/\/src\/factions\//i.test(normalized) || /factionmodels\.js/i.test(normalized))
-            score += 90;
-        if (/game_design_document\.md/i.test(normalized))
-            score += 85;
-        if (/\.(js|ts|tsx|jsx|mjs|cjs)$/i.test(normalized))
-            score += 70;
-        if (normalized.endsWith('index.html'))
-            score += 50;
-        if (/production_roadmap|project_status_report|status_report/i.test(normalized))
-            score += 5;
-        if (normalized.endsWith('readme.md'))
-            score += normalized.includes('vigthoria-dominion') ? 25 : 10;
-        return score;
-    }
-    isLowTrustDocPath(filePath) {
-        const normalized = String(filePath || '').replace(/\\/g, '/').toLowerCase();
-        return normalized.endsWith('readme.md')
-            || /production_roadmap|project_status_report|status_report|roadmap\.md/i.test(normalized);
-    }
-    extractCodeSignalsFromEvidence(filesRead, liveToolEvidence = []) {
-        const signals = new Set();
-        const ingest = (filePath, excerpt) => {
-            const normalized = String(filePath || '').replace(/\\/g, '/').toLowerCase();
-            const text = String(excerpt || '');
-            const lower = text.toLowerCase();
-            if (normalized.endsWith('package.json')) {
-                const match = text.match(/"description"\s*:\s*"([^"]+)"/i);
-                if (match?.[1])
-                    signals.add(`package.json: ${match[1]}`);
-                if (/rts|real-time strategy|command & conquer/i.test(text)) {
-                    signals.add('package.json identifies a real-time strategy game project.');
-                }
-            }
-            if (/(^|\/)game\.js$/i.test(normalized) || /\/src\/game\.js$/i.test(normalized)) {
-                if (/rts|real-time strategy|command & conquer|dune 2000|3d rts/i.test(lower)) {
-                    signals.add('game.js entry identifies a 3D RTS engine (Command & Conquer / Dune 2000 style).');
-                }
-            }
-            if (/\/src\/factions\//i.test(normalized) || /factionmodels\.js/i.test(normalized)) {
-                const factions = ['Iron Dominion', 'Nova Collective', 'Aqua Tide', 'Swarm Hive']
-                    .filter((name) => lower.includes(name.toLowerCase()));
-                if (factions.length >= 2) {
-                    signals.add(`Faction code references: ${factions.join(', ')} (4-faction RTS).`);
-                }
-            }
-            if (/vigthoria-dominion-win/i.test(normalized) || /dist-desktop|electron/i.test(lower)) {
-                signals.add('Desktop/Electron build artifacts are present (full desktop RTS distribution).');
-            }
-        };
-        for (const entry of filesRead)
-            ingest(entry.path, entry.excerpt);
-        for (const entry of liveToolEvidence) {
-            if (entry?.success === false)
-                continue;
-            ingest(String(entry.target || entry.arguments?.path || ''), String(entry.output || ''));
-        }
-        return [...signals];
-    }
-    classifyGameGenreFromText(text) {
-        const lower = String(text || '').toLowerCase();
-        if (/card game|deck-building|dominion is a deck|treasure cards?|victory points?|buy phase|action phase/i.test(lower)) {
-            return 'card/deck-building game';
-        }
-        if (/rts|real-time strategy|command & conquer|dune 2000|3d rts|build bases|gather resources|train units/i.test(lower)) {
-            return '3D real-time strategy (RTS) game';
-        }
-        if (/turn-based strategy|4x strategy/i.test(lower)) {
-            return 'turn-based strategy game';
-        }
-        if (/platformer|roguelike|puzzle game/i.test(lower)) {
-            const match = lower.match(/(platformer|roguelike|puzzle game)/i);
-            return match?.[1] || null;
-        }
-        return null;
-    }
-    extractReadmeGenreClaims(filesRead, liveToolEvidence = []) {
-        const claims = [];
-        const ingest = (filePath, excerpt) => {
-            const normalized = String(filePath || '').replace(/\\/g, '/');
-            if (!/readme\.md$/i.test(normalized))
-                return;
-            const genre = this.classifyGameGenreFromText(excerpt);
-            if (!genre)
-                return;
-            const lines = String(excerpt || '').split('\n').map((line) => line.trim()).filter(Boolean);
-            const quoteLine = lines.find((line) => /card game|deck|rts|real-time strategy|strategy game|browser game|3d/i.test(line))
-                || lines.slice(0, 6).join(' ');
-            claims.push({
-                path: normalized,
-                genre,
-                quote: quoteLine.slice(0, 220),
-            });
-        };
-        for (const entry of filesRead)
-            ingest(entry.path, entry.excerpt);
-        for (const entry of liveToolEvidence) {
-            if (entry?.success === false)
-                continue;
-            ingest(String(entry.target || entry.arguments?.path || ''), String(entry.output || ''));
-        }
-        return claims;
-    }
-    extractCodeGenreClaims(filesRead, liveToolEvidence = []) {
-        const sources = [];
-        const factions = new Set();
-        let genre = null;
-        const ingest = (filePath, excerpt) => {
-            const normalized = String(filePath || '').replace(/\\/g, '/').toLowerCase();
-            const text = String(excerpt || '');
-            const detected = this.classifyGameGenreFromText(text);
-            const isCodeFile = normalized.endsWith('package.json')
-                || /(^|\/)game\.js$/i.test(normalized)
-                || /\/src\//i.test(normalized);
-            if (detected && isCodeFile) {
-                genre = genre || detected;
-                sources.push(normalized);
-            }
-            if (/\/src\/factions\//i.test(normalized) || /factionmodels\.js/i.test(normalized)) {
-                for (const name of ['Iron Dominion', 'Nova Collective', 'Aqua Tide', 'Swarm Hive']) {
-                    if (text.toLowerCase().includes(name.toLowerCase()))
-                        factions.add(name);
-                }
-            }
-        };
-        for (const entry of filesRead)
-            ingest(entry.path, entry.excerpt);
-        for (const entry of liveToolEvidence) {
-            if (entry?.success === false)
-                continue;
-            ingest(String(entry.target || entry.arguments?.path || ''), String(entry.output || ''));
-        }
-        return { genre, sources: [...new Set(sources)], factions: [...factions] };
-    }
-    buildReadmeCodeConsistencySection(filesRead, liveToolEvidence = []) {
-        const readmeClaims = this.extractReadmeGenreClaims(filesRead, liveToolEvidence);
-        const codeClaims = this.extractCodeGenreClaims(filesRead, liveToolEvidence);
-        if (readmeClaims.length === 0 && !codeClaims.genre) {
-            return null;
-        }
-        const lines = ['## README vs code — consistency check'];
-        if (codeClaims.genre) {
-            lines.push('', '**What the game actually is (from code):**');
-            lines.push(`- Genre: **${codeClaims.genre}**`);
-            if (codeClaims.factions.length >= 2) {
-                lines.push(`- Factions in source: ${codeClaims.factions.join(', ')}`);
-            }
-            if (codeClaims.sources.length > 0) {
-                lines.push(`- Evidence: ${codeClaims.sources.slice(0, 4).map((entry) => `\`${entry}\``).join(', ')}`);
-            }
-        }
-        else {
-            lines.push('', '**What the game actually is (from code):** _Not determined — core code files were not read yet._');
-        }
-        if (readmeClaims.length > 0) {
-            lines.push('', '**What README says:**');
-            for (const claim of readmeClaims.slice(0, 4)) {
-                lines.push(`- \`${claim.path}\` → **${claim.genre}**`);
-                if (claim.quote)
-                    lines.push(`  > "${claim.quote}"`);
-            }
-        }
-        const readmeGenres = new Set(readmeClaims.map((entry) => entry.genre));
-        const hasConflict = codeClaims.genre
-            && readmeClaims.some((entry) => entry.genre !== codeClaims.genre);
-        if (hasConflict && codeClaims.genre) {
-            lines.push('', '**Status: INCONSISTENT** — README documentation contradicts the codebase.', '', `The project code identifies this as a **${codeClaims.genre}**, but README describes it differently (${[...readmeGenres].join('; ')}).`, 'When reporting to the user, state the **code truth first**, then explicitly call out that README is wrong or stale and should be corrected.');
-        }
-        else if (codeClaims.genre && readmeClaims.length > 0) {
-            lines.push('', '**Status: CONSISTENT** — README and code agree on the project type.');
-        }
-        else if (readmeClaims.length > 0 && !codeClaims.genre) {
-            lines.push('', '**Status: UNVERIFIED** — README was read but core code was not inspected.', 'Do not present README claims as fact until package.json, game.js, and src/ are read.');
-        }
-        return lines.join('\n');
-    }
-    detectDocReliabilityWarnings(filesRead, liveToolEvidence = []) {
-        const warnings = [];
-        let subfolderCardGameReadme = false;
-        let codeSaysRts = false;
-        let readRootPlanningDocs = false;
-        let readCoreCode = false;
-        const inspect = (filePath, excerpt) => {
-            const normalized = String(filePath || '').replace(/\\/g, '/').toLowerCase();
-            const lower = String(excerpt || '').toLowerCase();
-            if (/production_roadmap|project_status_report|status_report/i.test(normalized)) {
-                readRootPlanningDocs = true;
-            }
-            if (/vigthoria-dominion\/readme\.md$/i.test(normalized) && /card game|deck-building|dominion is a deck/i.test(lower)) {
-                subfolderCardGameReadme = true;
-            }
-            if (/readme\.md$/i.test(normalized) && /card game|deck-building|dominion is a deck/i.test(lower)) {
-                subfolderCardGameReadme = true;
-            }
-            if (/(^|\/)game\.js$/i.test(normalized) || /\/src\/game\.js$/i.test(normalized) || normalized.endsWith('package.json')) {
-                if (/rts|real-time strategy|command & conquer|3d rts/i.test(lower)) {
-                    codeSaysRts = true;
-                    readCoreCode = true;
-                }
-            }
-            if (/\/src\//i.test(normalized) && /\.(js|ts)$/i.test(normalized)) {
-                readCoreCode = true;
-            }
-        };
-        for (const entry of filesRead)
-            inspect(entry.path, entry.excerpt);
-        for (const entry of liveToolEvidence) {
-            if (entry?.success === false)
-                continue;
-            inspect(String(entry.target || entry.arguments?.path || ''), String(entry.output || ''));
-        }
-        if (subfolderCardGameReadme && codeSaysRts) {
-            warnings.push('README describes a card/deck-building game, but code (`game.js` / `package.json`) describes a 3D RTS. Report the RTS truth first, then tell the user README is inconsistent and should be fixed.');
-        }
-        if (readRootPlanningDocs && !readCoreCode) {
-            warnings.push('The agent read planning/status markdown at the workspace root but did not read core game code under `Vigthoria-dominion/src/` or `package.json`. Any genre/feature summary from those docs may be wrong.');
-        }
-        if (!readCoreCode) {
-            warnings.push('Core source files (`package.json`, entry `game.js`, and key files under `src/`) were not read. The overview may be incomplete until those files are inspected.');
-        }
-        return warnings;
+    sanitizeV3AgentResponseText(input) {
+        let text = sanitizeUserFacingPathText(String(input || ''));
+        text = text
+            .replace(/<think>/gi, '<thinking>')
+            .replace(/<\/think>/gi, '</thinking>')
+            .replace(/<thinking>[\s\S]*?<\/thinking>/gi, '')
+            .replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '')
+            .replace(/```json\s*\[\s*\{[\s\S]*?"tool"[\s\S]*?\}\s*\]\s*```/gi, '')
+            .replace(/```json\s*\{[\s\S]*?"tool"[\s\S]*?\}\s*```/gi, '')
+            .replace(/^\s*(?:json\s*)?\[\s*\{[\s\S]*?"tool"[\s\S]*$/gim, '')
+            .replace(/^\s*(?:list_dir|read_file|write_file|edit_file|glob|grep|bash)\s*$/gim, '')
+            .replace(/\n{3,}/g, '\n\n')
+            .trim();
+        return text;
     }
     /**
      * Build a human-readable answer from the tool results in a V3 event
      * stream when the server didn't emit a proper complete/message event.
      */
-    synthesizeAnswerFromV3Events(events, liveToolEvidence = []) {
+    synthesizeAnswerFromV3Events(events) {
         const toolResults = [];
-        const failedPaths = [];
         const filesRead = [];
         const filesWritten = [];
-        const directoriesListed = [];
-        const searches = [];
         const assistantFragments = [];
-        const pendingToolCalls = [];
-        const ingestToolEvidence = (name, args, output, success) => {
-            const target = String(args.path || args.file_path || args.file || args.target || '').trim();
-            const cleanOutput = sanitizeUserFacingPathText(String(output || '').trim());
-            if (!success || !cleanOutput) {
-                if (!success && cleanOutput) {
-                    const failPath = target || name;
-                    failedPaths.push({
-                        path: sanitizeUserFacingPathText(failPath),
-                        detail: cleanOutput.split('\n').find(Boolean)?.slice(0, 160) || cleanOutput.slice(0, 160),
-                    });
-                    toolResults.push(`[${name}] ${cleanOutput.slice(0, 400)}`);
-                }
-                return;
-            }
-            if (name === 'read_file') {
-                const filePath = target || 'unknown file';
-                const excerpt = cleanOutput.length > 4000 ? `${cleanOutput.slice(0, 4000)}\n\n[...truncated...]` : cleanOutput;
-                filesRead.push({ path: sanitizeUserFacingPathText(filePath), excerpt });
-                return;
-            }
-            if (name === 'list_directory') {
-                const excerpt = cleanOutput.length > 1200 ? `${cleanOutput.slice(0, 1200)}\n[...truncated...]` : cleanOutput;
-                directoriesListed.push({ path: sanitizeUserFacingPathText(target || '.'), excerpt });
-                return;
-            }
-            if (name === 'search_files') {
-                const pattern = String(args.pattern || args.query || '').trim();
-                const searchPath = String(args.path || '.').trim();
-                searches.push(`${pattern || 'search'} in ${sanitizeUserFacingPathText(searchPath)}`);
-                if (cleanOutput.length > 0) {
-                    toolResults.push(`[search_files] ${cleanOutput.slice(0, 600)}`);
-                }
-                return;
-            }
-            if (name === 'write_file' || name === 'create_file' || name === 'edit_file') {
-                if (target)
-                    filesWritten.push(sanitizeUserFacingPathText(target));
-                return;
-            }
-            toolResults.push(`[${name}] ${cleanOutput.slice(0, 600)}`);
-        };
         for (const event of events) {
             if (!event)
                 continue;
-            if (event.type === 'tool_call') {
-                pendingToolCalls.push({
-                    name: String(event.name || event.tool || 'unknown_tool'),
-                    args: event.arguments && typeof event.arguments === 'object' ? event.arguments : {},
-                });
-                continue;
-            }
-            if (event.type === 'tool_result') {
-                const success = event.success !== false;
-                const output = typeof event.output === 'string'
-                    ? event.output
-                    : typeof event.result === 'string'
-                        ? event.result
-                        : '';
-                const name = String(event.name || event.tool || 'unknown_tool');
-                const callIndex = pendingToolCalls.findIndex((call) => call.name === name);
-                const call = callIndex >= 0 ? pendingToolCalls.splice(callIndex, 1)[0] : pendingToolCalls.shift();
-                ingestToolEvidence(name, call?.args || {}, output, success);
+            if (event.type === 'tool_result' && event.success && typeof event.output === 'string') {
+                const name = event.name || 'unknown_tool';
+                if (name === 'read_file' && typeof event.target === 'string') {
+                    filesRead.push(sanitizeUserFacingPathText(event.target));
+                }
+                else if ((name === 'write_file' || name === 'create_file') && typeof event.target === 'string') {
+                    filesWritten.push(sanitizeUserFacingPathText(event.target));
+                }
+                else {
+                    // Keep last ~300 chars of output for context
+                    const excerpt = event.output.length > 300 ? event.output.slice(-300) : event.output;
+                    toolResults.push(`[${name}] ${sanitizeUserFacingPathText(excerpt)}`);
+                }
             }
             if (event.type === 'assistant' && typeof event.content === 'string' && event.content.trim()) {
-                const fragment = sanitizeUserFacingPathText(event.content.trim());
-                if (!this.isV3StreamStatusMessage(fragment)) {
-                    assistantFragments.push(fragment);
-                }
+                const cleaned = this.sanitizeV3AgentResponseText(event.content.trim());
+                if (cleaned)
+                    assistantFragments.push(cleaned);
             }
             // Some servers emit 'text' events for incremental assistant text
             if (event.type === 'text' && typeof event.content === 'string' && event.content.trim()) {
-                const fragment = sanitizeUserFacingPathText(event.content.trim());
-                if (!this.isV3StreamStatusMessage(fragment)) {
-                    assistantFragments.push(fragment);
-                }
-            }
-            if (event.type === 'message' && typeof event.content === 'string' && event.content.trim()) {
-                const fragment = sanitizeUserFacingPathText(event.content.trim());
-                if (!this.isV3StreamStatusMessage(fragment)) {
-                    assistantFragments.push(fragment);
-                }
+                const cleaned = this.sanitizeV3AgentResponseText(event.content.trim());
+                if (cleaned)
+                    assistantFragments.push(cleaned);
             }
             // Some servers emit content_block_delta for streamed text
             if (event.type === 'content_block_delta' && typeof event.delta?.text === 'string' && event.delta.text.trim()) {
-                assistantFragments.push(sanitizeUserFacingPathText(event.delta.text.trim()));
+                const cleaned = this.sanitizeV3AgentResponseText(event.delta.text.trim());
+                if (cleaned)
+                    assistantFragments.push(cleaned);
             }
         }
-        for (const entry of liveToolEvidence) {
-            if (!entry || typeof entry !== 'object')
-                continue;
-            ingestToolEvidence(String(entry.name || entry.tool || 'unknown_tool'), entry.arguments && typeof entry.arguments === 'object' ? entry.arguments : { path: entry.target || entry.path || '' }, String(entry.output || ''), entry.success !== false);
-        }
-        // Prefer grounded tool evidence over streamed status chatter.
-        const hasEvidence = directoriesListed.length > 0
-            || filesRead.length > 0
-            || searches.length > 0
-            || filesWritten.length > 0
-            || toolResults.length > 0
-            || failedPaths.length > 0;
-        if (hasEvidence) {
-            const sections = [];
-            sections.push('## Workspace analysis (from local file inspection)');
-            sections.push('This report is rebuilt from files the agent actually read. **Code and package manifests outrank README/planning docs**, which may be stale or AI-generated.');
-            const codeSignals = this.extractCodeSignalsFromEvidence(filesRead, liveToolEvidence);
-            const consistencySection = this.buildReadmeCodeConsistencySection(filesRead, liveToolEvidence);
-            if (consistencySection) {
-                sections.unshift(consistencySection);
-            }
-            if (codeSignals.length > 0) {
-                sections.push(['## What the code says (trusted)', ...codeSignals.map((line) => `- ${line}`)].join('\n'));
-                if (!consistencySection && codeSignals.some((line) => /rts|real-time strategy|3d rts|4-faction|desktop\/electron/i.test(line))) {
-                    sections.unshift([
-                        '## Executive summary',
-                        'Vigthoria Dominion is a **3D real-time strategy game** (Command & Conquer / Dune 2000 style) with **four factions**, based on code evidence from your local workspace — not from README/planning docs, which may be wrong.',
-                        'The project includes browser/Three.js source (`Vigthoria-dominion/`) and may include a desktop Electron build (`vigthoria-dominion-win/`).',
-                    ].join('\n'));
-                }
-            }
-            else if (consistencySection && /INCONSISTENT/i.test(consistencySection)) {
-                sections.unshift([
-                    '## Executive summary',
-                    'The agent found that **README documentation does not match the codebase**. See the consistency check below — the code defines what this game actually is.',
-                ].join('\n'));
-            }
-            const docWarnings = this.detectDocReliabilityWarnings(filesRead, liveToolEvidence);
-            if (docWarnings.length > 0) {
-                sections.push(['## Documentation reliability warnings', ...docWarnings.map((line) => `- ${line}`)].join('\n'));
-            }
-            if (directoriesListed.length > 0) {
-                const uniqueDirs = new Map();
-                for (const entry of directoriesListed) {
-                    if (!uniqueDirs.has(entry.path))
-                        uniqueDirs.set(entry.path, entry.excerpt);
-                }
-                const dirLines = [...uniqueDirs.entries()].slice(0, 8).map(([dirPath, excerpt]) => {
-                    const preview = excerpt.split('\n').filter(Boolean).slice(0, 12).join('\n');
-                    return `### ${dirPath}\n${preview}`;
-                });
-                sections.push(['## Directories inspected', ...dirLines].join('\n\n'));
-            }
-            if (filesRead.length > 0) {
-                const uniqueFiles = new Map();
-                for (const entry of filesRead) {
-                    if (!uniqueFiles.has(entry.path))
-                        uniqueFiles.set(entry.path, entry.excerpt);
-                }
-                const sortedFiles = [...uniqueFiles.entries()].sort((a, b) => this.scoreEvidenceFilePath(b[0]) - this.scoreEvidenceFilePath(a[0]));
-                const fileLines = sortedFiles.slice(0, 8).map(([filePath, excerpt]) => {
-                    const tag = this.isLowTrustDocPath(filePath) ? ' _(low-trust doc)_' : '';
-                    return `### ${filePath}${tag}\n${excerpt}`;
-                });
-                sections.push(['## Files read (code-first order)', ...fileLines].join('\n\n'));
-            }
-            if (searches.length > 0) {
-                sections.push(`## Searches run\n${Array.from(new Set(searches)).slice(0, 8).map((entry) => `- ${entry}`).join('\n')}`);
-            }
-            if (filesWritten.length > 0) {
-                sections.push(`## Files written\n${Array.from(new Set(filesWritten)).slice(0, 12).map((entry) => `- ${entry}`).join('\n')}`);
-            }
-            if (failedPaths.length > 0) {
-                const uniqueFails = new Map();
-                for (const entry of failedPaths) {
-                    if (!uniqueFails.has(entry.path))
-                        uniqueFails.set(entry.path, entry.detail);
-                }
-                const failLines = [...uniqueFails.entries()].slice(0, 12).map(([failPath, detail]) => `- \`${failPath}\`${detail ? ` — ${detail}` : ''}`);
-                sections.push([
-                    '## Paths not found (exploration misses)',
-                    ...failLines,
-                    '',
-                    '_These paths were guessed by the agent and do not exist at that location. Check the directories inspected above for the correct layout (often under `src/`)._',
-                ].join('\n'));
-            }
-            if (toolResults.length > 0) {
-                sections.push(`## Additional tool evidence\n${toolResults.slice(-5).join('\n\n')}`);
-            }
-            return sections.join('\n\n');
-        }
-        // Concatenate substantive assistant text fragments in order.
+        // Concatenate ALL assistant text fragments in order — keeps full
+        // multi-turn reasoning instead of only the last fragment.
         const fullAssistantText = assistantFragments.join('\n\n').trim();
-        if (fullAssistantText.length > 80 && !this.isGenericV3AgentSummary(fullAssistantText)) {
+        if (fullAssistantText.length > 20) {
             return fullAssistantText;
         }
-        return '';
+        // Otherwise build a summary from tool evidence
+        const sections = [];
+        if (filesRead.length > 0) {
+            sections.push(`Files inspected: ${filesRead.join(', ')}`);
+        }
+        if (filesWritten.length > 0) {
+            sections.push(`Files written: ${filesWritten.join(', ')}`);
+        }
+        if (toolResults.length > 0) {
+            sections.push(toolResults.slice(-5).join('\n'));
+        }
+        return sections.length > 0
+            ? sections.join('\n\n')
+            : '';
     }
     sanitizeV3AgentEventForUser(event) {
         const sanitizeValue = (value) => {
@@ -4288,36 +3257,6 @@ document.addEventListener('DOMContentLoaded', () => {
                         }
                     }
                 }
-                if (event.type === 'approval_required') {
-                    const activeContextId = String(event.context_id || contextId || context.contextId || '').trim();
-                    const approvalId = String(event.approval_id || '').trim();
-                    const command = String(event.command || '').trim();
-                    let approved = context.autoApprove === true;
-                    let allowMode = 'once';
-                    if (!approved) {
-                        const handler = context.onCommandApproval;
-                        if (typeof handler === 'function') {
-                            try {
-                                const decision = await handler(event);
-                                if (decision === true) {
-                                    approved = true;
-                                }
-                                else if (decision && typeof decision === 'object') {
-                                    approved = decision.approved === true;
-                                    allowMode = String(decision.allowMode || decision.allow_mode || 'once');
-                                }
-                            }
-                            catch (error) {
-                                approved = false;
-                                this.logger?.warn?.(`Command approval prompt failed: ${error?.message || error}`);
-                            }
-                        }
-                    }
-                    if (activeContextId && approvalId) {
-                        await this.submitCommandApproval(activeContextId, approvalId, approved, command, allowMode, context.v3BackendUrl);
-                    }
-                    continue;
-                }
                 if (typeof context.onStreamEvent === 'function') {
                     try {
                         context.onStreamEvent(userEvent);
@@ -4326,43 +3265,6 @@ document.addEventListener('DOMContentLoaded', () => {
                         // Ignore UI callback failures; never break the agent stream for them.
                     }
                 }
-                if (event.type === 'client_tool_request') {
-                    const activeContextId = String(event.context_id || contextId || context.contextId || '').trim();
-                    const callId = String(event.call_id || '').trim();
-                    const handler = context.onClientToolExecute;
-                    let toolResult = {
-                        success: false,
-                        output: '',
-                        error: 'No local tool handler configured',
-                    };
-                    if (typeof handler === 'function' && activeContextId && callId) {
-                        try {
-                            toolResult = await handler(event);
-                        }
-                        catch (error) {
-                            toolResult = {
-                                success: false,
-                                output: '',
-                                error: sanitizeUserFacingErrorText(error?.message || 'Local tool execution failed'),
-                            };
-                        }
-                    }
-                    if (activeContextId && callId) {
-                        await this.submitClientToolResult(activeContextId, callId, toolResult, context.v3BackendUrl);
-                    }
-                    continue;
-                }
-                if (event.type === 'context' && typeof context.onWorkspaceContext === 'function') {
-                    try {
-                        await context.onWorkspaceContext({
-                            contextId: String(event.context_id || contextId || '').trim(),
-                            serverWorkspaceRoot: String(event.workspace_root || serverWorkspaceRoot || '').trim(),
-                        });
-                    }
-                    catch {
-                        // Ignore workspace bind callback failures.
-                    }
-                }
                 if (event.type === 'error') {
                     if (event.checkpointed && event.task_id) {
                         // Agent checkpointed — return data so caller can auto-continue
@@ -4416,75 +3318,6 @@ document.addEventListener('DOMContentLoaded', () => {
             serverWorkspaceRoot: serverWorkspaceRoot || null,
         };
     }
-    async submitClientToolResult(contextId, callId, result, backendUrl) {
-        const trimmedContextId = String(contextId || '').trim();
-        const trimmedCallId = String(callId || '').trim();
-        if (!trimmedContextId || !trimmedCallId) {
-            return;
-        }
-        const baseUrl = String(backendUrl || this.getV3AgentBaseUrls()[0] || '').replace(/\/$/, '');
-        if (!baseUrl) {
-            return;
-        }
-        const headers = await this.getV3AgentHeaders();
-        const endpoint = /127\.0\.0\.1:8030|localhost:8030/.test(baseUrl)
-            ? `${baseUrl}/api/agent/client-tool-result`
-            : `${baseUrl}/api/v3-agent/client-tool-result`;
-        const body = JSON.stringify({
-            context_id: trimmedContextId,
-            call_id: trimmedCallId,
-            success: result.success === true,
-            output: String(result.output || ''),
-            error: String(result.error || ''),
-        });
-        for (let attempt = 0; attempt < 3; attempt += 1) {
-            const response = await fetch(endpoint, {
-                method: 'POST',
-                headers: { ...headers, 'Content-Type': 'application/json' },
-                body,
-            });
-            if (response.ok) {
-                return;
-            }
-            const errorText = await response.text().catch(() => '');
-            const isPendingRace = response.status === 404 && /no pending client tool call/i.test(errorText);
-            if (isPendingRace && attempt < 2) {
-                await new Promise((resolve) => setTimeout(resolve, 120 * (attempt + 1)));
-                continue;
-            }
-            throw new Error(`Client tool result rejected (${response.status}): ${sanitizeUserFacingErrorText(errorText).slice(0, 200)}`);
-        }
-    }
-    async submitCommandApproval(contextId, approvalId, approved, command = '', allowMode = 'once', backendUrl) {
-        const trimmedContextId = String(contextId || '').trim();
-        const trimmedApprovalId = String(approvalId || '').trim();
-        if (!trimmedContextId || !trimmedApprovalId) {
-            return;
-        }
-        const baseUrl = String(backendUrl || this.getV3AgentBaseUrls()[0] || '').replace(/\/$/, '');
-        if (!baseUrl) {
-            return;
-        }
-        const headers = await this.getV3AgentHeaders();
-        const endpoint = /127\.0\.0\.1:8030|localhost:8030/.test(baseUrl)
-            ? `${baseUrl}/api/agent/approval`
-            : `${baseUrl}/api/v3-agent/approval`;
-        const response = await fetch(endpoint, {
-            method: 'POST',
-            headers: { ...headers, 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                context_id: trimmedContextId,
-                approval_id: trimmedApprovalId,
-                approved: approved === true,
-                command: String(command || ''),
-                allow_mode: String(allowMode || 'once'),
-            }),
-        });
-        if (!response.ok) {
-            const errorText = await response.text().catch(() => '');
-            throw new Error(`Command approval rejected (${response.status}): ${sanitizeUserFacingErrorText(errorText).slice(0, 200)}`);
-        }
-    }
     async runV3AgentWorkflow(message, context = {}) {
         const executionContext = await this.bindExecutionContext(context);
         const requestedTimeoutMs = Number(executionContext.agentTimeoutMs ?? DEFAULT_V3_AGENT_TIMEOUT_MS);
@@ -4553,10 +3386,7 @@ document.addEventListener('DOMContentLoaded', () => {
                             }
                             throw new Error(`V3 agent ${response.status}: ${sanitized}`);
                         }
-                        const data = await this.collectV3AgentStream(response, {
-                            ...requestExecutionContext,
-                            v3BackendUrl: baseUrl,
-                        });
+                        const data = await this.collectV3AgentStream(response, requestExecutionContext);
                         // Auto-continuation: if the agent checkpointed (budget exceeded), continue automatically
                         if (data.checkpointed && data.checkpointed_task_id) {
                             const maxContinuations = 10;
@@ -4593,10 +3423,7 @@ document.addEventListener('DOMContentLoaded', () => {
                                     if (!continueResponse.ok) {
                                         break; // Fall through to normal completion with partial data
                                     }
-                                    continuationData = await this.collectV3AgentStream(continueResponse, {
-                                        ...requestExecutionContext,
-                                        v3BackendUrl: baseUrl,
-                                    });
+                                    continuationData = await this.collectV3AgentStream(continueResponse, requestExecutionContext);
                                 }
                                 catch {
                                     break; // Fall through to normal completion with partial data
@@ -4613,13 +3440,7 @@ document.addEventListener('DOMContentLoaded', () => {
                             const previewGate = await this.runTemplateServicePreviewGate(message, executionContext);
                             const finalContextId = continuationData.context_id || data.context_id || response.headers.get('x-context-id') || requestExecutionContext.contextId || null;
                             return {
-                                content: this.formatV3AgentResponse({
-                                    ...continuationData,
-                                    liveToolEvidence: requestExecutionContext.liveToolEvidence,
-                                }) || this.formatV3AgentResponse({
-                                    ...data,
-                                    liveToolEvidence: requestExecutionContext.liveToolEvidence,
-                                }),
+                                content: this.formatV3AgentResponse(continuationData) || this.formatV3AgentResponse(data),
                                 taskId: continuationData.task_id || data.task_id || null,
                                 contextId: finalContextId,
                                 backendUrl: baseUrl,
@@ -4638,10 +3459,7 @@ document.addEventListener('DOMContentLoaded', () => {
                             continue;
                         }
                         return {
-                            content: this.formatV3AgentResponse({
-                                ...data,
-                                liveToolEvidence: requestExecutionContext.liveToolEvidence,
-                            }),
+                            content: this.formatV3AgentResponse(data),
                             taskId: data.task_id || null,
                             contextId,
                             backendUrl: baseUrl,
@@ -4655,10 +3473,7 @@ document.addEventListener('DOMContentLoaded', () => {
                             await this.ensureAgentFrontendPolish(message, executionContext);
                             const previewGate = await this.runTemplateServicePreviewGate(message, executionContext);
                             return {
-                                content: this.formatV3AgentResponse({
-                                    ...error.partialData,
-                                    liveToolEvidence: requestExecutionContext.liveToolEvidence,
-                                }) || 'V3 agent wrote workspace files before the request timed out waiting for a final summary.',
+                                content: this.formatV3AgentResponse(error.partialData) || 'V3 agent wrote workspace files before the request timed out waiting for a final summary.',
                                 taskId: error.partialData.task_id || null,
                                 contextId: error.partialData.context_id || requestExecutionContext.contextId || executionContext.contextId || null,
                                 backendUrl: baseUrl,
@@ -4929,7 +3744,7 @@ document.addEventListener('DOMContentLoaded', () => {
      *
      * NO localhost fallbacks - CLI is for external users, not server-side!
      */
-    async chat(messages, model, useLocal = false, options = {}) {
+    async chat(messages, model, useLocal = false) {
         this.lastChatTransportErrors = [];
         const resolvedModel = this.resolveModelId(model);
         const candidateModels = this.isCloudModelId(resolvedModel) && !this.canUseCloudModel()
@@ -4940,7 +3755,7 @@ document.addEventListener('DOMContentLoaded', () => {
             candidateModels.push(fallbackModel);
         }
         for (const candidateModel of candidateModels) {
-            const response = await this.tryChatWithModel(messages, candidateModel, model, options);
+            const response = await this.tryChatWithModel(messages, candidateModel, model);
             if (response) {
                 if (candidateModel !== resolvedModel) {
                     this.logger.debug(`Recovered chat request using fallback model: ${candidateModel}`);
@@ -4954,94 +3769,79 @@ document.addEventListener('DOMContentLoaded', () => {
         }
         throw new CLIError(VIGTHORIA_SERVER_TEMPORARILY_UNAVAILABLE_MESSAGE, 'model_backend');
     }
-    getLastChatTransportErrors() {
-        return [...this.lastChatTransportErrors];
-    }
     shouldSkipCloudRoutes(resolvedModel) {
         return this.shouldSimulateCloudFailure() && this.isCloudModelId(resolvedModel);
     }
-    async tryChatWithModel(messages, resolvedModel, requestedModel, options = {}) {
+    async tryChatWithModel(messages, resolvedModel, requestedModel) {
         const routeFailures = [];
-        const connectTimeoutMs = this.resolveChatConnectTimeoutMs(options);
-        const idleTimeoutMs = this.resolveChatIdleTimeoutMs(options);
-        const useStream = options.stream === true;
-        const notifyRoute = (label) => {
-            try {
-                options.onRouteAttempt?.(label);
-            }
-            catch {
-                // Spinner callbacks must not break chat routing.
-            }
-        };
-        const tryModelsRoute = async () => {
-            if (this.shouldSkipCloudRoutes(resolvedModel) || this.isCloudModelId(resolvedModel)) {
-                return null;
-            }
-            const token = this.getAccessToken();
-            const authHeaders = token ? { Authorization: `Bearer ${token}` } : {};
-            if (useStream) {
-                try {
-                    notifyRoute('Streaming from Vigthoria Models API...');
-                    return await this.tryStreamingModelRouterChat(this.modelRouterClient.defaults.baseURL || 'https://api.vigthoria.io', messages, resolvedModel, requestedModel, authHeaders, options);
-                }
-                catch (error) {
-                    const errMsg = error?.message || 'Unknown error';
-                    routeFailures.push(`models-stream:${String(errMsg).slice(0, 120)}`);
-                }
+        const preferSelfHostedFirst = this.isSelfHostedPreferredModel(resolvedModel, requestedModel);
+        if (preferSelfHostedFirst) {
+            const selfHostedResponse = await this.trySelfHostedChatWithModel(messages, resolvedModel, requestedModel);
+            if (selfHostedResponse) {
+                return selfHostedResponse;
             }
+        }
+        // STRATEGY 1: Direct Vigthoria Models API (api.vigthoria.io)
+        // Cloud aliases must be charged through Coder wallet gates first.
+        if (!this.shouldSkipCloudRoutes(resolvedModel) && !this.isCloudModelId(resolvedModel)) {
             try {
-                notifyRoute('Connecting to Vigthoria Models API...');
+                this.logger.debug(`Direct Vigthoria Models API: ${resolvedModel}`);
+                const token = this.getAccessToken();
                 const response = await this.modelRouterClient.post('/v1/chat/completions', {
                     model: resolvedModel,
                     messages,
                     max_tokens: this.config.get('preferences').maxTokens,
                     temperature: 0.7,
                     stream: false,
-                    cloudAccessApproved: this.isCloudModelId(resolvedModel),
-                    routeClass: 'direct-chat',
                 }, {
-                    timeout: connectTimeoutMs,
-                    headers: {
-                        ...authHeaders,
-                        ...this.buildDirectChatHeaders(this.isCloudModelId(resolvedModel)),
-                    },
+                    headers: token ? { Authorization: `Bearer ${token}` } : {},
                 });
-                const content = response.data.choices?.[0]?.message?.content || response.data.choices?.[0]?.text;
-                if (typeof content === 'string' && content.trim()) {
-                    return {
-                        id: response.data.id || `vigthoria-${Date.now()}`,
-                        message: content,
-                        model: response.data.model || resolvedModel || requestedModel,
-                        usage: response.data.usage,
-                    };
+                if (response.data.choices && response.data.choices.length > 0) {
+                    const content = response.data.choices[0].message?.content || response.data.choices[0].text;
+                    if (typeof content !== 'string' || !content.trim()) {
+                        this.logger.debug(`Direct API returned empty message content for ${resolvedModel}`);
+                    }
+                    else {
+                        return {
+                            id: response.data.id || `vigthoria-${Date.now()}`,
+                            message: content,
+                            model: response.data.model || resolvedModel || requestedModel,
+                            usage: response.data.usage,
+                        };
+                    }
                 }
+                this.logger.debug(`Direct API returned no choices for ${resolvedModel}`);
             }
             catch (error) {
                 const errMsg = error.response?.data?.error || error.message || 'Unknown error';
+                this.logger.debug(`Direct Vigthoria Models API failed for ${resolvedModel}: ${errMsg}`);
                 routeFailures.push(`models:${String(errMsg).slice(0, 120)}`);
             }
-            return null;
-        };
-        const tryCoderRoute = async () => {
-            if (!this.config.isAuthenticated() || this.shouldSkipCloudRoutes(resolvedModel)) {
-                return null;
+        }
+        else {
+            if (this.isCloudModelId(resolvedModel)) {
+                this.logger.debug(`Cloud model ${resolvedModel} routed through Coder wallet gate first; skipping direct models API route.`);
+            }
+            else {
+                this.logger.debug(`Simulating cloud failure for ${resolvedModel}; skipping cloud-backed public API route.`);
             }
+        }
+        // STRATEGY 2: Vigthoria Cloud API via Coder (authenticated users only)
+        if (this.config.isAuthenticated() && !this.shouldSkipCloudRoutes(resolvedModel)) {
             try {
-                notifyRoute('Connecting to Vigthoria Coder API...');
+                this.logger.debug(`Vigthoria Cloud API fallback: ${resolvedModel}`);
                 const response = await this.client.post('/api/ai/chat', {
                     messages,
                     model: resolvedModel,
                     maxTokens: this.config.get('preferences').maxTokens,
                     temperature: 0.7,
-                    routeClass: 'direct-chat',
-                    cloudAccessApproved: this.isCloudModelId(resolvedModel),
-                }, {
-                    timeout: idleTimeoutMs,
-                    headers: this.buildDirectChatHeaders(this.isCloudModelId(resolvedModel)),
                 });
                 if (response.data.success !== false) {
                     const content = response.data.response || response.data.message || response.data.content;
-                    if (typeof content === 'string' && content.trim()) {
+                    if (typeof content !== 'string' || !content.trim()) {
+                        this.logger.debug(`Cloud API returned empty message content for ${resolvedModel}`);
+                    }
+                    else {
                         return {
                             id: response.data.id || `vigthoria-coder-${Date.now()}`,
                             message: content,
@@ -5050,81 +3850,48 @@ document.addEventListener('DOMContentLoaded', () => {
                         };
                     }
                 }
+                this.logger.debug(`Cloud API returned success=false for ${resolvedModel}`);
             }
             catch (error) {
                 const errMsg = error.response?.data?.error || error.message || 'Unknown error';
+                this.logger.debug(`Vigthoria Cloud API failed for ${resolvedModel}: ${errMsg}`);
                 routeFailures.push(`coder:${String(errMsg).slice(0, 120)}`);
             }
-            return null;
-        };
-        const tryCanonicalRoute = async () => {
-            if (options.fastFail || this.isCanonicalCoderDuplicate() || !this.config.isAuthenticated()) {
-                return null;
-            }
             try {
-                notifyRoute('Connecting to Vigthoria Coder (canonical)...');
+                this.logger.debug(`Canonical Vigthoria Cloud fallback: ${resolvedModel}`);
                 const token = this.getAccessToken();
                 const response = await axios.post('https://coder.vigthoria.io/api/ai/chat', {
                     messages,
                     model: resolvedModel,
                     maxTokens: this.config.get('preferences').maxTokens,
                     temperature: 0.7,
-                    routeClass: 'direct-chat',
-                    cloudAccessApproved: this.isCloudModelId(resolvedModel),
                 }, {
-                    timeout: idleTimeoutMs,
+                    timeout: 180000,
                     httpsAgent: this._httpsAgent ?? undefined,
-                    headers: {
-                        ...(token ? { Authorization: `Bearer ${token}`, Cookie: `vigthoria-auth-token=${token}` } : {}),
-                        ...this.buildDirectChatHeaders(this.isCloudModelId(resolvedModel)),
-                    },
+                    headers: token ? { Authorization: `Bearer ${token}`, Cookie: `vigthoria-auth-token=${token}` } : {},
                 });
-                const content = response.data?.response || response.data?.message || response.data?.content;
-                if (response.data?.success !== false && typeof content === 'string' && content.trim()) {
-                    return {
-                        id: response.data.id || `vigthoria-coder-canonical-${Date.now()}`,
-                        message: content,
-                        model: response.data.model || resolvedModel || requestedModel,
-                        usage: response.data.usage,
-                    };
+                if (response.data?.success !== false) {
+                    const content = response.data.response || response.data.message || response.data.content;
+                    if (typeof content === 'string' && content.trim()) {
+                        return {
+                            id: response.data.id || `vigthoria-coder-canonical-${Date.now()}`,
+                            message: content,
+                            model: response.data.model || resolvedModel || requestedModel,
+                            usage: response.data.usage,
+                        };
+                    }
                 }
             }
             catch (error) {
                 const errMsg = error.response?.data?.error || error.message || 'Unknown error';
+                this.logger.debug(`Canonical Vigthoria Cloud fallback failed for ${resolvedModel}: ${errMsg}`);
                 routeFailures.push(`coder-canonical:${String(errMsg).slice(0, 120)}`);
             }
-            return null;
-        };
-        const trySelfHostedRoute = async () => {
-            notifyRoute('Connecting to dedicated model endpoint...');
-            return this.trySelfHostedChatWithModel(messages, resolvedModel, requestedModel, idleTimeoutMs, options);
-        };
-        const preferred = options.preferredRoute
-            || (this.config.isAuthenticated() ? 'coder' : 'models');
-        const singleRouteMode = options.fastFail === true && (options.singleRoute === true || !!options.preferredRoute);
-        const routeOrder = singleRouteMode && options.preferredRoute
-            ? [options.preferredRoute]
-            : preferred === 'coder'
-                ? ['coder', 'models', 'selfhosted']
-                : preferred === 'selfhosted'
-                    ? ['selfhosted', 'coder', 'models']
-                    : ['models', 'coder', 'selfhosted'];
-        for (const route of routeOrder) {
-            let result = null;
-            if (route === 'coder') {
-                result = await tryCoderRoute();
-                if (!result) {
-                    result = await tryCanonicalRoute();
-                }
-            }
-            else if (route === 'models') {
-                result = await tryModelsRoute();
-            }
-            else {
-                result = await trySelfHostedRoute();
-            }
-            if (result) {
-                return result;
+        }
+        if (!preferSelfHostedFirst) {
+            const selfHostedResponse = await this.trySelfHostedChatWithModel(messages, resolvedModel, requestedModel);
+            if (selfHostedResponse) {
+                return selfHostedResponse;
             }
         }
         if (routeFailures.length > 0) {
@@ -5132,7 +3899,7 @@ document.addEventListener('DOMContentLoaded', () => {
         }
         return null;
     }
-    async trySelfHostedChatWithModel(messages, resolvedModel, requestedModel, requestTimeoutMs, options = {}) {
+    async trySelfHostedChatWithModel(messages, resolvedModel, requestedModel) {
         if (!this.selfHostedModelRouterClient || !this.shouldTrySelfHostedFallback(resolvedModel, requestedModel)) {
             return null;
         }
@@ -5146,7 +3913,6 @@ document.addEventListener('DOMContentLoaded', () => {
                 temperature: 0.7,
                 stream: false,
             }, {
-                timeout: requestTimeoutMs,
                 headers: {
                     'x-agent-mode': 'true',
                 },
@@ -5186,37 +3952,11 @@ document.addEventListener('DOMContentLoaded', () => {
         return null;
     }
     isCloudModelId(resolvedModel) {
-        const normalized = String(resolvedModel || '').trim().toLowerCase();
-        const cloudIds = new Set([
-            'deepseek-v3.1:671b-cloud',
-            'moonshotai/kimi-k2.5',
-            'vigthoria-cloud-pro',
-            'vigthoria-cloud-k2',
-            'vigthoria-cloud-ultra',
-            'vigthoria-cloud-fast',
-            'vigthoria-cloud-balanced',
-            'vigthoria-cloud-code',
-            'vigthoria-cloud-power',
-            'vigthoria-cloud-maximum',
-            'cloud-fast',
-            'cloud-balanced',
-            'cloud-code',
-            'cloud-power',
-            'cloud-maximum',
-            'cloud',
-            'cloud-reason',
-            'ultra',
-        ]);
-        return cloudIds.has(normalized) || normalized.includes('vigthoria-cloud-');
-    }
-    buildDirectChatHeaders(isCloud) {
-        const headers = {
-            'x-vigthoria-route-class': 'direct-chat',
-        };
-        if (isCloud) {
-            headers['x-vigthoria-cloud-approved'] = 'true';
-        }
-        return headers;
+        return resolvedModel === 'deepseek-v3.1:671b-cloud'
+            || resolvedModel === 'moonshotai/kimi-k2.5'
+            || resolvedModel === 'vigthoria-cloud-pro'
+            || resolvedModel === 'vigthoria-cloud-k2'
+            || resolvedModel === 'vigthoria-cloud-ultra';
     }
     canUseCloudModel() {
         return this.config.hasCloudAccess();
@@ -6258,6 +4998,123 @@ document.addEventListener('DOMContentLoaded', () => {
             };
         }
     }
+    /**
+     * Fast preflight for local agent loop — probes model backends in parallel
+     * so users see a clear pass/fail before "Planning..." hangs on slow routes.
+     */
+    async runChatModelPreflight(requestedModel = 'agent') {
+        const routes = [];
+        const probes = [
+            {
+                name: 'Vigthoria Coder API',
+                run: async () => {
+                    const health = await this.getCoderHealth();
+                    return { ok: health.ok, error: health.error };
+                },
+            },
+            {
+                name: 'Vigthoria Models API',
+                run: async () => {
+                    const health = await this.getModelsHealth();
+                    return { ok: health.ok, error: health.error };
+                },
+            },
+        ];
+        const selfHostedHealth = await this.getSelfHostedHealth();
+        if (selfHostedHealth) {
+            const sh = selfHostedHealth;
+            probes.unshift({
+                name: sh.name || 'Dedicated Models API',
+                run: async () => ({ ok: sh.ok, error: sh.error }),
+            });
+        }
+        if (this.isSelfHostedPreferredModel(this.resolveModelId(requestedModel), requestedModel)) {
+            // Agent/code models should also accept V3 health as a usable inference path.
+            probes.push({
+                name: 'V3 Agent API',
+                run: async () => {
+                    const v3 = await this.runV3HealthCheck();
+                    return { ok: v3.healthy, error: v3.error };
+                },
+            });
+        }
+        const results = await Promise.all(probes.map(async (probe) => {
+            try {
+                const result = await probe.run();
+                routes.push({ name: probe.name, ok: result.ok, error: result.error });
+                return result.ok;
+            }
+            catch (error) {
+                const message = error?.message || String(error);
+                routes.push({ name: probe.name, ok: false, error: message });
+                return false;
+            }
+        }));
+        const healthy = results.some(Boolean);
+        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,
+        };
+    }
+    mapPreflightEndpointToRoute(endpoint) {
+        const normalized = String(endpoint || '').toLowerCase();
+        if (normalized.includes('coder'))
+            return 'coder';
+        if (normalized.includes('models'))
+            return 'models';
+        if (normalized.includes('dedicated') || normalized.includes('self-hosted') || normalized.includes('selfhosted')) {
+            return 'selfhosted';
+        }
+        return null;
+    }
+    getLastChatTransportErrors() {
+        return this.lastChatTransportErrors;
+    }
+    async submitClientToolResult(contextId, callId, result, backendUrl) {
+        const trimmedContextId = String(contextId || '').trim();
+        const trimmedCallId = String(callId || '').trim();
+        if (!trimmedContextId || !trimmedCallId) {
+            return;
+        }
+        const baseUrl = String(backendUrl || this.getV3AgentBaseUrls()[0] || '').replace(/\/$/, '');
+        if (!baseUrl) {
+            return;
+        }
+        const headers = await this.getV3AgentHeaders();
+        const endpoint = /127\.0\.0\.1:8030|localhost:8030/.test(baseUrl)
+            ? `${baseUrl}/api/agent/client-tool-result`
+            : `${baseUrl}/api/v3-agent/client-tool-result`;
+        const body = JSON.stringify({
+            context_id: trimmedContextId,
+            call_id: trimmedCallId,
+            success: result.success === true,
+            output: String(result.output || ''),
+            error: String(result.error || ''),
+        });
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: { ...headers, 'Content-Type': 'application/json' },
+                body,
+            });
+            if (response.ok) {
+                return;
+            }
+            const errorText = await response.text().catch(() => '');
+            const isPendingRace = response.status === 404 && /no pending client tool call/i.test(errorText);
+            if (isPendingRace && attempt < 2) {
+                await new Promise((resolve) => setTimeout(resolve, 120 * (attempt + 1)));
+                continue;
+            }
+            throw new Error(`Client tool result rejected (${response.status}): ${sanitizeUserFacingErrorText(errorText).slice(0, 200)}`);
+        }
+    }
     isHealthyServicePayload(payload) {
         const status = String(payload?.status || '').toLowerCase();
         return payload?.healthy === true