create-walle 0.9.13 → 0.9.15

package/template/wall-e/chat.js

@@ -282,6 +282,101 @@ function _providerConfigFromRegistryRow(row) {
   return config;
 }
 
+function _createChatProvider(type, config = {}, opts = {}) {
+  if (typeof opts.providerFactory === 'function') return opts.providerFactory(type, config);
+  return createClient(type, config);
+}
+
+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;
+}
+
+function _providerRuntimeConfig(row = {}) {
+  if (row.type === 'anthropic' && row.auth_method === 'oauth_proxy') {
+    return {
+      apiKey: 'oauth-proxy-placeholder',
+      baseUrl: `http://127.0.0.1:${process.env.OAUTH_PROXY_PORT || '3458'}`,
+    };
+  }
+  return _providerConfigFromRegistryRow(row);
+}
+
+function _providerRowHasRuntimeAccess(row = {}) {
+  if (!row.enabled) return false;
+  if (row.type === 'ollama' || row.type === 'mlx') return true;
+  if (row.auth_method && row.auth_method !== 'api_key') return true;
+  if (row.api_key_encrypted) return true;
+  if (row.type === 'anthropic' && process.env.ANTHROPIC_API_KEY) return true;
+  if (row.type === 'openai' && process.env.OPENAI_API_KEY) return true;
+  if (row.type === 'google' && (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY)) return true;
+  if (row.type === 'deepseek' && process.env.DEEPSEEK_API_KEY) return true;
+  return false;
+}
+
+function _fallbackErrorType(providerError = {}) {
+  return new Set(['rate_limited', 'network', 'provider_unavailable', 'timeout']).has(providerError.type);
+}
+
+function _selectFallbackModel(providerId, runtimeType, taskType) {
+  try {
+    const preferred = brain.getModelDefault(taskType || 'chat');
+    if (preferred?.model_registry_id) {
+      const entry = brain.getModelRegistryEntry?.(preferred.model_registry_id);
+      if (entry?.provider_id === providerId && entry.model_id) return entry.model_id;
+    }
+  } catch {}
+  try {
+    const models = brain.listModelsByProvider?.(providerId) || [];
+    const first = models.find(m => m.enabled !== 0);
+    if (first?.model_id) return first.model_id;
+  } catch {}
+  return getDefaultModelForProvider(runtimeType);
+}
+
+function _listChatFallbackRows({ attemptedProviderTypes, providerAvailability }) {
+  let rows = [];
+  try {
+    rows = (brain.listModelProviders?.() || [])
+      .map(row => brain.getModelProviderWithKey?.(row.id) || row)
+      .filter(row => row && _providerRowHasRuntimeAccess(row));
+  } catch {
+    rows = [];
+  }
+  const candidates = [];
+  for (const row of rows) {
+    const runtimeType = _providerRuntimeType(row);
+    if (!runtimeType) continue;
+    if (attemptedProviderTypes.has(row.type) || attemptedProviderTypes.has(runtimeType)) continue;
+    if (providerAvailability?.isProviderUsable) {
+      if (!providerAvailability.isProviderUsable(row.id) || !providerAvailability.isProviderUsable(runtimeType)) continue;
+    }
+    candidates.push({ row, runtimeType });
+  }
+  return candidates;
+}
+
+function _findChatProviderFallback({ attemptedProviderTypes, providerError, taskType, opts, providerAvailability }) {
+  if (opts.provider || opts.model || _clientOverride) return null;
+  if (!_fallbackErrorType(providerError)) return null;
+  for (const { row, runtimeType } of _listChatFallbackRows({ attemptedProviderTypes, providerAvailability })) {
+    const model = resolveCompatibleModel(
+      _selectFallbackModel(row.id, runtimeType, taskType),
+      runtimeType,
+    );
+    try {
+      return {
+        provider: _createChatProvider(runtimeType, _providerRuntimeConfig(row), opts),
+        providerId: row.id,
+        providerType: runtimeType,
+        model,
+      };
+    } catch {}
+  }
+  return null;
+}
+
 function resolveModelSelection(model, explicitProvider) {
   if (!model) {
     return { input: model, model: null, provider: explicitProvider || null, providerConfig: null, registryId: null };
@@ -547,11 +642,18 @@ async function chat(message, opts = {}) {
     }
   }
 
+  let workspaceContextBlock = '';
+  if (effectiveCwd) {
+    workspaceContextBlock = '\n\n## Current Workspace\n'
+      + `Working directory: ${effectiveCwd}\n`
+      + 'When the user refers to this project, current project, codebase, repo, or asks to study/review/summarize code without a path, treat that as this working directory. Do not ask for a project path first; explore it with glob, search_files, grep_files, read_file, read_project_file, or search_project. Ask for a path only if this directory is unavailable or the user explicitly asks for a different project.';
+  }
+
   const promptStart = Date.now();
   const baseSystemPrompt = await buildSystemPrompt(message, channel, {
     sessionSummary: existingSession?.summary || null,
     intent,
-  }) + reviewContextBlock + codeReviewContextBlock;
+  }) + reviewContextBlock + codeReviewContextBlock + workspaceContextBlock;
   // 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
@@ -579,8 +681,8 @@ async function chat(message, opts = {}) {
     const routeConfig = selectedRoute.providerConfig || {};
     const providerConfig = { ...routeConfig, ...(opts.providerConfig || {}) };
     const hasSpecificConfig = !!(providerConfig.apiKey || providerConfig.baseUrl || providerConfig.customHeaders);
-    if (targetProviderType !== defaultProviderType || opts.provider || hasSpecificConfig) {
-      provider = createClient(targetProviderType, providerConfig);
+    if (opts.providerFactory || targetProviderType !== defaultProviderType || opts.provider || hasSpecificConfig) {
+      provider = _createChatProvider(targetProviderType, providerConfig, opts);
     } else {
       provider = getDefaultClient();
     }
@@ -591,7 +693,7 @@ async function chat(message, opts = {}) {
     try {
       const localEngine = brain.getDb().prepare("SELECT value FROM brain_metadata WHERE key = 'local_engine'").get()?.value;
       if (localEngine === 'mlx') {
-        provider = createClient('mlx', {});
+        provider = _createChatProvider('mlx', {}, opts);
       }
     } catch (e) {
       console.warn('[chat] MLX engine swap failed, staying on Ollama:', e.message);
@@ -667,7 +769,7 @@ async function chat(message, opts = {}) {
     },
     {
       name: 'search_memories',
-      description: 'Hybrid search (BM25 + semantic vectors). Call MULTIPLE searches in ONE turn to batch them. Finds both exact keyword matches AND semantically related content.',
+      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.',
       input_schema: { type: 'object', properties: { query: { type: 'string', description: 'Search query. Finds keyword matches AND semantically similar content.' }, source: { type: 'string', description: 'Filter: slack, ctm, wall-e-chat' }, limit: { type: 'number', default: 15 } }, required: ['query'] },
     },
     {
@@ -900,6 +1002,8 @@ 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 === 'glob' && !input.directory) {
         input = { ...input, directory: effectiveCwd, projectRoot: effectiveCwd };
       } else if (name === 'grep_files' && !input.directory) {
@@ -1480,6 +1584,7 @@ async function chat(message, opts = {}) {
     console.log('[chat] Intent:', intent, '| topics:', queryTopics.join(','), '| limits: turns=', MAX_TURNS, 'tools=', MAX_TOOL_CALLS, 'timeout=', MESSAGE_TIMEOUT_MS, 'ms');
 
     const chatStart = Date.now();
+    const attemptedProviderTypes = new Set([targetProviderType, provider.type].filter(Boolean));
     for (let turn = 0; turn < MAX_TURNS; turn++) {
       if (opts.abortSignal?.aborted) {
         clearTimeout(timeout);
@@ -1552,15 +1657,19 @@ async function chat(message, opts = {}) {
       }
 
       resetTurnTimeout();
+      const { withRetry } = require('./llm/retry');
+      const toolsForTurn = (() => {
+        if (codeReviewFastPath) return [];
+        let tools = opts.allowedTools ? chatTools.filter(t => opts.allowedTools.includes(t.name)) : filterToolsForIntent(chatTools, intent);
+        if (channel === 'task' || channel === 'eval') tools = tools.filter(t => !TASK_CHANNEL_EXCLUDE.has(t.name));
+        return tools;
+      })();
+      const primaryRetries = (!opts.provider && !opts.model && !_clientOverride
+        && _listChatFallbackRows({ attemptedProviderTypes, providerAvailability }).length > 0)
+        ? 0
+        : 2;
       let response;
       try {
-        const { withRetry } = require('./llm/retry');
-        const toolsForTurn = (() => {
-          if (codeReviewFastPath) return [];
-          let tools = opts.allowedTools ? chatTools.filter(t => opts.allowedTools.includes(t.name)) : filterToolsForIntent(chatTools, intent);
-          if (channel === 'task' || channel === 'eval') tools = tools.filter(t => !TASK_CHANNEL_EXCLUDE.has(t.name));
-          return tools;
-        })();
         response = await withRetry(() => provider.chat({
           model: selectedModel,
           maxTokens: codeReviewFastPath ? 2048 : 4096,
@@ -1569,7 +1678,7 @@ async function chat(message, opts = {}) {
           tools: toolsForTurn,
           ...reasoningOptions,
           signal: controller.signal,
-        }), 2); // max 2 retries for chat (faster failure than coding agent)
+        }), primaryRetries); // Fast-fail automatic routing when another provider can handle fallback.
       } catch (llmErr) {
         // Track provider health — failed LLM call
         try {
@@ -1581,8 +1690,56 @@ async function chat(message, opts = {}) {
           provider: usedProvider || targetProviderType || getDefaultProviderType(),
           model: selectedModel,
         });
-        recordProviderFailureAlert(decorated.providerError, brain);
-        throw decorated;
+        const fallback = _findChatProviderFallback({
+          attemptedProviderTypes,
+          providerError: decorated.providerError,
+          taskType: opts.taskType || 'chat',
+          opts,
+          providerAvailability,
+        });
+        if (fallback) {
+          try {
+            provider = fallback.provider;
+            selectedModel = fallback.model;
+            usedProvider = fallback.provider.type || fallback.providerType;
+            attemptedProviderTypes.add(fallback.providerType);
+            attemptedProviderTypes.add(fallback.provider?.type);
+            try {
+              _telemetry.track('chat_provider_failover', {
+                from_provider: decorated.providerError.provider || targetProviderType,
+                from_model: decorated.providerError.model || selectedModel,
+                to_provider: fallback.providerType,
+                to_model: fallback.model,
+                reason: decorated.providerError.type,
+              });
+            } catch {}
+            response = await withRetry(() => provider.chat({
+              model: selectedModel,
+              maxTokens: codeReviewFastPath ? 2048 : 4096,
+              system: systemPrompt,
+              messages,
+              tools: toolsForTurn,
+              ...reasoningOptions,
+              signal: controller.signal,
+            }), 2);
+            try {
+              if (fallback.providerId) providerAvailability.recordSuccess(fallback.providerId);
+            } catch {}
+          } catch (fallbackErr) {
+            try {
+              if (fallback.providerId) providerAvailability.recordFailure(fallback.providerId, fallbackErr.message);
+            } catch {}
+            const fallbackDecorated = decorateProviderError(fallbackErr, {
+              provider: fallback.providerType,
+              model: fallback.model,
+            });
+            recordProviderFailureAlert(fallbackDecorated.providerError, brain);
+            throw fallbackDecorated;
+          }
+        } else {
+          recordProviderFailureAlert(decorated.providerError, brain);
+          throw decorated;
+        }
       }
       const modelElapsed = Date.now() - turnStart;
       timings.modelMs += modelElapsed;

package/template/wall-e/coding/compaction-service.js

@@ -97,6 +97,8 @@ class CompactionService {
     sessionMemory = null,
     tailTokenBudget,
     keepRecentUserTurns,
+    tailMode = 'preserve',
+    continuePrompt = '',
   } = {}) {
     if (sessionMemory && typeof sessionMemory.precompact === 'function') {
       await sessionMemory.precompact({ messages, sessionId, cwd, reason });
@@ -104,7 +106,11 @@ class CompactionService {
 
     const selection = this.selectTail(messages, { tailTokenBudget, keepRecentUserTurns });
     const tokensBefore = estimateMessagesTokens(messages);
-    if (selection.head.length === 0) {
+    const summarizeAndContinue = tailMode === 'continue';
+    const summaryMessages = summarizeAndContinue
+      ? cloneMessages(messages)
+      : selection.head;
+    if (summaryMessages.length === 0) {
       const noCompaction = {
         compacted: false,
         reason: 'no_compactable_head',
@@ -117,7 +123,8 @@ class CompactionService {
     }
 
     const compactionId = newId('compaction');
-    const summary = await this._summarize(selection.head, selection);
+    const summarySelection = { ...selection, head: summaryMessages };
+    const summary = await this._summarize(summaryMessages, summarySelection);
     const timestamp = this.now();
     const userMessage = {
       role: 'user',
@@ -127,7 +134,13 @@ class CompactionService {
       role: 'assistant',
       content: `Compaction summary:\n${summary}`,
     };
-    const compactedMessages = [userMessage, assistantMessage, ...selection.tail];
+    const continuationMessage = {
+      role: 'user',
+      content: continuePrompt || 'Continue the Wall-E coding task from the compaction summary above. Re-read files or rerun commands if any exact detail is missing.',
+    };
+    const compactedMessages = summarizeAndContinue
+      ? [userMessage, assistantMessage, continuationMessage]
+      : [userMessage, assistantMessage, ...selection.tail];
     const tokensAfter = estimateMessagesTokens(compactedMessages);
     const metadata = {
       compactionId,
@@ -140,8 +153,9 @@ class CompactionService {
       tail_start_id: selection.tailStartId,
       tail_start_index: selection.tailStartIndex,
       tail_message_ids: selection.tail.map((msg, index) => getMessageId(msg, selection.tailStartIndex + index)),
-      compacted_message_count: selection.head.length,
-      retained_message_count: selection.tail.length,
+      tail_mode: summarizeAndContinue ? 'continue' : 'preserve',
+      compacted_message_count: summaryMessages.length,
+      retained_message_count: summarizeAndContinue ? 1 : selection.tail.length,
       tokens_before: tokensBefore,
       tokens_after: tokensAfter,
       summary,

package/template/wall-e/coding/stream-processor.js

@@ -84,6 +84,9 @@ class StreamProcessor extends EventEmitter {
       stopReason: '',
       status: 'running',
       errors: [],
+      toolErrors: [],
+      hadEdit: false,
+      verified: false,
       events: [],
     };
 
@@ -111,7 +114,7 @@ class StreamProcessor extends EventEmitter {
         const snapshot = await this.snapshotService.captureStepFinish({ sessionId, cwd, messageId: assistantMessageId });
         if (snapshot) await this._record(sessionId, cwd, 'snapshot', snapshot);
       }
-      state.status = state.errors.length > 0 ? 'error' : 'finished';
+      state.status = 'finished';
     } catch (err) {
       state.status = 'error';
       state.errors.push(err.message);
@@ -135,6 +138,8 @@ class StreamProcessor extends EventEmitter {
         toolCalls: state.toolCalls,
       }),
       toolResultMessage: state.toolResults.length > 0 ? toolResultMessage(state.toolResults) : null,
+      hadEdit: state.hadEdit,
+      verified: state.verified,
       next: state.status === 'error' ? 'stop' : state.toolResults.length > 0 ? 'continue' : 'stop',
     };
   }
@@ -223,6 +228,8 @@ class StreamProcessor extends EventEmitter {
         input: call.input,
       });
       const result = await this.toolExecutor(call, { sessionId, cwd, model: state.model, provider: state.provider });
+      if (isEditTool(call.name) && !result?.error) state.hadEdit = true;
+      if (isSuccessfulTestCommand(call, result)) state.verified = true;
       state.toolResults.push({ toolCallId: call.id, name: call.name, result });
       await this._record(sessionId, cwd, 'tool', {
         state: 'completed',
@@ -231,7 +238,7 @@ class StreamProcessor extends EventEmitter {
         result,
       });
     } catch (err) {
-      state.errors.push(err.message);
+      state.toolErrors.push(err.message);
       state.toolResults.push({ toolCallId: call.id, name: call.name, error: err.message });
       await this._record(sessionId, cwd, 'tool', {
         state: 'error',
@@ -262,7 +269,20 @@ class StreamProcessor extends EventEmitter {
   }
 }
 
+function isEditTool(name) {
+  return ['edit_file', 'write_file', 'apply_patch', 'multi_edit'].includes(name);
+}
+
+function isSuccessfulTestCommand(call, result) {
+  if (call?.name !== 'run_shell') return false;
+  const command = String(call.input?.command || '');
+  if (!/\b(test|spec|jest|mocha|pytest|npm\s+test|node\s+test\.js)\b/i.test(command)) return false;
+  if (result?.error || result?.exitCode) return false;
+  return true;
+}
+
 module.exports = {
   StreamProcessor,
   streamFromChat,
+  isSuccessfulTestCommand,
 };

package/template/wall-e/coding/workspace-replay.js

@@ -153,9 +153,7 @@ function defaultSessionsDir(env = process.env) {
   if (env.WALL_E_DATA_DIR && env.WALL_E_DATA_DIR !== path.join(os.homedir(), '.walle', 'data')) {
     return path.join(env.WALL_E_DATA_DIR, 'sessions');
   }
-  if (env.CTM_DATA_DIR && env.CTM_DATA_DIR !== path.join(os.homedir(), '.walle', 'data')) {
-    return path.join(env.CTM_DATA_DIR, 'sessions');
-  }
+  // CTM_DATA_DIR belongs to the task manager; Wall-E transcripts stay in Wall-E-owned storage.
   return path.join(os.homedir(), '.walle', 'sessions');
 }
 
@@ -180,7 +178,6 @@ function findSessionPath(sessionId, { transcriptPath = '', sessionsDir = default
     process.env.WALL_E_SESSIONS_DIR,
     process.env.WALLE_DEV_DIR ? path.join(process.env.WALLE_DEV_DIR, 'sessions') : '',
     process.env.WALL_E_DATA_DIR ? path.join(process.env.WALL_E_DATA_DIR, 'sessions') : '',
-    process.env.CTM_DATA_DIR ? path.join(process.env.CTM_DATA_DIR, 'sessions') : '',
     path.join(os.homedir(), '.walle', 'sessions'),
   ].filter(Boolean);
   for (const root of [...new Set(roots)]) {