create-walle 0.9.11 → 0.9.13

package/template/wall-e/channels/session-bindings.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const { makePrincipalKey, normalizePrincipal } = require('./policy');
+
+class ChannelSessionBindings {
+  constructor({ initial = [] } = {}) {
+    this.bindings = new Map();
+    for (const binding of initial || []) {
+      this.bind(binding.principal || binding, binding.sessionId, binding.metadata || {});
+    }
+  }
+
+  bind(principal, sessionId, metadata = {}) {
+    if (!sessionId) throw new Error('sessionId is required');
+    const normalized = normalizePrincipal(principal);
+    const key = makePrincipalKey(normalized);
+    const record = {
+      key,
+      principal: normalized,
+      sessionId,
+      metadata: { ...metadata },
+      updatedAt: new Date().toISOString(),
+    };
+    this.bindings.set(key, record);
+    return { ...record, principal: { ...record.principal }, metadata: { ...record.metadata } };
+  }
+
+  resolve(principal) {
+    const key = makePrincipalKey(principal);
+    const record = this.bindings.get(key);
+    return record ? { ...record, principal: { ...record.principal }, metadata: { ...record.metadata } } : null;
+  }
+
+  unbind(principal) {
+    return this.bindings.delete(makePrincipalKey(principal));
+  }
+
+  list({ channel = null } = {}) {
+    return [...this.bindings.values()]
+      .filter(record => !channel || record.principal.channel === channel)
+      .map(record => ({ ...record, principal: { ...record.principal }, metadata: { ...record.metadata } }));
+  }
+
+  toJSON() {
+    return this.list();
+  }
+}
+
+module.exports = {
+  ChannelSessionBindings,
+};

package/template/wall-e/chat/code-review-context.js

@@ -12,6 +12,10 @@ function isCodeReviewRequest(message) {
   const text = String(message || '').toLowerCase();
   return /\bcode\s+review\b/.test(text)
     || /\breview\s+(?:the\s+)?(?:code|diff|patch|changes?|changed files|pull request|pr)\b/.test(text)
+    || /\breview\s+(?:my\s+|the\s+)?(?:local\s+|uncommitted\s+|unstaged\s+|staged\s+|working\s+tree\s+|workspace\s+)?changes?\b/.test(text)
+    || /\b(?:review|inspect|check|audit)\s+(?:my\s+|the\s+)?(?:local\s+|working\s+tree\s+|workspace\s+|uncommitted\s+|unstaged\s+|staged\s+)?(?:diff|patch|changes?)\b/.test(text)
+    || /\b(?:what|show|tell\s+me)\s+(?:changed|is\s+changed|local\s+changes|unstaged\s+changes|uncommitted\s+changes)\b/.test(text)
+    || /\b(?:check|show|run)\s+(?:git\s+)?status\b/.test(text)
     || /\b(?:do|run|perform|take)\s+(?:a\s+)?(?:close\s+|thorough\s+)?code\s+review\b/.test(text)
     || /\b(?:review|audit)\s+my\s+(?:changes?|diff|patch|code)\b/.test(text);
 }
@@ -25,6 +29,27 @@ function looksLikePrematureCodeReviewReply(text) {
   return promisesInspection && !hasFindingsShape;
 }
 
+function snapshotIndicatesDirty(codeReviewContextBlock) {
+  const block = String(codeReviewContextBlock || '');
+  if (!/## Code Review Workspace Snapshot/.test(block)) return false;
+  const statusMatch = block.match(/### Git status\s*\n([\s\S]*?)(?:\n### |\n\n### |$)/);
+  if (!statusMatch) return false;
+  const status = statusMatch[1].trim();
+  return !!status && status !== '(clean)';
+}
+
+function looksLikeContradictoryCleanReviewReply(text, codeReviewContextBlock) {
+  if (!snapshotIndicatesDirty(codeReviewContextBlock)) return false;
+  const lower = String(text || '').toLowerCase();
+  if (!lower.trim()) return false;
+  return /\bworking tree (?:is )?clean\b/.test(lower)
+    || /\bworktree (?:is )?clean\b/.test(lower)
+    || /\bno (?:local |uncommitted |unstaged |staged )?changes\b/.test(lower)
+    || /\bnothing (?:is )?(?:staged|unstaged|changed|to review)\b/.test(lower)
+    || /\bno staged,?\s+unstaged,?\s+(?:or\s+)?untracked\b/.test(lower)
+    || /\bindex (?:is )?clean\b/.test(lower);
+}
+
 function runGit(cwd, args, opts = {}) {
   try {
     return execFileSync('git', args, {
@@ -166,6 +191,7 @@ function buildCodeReviewContextBlock({ message, cwd, maxContextBytes = DEFAULT_M
 
   const block = [
     '## Code Review Workspace Snapshot',
+    `Requested cwd: ${path.resolve(cwd)}`,
     `Project: ${root}`,
     `Branch: ${branch}`,
     `HEAD: ${head}`,
@@ -177,6 +203,7 @@ function buildCodeReviewContextBlock({ message, cwd, maxContextBytes = DEFAULT_M
     '',
     '### Code Review Instructions',
     'You already have the git status and diff above. Do not say you will inspect, read, or fetch diffs.',
+    `Start with: Checked ${root} (requested cwd ${path.resolve(cwd)}, branch ${branch}, status ${status === '(clean)' ? 'clean' : 'dirty'}).`,
     'Produce the review now. Lead with findings ordered by severity. Cite file paths and line references when the diff gives enough context.',
     'If there are no issues, say that clearly and include remaining test gaps or residual risk.',
   ].join('\n');
@@ -187,6 +214,8 @@ function buildCodeReviewContextBlock({ message, cwd, maxContextBytes = DEFAULT_M
 module.exports = {
   isCodeReviewRequest,
   looksLikePrematureCodeReviewReply,
+  snapshotIndicatesDirty,
+  looksLikeContradictoryCleanReviewReply,
   buildCodeReviewContextBlock,
   gitRootFor,
 };

package/template/wall-e/chat.js

@@ -4,7 +4,9 @@ const {
   createClient,
   detectProviderForModel,
   getDefaultClient,
+  getDefaultModelForProvider,
   getDefaultProviderType,
+  resolveCompatibleModel,
 } = require('./llm/client');
 const { executeLocalTool, LOCAL_TOOL_DEFINITIONS, resolveProjectPath } = require('./tools/local-tools');
 const slackMcp = require('./tools/slack-mcp');
@@ -17,8 +19,15 @@ const { runShadow } = require('./eval/shadow');
 const {
   buildCodeReviewContextBlock,
   isCodeReviewRequest,
+  looksLikeContradictoryCleanReviewReply,
   looksLikePrematureCodeReviewReply,
 } = require('./chat/code-review-context');
+const { createSessionRecorder } = require('./session-files');
+const {
+  decorateProviderError,
+  recordProviderFailureAlert,
+  unavailableProviderError,
+} = require('./llm/provider-error');
 let _telemetry;
 try { _telemetry = require('./telemetry'); } catch { _telemetry = { trackError() {}, track() {} }; }
 let _embeddings;
@@ -96,8 +105,12 @@ function _getCommandRegistry() {
   _commandRegistry.registerBuiltins();
   try {
     const { findSkill } = require('./skills/skill-loader');
-    const { executeSkill } = require('./loops/tasks');
-    _commandRegistry.registerSkills(findSkill, executeSkill);
+    const { runScriptSkillByName } = require('./skills/script-skill-runner');
+    _commandRegistry.registerSkills(findSkill, async (taskId, task) => {
+      return runScriptSkillByName(task.skill, task, {
+        log: line => console.error(`[skill:${taskId}] ${line}`),
+      });
+    });
   } catch { /* skill loader not available */ }
   return _commandRegistry;
 }
@@ -294,6 +307,20 @@ function resolveModelSelection(model, explicitProvider) {
       LIMIT 1
     `).get(raw, raw, explicitProvider || null, explicitProvider || null, raw);
     if (row) {
+      if (explicitProvider) {
+        const compatibleModel = resolveCompatibleModel(row.model_id, explicitProvider);
+        if (compatibleModel !== row.model_id) {
+          return {
+            input: raw,
+            model: compatibleModel,
+            provider: explicitProvider,
+            providerConfig: null,
+            registryId: null,
+            coercedFrom: row.model_id,
+            detectedProvider: row.provider_type || detectProviderForModel(row.model_id) || null,
+          };
+        }
+      }
       return {
         input: raw,
         model: row.model_id,
@@ -306,10 +333,24 @@ function resolveModelSelection(model, explicitProvider) {
     }
   } catch {}
 
+  const detectedProvider = detectProviderForModel(raw);
+  if (explicitProvider) {
+    const compatibleModel = resolveCompatibleModel(raw, explicitProvider);
+    return {
+      input: raw,
+      model: compatibleModel,
+      provider: explicitProvider,
+      providerConfig: null,
+      registryId: null,
+      coercedFrom: compatibleModel === raw ? null : raw,
+      detectedProvider,
+    };
+  }
+
   return {
     input: raw,
     model: raw,
-    provider: explicitProvider || detectProviderForModel(raw) || null,
+    provider: detectedProvider || null,
     providerConfig: null,
     registryId: null,
   };
@@ -363,28 +404,12 @@ async function chat(message, opts = {}) {
   // backward compatibility (the LLM client will use its own env-based config).
   const { default: providerAvailability } = require('./llm/provider-availability');
   if (providerAvailability.getConfiguredProviders().length > 0 && !providerAvailability.isAnyProviderAvailable()) {
-    let guidance = 'I need an AI provider to think, but none are configured yet.\n\n';
-    try {
-      const { detectAll } = require('./llm/provider-detector');
-      const detection = await detectAll();
-      if (detection.setupAction === 'auto-register-detected') {
-        guidance += `Good news — I found existing API keys on your system (${detection.detected.map(d => d.type).join(', ')}). Open the Wall-E settings to activate them.`;
-      } else if (detection.setupAction === 'ollama-running') {
-        guidance += 'I see Ollama is already running on your system. Use the setup button to connect it.';
-      } else if (detection.ollamaRecommendation) {
-        guidance += `I can set up a free local AI (${detection.ollamaRecommendation.label}, ${detection.ollamaRecommendation.size} download). Use the setup button in the toolbar.`;
-      } else {
-        guidance += 'Please add an API key in the setup page, or install Ollama for free local AI.';
-      }
-    } catch {
-      guidance += 'Please configure an AI provider in the setup page.';
-    }
-    return {
-      reply: guidance,
-      model: 'system', provider: 'none', latencyMs: 0,
-      tokens: { input: 0, output: 0 }, cost: 0, toolCalls: [],
-      providerStatus: { configured: false },
-    };
+    const unavailableErr = unavailableProviderError(providerAvailability.getConfiguredProviders(), {
+      provider: opts.provider || getDefaultProviderType(),
+      model: opts.model || null,
+    });
+    recordProviderFailureAlert(unavailableErr.providerError, brain);
+    throw unavailableErr;
   }
 
   // Detect user signals from follow-up messages (retroactive quality scoring)
@@ -429,7 +454,7 @@ async function chat(message, opts = {}) {
   const modelSelection = explicitModelSelection
     ? { model: explicitModelSelection.model, modelTier: 'balanced', scorecardUsed: false }
     : selectModelForMessage(message, opts.taskType);
-  const selectedModel = modelSelection.model;
+  let selectedModel = modelSelection.model;
   const selectedRoute = explicitModelSelection || resolveModelSelection(selectedModel, opts.provider);
   const effectiveCwd = opts.cwd || opts.context?.cwd || opts.context?.projectPath || null;
 
@@ -471,6 +496,25 @@ async function chat(message, opts = {}) {
     brain,
   });
   const existingSession = brain.getSession(sessionId);
+  const sessionRecorder = createSessionRecorder({
+    sessionId,
+    channel,
+    cwd: effectiveCwd || opts.cwd || process.cwd(),
+    metadata: {
+      taskType: opts.taskType || 'chat',
+      source: opts.source || channel || 'chat',
+      model: selectedModel,
+      provider: selectedRoute.provider || opts.provider || null,
+    },
+  });
+  const recordSessionMessage = (role, content, extra) => {
+    try {
+      return sessionRecorder.appendMessage(role, content, extra);
+    } catch (err) {
+      console.error('[chat] Failed to append session message:', err.message);
+      return null;
+    }
+  };
 
   // Review channel: build a focused code review system prompt
   let reviewContextBlock = '';
@@ -554,6 +598,8 @@ async function chat(message, opts = {}) {
     }
   }
 
+  selectedModel = resolveCompatibleModel(selectedModel || getDefaultModelForProvider(targetProviderType), provider.type || targetProviderType);
+
   const codeReviewFastPath = codeReviewRequested
     && isUsableCodeReviewSnapshot(codeReviewContextBlock)
     && opts.codeReviewMode !== 'deep';
@@ -571,19 +617,31 @@ async function chat(message, opts = {}) {
     };
   }
 
-  // Per-turn abort controller — each API call gets its own 2-min timeout.
-  // This prevents long multi-turn tasks (e.g., Morning Briefing) from aborting
-  // as long as each individual turn completes within the timeout.
+  // Per-turn abort controller. Each API call is capped by the remaining
+  // per-message budget, with a 2-minute ceiling for long-running intents.
   let controller = new AbortController();
   let timeout = null;
-  function resetTurnTimeout() {
+  let messageDeadline = null;
+  const MAX_TURN_TIMEOUT_MS = 120000;
+  const MIN_TURN_TIMEOUT_MS = 50;
+  function resolveTurnTimeoutMs(requestedMs) {
+    if (Number.isFinite(requestedMs)) {
+      return Math.max(MIN_TURN_TIMEOUT_MS, Math.min(MAX_TURN_TIMEOUT_MS, requestedMs));
+    }
+    if (!messageDeadline) return MAX_TURN_TIMEOUT_MS;
+    return Math.max(
+      MIN_TURN_TIMEOUT_MS,
+      Math.min(MAX_TURN_TIMEOUT_MS, messageDeadline - Date.now()),
+    );
+  }
+  function resetTurnTimeout(requestedMs) {
     if (timeout) clearTimeout(timeout);
     controller = new AbortController();
     if (opts.abortSignal?.aborted) controller.abort();
     else if (opts.abortSignal) {
       opts.abortSignal.addEventListener('abort', () => controller.abort(), { once: true });
     }
-    timeout = setTimeout(() => controller.abort(), 120000); // 2 min per turn
+    timeout = setTimeout(() => controller.abort(), resolveTurnTimeoutMs(requestedMs));
   }
 
   // Define internal tools WALL-E can use during chat
@@ -823,7 +881,13 @@ async function chat(message, opts = {}) {
     return tools;
   }
 
-  const onProgress = opts.onProgress || (() => {});
+  const progressSink = opts.onProgress || (() => {});
+  const onProgress = (event) => {
+    try { sessionRecorder.appendProgress(event); } catch (err) {
+      console.error('[chat] Failed to append session progress:', err.message);
+    }
+    return progressSink(event);
+  };
 
   // Execute a chat tool call
   async function executeChatTool(name, input) {
@@ -909,9 +973,12 @@ async function chat(message, opts = {}) {
       const bundledSkill = findSkill(input.skill_name);
       if (bundledSkill && bundledSkill.execution === 'script') {
         try {
-          const { executeSkill } = require('./loops/tasks');
+          const { runScriptSkillByName } = require('./skills/script-skill-runner');
           const fakeTaskId = `chat-${Date.now()}`;
-          const result = await executeSkill(fakeTaskId, { id: fakeTaskId, skill: input.skill_name, title: bundledSkill.name });
+          const result = await runScriptSkillByName(input.skill_name, { id: fakeTaskId, skill: input.skill_name, title: bundledSkill.name }, {
+            skill: bundledSkill,
+            log: line => console.error(`[skill:${fakeTaskId}] ${line}`),
+          });
           return { success: true, output: result.slice(0, 5000) };
         } catch (err) {
           return { error: err.message };
@@ -1324,8 +1391,13 @@ async function chat(message, opts = {}) {
         channel, session_id: sessionId,
         attachments: persisted,
       });
+      recordSessionMessage('user', message, {
+        dbMessageId: _userMessageId,
+        attachments: persisted,
+      });
     } else if (persistUserTurn) {
       brain.insertChatMessage({ role: 'user', content: message, channel, session_id: sessionId });
+      recordSessionMessage('user', message);
     }
     if (persistUserTurn) {
       brain.insertMemory({
@@ -1391,6 +1463,7 @@ async function chat(message, opts = {}) {
     let finalText = '';
     let lastTurnText = '';  // Only the last turn's text (prevents error accumulation across turns)
     let lastTurn = 0;
+    let finalResponseMeta = null;
 
     // Adaptive limits based on intent classification
     const INTENT_LIMITS = {
@@ -1403,7 +1476,7 @@ async function chat(message, opts = {}) {
     const MAX_TOOL_CALLS = opts.maxToolCalls != null ? opts.maxToolCalls : limits.maxTools;
     let toolCallCount = 0;
     const MESSAGE_TIMEOUT_MS = opts.timeoutMs || limits.timeoutMs;
-    const messageDeadline = Date.now() + MESSAGE_TIMEOUT_MS;
+    messageDeadline = Date.now() + MESSAGE_TIMEOUT_MS;
     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();
@@ -1500,11 +1573,16 @@ async function chat(message, opts = {}) {
       } catch (llmErr) {
         // Track provider health — failed LLM call
         try {
-          const provType = usedProvider || getDefaultProviderType();
+          const provType = usedProvider || targetProviderType || getDefaultProviderType();
           const registeredProv = providerAvailability.getConfiguredProviders().find(p => p.providerType === provType);
           if (registeredProv) providerAvailability.recordFailure(registeredProv.providerId, llmErr.message);
         } catch {}
-        throw llmErr;
+        const decorated = decorateProviderError(llmErr, {
+          provider: usedProvider || targetProviderType || getDefaultProviderType(),
+          model: selectedModel,
+        });
+        recordProviderFailureAlert(decorated.providerError, brain);
+        throw decorated;
       }
       const modelElapsed = Date.now() - turnStart;
       timings.modelMs += modelElapsed;
@@ -1537,6 +1615,12 @@ async function chat(message, opts = {}) {
       // If no tool calls, we have our final answer
       if (response.toolCalls.length === 0) {
         finalText = response.content || '';
+        finalResponseMeta = {
+          model: response.model || selectedModel,
+          provider: response.provider || usedProvider || targetProviderType,
+          usage: response.usage || null,
+          stopReason: response.stopReason || null,
+        };
         console.log('[chat] Total time:', Date.now() - chatStart, 'ms across', turn + 1, 'turns');
         break;
       }
@@ -1653,6 +1737,16 @@ async function chat(message, opts = {}) {
       for (const tc of response.toolCalls) {
         assistantContent.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input });
       }
+      recordSessionMessage('assistant', assistantContent, {
+        model: response.model || selectedModel,
+        provider: response.provider || usedProvider || targetProviderType,
+        usage: response.usage || null,
+        stopReason: response.stopReason || null,
+      });
+      recordSessionMessage('user', toolResults, {
+        synthetic: true,
+        reason: 'tool_results',
+      });
       messages.push({ role: 'assistant', content: assistantContent });
       messages.push({ role: 'user', content: toolResults });
 
@@ -1678,9 +1772,12 @@ async function chat(message, opts = {}) {
       // Otherwise, continue: the model needs to see tool results before responding.
     }
 
-    if (codeReviewContextBlock && looksLikePrematureCodeReviewReply(finalText)) {
+    const needsCodeReviewRepair = codeReviewContextBlock
+      && (looksLikePrematureCodeReviewReply(finalText)
+        || looksLikeContradictoryCleanReviewReply(finalText, codeReviewContextBlock));
+    if (needsCodeReviewRepair) {
       try {
-        console.log('[chat] Premature code-review reply detected; forcing final review follow-up');
+        console.log('[chat] Invalid code-review reply detected; forcing final review follow-up');
         resetTurnTimeout();
         const repairStart = Date.now();
         const repairMessages = [
@@ -1706,13 +1803,29 @@ async function chat(message, opts = {}) {
         }
         timings.repairMs += Date.now() - repairStart;
         if (!usedModel) { usedModel = repairResponse.model; usedProvider = repairResponse.provider; }
-        if (repairResponse.content && !looksLikePrematureCodeReviewReply(repairResponse.content)) {
+        if (repairResponse.content
+            && !looksLikePrematureCodeReviewReply(repairResponse.content)
+            && !looksLikeContradictoryCleanReviewReply(repairResponse.content, codeReviewContextBlock)) {
           finalText = repairResponse.content;
           lastTurnText = repairResponse.content;
+          finalResponseMeta = {
+            model: repairResponse.model || selectedModel,
+            provider: repairResponse.provider || usedProvider || targetProviderType,
+            usage: repairResponse.usage || null,
+            stopReason: repairResponse.stopReason || null,
+            repair: true,
+          };
         }
       } catch (repairErr) {
         timings.repairMs = timings.repairMs || 0;
         console.error('[chat] Code-review repair call failed:', repairErr.message);
+        try {
+          const decorated = decorateProviderError(repairErr, {
+            provider: usedProvider || targetProviderType || getDefaultProviderType(),
+            model: selectedModel,
+          });
+          recordProviderFailureAlert(decorated.providerError, brain);
+        } catch {}
       }
     }
 
@@ -1728,15 +1841,36 @@ async function chat(message, opts = {}) {
           signal: controller.signal,
         });
         finalText = summaryResponse.content || '';
+        finalResponseMeta = {
+          model: summaryResponse.model || selectedModel,
+          provider: summaryResponse.provider || usedProvider || targetProviderType,
+          usage: summaryResponse.usage || null,
+          stopReason: summaryResponse.stopReason || null,
+          summaryFallback: true,
+        };
       } catch (summaryErr) {
         console.error('[chat] Summary call failed:', summaryErr.message);
+        let summaryProviderError = null;
+        try {
+          const decorated = decorateProviderError(summaryErr, {
+            provider: usedProvider || targetProviderType || getDefaultProviderType(),
+            model: selectedModel,
+          });
+          summaryProviderError = decorated.providerError;
+          recordProviderFailureAlert(summaryProviderError, brain);
+        } catch {}
         // Include the tool results directly so the user at least sees what the tool returned
         const lastToolResults = messages.filter(m => m.role === 'user' && Array.isArray(m.content))
           .pop()?.content?.map(r => {
             try { const parsed = JSON.parse(r.content); return JSON.stringify(parsed, null, 2); } catch { return r.content; }
           }).join('\n');
+        const summaryFailureText = summaryProviderError
+          ? `${summaryProviderError.title}: ${summaryProviderError.userMessage}`
+          : `Summary generation failed: ${summaryErr.message}`;
         if (lastToolResults) {
-          finalText = 'Here are the raw results (summary generation failed):\n\n```\n' + lastToolResults.slice(0, 3000) + '\n```';
+          finalText = summaryFailureText + '\n\nHere are the raw tool results:\n\n```\n' + lastToolResults.slice(0, 3000) + '\n```';
+        } else {
+          finalText = summaryFailureText;
         }
       }
     }
@@ -1796,7 +1930,13 @@ async function chat(message, opts = {}) {
 
     // Save assistant response (user message was already saved before calling Claude)
     const persistStart = Date.now();
-    brain.insertChatMessage({ role: 'assistant', content: text, channel, session_id: sessionId });
+    const assistantMessage = brain.insertChatMessage({ role: 'assistant', content: text, channel, session_id: sessionId });
+    recordSessionMessage('assistant', text, {
+      ...(finalResponseMeta || {}),
+      dbMessageId: assistantMessage.id,
+      selfCritique: selfCritiqueOutcome,
+      final: true,
+    });
 
     brain.insertMemory({
       source: 'wall-e-chat',
@@ -1926,7 +2066,13 @@ async function chat(message, opts = {}) {
       cost, toolCalls: allToolCalls,
       latencyBreakdown: timings,
       silentReply,
+      ...(opts.includeSessionFile ? { sessionFile: sessionRecorder.filePath } : {}),
     };
+  } catch (err) {
+    try { sessionRecorder.appendError(err); } catch (sessionErr) {
+      console.error('[chat] Failed to append session error:', sessionErr.message);
+    }
+    throw err;
   } finally {
     clearTimeout(timeout);
   }