create-walle 0.9.21 → 0.9.23

package/template/wall-e/chat.js

@@ -6,12 +6,34 @@ const {
   getDefaultClient,
   getDefaultModelForProvider,
   getDefaultProviderType,
+  getProviderRuntimeConfig,
   resolveCompatibleModel,
+  withProviderMessageGuard,
 } = require('./llm/client');
+const { canonicalModelId: canonicalSessionModelId } = require('./llm/model-catalog');
 const { routeLabel } = require('./llm/portkey');
 const { executeLocalTool, LOCAL_TOOL_DEFINITIONS, resolveProjectPath } = require('./tools/local-tools');
+const { buildAttachmentBlocks } = require('./chat/attachment-blocks');
+const ctmContextClient = require('./memory/ctm-context-client');
+const ctmOperationalContext = require('./memory/ctm-operational-context');
 const slackMcp = require('./tools/slack-mcp');
 const { estimateTokens, estimateMessagesTokens } = require('./context/token-counter');
+
+// search_memories returns total_memories / total_slack for context. These were two
+// count(*) scans of the memories table on EVERY search (a hot MCP path). The totals
+// barely move between searches, so cache them briefly.
+let _searchTotalsCache = { at: 0, total_memories: 0, total_slack: 0 };
+const _SEARCH_TOTALS_TTL_MS = 60 * 1000;
+function _searchTotals(db) {
+  const now = Date.now();
+  if (now - _searchTotalsCache.at < _SEARCH_TOTALS_TTL_MS) return _searchTotalsCache;
+  try {
+    const total_memories = db.prepare('SELECT count(*) as c FROM memories').get().c;
+    const total_slack = db.prepare('SELECT count(*) as c FROM memories WHERE source = ?').get('slack').c;
+    _searchTotalsCache = { at: now, total_memories, total_slack };
+  } catch { /* keep last good cache on error */ }
+  return _searchTotalsCache;
+}
 const { shouldCompact, compactToolResult, compactMessages } = require('./context/compactor');
 const { buildSystemPrompt } = require('./context/context-builder');
 const {
@@ -29,9 +51,19 @@ const { sanitizeQuery } = require('./context/query-sanitizer');
 const { checkPermission, recordDecision, configure: configurePermissions } = require('./tools/permission-checker');
 const {
   inputForExternalActionEnvelope,
+  isExternalActionTool,
   reviewExternalAction,
 } = require('./external-action-controller');
 const { reviewExternalActionGateway } = require('./external-action-gateway');
+const {
+  hasVerificationEvidence,
+  normalizeToolCallEvidence,
+} = require('./coding/acceptance-contract');
+const {
+  analyzeLocalPreviewClaims,
+  buildLocalPreviewVerificationNudge,
+  buildUnsupportedLocalPreviewReply,
+} = require('./coding/local-preview-contract');
 const { runShadow } = require('./eval/shadow');
 const {
   buildCodeReviewContextBlock,
@@ -40,6 +72,15 @@ const {
   looksLikePrematureCodeReviewReply,
 } = require('./chat/code-review-context');
 const { createSessionRecorder } = require('./session-files');
+const { normalizeContextMessagesForChat } = require('./chat/context-messages');
+const { buildProviderMessagesForChat } = require('./chat/provider-messages');
+const {
+  buildConversationFramePrompt,
+  buildConversationRuntime,
+  buildFrameRepairPrompt,
+  parseSessionMetadata,
+  validateFrameAnswer,
+} = require('./chat/conversation-frame');
 const {
   decorateProviderError,
   recordProviderFailureAlert,
@@ -49,8 +90,17 @@ const { extractTextToolCalls, normalizeToolCall } = require('./llm/text-tool-cal
 const {
   emitAgentRunContextWarnings,
   isCodingAgentContext,
-  resolveAgentRunContext,
 } = require('./runtime/agent-run-context');
+const { classifyCodingTurnIntent } = require('./coding/coding-run-controller');
+const {
+  createWallEToolRegistry,
+  executeRuntimeTool,
+  getRuntimeToolDefinitions,
+  RuntimeToolExecutor,
+  resolveWallERuntimeProfile,
+  runtimeToolContext,
+} = require('./runtime/walle-runtime');
+const { buildRuntimePromptManifest } = require('./runtime/prompt-manifest');
 let _telemetry;
 try { _telemetry = require('./telemetry'); } catch { _telemetry = { trackError() {}, track() {} }; }
 let _embeddings;
@@ -62,6 +112,28 @@ function providerTypeOf(provider) {
   return provider.type || provider.provider || provider.id || '';
 }
 
+// Native-tool-call providers never legitimately emit text-form tool markup.
+// Anthropic (Claude) returns `tool_use` blocks; if an "anthropic" route returns
+// DeepSeek-style DSML instead, the route is almost certainly NOT serving real
+// Claude (e.g. a Portkey catalog slug mapped to a DSML-emitting backend). Warn
+// once per (provider, model, format) so the misconfiguration is visible without
+// log spam. Detection only — finalization already strips/recovers the markup.
+const NATIVE_TOOL_CALL_PROVIDERS = new Set(['anthropic', 'google', 'openai']);
+const _routeFormatMismatchWarned = new Set();
+function warnOnTextToolCallFormatMismatch(providerType, model, format) {
+  const type = String(providerType || '').toLowerCase();
+  if (!format || !NATIVE_TOOL_CALL_PROVIDERS.has(type)) return;
+  const key = `${type}|${model || ''}|${format}`;
+  if (_routeFormatMismatchWarned.has(key)) return;
+  _routeFormatMismatchWarned.add(key);
+  console.warn(
+    `[chat] Route mismatch: provider "${type}" (model ${model || 'unknown'}) returned ` +
+    `text-form tool calls (${format}) instead of native tool_use. A genuine ${type} ` +
+    `model does not emit ${format}; this route is likely proxying to a different ` +
+    `backend (e.g. a misconfigured Portkey catalog slug). Verify the route's underlying model.`,
+  );
+}
+
 function isDeepSeekV4Pro(provider, model) {
   const type = providerTypeOf(provider).toLowerCase();
   return (type === 'deepseek' || type.includes('deepseek'))
@@ -104,6 +176,10 @@ function looksLikePrematureToolFollowupReply(text) {
     || value.length > 500;
   if (hasFinalShape) return false;
 
+  const deferredToolOffer = /\b(?:would you like me to|want me to|should i)\s+(?:look up|search|get|check|inspect|read|pull|fetch|find)\b/i.test(value)
+    && /[?？]/.test(value);
+  if (concise && deferredToolOffer) return true;
+
   const progressCue = /\b(?:content inventory confirmed|inventory confirmed|analysis complete|context confirmed|now|next|then)\b/i.test(value);
   const sequenceCue = /\b(?:now|next)\b[\s:,-—;]+[\s\S]{0,160}\bthen\b/i.test(value);
   if (firstPersonFuture && executionFutureVerb && concise) return true;
@@ -112,6 +188,26 @@ function looksLikePrematureToolFollowupReply(text) {
   return concise && progressCue && (sequenceCue || executionVerb);
 }
 
+function _chatToolCallHistoryForActionGuard(toolCalls = []) {
+  return (toolCalls || [])
+    .map((call) => {
+      const name = call?.name || call?.tool || '';
+      if (!name) return null;
+      return normalizeToolCallEvidence({ ...call, name });
+    })
+    .filter(Boolean);
+}
+
+function _chatNoActionContinuation(args) {
+  try {
+    const { getNoActionContinuation } = require('./coding-orchestrator');
+    return getNoActionContinuation(args);
+  } catch (err) {
+    console.warn('[chat] Action completion guard unavailable:', err.message);
+    return null;
+  }
+}
+
 function _hasExplicitWeatherLocation(message) {
   const text = String(message || '').trim();
   if (!text) return false;
@@ -272,7 +368,7 @@ function hasOwn(obj, key) {
 }
 
 function isWallECodingMode({ opts = {}, channel = '' } = {}) {
-  return isCodingAgentContext(resolveAgentRunContext({ ...opts, channel }));
+  return isCodingAgentContext(resolveWallERuntimeProfile({ ...opts, channel }).context);
 }
 
 function resolveReasoningOptions({
@@ -305,36 +401,6 @@ function resolveReasoningOptions({
   return out;
 }
 
-const PARALLEL_SAFE_CHAT_TOOLS = new Set([
-  'think',
-  'search_memories',
-  'lookup_person',
-  'list_mcp_tools',
-  'list_tasks',
-  'calendar_events',
-  'calendar_list',
-  'system_info',
-  'clipboard_read',
-  'mail_messages',
-  'mail_read',
-  'mail_search',
-  'read_project_file',
-  'search_project',
-  'read_file',
-  'search_files',
-  'web_fetch',
-  'glean_search',
-  'glean_people',
-  'glean_chat',
-  'glob',
-  'grep_files',
-  'list_directory',
-]);
-
-function _shouldRunToolCallsSequentially(toolCalls) {
-  return toolCalls.some((tu) => !PARALLEL_SAFE_CHAT_TOOLS.has(tu.name));
-}
-
 let _codingOrchestrator;
 function getCodingOrchestrator() {
   if (!_codingOrchestrator) _codingOrchestrator = require('./coding-orchestrator');
@@ -521,90 +587,6 @@ function _requestedSkillProgressEvents(resolution = {}) {
     });
 }
 
-/**
- * Convert validated ParsedAttachments into the LLM content-block shape
- * that the active provider expects. The provider adapter is responsible
- * for any further reshaping (e.g. OpenAI's `image_url` envelope).
- *
- * Anthropic:
- *   image → { type:'image',    source:{type:'base64', media_type, data} }
- *   pdf   → { type:'document', source:{type:'base64', media_type:'application/pdf', data} }
- *   audio → throws (Anthropic vision API doesn't accept audio).
- * OpenAI (vision/audio-capable models):
- *   image → internal {type:'image',source:...} — messagesToOpenAI
- *           rewrites to {type:'image_url',image_url:{url:'data:...'}}.
- *   audio → internal {type:'audio',source:...} — messagesToOpenAI
- *           rewrites to {type:'input_audio',input_audio:{data,format}}.
- *   pdf   → throws (OpenAI doesn't natively support PDF in chat).
- * Google Gemini:
- *   image/pdf/audio → {type:<kind>,source:{type:'base64',media_type,data}}
- *           — Gemini provider's messagesToGemini (TBD) rewrites to
- *           {inline_data:{mime_type,data}}. For now Phase 4 wires the
- *           internal shape only; audio reaches OpenAI today, Gemini
- *           lands when its adapter ships.
- *
- * @throws Error with .code='MULTIMODAL_NOT_AVAILABLE' when the active
- *   provider can't carry the requested attachment kinds.
- */
-function buildAttachmentBlocks(providerType, attachments) {
-  if (!attachments || attachments.length === 0) return null;
-
-  // Internal canonical content-block shape (Anthropic-flavored). Each
-  // adapter's messages converter rewrites to its native shape on the
-  // way out. New attachment kinds add a `type` and optionally a
-  // `format` field for adapter convenience.
-  const toInternalBlock = (a) => {
-    const baseSrc = { type: 'base64', media_type: a.mediaType, data: a.base64 };
-    if (a.type === 'image') return { type: 'image', source: baseSrc };
-    if (a.type === 'pdf') return { type: 'document', source: { ...baseSrc, media_type: 'application/pdf' } };
-    if (a.type === 'audio') {
-      // OpenAI's input_audio API requires a `format` like 'wav'|'mp3'.
-      // Derive from the media type so the adapter can wire it up.
-      const fmt = a.mediaType.split('/')[1] || 'mp3';
-      return { type: 'audio', source: baseSrc, format: fmt };
-    }
-    const err = new Error(`Unknown attachment kind "${a.type}"`);
-    err.code = 'MULTIMODAL_NOT_AVAILABLE';
-    throw err;
-  };
-
-  if (providerType === 'anthropic') {
-    return attachments.map((a) => {
-      if (a.type === 'audio') {
-        const e = new Error('Anthropic chat does not accept audio attachments. Switch to OpenAI or Gemini for audio.');
-        e.code = 'MULTIMODAL_NOT_AVAILABLE';
-        throw e;
-      }
-      return toInternalBlock(a);
-    });
-  }
-
-  if (providerType === 'openai') {
-    return attachments.map((a) => {
-      if (a.type === 'pdf') {
-        const e = new Error('OpenAI chat does not natively support PDF attachments. Switch to Anthropic for PDF support.');
-        e.code = 'MULTIMODAL_NOT_AVAILABLE';
-        throw e;
-      }
-      return toInternalBlock(a); // image and audio
-    });
-  }
-
-  if (providerType === 'google' || providerType === 'gemini') {
-    // All three kinds are accepted; the Google adapter will rewrite to
-    // Gemini's `inline_data` shape on the way out.
-    return attachments.map(toInternalBlock);
-  }
-
-  // Other providers (Ollama, MLX, etc.) reach this only when the
-  // capability resolver was bypassed or has a gap. Surface clearly.
-  const e = new Error(
-    `Attachments not supported on provider "${providerType}". Switch to a configured Anthropic/OpenAI/Gemini provider for this turn.`
-  );
-  e.code = 'MULTIMODAL_NOT_AVAILABLE';
-  throw e;
-}
-
 /**
  * Format a coding progress event as a human-readable chat message.
  * Used by both inline execution and SSE streaming.
@@ -703,11 +685,12 @@ function _providerConfigFromRegistryRow(row) {
 }
 
 function _registryRouteFromRow(row, input, explicitProvider) {
+  const runtimeType = _providerRuntimeType(row) || row.provider_type || explicitProvider || null;
   return {
     input,
     model: row.model_id,
-    provider: row.provider_type || explicitProvider || null,
-    providerConfig: _providerConfigFromRegistryRow(row),
+    provider: runtimeType,
+    providerConfig: _providerRuntimeConfig(row),
     registryId: row.id,
     providerId: row.provider_id,
     displayName: row.display_name,
@@ -734,19 +717,37 @@ function _ambiguousModelRoute(input, rows, explicitProvider) {
   };
 }
 
+function _preferredRouteRowForBareModel(rows = [], explicitProvider) {
+  if (!rows.length) return null;
+  const type = explicitProvider || rows[0].provider_type;
+  const policy = (type && typeof brain.getProviderRoutePolicy === 'function')
+    ? brain.getProviderRoutePolicy(type)
+    : 'auto';
+  if (typeof brain.sortModelProvidersByRoutePolicy !== 'function') return null;
+  const sorted = brain.sortModelProvidersByRoutePolicy(
+    rows.map((row) => ({ ...row, type: row.provider_type || row.type })),
+    policy,
+  );
+  return sorted[0] || null;
+}
+
 function _createChatProvider(type, config = {}, opts = {}) {
-  if (typeof opts.providerFactory === 'function') return opts.providerFactory(type, config);
-  return createClient(type, config);
+  const provider = typeof opts.providerFactory === 'function'
+    ? opts.providerFactory(type, config)
+    : createClient(type, config);
+  return withProviderMessageGuard(provider);
 }
 
 function _providerRuntimeType(row = {}) {
-  if (row.type === 'anthropic' && row.auth_method === 'claude_cli') return 'claude-cli';
-  if (row.type === 'openai' && row.auth_method === 'codex_cli') return 'codex-cli';
-  return row.type;
+  const type = row.type || row.provider_type;
+  if (type === 'anthropic' && row.auth_method === 'claude_cli') return 'claude-cli';
+  if (type === 'openai' && row.auth_method === 'codex_cli') return 'codex-cli';
+  return type;
 }
 
 function _providerRuntimeConfig(row = {}) {
-  if (row.type === 'anthropic' && row.auth_method === 'oauth_proxy') {
+  const type = row.type || row.provider_type;
+  if (type === 'anthropic' && row.auth_method === 'oauth_proxy') {
     return {
       apiKey: 'oauth-proxy-placeholder',
       baseUrl: `http://127.0.0.1:${process.env.OAUTH_PROXY_PORT || '3458'}`,
@@ -861,30 +862,35 @@ function _toolArtifactSummary(toolCalls = []) {
 }
 
 function _hasSuccessfulWrite(toolCalls = []) {
-  return (toolCalls || []).some(call => call && !call.error && call.tool === 'write_file');
+  return (toolCalls || []).some(call => (
+    call
+    && (call.tool === 'write_file' || call.name === 'write_file')
+    && normalizeToolCallEvidence(call).ok === true
+  ));
 }
 
 function _hasSuccessfulScreenshotAfterLastWrite(toolCalls = []) {
   let lastWriteIndex = -1;
   for (let i = 0; i < (toolCalls || []).length; i++) {
     const call = toolCalls[i];
-    if (call && !call.error && call.tool === 'write_file') lastWriteIndex = i;
+    if (
+      call
+      && (call.tool === 'write_file' || call.name === 'write_file')
+      && normalizeToolCallEvidence(call).ok === true
+    ) {
+      lastWriteIndex = i;
+    }
   }
   if (lastWriteIndex < 0) return false;
-  return (toolCalls || []).some((call, index) => (
-    index > lastWriteIndex
-    && call
-    && !call.error
-    && call.tool === 'browser_screenshot'
-  ));
+  return hasVerificationEvidence(_chatToolCallHistoryForActionGuard((toolCalls || []).slice(lastWriteIndex + 1)));
 }
 
 function _postToolProgressFailureReply(toolCalls = []) {
   if (_hasSuccessfulWrite(toolCalls)) {
-    const verificationText = _hasSuccessfulScreenshotAfterLastWrite(toolCalls)
-      ? '\n\nVerified with browser screenshots; detailed tool output is preserved in the activity panel.'
-      : '\n\nDetailed tool output is preserved in the activity panel.';
-    return `Completed the requested changes.${_toolArtifactSummary(toolCalls)}${verificationText}`;
+    if (_hasSuccessfulScreenshotAfterLastWrite(toolCalls)) {
+      return `Completed the requested changes.${_toolArtifactSummary(toolCalls)}\n\nVerified with tool evidence; detailed tool output is preserved in the activity panel.`;
+    }
+    return `I made file changes, but final answer generation failed before successful verification evidence was captured.${_toolArtifactSummary(toolCalls)}\n\nThe detailed tool outputs are preserved in the activity panel. Please treat this as incomplete until tests, build, check_url, or browser_screenshot succeeds.`;
   }
   return `I ran the requested tools, but final answer generation kept returning progress/tool-control text instead of a clean final answer.${_toolArtifactSummary(toolCalls)}\n\nThe detailed tool outputs are preserved in the activity panel.`;
 }
@@ -1375,6 +1381,7 @@ async function _tryProviderFinalizationFallback({
       const decorated = decorateProviderError(err, {
         provider: fallback.providerType,
         model: fallback.model,
+        providerId: fallback.providerId || null,
       });
       recordProviderFailureAlert(decorated.providerError, brain);
       console.warn('[chat] Finalization provider fallback failed, trying next candidate:', fallback.providerType, decorated.providerError.type);
@@ -1383,16 +1390,213 @@ async function _tryProviderFinalizationFallback({
   return null;
 }
 
+function _truncateFinalizationEvidence(value, maxChars) {
+  const text = String(value || '').trim();
+  if (text.length <= maxChars) return text;
+  return text.slice(0, Math.max(0, maxChars - 80)).trimEnd() + '\n[... evidence truncated ...]';
+}
+
+function _jsonForFinalizationEvidence(value, maxChars = 4000) {
+  try {
+    return _truncateFinalizationEvidence(JSON.stringify(value, null, 2), maxChars);
+  } catch {
+    return _truncateFinalizationEvidence(String(value || ''), maxChars);
+  }
+}
+
+function _mailMessageLine(message = {}) {
+  const parts = [];
+  if (message.subject) parts.push(`Subject: ${message.subject}`);
+  if (message.from) parts.push(`From: ${message.from}`);
+  if (message.to) parts.push(`To: ${message.to}`);
+  if (message.date) parts.push(`Date: ${message.date}`);
+  if (message.messageId) parts.push(`Message ID: ${message.messageId}`);
+  if (message.snippet) parts.push(`Snippet: ${message.snippet}`);
+  return parts.join(' | ');
+}
+
+function _finalizationEvidenceForToolCall(call, index) {
+  const name = call?.name || call?.tool || 'tool';
+  const result = call?.result;
+  const evidence = normalizeToolCallEvidence(call);
+  const ok = evidence.ok === true;
+  const lines = [`Tool ${index + 1}: ${name} (${ok ? 'ok' : 'error'})`];
+  if (call?.args || call?.input) {
+    lines.push(`Input: ${_jsonForFinalizationEvidence(call.args || call.input, 1200)}`);
+  }
+  if (!result) return lines.join('\n');
+
+  if (name === 'mail_search') {
+    if (result.count != null) lines.push(`Count: ${result.count}`);
+    if (result.query) lines.push(`Query: ${result.query}`);
+    if (Array.isArray(result.accounts) && result.accounts.length) {
+      lines.push(`Accounts searched: ${result.accounts.join(', ')}`);
+    }
+    if (Array.isArray(result.messages) && result.messages.length) {
+      lines.push('Messages:');
+      for (const message of result.messages.slice(0, 6)) {
+        lines.push(`- ${_mailMessageLine(message)}`);
+      }
+      if (result.messages.length > 6) lines.push(`- ... ${result.messages.length - 6} more message(s) omitted`);
+    }
+    if (result.error) lines.push(`Error: ${result.error}`);
+    return _truncateFinalizationEvidence(lines.join('\n'), 6500);
+  }
+
+  if (name === 'mail_read') {
+    for (const field of ['account', 'mailbox', 'subject', 'from', 'to', 'cc', 'date', 'messageId', 'threadId']) {
+      if (result[field]) lines.push(`${field}: ${result[field]}`);
+    }
+    if (result.content) {
+      lines.push('Content:');
+      lines.push(_truncateFinalizationEvidence(result.content, 10000));
+    } else if (result.snippet) {
+      lines.push(`Snippet: ${result.snippet}`);
+    }
+    if (result.error) lines.push(`Error: ${result.error}`);
+    return _truncateFinalizationEvidence(lines.join('\n'), 12000);
+  }
+
+  if (name === 'web_fetch') {
+    if (result.url) lines.push(`URL: ${result.url}`);
+    if (result.title) lines.push(`Title: ${result.title}`);
+    if (result.error) lines.push(`Error: ${result.error}`);
+    const body = result.text || result.content || result.body || result.markdown || result.html;
+    if (body) {
+      lines.push('Fetched content:');
+      lines.push(_truncateFinalizationEvidence(body, 7000));
+    }
+    return _truncateFinalizationEvidence(lines.join('\n'), 8500);
+  }
+
+  if (result.error) lines.push(`Error: ${result.error}`);
+  lines.push(`Result: ${_jsonForFinalizationEvidence(result, 5000)}`);
+  return _truncateFinalizationEvidence(lines.join('\n'), 6500);
+}
+
+function _buildEvidenceOnlyFinalizationMessages({ originalRequest, toolCalls = [] }) {
+  const parts = [];
+  let used = 0;
+  const maxTotal = 22000;
+  for (const [index, call] of toolCalls.entries()) {
+    const block = _finalizationEvidenceForToolCall(call, index);
+    if (!block.trim()) continue;
+    if (used + block.length > maxTotal && parts.length > 0) {
+      parts.push('[... additional tool evidence omitted to keep finalization focused ...]');
+      break;
+    }
+    parts.push(block);
+    used += block.length;
+  }
+  const evidence = parts.join('\n\n');
+  return [{
+    role: 'user',
+    content: [
+      'Original user request:',
+      String(originalRequest || '').trim(),
+      '',
+      'Tool evidence already gathered:',
+      evidence || 'No structured tool evidence is available.',
+      '',
+      'Write the final answer now. Use only this evidence. Do not mention tool calls, JSON, protocols, activity panels, or future inspection. If the request asks for drafts, write the drafts directly.',
+    ].join('\n'),
+  }];
+}
+
+async function _tryEvidenceOnlyFinalization({
+  provider,
+  model,
+  originalRequest,
+  toolCalls = [],
+  opts = {},
+  resetFinalizationTimeout,
+  resolveCurrentReasoningOptions,
+  signal,
+  getSignal,
+} = {}) {
+  if (typeof opts.finalizationFailureReply === 'string') return null;
+  if (!provider || !Array.isArray(toolCalls) || toolCalls.length === 0) return null;
+  try {
+    resetFinalizationTimeout?.();
+    const activeSignal = typeof getSignal === 'function' ? getSignal() : signal;
+    const reasoning = typeof resolveCurrentReasoningOptions === 'function'
+      ? resolveCurrentReasoningOptions(provider, model)
+      : {};
+    const response = await provider.chat({
+      model,
+      maxTokens: Math.max(2048, Math.min(4096, Number(opts.finalizationMaxTokens) || 4096)),
+      system: [
+        'You are Wall-E final-answer synthesizer.',
+        'The main agent has already gathered tool evidence.',
+        'You cannot call tools and must not emit tool markup or progress notes.',
+        'Answer the original user request directly from the supplied evidence.',
+      ].join(' '),
+      messages: _buildEvidenceOnlyFinalizationMessages({ originalRequest, toolCalls }),
+      tools: [],
+      ...reasoning,
+      thinking: 'disabled',
+      signal: activeSignal,
+    });
+    const parsed = extractTextToolCalls(response);
+    const text = String(parsed.content || response.content || '').trim();
+    if (text && !_finalizationResponseIsProtocol(parsed, text)) {
+      try {
+        _telemetry.track('chat_evidence_only_finalization', {
+          status: 'success',
+          provider: response.provider || provider.type || '',
+          model: response.model || model || '',
+        });
+      } catch {}
+      return {
+        text,
+        response,
+        meta: {
+          model: response.model || model,
+          provider: response.provider || provider.type,
+          usage: response.usage || null,
+          stopReason: response.stopReason || null,
+          evidenceOnlyFinalization: true,
+        },
+      };
+    }
+    try {
+      _telemetry.track('chat_evidence_only_finalization', {
+        status: 'protocol_text',
+        provider: response.provider || provider.type || '',
+        model: response.model || model || '',
+      });
+    } catch {}
+  } catch (err) {
+    if (_isUserCancellation(opts, err)) throw _cancelledError();
+    console.warn('[chat] Evidence-only finalization failed:', err.message);
+    try {
+      _telemetry.track('chat_evidence_only_finalization', {
+        status: 'error',
+        provider: provider.type || '',
+        model: model || '',
+        error_type: err.name || err.code || 'error',
+      });
+    } catch {}
+  }
+  return null;
+}
+
 function _findChatProviderFallback(args) {
   return (_listChatProviderFallbacks(args) || [])[0] || null;
 }
 
 function resolveModelSelection(model, explicitProvider) {
   if (!model) {
-    return { input: model, model: null, provider: explicitProvider || null, providerConfig: null, registryId: null };
+    return {
+      input: model,
+      model: null,
+      provider: explicitProvider || null,
+      providerConfig: explicitProvider ? getProviderRuntimeConfig(explicitProvider) : null,
+      registryId: null,
+    };
   }
 
-  const raw = String(model);
+  const input = String(model);
   try {
     const exact = brain.getDb().prepare(`
       SELECT
@@ -1412,11 +1616,12 @@ function resolveModelSelection(model, explicitProvider) {
         AND mr.enabled = 1
         AND mp.enabled = 1
       LIMIT 1
-    `).get(raw);
+    `).get(input);
     if (exact) {
-      return _registryRouteFromRow(exact, raw, explicitProvider);
+      return _registryRouteFromRow(exact, input, explicitProvider);
     }
 
+    const raw = canonicalSessionModelId(input, explicitProvider || detectProviderForModel(input) || '');
     const rows = brain.getDb().prepare(`
       SELECT
         mr.id,
@@ -1445,7 +1650,7 @@ function resolveModelSelection(model, explicitProvider) {
         const compatibleModel = resolveCompatibleModel(row.model_id, explicitProvider);
         if (compatibleModel !== row.model_id) {
           return {
-            input: raw,
+            input,
             model: compatibleModel,
             provider: explicitProvider,
             providerConfig: null,
@@ -1455,36 +1660,39 @@ function resolveModelSelection(model, explicitProvider) {
           };
         }
       }
-      return _registryRouteFromRow(row, raw, explicitProvider);
+      return _registryRouteFromRow(row, input, explicitProvider);
     }
 
     if (rows.length > 1) {
       const defaultRegistryId = (brain.getKv?.('walle_model_registry_id') || (explicitProvider ? brain.getKv?.(`walle_model_registry_${explicitProvider}`) : null) || '').trim();
       const defaultRow = defaultRegistryId ? rows.find((row) => row.id === defaultRegistryId) : null;
-      if (defaultRow) return _registryRouteFromRow(defaultRow, raw, explicitProvider);
-      return _ambiguousModelRoute(raw, rows, explicitProvider);
+      if (defaultRow) return _registryRouteFromRow(defaultRow, input, explicitProvider);
+      const preferredRow = _preferredRouteRowForBareModel(rows, explicitProvider);
+      if (preferredRow) return _registryRouteFromRow(preferredRow, input, explicitProvider);
+      return _ambiguousModelRoute(input, rows, explicitProvider);
     }
   } catch {}
 
+  const raw = canonicalSessionModelId(input, explicitProvider || detectProviderForModel(input) || '');
   const detectedProvider = detectProviderForModel(raw);
   if (explicitProvider) {
     const compatibleModel = resolveCompatibleModel(raw, explicitProvider);
     return {
-      input: raw,
+      input,
       model: compatibleModel,
       provider: explicitProvider,
-      providerConfig: null,
+      providerConfig: getProviderRuntimeConfig(explicitProvider),
       registryId: null,
-      coercedFrom: compatibleModel === raw ? null : raw,
+      coercedFrom: compatibleModel === input ? null : input,
       detectedProvider,
     };
   }
 
   return {
-    input: raw,
+    input,
     model: raw,
     provider: detectedProvider || null,
-    providerConfig: null,
+    providerConfig: detectedProvider ? getProviderRuntimeConfig(detectedProvider) : null,
     registryId: null,
   };
 }
@@ -1571,8 +1779,9 @@ async function chat(message, opts = {}) {
   let usedProvider = null;
   const allToolCalls = [];
   const channel = opts.channel || 'ctm';
-  const agentRunContext = resolveAgentRunContext({ ...opts, channel });
-  emitAgentRunContextWarnings(agentRunContext, { telemetry: _telemetry });
+  const wallERuntimeProfile = resolveWallERuntimeProfile({ ...opts, channel });
+  const agentRunContext = wallERuntimeProfile.context;
+  emitAgentRunContextWarnings({ ...agentRunContext, warnings: wallERuntimeProfile.warnings }, { telemetry: _telemetry });
   const wallECodingMode = isCodingAgentContext(agentRunContext);
 
   // Scorecard-aware model selection (computed once per chat, used by all turns)
@@ -1590,6 +1799,11 @@ async function chat(message, opts = {}) {
       .join(', ');
     throw new Error(`Ambiguous model route for "${selectedRoute.input}". Choose a specific model route: ${choices}`);
   }
+  if (selectedRoute.model) {
+    // Registry routes own the executable model id. The picker may pass an alias
+    // or display id, but provider calls must use the route's canonical model.
+    selectedModel = selectedRoute.model;
+  }
   const effectiveCwd = opts.cwd || opts.context?.cwd || opts.context?.projectPath || null;
 
   // Plug-provider-routing Item B+E: log routing decision via
@@ -1618,6 +1832,7 @@ async function chat(message, opts = {}) {
   const routingMessage = String(opts.routingMessage || opts.originalMessage || message || '');
   const queryTopics = classifyTopics(routingMessage);
   const intent = classifyIntent(queryTopics);
+  const codingTurnIntent = classifyCodingTurnIntent(routingMessage);
 
   // Item F (multi-agent deep-dive): conversation collapse policy.
   // 'main' (default) keeps the historical 'default' bucket;
@@ -1631,6 +1846,7 @@ async function chat(message, opts = {}) {
     brain,
   });
   const existingSession = brain.getSession(sessionId);
+  const existingSessionMetadata = parseSessionMetadata(existingSession?.metadata);
   const sessionRecorder = createSessionRecorder({
     sessionId,
     channel,
@@ -1640,6 +1856,8 @@ async function chat(message, opts = {}) {
       source: opts.source || channel || 'chat',
       model: selectedModel,
       provider: selectedRoute.provider || opts.provider || null,
+      runtimeProfile: wallERuntimeProfile.profileId,
+      permissionProfile: wallERuntimeProfile.permissionProfile,
     },
   });
   const recordSessionMessage = (role, content, extra) => {
@@ -1650,6 +1868,52 @@ async function chat(message, opts = {}) {
       return null;
     }
   };
+  const recordUsageLedger = (response, feature, extra = {}) => {
+    if (!response?.usage) return null;
+    try {
+      const raw = response.raw && typeof response.raw === 'object' ? response.raw : {};
+      const providerType = response.provider || extra.provider || usedProvider || targetProviderType || null;
+      const modelId = response.model || extra.model || selectedModel || null;
+      const routeProvider = selectedRoute?.provider || null;
+      const routeModel = selectedRoute?.model || null;
+      const routeMatches = !!selectedRoute
+        && (!providerType || !routeProvider || String(providerType).toLowerCase() === String(routeProvider).toLowerCase())
+        && (!modelId || !routeModel || String(modelId).toLowerCase() === String(routeModel).toLowerCase());
+      const requestId = response.requestId
+        || response.responseId
+        || response.id
+        || raw.id
+        || raw.response_id
+        || raw.request_id
+        || null;
+      return brain.recordModelUsage?.({
+        source: 'wall-e.chat',
+        feature,
+        sessionId,
+        providerType,
+        providerId: extra.providerId || (routeMatches ? selectedRoute.providerId : null) || null,
+        modelId,
+        modelRegistryId: extra.modelRegistryId || (routeMatches ? selectedRoute.registryId : null) || null,
+        gatewayType: extra.gatewayType || (routeMatches ? selectedRoute.gatewayType : null) || null,
+        routeLabel: extra.routeLabel || (routeMatches ? selectedRoute.routeLabel : null) || null,
+        requestId,
+        usage: response.usage,
+        latencyMs: response.latencyMs,
+        stopReason: response.stopReason || null,
+        metadata: {
+          channel,
+          taskType: opts.taskType || 'chat',
+          turn: extra.turn ?? null,
+          fallback: !!extra.fallback,
+          repair: extra.repair || null,
+          runtimeProfile: wallERuntimeProfile.profileId,
+        },
+      });
+    } catch (err) {
+      console.warn('[chat] Failed to record model usage ledger:', err.message);
+      return null;
+    }
+  };
   const progressSink = opts.onProgress || (() => {});
   const onProgress = (event) => {
     try { sessionRecorder.appendProgress(event); } catch (err) {
@@ -1657,6 +1921,16 @@ async function chat(message, opts = {}) {
     }
     return progressSink(event);
   };
+  const recordSessionFrame = (frame, extra = {}) => {
+    try {
+      return typeof sessionRecorder.appendFrame === 'function'
+        ? sessionRecorder.appendFrame(frame, extra)
+        : sessionRecorder.appendProgress({ type: 'conversation_frame', frame, ...(extra || {}) });
+    } catch (err) {
+      console.error('[chat] Failed to append conversation frame:', err.message);
+      return null;
+    }
+  };
   const returnSystemReply = (text, meta = {}) => {
     const persistStart = Date.now();
     if (!opts._fallbackRetry) {
@@ -1688,7 +1962,11 @@ async function chat(message, opts = {}) {
         metadata: JSON.stringify({ channel }),
       });
     }
-    const assistantMessage = brain.insertChatMessage({ role: 'assistant', content: text, channel, session_id: sessionId });
+    const assistantMessage = brain.insertChatMessage({
+      role: 'assistant', content: text, channel, session_id: sessionId,
+      model_id: meta.model || null,
+      model_provider: meta.provider || null,
+    });
     recordSessionMessage('assistant', text, {
       dbMessageId: assistantMessage.id,
       provider: meta.provider || 'system',
@@ -1740,6 +2018,35 @@ async function chat(message, opts = {}) {
     });
   }
 
+  const runtimeFrameContextMessages = (() => {
+    const override = normalizeContextMessagesForChat(opts.contextMessages, message);
+    if (override.length > 0) return override;
+    try {
+      const recentChat = brain.listChatMessages({ session_id: sessionId, limit: 20 });
+      return normalizeContextMessagesForChat(
+        recentChat.map(m => ({ role: m.role, content: m.content })),
+        message,
+      );
+    } catch {
+      return normalizeContextMessagesForChat([], message);
+    }
+  })();
+  const conversationRuntime = buildConversationRuntime({
+    messages: runtimeFrameContextMessages,
+    currentMessage: message,
+    previousFrame: existingSessionMetadata.conversationFrame || existingSessionMetadata.activeFrame || null,
+    channel,
+    cwd: effectiveCwd || opts.cwd || process.cwd(),
+    taskType: opts.taskType || 'chat',
+  });
+  const conversationFrameContextBlock = buildConversationFramePrompt(conversationRuntime.frame);
+  if (conversationFrameContextBlock) {
+    recordSessionFrame(conversationRuntime.frame, {
+      reason: 'turn_start',
+      validators: conversationRuntime.validators,
+    });
+  }
+
   let currentLocationSummary = null;
   if (shouldUseLocationForMessage(routingMessage, queryTopics)) {
     currentLocationSummary = await resolveLocationForMessage(opts.locationRequest || opts.req || null, brain, routingMessage, {
@@ -1841,7 +2148,7 @@ async function chat(message, opts = {}) {
     intent,
     topics: queryTopics,
     currentLocation: currentLocationContext,
-  }) + reviewContextBlock + codeReviewContextBlock + workspaceContextBlock + promptCapabilityContextBlock;
+  }) + conversationFrameContextBlock + reviewContextBlock + codeReviewContextBlock + workspaceContextBlock + promptCapabilityContextBlock;
   // Item D (multi-agent deep-dive): opt-in workspace directives override
   // for the chat surface. Tutorial-style or persona-tweak directives can
   // live in `wall-e/loops/chat.directives.md` (or
@@ -1851,11 +2158,14 @@ async function chat(message, opts = {}) {
   const wallECodingScopeReminder = wallECodingMode
     ? '\n\n## Wall-E Coding Scope Reminder\nMatch the phase the user asked for. If the user asks to design, plan, analyze, review, or discuss without asking for changes, deliver that artifact and stop. If the user combines review/analyze/design with improve, polish, enhance, upgrade, fix, build, implement, refactor, code, edit, update, or change, then actually perform the requested change or start the coding agent; do not stop at a review-only answer.'
     : '';
+  const wallECodingContinuationReminder = wallECodingMode && codingTurnIntent.readOnly && !codingTurnIntent.expectsChange
+    ? '\n\n## Wall-E Coding Conversation Continuation\nThis turn is read-only or conversational. Do not start a coding task, do not call start_coding, and do not evaluate code-change completion. Use the existing conversation, supplied context, and any read-only tool results to answer directly. If the user asks to refine, update, or correct a prior summary, produce the updated summary now. Ask for more input only when the missing detail is truly required and say what evidence you checked.'
+    : '';
   const finalLanguageReminder = buildResponseLanguagePolicy({
     heading: '## Final Response Language Reminder',
     userMessage: message,
   });
-  const systemPrompt = `${augmentedSystemPrompt}${wallECodingScopeReminder}\n\n${finalLanguageReminder}`;
+  const systemPrompt = `${augmentedSystemPrompt}${wallECodingScopeReminder}${wallECodingContinuationReminder}\n\n${finalLanguageReminder}`;
   timings.promptBuildMs = Date.now() - promptStart;
 
   // Expire old sessions occasionally (at most once per hour)
@@ -1875,14 +2185,22 @@ async function chat(message, opts = {}) {
   let provider = _clientOverride || null;
   if (!provider) {
     const routeConfig = selectedRoute.providerConfig || {};
-    const providerConfig = { ...routeConfig, ...(opts.providerConfig || {}) };
-    const hasSpecificConfig = !!(providerConfig.apiKey || providerConfig.baseUrl || providerConfig.customHeaders);
+    const suppliedProviderConfig = { ...routeConfig, ...(opts.providerConfig || {}) };
+    const hasSpecificConfig = !!(
+      suppliedProviderConfig.apiKey
+      || suppliedProviderConfig.baseUrl
+      || suppliedProviderConfig.customHeaders
+      || suppliedProviderConfig.authMode
+      || suppliedProviderConfig.refreshToken
+    );
     if (opts.providerFactory || targetProviderType !== defaultProviderType || opts.provider || hasSpecificConfig) {
+      const providerConfig = getProviderRuntimeConfig(targetProviderType, suppliedProviderConfig);
       provider = _createChatProvider(targetProviderType, providerConfig, opts);
     } else {
       provider = getDefaultClient();
     }
   }
+  provider = withProviderMessageGuard(provider);
 
   // Engine swap: if using ollama and user prefers MLX, transparently switch
   if (!_clientOverride && (provider.type === 'ollama' || opts.provider === 'ollama')) {
@@ -1890,6 +2208,7 @@ async function chat(message, opts = {}) {
       const localEngine = brain.getDb().prepare("SELECT value FROM brain_metadata WHERE key = 'local_engine'").get()?.value;
       if (localEngine === 'mlx') {
         provider = _createChatProvider('mlx', {}, opts);
+        provider = withProviderMessageGuard(provider);
       }
     } catch (e) {
       console.warn('[chat] MLX engine swap failed, staying on Ollama:', e.message);
@@ -1897,6 +2216,20 @@ async function chat(message, opts = {}) {
   }
 
   selectedModel = resolveCompatibleModel(selectedModel || getDefaultModelForProvider(targetProviderType), provider.type || targetProviderType);
+  const primaryProviderErrorContext = (providerType, model) => {
+    const resolvedProvider = providerType || targetProviderType || getDefaultProviderType();
+    const resolvedModel = model || selectedModel;
+    const routeApplies = selectedRoute
+      && (!selectedRoute.provider || selectedRoute.provider === resolvedProvider)
+      && (!selectedRoute.model || selectedRoute.model === resolvedModel);
+    return {
+      provider: resolvedProvider,
+      model: resolvedModel,
+      providerId: routeApplies ? (selectedRoute.providerId || null) : null,
+      registryId: routeApplies ? (selectedRoute.registryId || null) : null,
+      routeLabel: routeApplies ? (selectedRoute.routeLabel || null) : null,
+    };
+  };
 
   const codeReviewFastPath = codeReviewRequested
     && isUsableCodeReviewSnapshot(codeReviewContextBlock)
@@ -1965,6 +2298,35 @@ async function chat(message, opts = {}) {
       description: `Run one of my skills to fetch data or perform an action. PREFER skills over raw mcp_call when a matching skill exists — skills parse data correctly and store results in brain. Available skills: ${(() => { try { const { loadAllSkills } = require('./skills/skill-loader'); const bundled = loadAllSkills().map(s => s.name + ': ' + (s.description || '').slice(0, 60)); const db = brain.listSkills({ enabled: 1 }).map(s => s.name + ': ' + (s.description || '').slice(0, 60)); const all = [...new Set([...bundled, ...db])]; return all.join('; ') || 'none'; } catch { return 'unknown'; } })()}`,
       input_schema: { type: 'object', properties: { skill_name: { type: 'string', description: 'Name of the skill to run' } }, required: ['skill_name'] },
     },
+    {
+      name: 'ctm_context',
+      description: 'Authoritative CTM operational/session-memory lookup for CTM primary, mobile phone URL, /m/, Dev Tunnel, Tailscale, and "CTM session memory" questions. Use this before generic memories for CTM remote-access answers.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'The CTM/mobile/session-memory question to resolve. Defaults to the user message.' },
+          limit: { type: 'number', default: 5 },
+          force: { type: 'boolean', default: true },
+        },
+      },
+    },
+    {
+      name: 'ctm_remote_access_status',
+      description: 'Read current CTM setup/network status and return active phone URLs and tunnel state. Use for "what URL should my phone use?"',
+      input_schema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'ctm_session_search',
+      description: 'Search cached CTM coding-session messages. Use for questions that explicitly ask for CTM session memory, prior coding sessions, or remembered CTM operational fixes.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Search query' },
+          limit: { type: 'number', default: 5 },
+        },
+        required: ['query'],
+      },
+    },
     {
       name: 'search_memories',
       description: 'Hybrid search (BM25 + semantic vectors) across private/user memory. Use before public web search for remembered context, prior discussions, decisions, preferences, people, projects, tools, or Slack/email/calendar work context. Call MULTIPLE searches in ONE turn to batch them.',
@@ -2126,7 +2488,14 @@ async function chat(message, opts = {}) {
   ]);
 
   // Intent-based tool filtering — fewer tools = fewer wrong choices
-  const CONVERSATIONAL_TOOLS = new Set(['think', 'remember_fact', 'search_memories']);
+  const CONVERSATIONAL_TOOLS = new Set([
+    'think',
+    'remember_fact',
+    'search_memories',
+    'ctm_context',
+    'ctm_remote_access_status',
+    'ctm_session_search',
+  ]);
   const DIRECT_ACTION_EXCLUDE = new Set([
     'search_memories', 'lookup_person', 'remember_fact', 'think',
     'pull_slack', 'slack_connect', 'slack_search', 'slack_read_channel', 'slack_send_message',
@@ -2148,6 +2517,7 @@ async function chat(message, opts = {}) {
 
   function isCodingActionRequest() {
     const text = String(routingMessage || '');
+    if (codingTurnIntent.readOnly && !codingTurnIntent.expectsChange) return false;
     if (CODING_AGENT_RE.test(text)) return true;
     if (STRONG_CODE_CHANGE_RE.test(text)) return queryTopics.includes('technical') || CODE_TARGET_RE.test(text);
     return GENERIC_CODE_CHANGE_RE.test(text) && CODE_TARGET_RE.test(text);
@@ -2194,6 +2564,20 @@ async function chat(message, opts = {}) {
     return filtered;
   }
 
+  const chatToolRegistry = createWallEToolRegistry({
+    runtimeProfile: wallERuntimeProfile,
+    builtinTools: chatTools,
+    prepareBuiltinArgs: (toolName, args) => normalizeToolCall({ name: toolName, input: args }).input,
+    executeBuiltinTool: (toolName, args, ctx) => executeChatTool(toolName, args, ctx),
+    unknownToolHandler: (toolName, args, ctx) => executeChatTool(toolName, args, ctx),
+  });
+  const chatToolContextBase = runtimeToolContext(wallERuntimeProfile, {
+    provider: usedProvider || targetProviderType,
+    model: selectedModel,
+    sessionId,
+    cwd: effectiveCwd || opts.cwd || process.cwd(),
+  });
+
   for (const event of requestedSkillEvents) onProgress(event);
 
   // Execute a chat tool call
@@ -2220,14 +2604,16 @@ async function chat(message, opts = {}) {
     if (effectiveCwd && input && typeof input === 'object') {
       if (name === 'run_shell' && !input.cwd) {
         input = { ...input, cwd: effectiveCwd };
-      } else if (name === 'search_files' && !input.directory) {
-        input = { ...input, directory: effectiveCwd };
+      } else if (name === 'search_files') {
+        input = { ...input, directory: input.directory || effectiveCwd, projectRoot: input.projectRoot || effectiveCwd };
       } else if (name === 'glob') {
         input = { ...input, directory: input.directory || effectiveCwd, projectRoot: input.projectRoot || effectiveCwd };
       } else if (name === 'grep_files') {
         input = { ...input, directory: input.directory || effectiveCwd, projectRoot: input.projectRoot || effectiveCwd };
       } else if ((name === 'read_file' || name === 'write_file' || name === 'edit_file') && !input.projectRoot) {
         input = { ...input, projectRoot: effectiveCwd };
+      } else if (name === 'start_static_server') {
+        input = { ...input, directory: input.directory || effectiveCwd, projectRoot: input.projectRoot || effectiveCwd };
       } else if (name === 'list_directory') {
         input = { ...input, directory: input.directory || effectiveCwd, projectRoot: input.projectRoot || effectiveCwd };
       }
@@ -2242,9 +2628,18 @@ async function chat(message, opts = {}) {
     if (!externalActionReview.admitted) {
       return externalActionReview.result;
     }
+    if (externalActionReview.envelope && isExternalActionTool(name)) {
+      const executeExternalAction = typeof opts.externalActionExecutor === 'function'
+        ? opts.externalActionExecutor
+        : executeLocalTool;
+      return executeExternalAction(name, input, {
+        envelope: externalActionReview.envelope,
+        approval: externalActionReview.envelope.approval || null,
+      });
+    }
 
     // Permission check — skip for internal-only tools
-    const SKIP_PERM_CHECK = new Set(['think', 'search_memories', 'lookup_person', 'remember_fact', 'list_mcp_tools', 'list_tasks', 'calendar_events', 'calendar_list', 'system_info', 'clipboard_read', 'mail_messages', 'mail_search', 'read_project_file', 'search_project', 'read_file', 'glob', 'grep_files', 'list_directory']);
+    const SKIP_PERM_CHECK = new Set(['think', 'search_memories', 'ctm_context', 'ctm_remote_access_status', 'ctm_session_search', 'lookup_person', 'remember_fact', 'list_mcp_tools', 'list_tasks', 'calendar_events', 'calendar_list', 'system_info', 'clipboard_read', 'mail_messages', 'mail_search', 'read_project_file', 'search_project', 'read_file', 'glob', 'grep_files', 'list_directory', 'check_url', 'start_static_server', 'stop_static_server']);
     if (!SKIP_PERM_CHECK.has(name)) {
       const permCommand = name === 'run_shell' ? (input.command || '')
         : name === 'write_file' || name === 'read_file' ? (input.file_path || '')
@@ -2336,6 +2731,39 @@ async function chat(message, opts = {}) {
         return { error: err.message };
       }
     }
+    if (name === 'ctm_context') {
+      const query = String(input.query || routingMessage || message || '').trim();
+      return ctmOperationalContext.lookupCtmOperationalContext({
+        query,
+        limit: input.limit || 5,
+        force: input.force !== false,
+      }, {
+        timeoutMs: input.timeout_ms || 6000,
+        cooldownMs: input.cooldown_ms || 0,
+      });
+    }
+    if (name === 'ctm_remote_access_status') {
+      const status = await ctmContextClient.getRemoteAccessStatus({}, {
+        timeoutMs: input.timeout_ms || 6000,
+        cooldownMs: input.cooldown_ms || 0,
+      });
+      return {
+        ok: !status.reason,
+        source: status.source || 'ctm-api',
+        reason: status.reason || '',
+        api_transport: status.api_transport || null,
+        remote_access: status.reason ? null : ctmOperationalContext.summarizeRemoteAccess(status),
+      };
+    }
+    if (name === 'ctm_session_search') {
+      return ctmContextClient.searchSessions({
+        query: input.query,
+        limit: input.limit || 5,
+      }, {
+        timeoutMs: input.timeout_ms || 6000,
+        cooldownMs: input.cooldown_ms || 0,
+      });
+    }
     if (name === 'search_memories') {
       const sanitizedInput = { ...input, query: sanitizeQuery(input.query) || input.query };
       // Hybrid search: FTS5/LIKE + vector similarity (if available)
@@ -2422,16 +2850,15 @@ async function chat(message, opts = {}) {
         }
       }
 
-      // Touch accessed memories for importance decay tracking
-      for (const m of results) {
-        if (m.id) try { brain.touchMemory(m.id); } catch {}
-      }
+      // Touch accessed memories for importance decay tracking — one batched UPDATE
+      // instead of an N+1 of write-locked statements (one per result row).
+      try { brain.touchMemories(results.map(m => m.id)); } catch {}
 
-      const totalSlack = db.prepare('SELECT count(*) as c FROM memories WHERE source = ?').get('slack').c;
+      const totals = _searchTotals(db);
       return {
         count: results.length,
-        total_memories: db.prepare('SELECT count(*) as c FROM memories').get().c,
-        total_slack: totalSlack,
+        total_memories: totals.total_memories,
+        total_slack: totals.total_slack,
         search_method: searchMethod,
         memories: results.map(m => ({
           source: m.source,
@@ -2585,6 +3012,17 @@ async function chat(message, opts = {}) {
       return { created: true, id: result.id, title: input.title, status: 'pending', due_at: input.due_at || 'immediate' };
     }
     if (name === 'start_coding') {
+      const requestedCodingIntent = classifyCodingTurnIntent(input?.request || '');
+      if (requestedCodingIntent.readOnly && !requestedCodingIntent.expectsChange) {
+        return {
+          success: true,
+          skipped: true,
+          read_only: true,
+          intent: requestedCodingIntent,
+          message: 'This is a conversational/read-only follow-up, not a coding task. Answer from the existing conversation and context; do not run a coding task or append a no-code-changes blocker.',
+        };
+      }
+
       ensureBrainInit();
 
       // Inline execution with progress streaming (default)
@@ -2649,9 +3087,18 @@ async function chat(message, opts = {}) {
           progress: progressLog.join('\n'),
         };
       } catch (err) {
+        // Classify provider/LLM failures so a coding task that couldn't reach the model
+        // reports a clear message ("AI provider network error: …could not reach the
+        // provider endpoint…") instead of a raw "fetch failed".
+        let friendly = (err && err.message) || 'Coding task failed';
+        try {
+          const { decorateProviderError } = require('./llm/provider-error');
+          const pe = decorateProviderError(err, { model: (input && input.model) || undefined }).providerError;
+          if (pe && pe.userMessage) friendly = pe.userMessage;
+        } catch {}
         return {
           success: false,
-          error: err.message,
+          error: friendly,
           progress: progressLog.join('\n'),
         };
       }
@@ -2815,7 +3262,10 @@ async function chat(message, opts = {}) {
     // Load recent chat history, resuming from compacted state if available
     const chatSessionId = sessionId;
     let historyMessages;
-    if (existingSession?.compacted_messages) {
+    const contextOverride = normalizeContextMessagesForChat(opts.contextMessages, message);
+    if (contextOverride.length > 0) {
+      historyMessages = contextOverride;
+    } else if (existingSession?.compacted_messages) {
       // Resume from compacted state + recent messages
       try {
         const compacted = JSON.parse(existingSession.compacted_messages);
@@ -2831,36 +3281,17 @@ async function chat(message, opts = {}) {
       const recentChat = brain.listChatMessages({ session_id: chatSessionId, limit: 10 });
       historyMessages = recentChat.map(m => ({ role: m.role, content: m.content }));
     }
-    if (!persistUserTurn) {
-      const last = historyMessages[historyMessages.length - 1];
-      const lastContent = typeof last?.content === 'string' ? last.content : JSON.stringify(last?.content || '');
-      if (!last || last.role !== 'user' || lastContent !== message) {
-        historyMessages.push({ role: 'user', content: message });
-      }
-    }
-    // Agentic chat loop — history already includes the new user message
-    const messages = [...historyMessages];
-    // Attachment hydration: when the current turn carries attachments, the
-    // last user message in `messages` is the row we just inserted with
-    // string content. Replace its `content` with a content-block array so
-    // the LLM actually sees the image(s).
-    if (_attachmentBlocks && messages.length > 0) {
-      // Walk back to the last user-role entry (should be the one at -1
-      // for normal flows; defensive scan handles compacted resume edge).
-      for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i].role === 'user') {
-          const text = typeof messages[i].content === 'string' ? messages[i].content : message;
-          messages[i] = {
-            role: 'user',
-            content: [
-              { type: 'text', text },
-              ..._attachmentBlocks,
-            ],
-          };
-          break;
-        }
-      }
-    }
+    // Provider-boundary assembly is the authority for the current turn.
+    // Persistence happens before the model call, but a DB reread can still be
+    // stale or compacted. Always reassert the accepted user input here so no
+    // provider can receive an empty message list.
+    const messages = buildProviderMessagesForChat({
+      historyMessages,
+      currentMessage: message,
+      attachmentBlocks: _attachmentBlocks,
+      provider: provider.type || targetProviderType,
+      model: selectedModel,
+    });
     let finalText = '';
     let lastTurnText = '';  // Only the last turn's text (prevents error accumulation across turns)
     let lastTurn = 0;
@@ -2868,6 +3299,8 @@ async function chat(message, opts = {}) {
     let forceFinalNoTools = false;
     let toolLimitNoticeSent = false;
     let postToolProgressContinuationCount = 0;
+    let actionCompletionContinuationCount = 0;
+    let localPreviewVerificationContinuationCount = 0;
 
     // Adaptive limits based on intent classification
     const INTENT_LIMITS = {
@@ -2996,13 +3429,36 @@ async function chat(message, opts = {}) {
 
       resetTurnTimeout();
       const { withRetry } = require('./llm/retry');
-      const toolsForTurn = (() => {
+      const toolsForTurn = await (async () => {
         if (codeReviewFastPath || forceFinalNoTools) return [];
-        let tools = opts.allowedTools ? chatTools.filter(t => opts.allowedTools.includes(t.name)) : chatTools;
+        const registryTools = await getRuntimeToolDefinitions(chatToolRegistry, wallERuntimeProfile, {
+          ...chatToolContextBase,
+          provider: usedProvider || targetProviderType,
+          model: selectedModel,
+        });
+        let tools = opts.allowedTools ? registryTools.filter(t => opts.allowedTools.includes(t.name)) : registryTools;
         tools = filterToolsForIntent(tools, intent);
         if (channel === 'task' || channel === 'eval') tools = tools.filter(t => !TASK_CHANNEL_EXCLUDE.has(t.name));
         return tools;
       })();
+      const runtimePromptManifest = buildRuntimePromptManifest({
+        runtimeProfile: wallERuntimeProfile,
+        systemPrompt,
+        userTask: message,
+        messages,
+        tools: toolsForTurn,
+        provider: usedProvider || targetProviderType,
+        model: selectedModel,
+        metadata: { channel, turn },
+      });
+      try {
+        _telemetry.track('prompt_manifest', {
+          runtime_profile: wallERuntimeProfile.profileId,
+          stable_sections: runtimePromptManifest.stableSectionCount,
+          dynamic_sections: runtimePromptManifest.dynamicSectionCount,
+          token_estimate: runtimePromptManifest.tokenEstimate,
+        });
+      } catch {}
       const primaryRetries = (_allowChatProviderFallback(opts)
         && _allowCrossProviderFallbackForTurn({
           opts,
@@ -3037,8 +3493,7 @@ async function chat(message, opts = {}) {
           if (registeredProv) providerAvailability.recordFailure(registeredProv.providerId, llmErr.message);
         } catch {}
         const decorated = decorateProviderError(llmErr, {
-          provider: usedProvider || targetProviderType || getDefaultProviderType(),
-          model: selectedModel,
+          ...primaryProviderErrorContext(usedProvider || targetProviderType || getDefaultProviderType(), selectedModel),
         });
         const allowCrossProviderFallback = _allowCrossProviderFallbackForTurn({
           opts,
@@ -3060,7 +3515,7 @@ async function chat(message, opts = {}) {
           let lastFallbackDecorated = null;
           for (const fallback of fallbacks) {
             if (attemptedProviderTypes.has(fallback.providerType) || attemptedProviderTypes.has(fallback.provider?.type)) continue;
-            provider = fallback.provider;
+            provider = withProviderMessageGuard(fallback.provider);
             selectedModel = fallback.model;
             usedProvider = fallback.provider.type || fallback.providerType;
             attemptedProviderTypes.add(fallback.providerType);
@@ -3098,6 +3553,7 @@ async function chat(message, opts = {}) {
               const fallbackDecorated = decorateProviderError(fallbackErr, {
                 provider: fallback.providerType,
                 model: fallback.model,
+                providerId: fallback.providerId || null,
               });
               lastFallbackDecorated = fallbackDecorated;
               recordProviderFailureAlert(fallbackDecorated.providerError, brain);
@@ -3153,6 +3609,11 @@ async function chat(message, opts = {}) {
 
       const textToolResponse = extractTextToolCalls(response);
       if (textToolResponse.textToolCallFormat) {
+        warnOnTextToolCallFormatMismatch(
+          response.provider || usedProvider || targetProviderType,
+          response.model || selectedModel,
+          textToolResponse.textToolCallFormat,
+        );
         const allowedToolNames = new Set((Array.isArray(toolsForTurn) ? toolsForTurn : []).map((tool) => tool.name));
         const allowedToolCalls = textToolResponse.toolCalls.filter((call) => allowedToolNames.has(call.name));
         response = { ...textToolResponse, toolCalls: allowedToolCalls };
@@ -3175,6 +3636,7 @@ async function chat(message, opts = {}) {
       if (response.usage) {
         totalInputTokens += response.usage.input || 0;
         totalOutputTokens += response.usage.output || 0;
+        recordUsageLedger(response, 'turn', { turn });
       }
       if (!usedModel) { usedModel = response.model; usedProvider = response.provider; }
 
@@ -3266,6 +3728,84 @@ async function chat(message, opts = {}) {
           console.log('[chat] Premature post-tool progress text — continuing tool loop');
           continue;
         }
+
+        const shouldRunActionCompletionGuard = (wallECodingMode || isCodingActionRequest())
+          && !forceFinalNoTools
+          && !(codingTurnIntent.readOnly && !codingTurnIntent.expectsChange);
+        if (shouldRunActionCompletionGuard) {
+          let hasTurnBudgetForActionContinuation = turn + 1 < allowedTurns;
+          if (!hasTurnBudgetForActionContinuation) {
+            hasTurnBudgetForActionContinuation = extendCodingTurnBudget('action completion guard');
+          }
+          const toolsAvailableForActionContinuation = Array.isArray(toolsForTurn)
+            && toolsForTurn.length > 0
+            && toolCallCount < MAX_TOOL_CALLS
+            && hasTurnBudgetForActionContinuation;
+          const actionContinuation = _chatNoActionContinuation({
+            prompt: routingMessage || message,
+            content: finalText,
+            toolCallHistory: _chatToolCallHistoryForActionGuard(allToolCalls),
+            toolsAvailable: toolsAvailableForActionContinuation,
+            nudges: actionCompletionContinuationCount,
+            maxNudges: wallECodingMode ? 3 : 1,
+            cwd: effectiveCwd || opts.cwd || process.cwd(),
+            codingIntent: codingTurnIntent,
+          });
+          if (actionContinuation?.action === 'continue') {
+            actionCompletionContinuationCount += 1;
+            const assistantHistoryContent = [];
+            if (response.reasoningContent && typeof response.reasoningContent === 'string') {
+              assistantHistoryContent.push({ type: 'reasoning', text: response.reasoningContent });
+            }
+            if (finalText) assistantHistoryContent.push({ type: 'text', text: finalText });
+            messages.push({
+              role: 'assistant',
+              content: assistantHistoryContent.length > 0 ? assistantHistoryContent : finalText,
+            });
+            messages.push({
+              role: 'user',
+              content: `${actionContinuation.message}\n` +
+                'If the target project is outside the current working directory, do not run broad filesystem scans. Use start_coding with cwd set to the explicit target project directory, or use project-scoped file tools against that directory. For website/UI/UX requests, finish only after concrete edits and verification evidence.',
+            });
+            console.log('[chat] Action completion guard — continuing tool loop:', actionContinuation.reason);
+            continue;
+          }
+          if (actionContinuation?.action === 'fail') {
+            finalText = `I could not complete the requested code change: ${actionContinuation.reason}`;
+          }
+        }
+        const localPreviewClaim = analyzeLocalPreviewClaims(finalText, allToolCalls);
+        if (!forceFinalNoTools
+            && localPreviewClaim.hasPositiveClaim
+            && !localPreviewClaim.ok
+            && localPreviewVerificationContinuationCount < 2) {
+          let hasTurnBudgetForLocalPreviewVerification = turn + 1 < allowedTurns;
+          if (!hasTurnBudgetForLocalPreviewVerification) {
+            hasTurnBudgetForLocalPreviewVerification = extendCodingTurnBudget('local preview verification guard');
+          }
+          const toolsAvailableForLocalPreviewVerification = Array.isArray(toolsForTurn)
+            && toolsForTurn.length > 0
+            && toolCallCount < MAX_TOOL_CALLS
+            && hasTurnBudgetForLocalPreviewVerification;
+          if (toolsAvailableForLocalPreviewVerification) {
+            localPreviewVerificationContinuationCount += 1;
+            const assistantHistoryContent = [];
+            if (response.reasoningContent && typeof response.reasoningContent === 'string') {
+              assistantHistoryContent.push({ type: 'reasoning', text: response.reasoningContent });
+            }
+            if (finalText) assistantHistoryContent.push({ type: 'text', text: finalText });
+            messages.push({
+              role: 'assistant',
+              content: assistantHistoryContent.length > 0 ? assistantHistoryContent : finalText,
+            });
+            messages.push({
+              role: 'user',
+              content: buildLocalPreviewVerificationNudge(localPreviewClaim),
+            });
+            console.warn('[chat] Local preview claim lacked tool evidence; continuing tool loop');
+            continue;
+          }
+        }
         finalResponseMeta = {
           model: response.model || selectedModel,
           provider: response.provider || usedProvider || targetProviderType,
@@ -3280,6 +3820,12 @@ async function chat(message, opts = {}) {
       for (const tu of response.toolCalls) {
         const summary = tu.name === 'search_memories'
           ? `Searching: "${tu.input.query}"${tu.input.source ? ` (${tu.input.source})` : ''}`
+          : tu.name === 'ctm_context'
+          ? 'Checking CTM operational context...'
+          : tu.name === 'ctm_remote_access_status'
+          ? 'Checking CTM phone access...'
+          : tu.name === 'ctm_session_search'
+          ? `Searching CTM sessions: "${tu.input.query}"`
           : tu.name === 'think'
           ? 'Analyzing evidence...'
           : tu.name === 'lookup_person'
@@ -3338,7 +3884,13 @@ async function chat(message, opts = {}) {
       const executeToolCall = async (tu) => {
         const t0 = Date.now();
         console.log('[chat] Tool call:', tu.name, JSON.stringify(tu.input).slice(0, 150));
-        const result = await executeChatTool(tu.name, tu.input);
+        const result = await executeRuntimeTool(chatToolRegistry, wallERuntimeProfile, tu.name, tu.input, {
+          ...chatToolContextBase,
+          provider: usedProvider || targetProviderType,
+          model: selectedModel,
+          sessionId,
+          cwd: effectiveCwd || opts.cwd || process.cwd(),
+        });
         const resultStr = JSON.stringify(result);
         const elapsed = Date.now() - t0;
         timings.toolMs += elapsed;
@@ -3346,18 +3898,25 @@ async function chat(message, opts = {}) {
         // Per-tool-call telemetry: name + status + latency only. No tool args
         // or result content (those can carry user data); error_type is the
         // top-level shape only, not the message.
+        const evidence = normalizeToolCallEvidence({ name: tu.name, input: tu.input }, result);
+        const isError = evidence.ok === false;
         try {
-          const isError = !!(result && result.error);
           _telemetry.track('tool_call', {
             name: tu.name,
             status: isError ? 'error' : 'success',
             duration_ms: elapsed,
-            error_type: isError ? (typeof result.error === 'string' ? 'message' : (result.auth_required ? 'auth_required' : 'object')) : undefined,
+            error_type: isError ? (typeof result?.error === 'string' ? 'message' : (result?.auth_required ? 'auth_required' : 'object')) : undefined,
           });
         } catch {}
         // Emit tool completion with result summary
         const resultSummary = tu.name === 'search_memories'
           ? `Found ${result.count || 0} results (${result.search_method || 'search'})`
+          : tu.name === 'ctm_context'
+          ? `CTM context ${result.ok ? 'available' : 'unavailable'}`
+          : tu.name === 'ctm_remote_access_status'
+          ? `CTM phone access ${result.ok ? 'available' : 'unavailable'}`
+          : tu.name === 'ctm_session_search'
+          ? `Found ${(result.results || []).length} CTM session result(s)`
           : tu.name === 'think'
           ? 'Done thinking'
           : `Completed in ${elapsed}ms`;
@@ -3371,23 +3930,62 @@ async function chat(message, opts = {}) {
           name: tu.name,
           result: _progressToolResultPayload(result, resultStr),
           summary: resultSummary,
+          error: isError ? (result?.error || result?.stderr || 'Tool returned unsuccessful evidence') : null,
           fullSizeBytes: Buffer.byteLength(resultStr, 'utf8'),
         });
         return {
           message: { type: 'tool_result', tool_use_id: tu.id, content: compactedResult },
-          call: { id: tu.id, tool: tu.name, args: tu.input, result_summary: resultSummary, error: !!result?.error },
+          call: {
+            id: tu.id,
+            tool: tu.name,
+            name: tu.name,
+            args: tu.input,
+            input: tu.input,
+            result,
+            ok: evidence.ok === true,
+            result_summary: resultSummary,
+            error: isError ? (result?.error || true) : false,
+          },
         };
       };
 
-      let toolOutputs;
-      if (_shouldRunToolCallsSequentially(response.toolCalls)) {
-        toolOutputs = [];
-        for (const tu of response.toolCalls) {
-          toolOutputs.push(await executeToolCall(tu));
-        }
-      } else {
-        toolOutputs = await Promise.all(response.toolCalls.map(executeToolCall));
-      }
+      const runtimeToolExecutor = new RuntimeToolExecutor({
+        registry: chatToolRegistry,
+        runtimeProfile: wallERuntimeProfile,
+        executeToolCall,
+      });
+      const toolExecutionRows = await runtimeToolExecutor.run(response.toolCalls, {
+        ...chatToolContextBase,
+        provider: usedProvider || targetProviderType,
+        model: selectedModel,
+        sessionId,
+        cwd: effectiveCwd || opts.cwd || process.cwd(),
+      });
+      const toolOutputs = toolExecutionRows.map((row) => {
+        if (row.rawResult?.message && row.rawResult?.call) return row.rawResult;
+        const call = row.call || {};
+        const envelope = row.envelope || {};
+        const result = envelope.outputForModel || row.result || { error: envelope.error || 'Tool execution failed' };
+        const content = typeof result === 'string' ? result : JSON.stringify(result);
+        return {
+          message: {
+            type: 'tool_result',
+            tool_use_id: call.id,
+            content,
+            is_error: row.ok === false,
+          },
+          call: {
+            id: call.id,
+            tool: call.name,
+            name: call.name,
+            args: call.input,
+            input: call.input,
+            result,
+            ok: row.ok === true,
+            error: row.ok === true ? false : (envelope.error || true),
+          },
+        };
+      });
 
       for (const output of toolOutputs) allToolCalls.push(output.call);
       const toolResults = toolOutputs.map((output) => output.message);
@@ -3516,6 +4114,7 @@ async function chat(message, opts = {}) {
         if (repairResponse.usage) {
           totalInputTokens += repairResponse.usage.input || 0;
           totalOutputTokens += repairResponse.usage.output || 0;
+          recordUsageLedger(repairResponse, 'code_review_repair', { repair: 'code_review' });
         }
         timings.repairMs += Date.now() - repairStart;
         if (!usedModel) { usedModel = repairResponse.model; usedProvider = repairResponse.provider; }
@@ -3538,8 +4137,7 @@ async function chat(message, opts = {}) {
         console.error('[chat] Code-review repair call failed:', repairErr.message);
         try {
           const decorated = decorateProviderError(repairErr, {
-            provider: usedProvider || targetProviderType || getDefaultProviderType(),
-            model: selectedModel,
+            ...primaryProviderErrorContext(usedProvider || targetProviderType || getDefaultProviderType(), selectedModel),
           });
           recordProviderFailureAlert(decorated.providerError, brain);
         } catch {}
@@ -3572,6 +4170,7 @@ async function chat(message, opts = {}) {
         if (repairResponse.usage) {
           totalInputTokens += repairResponse.usage.input || 0;
           totalOutputTokens += repairResponse.usage.output || 0;
+          recordUsageLedger(repairResponse, 'post_tool_repair', { repair: 'tool_followup' });
         }
         timings.repairMs += Date.now() - repairStart;
         if (!usedModel) { usedModel = repairResponse.model; usedProvider = repairResponse.provider; }
@@ -3597,14 +4196,23 @@ async function chat(message, opts = {}) {
         console.error('[chat] Post-tool repair call failed:', repairErr.message);
         try {
           const decorated = decorateProviderError(repairErr, {
-            provider: usedProvider || targetProviderType || getDefaultProviderType(),
-            model: selectedModel,
+            ...primaryProviderErrorContext(usedProvider || targetProviderType || getDefaultProviderType(), selectedModel),
           });
           recordProviderFailureAlert(decorated.providerError, brain);
         } catch {}
       }
       if (repairFailed && hasPrematureToolControlText(null, finalText)) {
-        const fallback = await _tryProviderFinalizationFallback({
+        const evidenceFallback = await _tryEvidenceOnlyFinalization({
+          provider,
+          model: selectedModel,
+          originalRequest: routingMessage || message,
+          toolCalls: allToolCalls,
+          opts,
+          resetFinalizationTimeout,
+          resolveCurrentReasoningOptions,
+          getSignal: () => controller.signal,
+        });
+        const fallback = evidenceFallback || await _tryProviderFinalizationFallback({
           messages,
           systemPrompt,
           attemptedProviderTypes,
@@ -3623,13 +4231,19 @@ async function chat(message, opts = {}) {
           if (fallback.response?.usage) {
             totalInputTokens += fallback.response.usage.input || 0;
             totalOutputTokens += fallback.response.usage.output || 0;
+            recordUsageLedger(fallback.response, evidenceFallback ? 'tool_followup_evidence_only' : 'tool_followup_provider_fallback', {
+              fallback: true,
+              repair: evidenceFallback ? 'tool_followup_evidence_only' : 'tool_followup_provider_fallback',
+              provider: fallback.meta?.provider || null,
+              model: fallback.meta?.model || null,
+            });
           }
           usedModel = fallback.meta.model || usedModel;
           usedProvider = fallback.meta.provider || usedProvider;
           finalResponseMeta = {
             ...(finalResponseMeta || {}),
             ...fallback.meta,
-            repair: 'tool_followup_provider_fallback',
+            repair: evidenceFallback ? 'tool_followup_evidence_only' : 'tool_followup_provider_fallback',
           };
         } else {
           finalText = _postToolFinalizationFailureReply(opts, allToolCalls);
@@ -3667,14 +4281,25 @@ async function chat(message, opts = {}) {
         if (summaryResponse.usage) {
           totalInputTokens += summaryResponse.usage.input || 0;
           totalOutputTokens += summaryResponse.usage.output || 0;
+          recordUsageLedger(summaryResponse, 'summary_fallback', { repair: 'summary' });
         }
         const summaryTextResponse = extractTextToolCalls(summaryResponse);
         const summaryText = summaryTextResponse.content || '';
         if (summaryText && !hasPrematureToolControlText(summaryTextResponse, summaryText)) {
           finalText = summaryText;
         } else {
-          console.warn('[chat] Summary fallback returned progress/tool-control text; trying provider finalization fallback');
-          const fallback = await _tryProviderFinalizationFallback({
+          console.warn('[chat] Summary fallback returned progress/tool-control text; trying evidence-only finalization');
+          const evidenceFallback = await _tryEvidenceOnlyFinalization({
+            provider,
+            model: selectedModel,
+            originalRequest: routingMessage || message,
+            toolCalls: allToolCalls,
+            opts,
+            resetFinalizationTimeout,
+            resolveCurrentReasoningOptions,
+            getSignal: () => controller.signal,
+          });
+          const fallback = evidenceFallback || await _tryProviderFinalizationFallback({
             messages,
             systemPrompt,
             attemptedProviderTypes,
@@ -3693,6 +4318,12 @@ async function chat(message, opts = {}) {
             if (fallback.response?.usage) {
               totalInputTokens += fallback.response.usage.input || 0;
               totalOutputTokens += fallback.response.usage.output || 0;
+              recordUsageLedger(fallback.response, evidenceFallback ? 'summary_evidence_only' : 'summary_provider_fallback', {
+                fallback: true,
+                repair: evidenceFallback ? 'summary_evidence_only' : 'summary_provider_fallback',
+                provider: fallback.meta?.provider || null,
+                model: fallback.meta?.model || null,
+              });
             }
             usedModel = fallback.meta.model || usedModel;
             usedProvider = fallback.meta.provider || usedProvider;
@@ -3722,8 +4353,7 @@ async function chat(message, opts = {}) {
         let summaryProviderError = null;
         try {
           const decorated = decorateProviderError(summaryErr, {
-            provider: usedProvider || targetProviderType || getDefaultProviderType(),
-            model: selectedModel,
+            ...primaryProviderErrorContext(usedProvider || targetProviderType || getDefaultProviderType(), selectedModel),
           });
           summaryProviderError = decorated.providerError;
           recordProviderFailureAlert(summaryProviderError, brain);
@@ -3736,7 +4366,19 @@ async function chat(message, opts = {}) {
         const summaryFailureText = summaryProviderError
           ? `${summaryProviderError.title}: ${summaryProviderError.userMessage}`
           : `Summary generation failed: ${summaryErr.message}`;
-        const fallback = allToolCalls.length > 0
+        const evidenceFallback = allToolCalls.length > 0
+          ? await _tryEvidenceOnlyFinalization({
+            provider,
+            model: selectedModel,
+            originalRequest: routingMessage || message,
+            toolCalls: allToolCalls,
+            opts,
+            resetFinalizationTimeout,
+            resolveCurrentReasoningOptions,
+            getSignal: () => controller.signal,
+          })
+          : null;
+        const fallback = evidenceFallback || (allToolCalls.length > 0
           ? await _tryProviderFinalizationFallback({
             messages,
             systemPrompt,
@@ -3750,13 +4392,19 @@ async function chat(message, opts = {}) {
             fromProvider: usedProvider || targetProviderType,
             fromModel: usedModel || selectedModel,
           })
-          : null;
+          : null);
         if (fallback) {
           finalText = fallback.text;
           lastTurnText = finalText;
           if (fallback.response?.usage) {
             totalInputTokens += fallback.response.usage.input || 0;
             totalOutputTokens += fallback.response.usage.output || 0;
+            recordUsageLedger(fallback.response, evidenceFallback ? 'summary_error_evidence_only' : 'summary_error_provider_fallback', {
+              fallback: true,
+              repair: evidenceFallback ? 'summary_error_evidence_only' : 'summary_error_provider_fallback',
+              provider: fallback.meta?.provider || null,
+              model: fallback.meta?.model || null,
+            });
           }
           usedModel = fallback.meta.model || usedModel;
           usedProvider = fallback.meta.provider || usedProvider;
@@ -3838,6 +4486,91 @@ async function chat(message, opts = {}) {
       console.error('[chat] Self-critique error:', critiqueErr.message);
     }
 
+    const frameValidation = validateFrameAnswer(text, conversationRuntime.frame);
+    if (!frameValidation.ok && !opts.disableConversationFrameRepair) {
+      try {
+        console.warn('[chat] Conversation frame validation failed; forcing scoped final-answer repair:', frameValidation.violations.map(v => v.code).join(','));
+        resetFinalizationTimeout();
+        const repairStart = Date.now();
+        const frameRepairResponse = await provider.chat({
+          model: selectedModel,
+          maxTokens: Math.min(2048, Math.max(512, estimateTokens(text) + 512)),
+          system: systemPrompt,
+          messages: [
+            ...messages,
+            { role: 'assistant', content: text },
+            {
+              role: 'user',
+              content: buildFrameRepairPrompt({
+                frame: conversationRuntime.frame,
+                violations: frameValidation.violations,
+                originalUserMessage: message,
+              }),
+            },
+          ],
+          tools: [],
+          thinking: 'disabled',
+          signal: controller.signal,
+        });
+        if (frameRepairResponse.usage) {
+          totalInputTokens += frameRepairResponse.usage.input || 0;
+          totalOutputTokens += frameRepairResponse.usage.output || 0;
+          recordUsageLedger(frameRepairResponse, 'conversation_frame_repair', { repair: 'conversation_frame' });
+        }
+        timings.repairMs += Date.now() - repairStart;
+        const frameRepairSanitization = _sanitizeProtocolFinalText(frameRepairResponse.content || '', opts, allToolCalls);
+        const repairedText = frameRepairSanitization.text || '';
+        const repairedValidation = validateFrameAnswer(repairedText, conversationRuntime.frame);
+        if (repairedText && !frameRepairSanitization.finalizationFailed && repairedValidation.ok) {
+          text = repairedText;
+          lastTurnText = text;
+          finalResponseMeta = {
+            ...(finalResponseMeta || {}),
+            model: frameRepairResponse.model || selectedModel,
+            provider: frameRepairResponse.provider || usedProvider || targetProviderType,
+            usage: frameRepairResponse.usage || finalResponseMeta?.usage || null,
+            stopReason: frameRepairResponse.stopReason || finalResponseMeta?.stopReason || null,
+            conversationFrameRepair: true,
+            conversationFrameValidation: {
+              ok: true,
+              repairedFrom: frameValidation.violations.map(v => v.code),
+            },
+            ...(frameRepairSanitization.changed ? { conversationFrameRepairProtocolSanitized: true } : {}),
+          };
+        } else {
+          console.warn('[chat] Conversation frame repair did not satisfy validation; keeping original final response');
+          finalResponseMeta = {
+            ...(finalResponseMeta || {}),
+            conversationFrameValidation: {
+              ok: false,
+              violations: frameValidation.violations.map(v => ({ code: v.code, message: v.message })),
+              repairOk: false,
+              repairedViolations: repairedValidation.violations.map(v => ({ code: v.code, message: v.message })),
+            },
+          };
+        }
+      } catch (repairErr) {
+        if (_isUserCancellation(opts, repairErr)) throw _cancelledError();
+        console.error('[chat] Conversation frame repair call failed:', repairErr.message);
+        finalResponseMeta = {
+          ...(finalResponseMeta || {}),
+          conversationFrameValidation: {
+            ok: false,
+            violations: frameValidation.violations.map(v => ({ code: v.code, message: v.message })),
+            repairError: repairErr.message,
+          },
+        };
+      }
+    } else {
+      finalResponseMeta = {
+        ...(finalResponseMeta || {}),
+        conversationFrameValidation: {
+          ok: true,
+          validators: conversationRuntime.validators,
+        },
+      };
+    }
+
     const languageMismatch = detectResponseLanguageMismatch(message, text);
     if (languageMismatch && !opts.disableLanguageRepair) {
       try {
@@ -3860,6 +4593,7 @@ async function chat(message, opts = {}) {
         if (languageRepairResponse.usage) {
           totalInputTokens += languageRepairResponse.usage.input || 0;
           totalOutputTokens += languageRepairResponse.usage.output || 0;
+          recordUsageLedger(languageRepairResponse, 'language_repair', { repair: 'language' });
         }
         timings.repairMs += Date.now() - repairStart;
         const languageRepairSanitization = _sanitizeProtocolFinalText(languageRepairResponse.content || '', opts, allToolCalls);
@@ -3898,15 +4632,34 @@ async function chat(message, opts = {}) {
       };
     }
 
+    const finalLocalPreviewClaim = analyzeLocalPreviewClaims(text, allToolCalls);
+    if (finalLocalPreviewClaim.hasPositiveClaim && !finalLocalPreviewClaim.ok) {
+      console.warn('[chat] Blocking unsupported local preview claim before persistence');
+      text = buildUnsupportedLocalPreviewReply(finalLocalPreviewClaim);
+      lastTurnText = text;
+      finalResponseMeta = {
+        ...(finalResponseMeta || {}),
+        localPreviewClaimBlocked: true,
+        unsupportedLocalPreviewUrls: finalLocalPreviewClaim.unsupportedUrls.map((url) => url.raw),
+      };
+    }
+
     // Save enriched session state
     try {
       const metadata = {
+        ...existingSessionMetadata,
         lastTopic: message.slice(0, 200),
         turnCount: lastTurn + 1,
         toolsUsed: [...new Set(messages
           .filter(m => m.role === 'assistant' && Array.isArray(m.content))
           .flatMap(m => m.content.filter(b => b.type === 'tool_use').map(b => b.name))
         )],
+        conversationFrame: conversationRuntime.frame,
+        conversationRuntime: {
+          schemaVersion: conversationRuntime.schemaVersion,
+          validators: conversationRuntime.validators,
+          lastValidation: finalResponseMeta?.conversationFrameValidation || null,
+        },
       };
       brain.upsertSession({
         id: sessionId, channel,
@@ -3919,9 +4672,16 @@ async function chat(message, opts = {}) {
       console.error('[chat] Failed to save session:', sessionErr.message);
     }
 
-    // Save assistant response (user message was already saved before calling Claude)
+    // Save assistant response (user message was already saved before calling Claude).
+    // Record which model/provider actually produced this turn (finalResponseMeta is
+    // the synthesis turn's meta; fall back to the last used/selected model) so the
+    // conversation log can attribute it instead of showing a blank model.
     const persistStart = Date.now();
-    const assistantMessage = brain.insertChatMessage({ role: 'assistant', content: text, channel, session_id: sessionId });
+    const assistantMessage = brain.insertChatMessage({
+      role: 'assistant', content: text, channel, session_id: sessionId,
+      model_id: finalResponseMeta?.model || usedModel || selectedModel || null,
+      model_provider: finalResponseMeta?.provider || usedProvider || targetProviderType || null,
+    });
     recordSessionMessage('assistant', text, {
       ...(finalResponseMeta || {}),
       dbMessageId: assistantMessage.id,
@@ -3961,7 +4721,7 @@ async function chat(message, opts = {}) {
     timings.persistMs += Date.now() - persistStart;
 
     const latencyMs = Date.now() - chatStartTime;
-    const cost = calculateCost(usedModel, totalInputTokens, totalOutputTokens);
+    const cost = calculateCost(usedModel, totalInputTokens, totalOutputTokens, usedProvider);
 
     // Telemetry (anonymous — no message content)
     try {
@@ -4079,7 +4839,16 @@ async function chat(message, opts = {}) {
   }
 }
 
-function calculateCost(model, inputTokens, outputTokens) {
+function calculateCost(model, inputTokens, outputTokens, providerType) {
+  try {
+    const estimate = brain.estimateModelUsageCost?.({
+      providerType,
+      modelId: model,
+      inputTokens,
+      outputTokens,
+    });
+    if (Number.isFinite(estimate?.costUsd)) return estimate.costUsd;
+  } catch {}
   const pricing = {
     'claude-sonnet-4-6': { input: 3, output: 15 },
     'claude-opus-4-6': { input: 15, output: 75 },