create-walle 0.9.3 → 0.9.4

package/template/wall-e/skills/_bundled/slack-mentions/run.js

@@ -7,8 +7,8 @@ const brain = require(path.resolve(__dirname, '..', '..', '..', 'brain'));
 const slackMcp = require(path.resolve(__dirname, '..', '..', '..', 'tools', 'slack-mcp'));
 
 const WATERMARK_FILE = path.join(__dirname, '.watermark.json');
-const OWNER_HANDLE = process.env.SLACK_OWNER_HANDLE || 'juncao';
-const OWNER_NAME = process.env.WALLE_OWNER_NAME || 'Juncao Li';
+const OWNER_HANDLE = process.env.SLACK_OWNER_HANDLE || '';
+const OWNER_NAME = process.env.WALLE_OWNER_NAME || '';
 const PAUSE_MS = 800;
 const WATCH_DURATION_MS = 2 * 60 * 60 * 1000; // 2 hours
 
@@ -49,6 +49,12 @@ function classifyMention(text) {
   const cleaned = trimmed.replace(/@wall-?e/gi, '').trim();
   if (/\?\s*$/.test(cleaned)) return 'question';
   if (/^(what|who|where|when|why|how|is|are|do|does|did|can|could|would|should|will)\b/i.test(cleaned)) return 'question';
+
+  // Coding requests: action verbs + code concepts
+  const hasActionVerb = /\b(add|fix|build|create|implement|refactor|update|remove|delete|write|change|move|rename|extract|optimize)\b/i.test(cleaned);
+  const hasCodeConcept = /\b(api|endpoint|function|module|class|component|middleware|route|handler|test|database|schema|migration|config|server|client|ui|page|service|model)\b/i.test(cleaned);
+  if (hasActionVerb && hasCodeConcept) return 'coding';
+
   return 'task';
 }
 
@@ -244,6 +250,151 @@ async function pollWatchedThreads() {
 
 // ── New mention processing ──
 
+// Shared per-message processor — creates tasks/questions from a mention
+async function _processMention(msg, seenTs, stats) {
+  const dedupeKey = msg.ts || msg.permalink || msg.content;
+  if (seenTs.has(dedupeKey)) return;
+  seenTs.add(dedupeKey);
+
+  const now = new Date();
+  const sourceRef = (msg.permalink || (msg.channelId ? `${msg.channelId}:${msg.ts || 'unknown'}` : `unknown:${msg.ts}`)).split('?')[0];
+  const existing = brain.listTasks({ source: 'slack' }).find(t => t.source_ref && t.source_ref.split('?')[0] === sourceRef);
+  if (existing) {
+    console.log(`[slack-mentions] Skipping already-processed mention: ${sourceRef}`);
+    return;
+  }
+
+  stats.newMentions++;
+  const kind = classifyMention(msg.content);
+  const effectiveTs = msg.ts || msg.isoTimestamp || now.toISOString();
+  const threadTs = msg.threadTs || msg.ts;
+
+  // Fetch full thread context
+  let threadContext = null;
+  if (msg.channelId && threadTs) {
+    threadContext = await fetchThreadContext(msg.channelId, threadTs);
+    await sleep(PAUSE_MS);
+  }
+  const contextBlock = threadContext ? `\n\nFull thread context:\n${threadContext}` : '';
+
+  if (kind === 'coding') {
+    const title = extractTaskTitle(msg.content);
+    try {
+      const { id } = brain.insertTask({
+        title: title.slice(0, 100),
+        description: `Coding request from Slack:\n\n${msg.content}`,
+        priority: 'normal',
+        type: 'once',
+        execution: 'skill',
+        skill: 'coding-agent',
+        skill_config: JSON.stringify({
+          request: msg.content.replace(/@wall-?e/gi, '').trim(),
+          cwd: process.env.HOME || '/tmp',
+          options: { delivery: 'commit' },
+        }),
+        source: 'slack',
+        source_ref: sourceRef,
+      });
+      stats.tasksCreated++;
+      console.log(`[slack-mentions] Coding task created: ${id} — ${title}`);
+
+      if (msg.channelId) {
+        try {
+          await slackMcp.callSlackMcp('slack_send_message', {
+            channel_id: msg.channelId,
+            message: `On it — planning the implementation now. I'll update this thread when done.`,
+            thread_ts: threadTs,
+          });
+        } catch (replyErr) {
+          console.warn(`[slack-mentions] Could not reply in thread: ${replyErr.message}`);
+        }
+        await sleep(PAUSE_MS);
+      }
+    } catch (taskErr) {
+      console.error(`[slack-mentions] Failed to create coding task: ${taskErr.message}`);
+    }
+    return;
+  }
+
+  if (kind === 'task') {
+    const title = extractTaskTitle(msg.content);
+    try {
+      const { id } = brain.insertTask({
+        title,
+        description: `Slack task from ${OWNER_NAME}:\n\n${msg.content}${contextBlock}\n\n---\n**IMPORTANT**: When done, reply with results in the Slack thread using mcp_call with:\n- server: slack\n- tool: slack_send_message\n- arguments: { "channel_id": "${msg.channelId}", "thread_ts": "${threadTs}", "message": "<your results>" }`,
+        priority: 'normal',
+        type: 'once',
+        execution: 'chat',
+        source: 'slack',
+        source_ref: sourceRef,
+      });
+      stats.tasksCreated++;
+      console.log(`[slack-mentions] Task created: ${id} — ${title}`);
+
+      try {
+        brain.upsertSlackThread({ channelId: msg.channelId, threadTs, taskId: id, sessionId: `task-${id}` });
+      } catch (upsertErr) {
+        console.error(`[slack-mentions] FAILED to upsert watched thread: ${upsertErr.message}`);
+      }
+
+      if (msg.channelId) {
+        try {
+          await slackMcp.callSlackMcp('slack_send_message', {
+            channel_id: msg.channelId,
+            message: `Got it! I've created a task for this. I'll update you here when it's done.`,
+            thread_ts: threadTs,
+          });
+        } catch (replyErr) {
+          console.warn(`[slack-mentions] Could not reply in thread: ${replyErr.message}`);
+        }
+        await sleep(PAUSE_MS);
+      }
+    } catch (taskErr) {
+      console.error(`[slack-mentions] Failed to create task: ${taskErr.message}`);
+    }
+  } else {
+    stats.questionsFound++;
+    console.log(`[slack-mentions] Question detected: ${msg.content.slice(0, 80)}...`);
+
+    if (msg.channelId) {
+      try {
+        await slackMcp.callSlackMcp('slack_send_message', {
+          channel_id: msg.channelId,
+          message: `Let me look into that — I'll get back to you shortly.`,
+          thread_ts: threadTs,
+        });
+      } catch (replyErr) {
+        console.warn(`[slack-mentions] Could not reply in thread: ${replyErr.message}`);
+      }
+      await sleep(PAUSE_MS);
+    }
+
+    try {
+      const { id } = brain.insertTask({
+        title: `Answer Slack question: ${extractTaskTitle(msg.content)}`,
+        description: `Question from ${OWNER_NAME} in Slack:\n\n${msg.content}${contextBlock}\n\n---\n**IMPORTANT**: After answering, you MUST reply in the Slack thread using mcp_call with:\n- server: slack\n- tool: slack_send_message\n- arguments: { "channel_id": "${msg.channelId}", "thread_ts": "${threadTs}", "message": "<your answer>" }`,
+        priority: 'high',
+        type: 'once',
+        execution: 'chat',
+        source: 'slack',
+        source_ref: sourceRef,
+      });
+
+      try {
+        brain.upsertSlackThread({ channelId: msg.channelId, threadTs, taskId: id, sessionId: `task-${id}` });
+      } catch (upsertErr) {
+        console.error(`[slack-mentions] FAILED to upsert watched thread: ${upsertErr.message}`);
+      }
+    } catch (taskErr) {
+      console.error(`[slack-mentions] Failed to create question task: ${taskErr.message}`);
+    }
+  }
+
+  if (effectiveTs > (stats.maxTs || '')) {
+    stats.maxTs = effectiveTs;
+  }
+}
+
 async function processNewMentions() {
   const lastTs = loadWatermark();
   const now = new Date();
@@ -252,14 +403,12 @@ async function processNewMentions() {
 
   console.log(`[slack-mentions] Checking for @walle mentions (watermark: ${lastTs || 'none'})`);
 
-  let newMentions = 0;
-  let tasksCreated = 0;
-  let questionsFound = 0;
-  let maxTs = lastTs;
+  const stats = { newMentions: 0, tasksCreated: 0, questionsFound: 0, maxTs: lastTs };
   const seenTs = new Set();
 
   const queries = ['@walle', '@wall-e'];
 
+  // Phase 2a: Search-based discovery
   for (const query of queries) {
     try {
       const result = await slackMcp.callSlackMcp('slack_search_public_and_private', {
@@ -280,124 +429,15 @@ async function processNewMentions() {
         if (lastTs && msg.ts && msg.ts <= lastTs) continue;
         if (lastTs && msg.isoTimestamp && msg.isoTimestamp <= lastTs) continue;
 
-        const dedupeKey = msg.ts || msg.permalink || msg.content;
-        if (seenTs.has(dedupeKey)) continue;
-        seenTs.add(dedupeKey);
-
         const senderName = (msg.fromName || '').toLowerCase();
         const isFromOwner = senderName.includes(OWNER_HANDLE.toLowerCase()) ||
           senderName.includes(OWNER_NAME.split(' ')[0].toLowerCase());
-
         if (!isFromOwner) {
           console.log(`[slack-mentions] Skipping non-owner mention from: ${msg.fromName || 'unknown'}`);
           continue;
         }
 
-        newMentions++;
-        const kind = classifyMention(msg.content);
-        const effectiveTs = msg.ts || msg.isoTimestamp || now.toISOString();
-
-        const rawRef = msg.permalink || (msg.channelId ? `${msg.channelId}:${msg.ts || 'unknown'}` : `${kind}:${effectiveTs}`);
-        const sourceRef = rawRef.split('?')[0];
-        const existing = brain.listTasks({ source: 'slack' }).find(t => t.source_ref && t.source_ref.split('?')[0] === sourceRef);
-        if (existing) {
-          console.log(`[slack-mentions] Skipping already-processed mention: ${sourceRef}`);
-          continue;
-        }
-
-        // Fetch full thread context before creating the task
-        const threadTs = msg.threadTs || msg.ts;
-        let threadContext = null;
-        if (msg.channelId && threadTs) {
-          threadContext = await fetchThreadContext(msg.channelId, threadTs);
-          await sleep(PAUSE_MS);
-        }
-
-        const contextBlock = threadContext
-          ? `\n\nFull thread context:\n${threadContext}`
-          : '';
-
-        if (kind === 'task') {
-          const title = extractTaskTitle(msg.content);
-          try {
-            const { id } = brain.insertTask({
-              title,
-              description: `Slack task from ${OWNER_NAME}:\n\n${msg.content}${contextBlock}\n\n---\n**IMPORTANT**: When done, reply with results in the Slack thread using mcp_call with:\n- server: slack\n- tool: slack_send_message\n- arguments: { "channel_id": "${msg.channelId}", "thread_ts": "${threadTs}", "message": "<your results>" }`,
-              priority: 'normal',
-              type: 'once',
-              execution: 'chat',
-              source: 'slack',
-              source_ref: sourceRef,
-            });
-            tasksCreated++;
-            console.log(`[slack-mentions] Task created: ${id} — ${title}`);
-
-            // Watch this thread for follow-ups (in DB)
-            try {
-              const threadId1 = brain.upsertSlackThread({ channelId: msg.channelId, threadTs, taskId: id, sessionId: `task-${id}` });
-              console.log(`[slack-mentions] Upserted watched thread: ${threadId1} (task, channel=${msg.channelId})`);
-            } catch (upsertErr) {
-              console.error(`[slack-mentions] FAILED to upsert watched thread: ${upsertErr.message} (channelId=${msg.channelId}, threadTs=${threadTs})`);
-            }
-
-            if (msg.channelId) {
-              try {
-                await slackMcp.callSlackMcp('slack_send_message', {
-                  channel_id: msg.channelId,
-                  message: `Got it! I've created a task for this. I'll update you here when it's done.`,
-                  thread_ts: threadTs,
-                });
-              } catch (replyErr) {
-                console.warn(`[slack-mentions] Could not reply in thread: ${replyErr.message}`);
-              }
-              await sleep(PAUSE_MS);
-            }
-          } catch (taskErr) {
-            console.error(`[slack-mentions] Failed to create task: ${taskErr.message}`);
-          }
-        } else {
-          questionsFound++;
-          console.log(`[slack-mentions] Question detected: ${msg.content.slice(0, 80)}...`);
-
-          if (msg.channelId) {
-            try {
-              await slackMcp.callSlackMcp('slack_send_message', {
-                channel_id: msg.channelId,
-                message: `Let me look into that — I'll get back to you shortly.`,
-                thread_ts: threadTs,
-              });
-            } catch (replyErr) {
-              console.warn(`[slack-mentions] Could not reply in thread: ${replyErr.message}`);
-            }
-            await sleep(PAUSE_MS);
-          }
-
-          try {
-            const { id } = brain.insertTask({
-              title: `Answer Slack question: ${extractTaskTitle(msg.content)}`,
-              description: `Question from ${OWNER_NAME} in Slack:\n\n${msg.content}${contextBlock}\n\n---\n**IMPORTANT**: After answering, you MUST reply in the Slack thread using mcp_call with:\n- server: slack\n- tool: slack_send_message\n- arguments: { "channel_id": "${msg.channelId}", "thread_ts": "${threadTs}", "message": "<your answer>" }`,
-              priority: 'high',
-              type: 'once',
-              execution: 'chat',
-              source: 'slack',
-              source_ref: sourceRef,
-            });
-
-            // Watch this thread for follow-ups (in DB)
-            try {
-              const threadId2 = brain.upsertSlackThread({ channelId: msg.channelId, threadTs, taskId: id, sessionId: `task-${id}` });
-              console.log(`[slack-mentions] Upserted watched thread: ${threadId2} (question, channel=${msg.channelId})`);
-            } catch (upsertErr) {
-              console.error(`[slack-mentions] FAILED to upsert watched thread: ${upsertErr.message} (channelId=${msg.channelId}, threadTs=${threadTs})`);
-            }
-          } catch (taskErr) {
-            console.error(`[slack-mentions] Failed to create question task: ${taskErr.message}`);
-          }
-        }
-
-        if (effectiveTs > (maxTs || '')) {
-          maxTs = effectiveTs;
-        }
+        await _processMention(msg, seenTs, stats);
       }
     } catch (err) {
       if (err.message.includes('401') || err.message.includes('expired')) {
@@ -411,15 +451,122 @@ async function processNewMentions() {
     await sleep(PAUSE_MS);
   }
 
-  if (maxTs && maxTs !== lastTs) {
-    saveWatermark(maxTs);
-    console.log(`[slack-mentions] Watermark updated: ${maxTs}`);
+  // Phase 2b: DM channel polling — catches thread replies that search misses
+  try {
+    await pollDmChannels(lastTs, seenTs, async (msg, seen) => {
+      await _processMention(msg, seen, stats);
+    });
+  } catch (err) {
+    console.warn(`[slack-mentions] DM polling error: ${err.message}`);
+  }
+
+  if (stats.maxTs && stats.maxTs !== lastTs) {
+    saveWatermark(stats.maxTs);
+    console.log(`[slack-mentions] Watermark updated: ${stats.maxTs}`);
   }
 
-  if (newMentions === 0) {
+  if (stats.newMentions === 0) {
     console.log('[slack-mentions] No new mentions.');
   } else {
-    console.log(`[slack-mentions] Processed ${newMentions} mention(s): ${tasksCreated} task(s), ${questionsFound} question(s).`);
+    console.log(`[slack-mentions] Processed ${stats.newMentions} mention(s): ${stats.tasksCreated} task(s), ${stats.questionsFound} question(s).`);
+  }
+}
+
+// ── DM channel polling (catches thread replies that search misses) ──
+
+function parseDmMessages(rawText) {
+  const messages = [];
+  // Slack MCP read_channel returns messages in a structured format
+  const blocks = rawText.split(/(?=--- (?:Message|Reply) \d)/);
+
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+
+    const fromMatch = block.match(/From:\s*(.+?)(?:\s*\(ID:\s*(\w+)\)|\n)/);
+    const fromName = fromMatch ? fromMatch[1].trim() : null;
+    const fromUserId = fromMatch ? fromMatch[2] : null;
+
+    const tsMatch = block.match(/(?:Message[_ ]ts|TS|Timestamp):\s*(\d+\.\d+)/i);
+    const msgTs = tsMatch ? tsMatch[1] : null;
+
+    const threadMatch = block.match(/Thread[_ ]ts:\s*(\d+\.\d+)/i);
+    const threadTs = threadMatch ? threadMatch[1] : null;
+
+    const linkMatch = block.match(/Permalink:\s*\[.*?\]\((https?:\/\/[^\s)]+)\)/);
+    let permalink = linkMatch ? linkMatch[1] : null;
+    if (permalink) permalink = permalink.replace(/^(https:\/\/\w+)\.slack\.com/, '$1.enterprise.slack.com');
+
+    // Extract text content — everything after metadata lines
+    const textMatch = block.match(/(?:Text|Content|Message):\s*\n?([\s\S]*?)(?:\n---|$)/i);
+    let content = textMatch ? textMatch[1].trim() : '';
+    if (!content) {
+      // Fallback: grab everything after the last metadata line
+      const lines = block.split('\n');
+      const metaEnd = lines.reduce((last, l, i) => /^(?:From|Time|TS|Thread|Permalink|Channel):/.test(l) ? i : last, -1);
+      content = lines.slice(metaEnd + 1).join('\n').trim();
+    }
+
+    if (msgTs && /@wall-?e/i.test(content)) {
+      messages.push({ ts: msgTs, threadTs, fromName, fromUserId, permalink, content });
+    }
+  }
+
+  return messages;
+}
+
+async function pollDmChannels(lastTs, seenTs, processMsg) {
+  // Gather known channel IDs from existing Slack tasks and watched threads
+  const channelIds = new Set();
+
+  const allTasks = brain.listTasks({ source: 'slack' });
+  for (const t of allTasks) {
+    if (t.source_ref) {
+      const m = t.source_ref.match(/\/archives\/([A-Z0-9]+)\//);
+      if (m) channelIds.add(m[1]);
+    }
+  }
+
+  const activeThreads = brain.listActiveSlackThreads(WATCH_DURATION_MS);
+  for (const th of activeThreads) {
+    if (th.channel_id) channelIds.add(th.channel_id);
+  }
+
+  if (channelIds.size === 0) return;
+
+  // Only poll DM channels (D prefix) and group DMs (G prefix) — skip public channels to avoid noise
+  const dmChannels = [...channelIds].filter(id => /^[DG]/.test(id));
+  if (dmChannels.length === 0) return;
+
+  console.log(`[slack-mentions] Polling ${dmChannels.length} DM channel(s) for missed mentions`);
+
+  for (const channelId of dmChannels) {
+    try {
+      const result = await slackMcp.callSlackMcp('slack_read_channel', {
+        channel_id: channelId,
+        limit: 20,
+      });
+      const rawText = extractText(result);
+      if (!rawText || rawText.length < 10) continue;
+
+      const messages = parseDmMessages(rawText);
+      for (const msg of messages) {
+        if (lastTs && msg.ts <= lastTs) continue;
+        if (seenTs.has(msg.ts)) continue;
+
+        // Check sender is owner
+        const senderName = (msg.fromName || '').toLowerCase();
+        const isFromOwner = senderName.includes(OWNER_HANDLE.toLowerCase()) ||
+          senderName.includes(OWNER_NAME.split(' ')[0].toLowerCase());
+        if (!isFromOwner) continue;
+
+        msg.channelId = channelId;
+        await processMsg(msg, seenTs);
+      }
+
+      await sleep(PAUSE_MS);
+    } catch (err) {
+      console.warn(`[slack-mentions] DM poll error for ${channelId}: ${err.message}`);
+    }
   }
 }
 

package/template/wall-e/skills/_templates/data-fetcher.md

@@ -0,0 +1,27 @@
+---
+name: my-data-fetcher
+description: Fetches data from an external source and stores observations as memories
+version: 0.1.0
+execution: agent
+trigger:
+  type: interval
+  interval_ms: 3600000
+tags: [data, sync]
+requires:
+  env: []
+config:
+  source_url:
+    type: string
+    description: "URL or identifier of the data source"
+---
+
+# Data Fetcher
+
+Use the available tools to fetch data from the configured source. Parse the response
+and return a structured list of observations. Each observation should include:
+
+- A clear subject line
+- The relevant data points
+- A timestamp if available
+
+Focus on new or changed data since the last run.

package/template/wall-e/skills/_templates/manual-action.md

@@ -0,0 +1,19 @@
+---
+name: my-action
+description: A manually triggered one-shot action
+version: 0.1.0
+execution: agent
+trigger:
+  type: manual
+tags: [utility]
+---
+
+# Manual Action
+
+When triggered, perform the following steps:
+
+1. Gather the necessary context
+2. Execute the action
+3. Report the result
+
+This skill runs on-demand only — it will not run automatically.

package/template/wall-e/skills/_templates/periodic-checker.md

@@ -0,0 +1,29 @@
+---
+name: my-checker
+description: Periodically checks a condition and reports changes
+version: 0.1.0
+execution: agent
+trigger:
+  type: interval
+  interval_ms: 300000
+tags: [monitoring]
+config:
+  check_target:
+    type: string
+    description: "What to monitor (URL, file path, service name)"
+  alert_on:
+    type: string
+    default: change
+    description: "When to alert: 'change', 'error', 'threshold'"
+---
+
+# Periodic Checker
+
+Check the configured target at each interval. Compare the current state
+with the previous run. If a notable change is detected:
+
+1. Summarize what changed
+2. Assess the importance (low/medium/high)
+3. Store the observation as a memory
+
+Only report meaningful changes — skip routine/expected variations.

package/template/wall-e/skills/_templates/script-runner.md

@@ -0,0 +1,21 @@
+---
+name: my-script
+description: Runs a custom Node.js script
+version: 0.1.0
+execution: script
+entry: run.js
+trigger:
+  type: manual
+tags: [automation]
+config:
+  input_path:
+    type: string
+    description: "Path to input file or directory"
+---
+
+# Script Runner
+
+This skill executes `run.js` in the skill directory. The script receives
+configuration via the `WALL_E_SKILL_CONFIG` environment variable (JSON).
+
+Create a `run.js` file alongside this SKILL.md with your logic.

package/template/wall-e/skills/claude-code-reader.js

@@ -59,10 +59,15 @@ function readClaudeSkills() {
     } catch {}
   }
 
-  return skills;
+  // Deduplicate: keep latest entry per name (last one wins since deeper/newer versions scan later)
+  const seen = new Map();
+  for (const s of skills) {
+    seen.set(s.name, s);
+  }
+  return Array.from(seen.values());
 }
 
-function scanPluginSkills(dir, skills, depth) {
+function scanPluginSkills(dir, skills, depth, parentName) {
   if ((depth || 0) > 4) return;
   try {
     for (const entry of fs.readdirSync(dir)) {
@@ -77,11 +82,18 @@ function scanPluginSkills(dir, skills, depth) {
             try {
               const content = fs.readFileSync(sfPath, 'utf8');
               const description = extractDescription(content);
-              skills.push({ name: entry, description, source: 'plugin', path: sfPath });
+              // Derive name from path: prefer parent dir over version-like entry names
+              const isVersion = /^[\da-f]{6,}$|^\d+\.\d+/.test(entry);
+              const name = isVersion ? (parentName || entry) : entry;
+              // Derive group from path (e.g., "slack" from .../slack/1.0.0/README.md)
+              const pathParts = sfPath.split(path.sep);
+              const pluginIdx = pathParts.findIndex(p => p.includes('plugins'));
+              const group = pluginIdx >= 0 && pluginIdx + 1 < pathParts.length ? pathParts[pluginIdx + 1] : '';
+              skills.push({ name, description, source: 'plugin', path: sfPath, group });
             } catch {}
           }
         }
-        scanPluginSkills(fullPath, skills, (depth || 0) + 1);
+        scanPluginSkills(fullPath, skills, (depth || 0) + 1, entry);
       }
     }
   } catch {}

package/template/wall-e/skills/skill-executor.js

@@ -26,8 +26,12 @@ async function runSkill(skill, opts = {}) {
   let memoriesCreated = 0;
 
   // Agentic loop — Claude may make multiple tool calls
-  const MAX_TURNS = 5;
+  // Allow SKILL.md to override max_turns and timeout_ms
+  const MAX_TURNS = opts.max_turns || 5;
+  const timeoutMs = opts.timeout_ms || 120000;
+  try {
   for (let turn = 0; turn < MAX_TURNS; turn++) {
+    if (Date.now() - startTime > timeoutMs) break;
     const response = await client.messages.create({
       model: opts.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001',
       max_tokens: 4096,
@@ -98,6 +102,24 @@ async function runSkill(skill, opts = {}) {
   brain.updateSkillStats(skill.id, success);
 
   return { success, memoriesCreated, toolCalls: allToolCalls.length, duration };
+  } catch (err) {
+    const duration = Date.now() - startTime;
+    // Store full error stack for debugging
+    const errorDetail = err.stack || err.message || String(err);
+    try {
+      brain.insertSkillExecution({
+        skill_id: skill.id,
+        status: 'failure',
+        tool_calls: JSON.stringify(allToolCalls),
+        tool_results: JSON.stringify(allToolResults.map(r => ({ name: r.name, success: r.success, error: r.error }))),
+        memories_created: memoriesCreated,
+        error: errorDetail,
+        duration_ms: duration,
+      });
+      brain.updateSkillStats(skill.id, false);
+    } catch {}
+    throw err;
+  }
 }
 
 function buildDefaultPrompt(skill, ownerName) {