create-walle 0.9.5 → 0.9.7

package/README.md

@@ -31,7 +31,7 @@ An always-on AI agent that learns from your Slack, email, calendar, and coding s
 ## Install
 
 ```bash
-npx create-walle install ./my-agent
+npx create-walle install ./walle
 ```
 
 This copies the project, installs dependencies, auto-detects your name and timezone, and starts the server. Open **http://localhost:3456** to finish setup in the browser.
@@ -60,7 +60,7 @@ On first launch, the browser setup page guides you through:
 ## Custom Port
 
 ```bash
-CTM_PORT=5000 npx create-walle install ./my-agent
+CTM_PORT=5000 npx create-walle install ./walle
 ```
 
 Wall-E runs on `CTM_PORT + 1` (e.g., 5001).
@@ -76,9 +76,7 @@ Everything runs locally. CTM serves the dashboard, Wall-E runs as a background a
 
 ## Links
 
-- [Full Documentation](https://walle.sh)
-- [Configuration Reference](https://walle.sh/docs/guides/configuration/)
-- [Skill Catalog](https://walle.sh/docs/skills/)
+- [Homepage](https://walle.sh)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-walle",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "CTM + Wall-E — AI coding dashboard and personal digital twin agent. Multi-agent terminal for Claude Code, Codex, Gemini & Aider, plus prompt editor, task queue, and an agent that learns from Slack, email & calendar.",
   "bin": {
     "create-walle": "bin/create-walle.js"

package/template/claude-task-manager/public/index.html

@@ -4422,7 +4422,8 @@ function renderModelProviders(providers, models) {
     var costs = pModels.map(function(m) { return m.cost_per_1m_input || 0; }).filter(function(c) { return c > 0; });
     var minCost = costs.length ? Math.min.apply(null, costs) : 0;
     var maxCost = costs.length ? Math.max.apply(null, costs) : 0;
-    var costRange = costs.length ? _costExact(minCost) + ' - ' + _costExact(maxCost) : 'No pricing';
+    var isLocal = p.type === 'ollama' || p.type === 'local';
+    var costRange = isLocal ? 'Free (local)' : (costs.length ? _costExact(minCost) + ' - ' + _costExact(maxCost) : 'No pricing');
     // Aggregate capabilities
     var allCaps = new Set();
     pModels.forEach(function(m) {
@@ -4443,7 +4444,7 @@ function renderModelProviders(providers, models) {
       '<div style="margin-top:12px;display:grid;grid-template-columns:1fr 1fr;gap:8px;">' +
         '<div style="background:var(--bg,#1a1b26);border-radius:6px;padding:8px 10px;">' +
           '<div style="font-size:10px;color:var(--fg-dim,#565f89);text-transform:uppercase;letter-spacing:0.5px;">Cost Range</div>' +
-          '<div style="font-size:12px;color:#e0af68;margin-top:2px;">' + costRange + '</div>' +
+          '<div style="font-size:12px;color:' + (isLocal ? '#9ece6a' : '#e0af68') + ';margin-top:2px;">' + costRange + '</div>' +
         '</div>' +
         '<div style="background:var(--bg,#1a1b26);border-radius:6px;padding:8px 10px;">' +
           '<div style="font-size:10px;color:var(--fg-dim,#565f89);text-transform:uppercase;letter-spacing:0.5px;">Capabilities</div>' +

package/template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "walle",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "private": true,
   "description": "Wall-E — your personal digital twin",
   "scripts": {

package/template/wall-e/api-walle.js

@@ -27,6 +27,7 @@ function getTelemetryDb() {
         event TEXT NOT NULL,
         meta TEXT,
         client_ts INTEGER,
+        ip TEXT,
         received_at TEXT DEFAULT (datetime('now'))
       );
       CREATE INDEX IF NOT EXISTS idx_te_install ON telemetry_events(install_id);
@@ -39,9 +40,13 @@ function getTelemetryDb() {
         version TEXT,
         os TEXT,
         node_version TEXT,
+        ip TEXT,
         event_count INTEGER DEFAULT 0
       );
     `);
+    // Migrate: add ip column if missing
+    try { telemetryDb.prepare('ALTER TABLE telemetry_events ADD COLUMN ip TEXT').run(); } catch {}
+    try { telemetryDb.prepare('ALTER TABLE telemetry_installs ADD COLUMN ip TEXT').run(); } catch {}
     return telemetryDb;
   } catch (e) {
     console.error('[wall-e] Failed to init telemetry DB:', e.message);
@@ -1821,28 +1826,38 @@ function handleWalleApi(req, res, url) {
   if (p === '/api/wall-e/telemetry/ingest' && m === 'POST') {
     const tdb = getTelemetryDb();
     if (!tdb) return jsonResponse(res, { error: 'Telemetry not enabled' }, 404), true;
+    // Basic rate limiting: max 60 requests per minute per IP
+    const clientIpRL = (req.headers['x-forwarded-for'] || '').split(',')[0].trim() || req.socket?.remoteAddress || 'unknown';
+    if (!handleWalleApi._rlMap) { handleWalleApi._rlMap = new Map(); setInterval(() => handleWalleApi._rlMap.clear(), 60000); }
+    const rlCount = (handleWalleApi._rlMap.get(clientIpRL) || 0) + 1;
+    handleWalleApi._rlMap.set(clientIpRL, rlCount);
+    if (rlCount > 60) return jsonResponse(res, { error: 'Rate limited' }, 429), true;
     readBody(req).then(body => {
       if (!body || !body.id || !Array.isArray(body.events)) {
         return jsonResponse(res, { error: 'Invalid payload' }, 400);
       }
+      // Capture client IP from request (supports reverse proxy headers)
+      const clientIp = (req.headers['x-forwarded-for'] || '').split(',')[0].trim()
+        || req.socket?.remoteAddress || '';
       const insertEvent = tdb.prepare(
-        'INSERT INTO telemetry_events (install_id, version, os, node_version, event, meta, client_ts) VALUES (?, ?, ?, ?, ?, ?, ?)'
+        'INSERT INTO telemetry_events (install_id, version, os, node_version, event, meta, client_ts, ip) VALUES (?, ?, ?, ?, ?, ?, ?, ?)'
       );
       const upsertInstall = tdb.prepare(`
-        INSERT INTO telemetry_installs (install_id, version, os, node_version, event_count)
-        VALUES (?, ?, ?, ?, ?)
+        INSERT INTO telemetry_installs (install_id, version, os, node_version, ip, event_count)
+        VALUES (?, ?, ?, ?, ?, ?)
         ON CONFLICT(install_id) DO UPDATE SET
           last_seen = datetime('now'),
           version = excluded.version,
           os = excluded.os,
           node_version = excluded.node_version,
+          ip = excluded.ip,
           event_count = telemetry_installs.event_count + excluded.event_count
       `);
       const runBatch = tdb.transaction((events) => {
         for (const ev of events) {
-          insertEvent.run(body.id, body.v, body.os, body.node, ev.e, JSON.stringify(ev.m || {}), ev.t);
+          insertEvent.run(body.id, body.v, body.os, body.node, ev.e, JSON.stringify(ev.m || {}), ev.t, clientIp);
         }
-        upsertInstall.run(body.id, body.v, body.os, body.node, events.length);
+        upsertInstall.run(body.id, body.v, body.os, body.node, clientIp, events.length);
       });
       runBatch(body.events.slice(0, 500)); // cap at 500 events per request
       jsonResponse(res, { ok: true, received: Math.min(body.events.length, 500) });
@@ -1873,6 +1888,12 @@ function handleWalleApi(req, res, url) {
       os_breakdown: tdb.prepare(
         'SELECT os, count(*) as cnt FROM telemetry_installs GROUP BY os ORDER BY cnt DESC'
       ).all(),
+      unique_ips: tdb.prepare(
+        "SELECT count(DISTINCT ip) as cnt FROM telemetry_installs WHERE ip IS NOT NULL AND ip != ''"
+      ).get().cnt,
+      ip_breakdown: tdb.prepare(
+        "SELECT ip, count(*) as installs, group_concat(install_id) as install_ids FROM telemetry_installs WHERE ip IS NOT NULL AND ip != '' GROUP BY ip ORDER BY installs DESC"
+      ).all(),
       recent_errors: tdb.prepare(
         "SELECT install_id, version, meta, received_at FROM telemetry_events WHERE event = 'error' AND received_at >= ? ORDER BY received_at DESC LIMIT 50"
       ).all(since),

package/template/wall-e/chat.js

@@ -598,7 +598,7 @@ async function chat(message, opts = {}) {
     const MAX_TURNS = 8; // search(2-3) + think(1) + response(1) + possible follow-up tools
 
     // Guardrails
-    const MAX_TOOL_CALLS = opts.maxToolCalls || 15;
+    const MAX_TOOL_CALLS = opts.maxToolCalls != null ? opts.maxToolCalls : 15;
     let toolCallCount = 0;
     const MESSAGE_TIMEOUT_MS = opts.timeoutMs || 180000; // 3 minutes
     const messageDeadline = Date.now() + MESSAGE_TIMEOUT_MS;
@@ -655,7 +655,7 @@ async function chat(message, opts = {}) {
         maxTokens: 4096,
         system: systemPrompt,
         messages,
-        tools: chatTools,
+        tools: opts.allowedTools ? chatTools.filter(t => opts.allowedTools.includes(t.name)) : chatTools,
         signal: controller.signal,
       });
 

package/template/wall-e/loops/tasks.js

@@ -96,15 +96,36 @@ async function runDueTasks() {
       // Strip BRIEFING_ITEMS block from displayed result, store items separately
       const cleanResult = resultText.replace(/<!--\s*BRIEFING_ITEMS[\s\S]*?-->/, '').trim();
 
+      // Slack delivery verification: if the task originated from Slack but the
+      // LLM result suggests the reply was never delivered, retry once directly.
+      let slackDeliveryFailed = false;
+      if (task.source === 'slack' && (task.run_count || 0) < 3) {
+        const deliveryIssue = looksLikeSlackDeliveryFailure(cleanResult);
+        if (deliveryIssue) {
+          console.log(`[tasks] Slack delivery issue for task ${task.id}: ${deliveryIssue}`);
+          appendLog(task.id, `Slack delivery issue: ${deliveryIssue} — retrying send...`);
+          slackDeliveryFailed = !(await retrySlackDelivery(task, cleanResult));
+          if (!slackDeliveryFailed) {
+            appendLog(task.id, 'Slack retry succeeded');
+            console.log(`[tasks] Slack retry succeeded for task ${task.id}`);
+          } else {
+            appendLog(task.id, 'Slack retry also failed — marking task for retry');
+            console.log(`[tasks] Slack retry failed for task ${task.id}, will retry later`);
+          }
+        }
+      }
+
       brain.updateTask(task.id, {
-        status: task.type === 'recurring' ? 'pending' : 'completed',
+        status: slackDeliveryFailed ? 'pending' : (task.type === 'recurring' ? 'pending' : 'completed'),
         completed_at: completedAt,
         last_run_at: completedAt,
         run_count: (task.run_count || 0) + 1,
         result: cleanResult.slice(0, 10000),
-        error: null,
         checkpoint: null, // clear checkpoint on success
-        next_run_at: task.type === 'recurring' ? computeNextDue(task.schedule) : null,
+        error: slackDeliveryFailed ? 'Slack reply delivery failed — scheduled for retry' : null,
+        next_run_at: slackDeliveryFailed
+          ? new Date(Date.now() + 2 * 60 * 1000).toISOString()  // retry in 2 min
+          : (task.type === 'recurring' ? computeNextDue(task.schedule) : null),
         // Keep started_at so duration can be computed as completed_at - started_at
       });
 
@@ -534,4 +555,134 @@ function consolidateBriefingItems(task, resultText, timestamp) {
   }
 }
 
+/**
+ * Detect if a task result text indicates the Slack reply was never delivered.
+ * Returns a string describing the issue, or null if delivery looks OK.
+ */
+function looksLikeSlackDeliveryFailure(resultText) {
+  if (!resultText) return 'empty result';
+  const lower = resultText.toLowerCase();
+
+  // Explicit failure patterns
+  const failurePatterns = [
+    'mcp server error',
+    'error sending',
+    'failed to send',
+    "couldn't send",
+    'could not send',
+    'unable to send',
+    'slack_send_message failed',
+    'failed to deliver',
+    'error posting message',
+    'connection refused',
+    'mcp call failed',
+    'encountering a technical issue sending',
+  ];
+  for (const p of failurePatterns) {
+    if (lower.includes(p)) return `explicit failure: ${p}`;
+  }
+
+  // No reply was attempted — model researched but never sent
+  // Success patterns: if any of these appear, the reply was likely sent
+  const successPatterns = [
+    'replied to your slack',
+    'sent the message',
+    'message was sent',
+    'reply sent',
+    'posted to slack',
+    'slack_send_message',
+    'sent in thread',
+    'responded in the thread',
+    'replied in the slack thread',
+    'sent to the thread',
+    'delivered the answer',
+  ];
+  if (!successPatterns.some(p => lower.includes(p))) {
+    return 'no reply sent (model exhausted turns without calling slack_send_message)';
+  }
+
+  return null;
+}
+
+/**
+ * Attempt to retry sending the Slack reply directly via MCP.
+ * Extracts the answer from the result text and sends it to the channel/thread
+ * referenced in the task description.
+ * Returns true if the retry succeeded, false otherwise.
+ */
+async function retrySlackDelivery(task, resultText) {
+  try {
+    const slackMcp = require('../tools/slack-mcp');
+
+    // Extract channel_id and thread_ts from the task description
+    const channelMatch = task.description?.match(/"channel_id":\s*"([^"]+)"/);
+    const threadMatch = task.description?.match(/"thread_ts":\s*"([^"]+)"/);
+    console.log(`[tasks] retrySlackDelivery: channel=${channelMatch?.[1]}, thread=${threadMatch?.[1]}`);
+    if (!channelMatch) {
+      console.error('[tasks] Cannot retry Slack delivery: no channel_id in task description');
+      return false;
+    }
+
+    // Extract the useful content from the result, stripping failure/meta messages
+    let answer = resultText;
+
+    // Remove lines that are just research narration ("Let me...", "I'll...")
+    answer = answer.replace(/^(?:Let me|I'll|I will|Now let me|Let's)[^\n]*$/gm, '').trim();
+
+    // Strip error messages about delivery failure
+    answer = answer.replace(/(?:However|Unfortunately|I'm currently)[^.]*(?:unable to send|MCP server|authentication issue|technical issue|couldn't send|could not send)[^.]*\./gi, '').trim();
+
+    // Try to find substantive answer (before any error part)
+    const errorIdx = answer.search(/unfortunately.*(?:technical issue|error|couldn't send|MCP server)/i);
+    if (errorIdx > 50) {
+      answer = answer.slice(0, errorIdx).trim();
+    }
+
+    console.log(`[tasks] retrySlackDelivery: extracted answer (${answer.length} chars): ${answer.slice(0, 200)}`);
+
+    // If the answer is still just meta-narration with no real content, try to
+    // generate a brief reply using the chat engine with strict instructions
+    if (answer.length < 20 || !/[a-z]{3,}/i.test(answer)) {
+      console.log('[tasks] No substantive answer in result — generating a brief reply via chat...');
+      try {
+        const chatModule = require('../chat');
+        const briefReply = await chatModule.chat(
+          `[URGENT] You MUST reply to a Slack question immediately. The question was:\n\n${task.description?.match(/(?:Question|task) from.*?:\n\n([\s\S]*?)(?:\n\nFull thread|\n\n---)/i)?.[1] || task.title}\n\nGive a helpful 2-3 sentence answer. Do NOT use any tools. Just reply with your best answer based on what you know.`,
+          { channel: 'task', session_id: `retry-${task.id}`, maxToolCalls: 0, timeoutMs: 30000 }
+        );
+        answer = briefReply.reply || '';
+      } catch (chatErr) {
+        console.error(`[tasks] Brief reply generation failed: ${chatErr.message}`);
+        return false;
+      }
+    }
+
+    // Truncate if too long for Slack
+    if (answer.length > 3000) answer = answer.slice(0, 3000) + '...';
+    if (answer.length < 10) {
+      console.error('[tasks] Cannot retry Slack delivery: no substantive answer to send');
+      return false;
+    }
+
+    const args = { channel_id: channelMatch[1], message: answer };
+    if (threadMatch) args.thread_ts = threadMatch[1];
+
+    console.log(`[tasks] retrySlackDelivery: sending ${answer.length} chars to ${args.channel_id} thread=${args.thread_ts || 'none'}`);
+    const result = await slackMcp.callSlackMcp('slack_send_message', args);
+    const resultStr = JSON.stringify(result).slice(0, 200);
+    console.log(`[tasks] retrySlackDelivery: MCP result: ${resultStr}`);
+
+    // Check for actual success — look for message_link in response
+    const hasMessageLink = resultStr.includes('message_link') || resultStr.includes('message_ts');
+    if (!hasMessageLink) {
+      console.error(`[tasks] retrySlackDelivery: no message_link in response — likely failed`);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    console.error(`[tasks] Slack delivery retry failed: ${err.message}`);
+    return false;
+  }
+}
+
 module.exports = { runDueTasks, runTaskById, recoverInterruptedTasks, buildTaskPrompt, computeNextDue, getTaskLogs, clearTaskLogs, stopTask, executeSkill, executeMultiTurnChat, consolidateBriefingItems, taskLogs };

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

@@ -71,6 +71,65 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Generate an answer using chat (with limited tools) and send it directly to Slack.
+ * Returns the reply text on success, or null on failure.
+ *
+ * This bypasses the task→chat→mcp_call pipeline which is unreliable because:
+ * 1. The model ignores "reply first" instructions and calls slow tools
+ * 2. MCP tool calls from chat can hang indefinitely
+ * 3. There's no guarantee the model will call slack_send_message
+ *
+ * Instead: we call chat with search_memories + think only, get the answer text,
+ * then send it ourselves via callSlackMcp.
+ */
+async function generateAndSendReply(msg, threadTs, contextBlock, kind) {
+  const chatModule = require(path.resolve(__dirname, '..', '..', '..', 'chat'));
+  const question = (msg.content || '').replace(/@wall-?e/gi, '').trim();
+
+  // Step 1: Generate the answer with limited tools (search_memories + think only)
+  let answer;
+  try {
+    const prompt = `[SLACK ${kind.toUpperCase()}] ${OWNER_NAME} asked in Slack:\n\n${question}${contextBlock}\n\nSearch your memories for relevant info, then give a concise, helpful answer (2-6 sentences). Do NOT call any tools except search_memories and think. Just answer the question directly.`;
+
+    const result = await chatModule.chat(prompt, {
+      channel: 'task',
+      session_id: `slack-reply-${msg.ts || Date.now()}`,
+      allowedTools: ['search_memories', 'think', 'lookup_person'],
+      timeoutMs: 60000, // 1 minute max
+    });
+    answer = (result.reply || '').trim();
+    console.log(`[slack-mentions] Generated answer (${answer.length} chars): ${answer.slice(0, 150)}`);
+  } catch (err) {
+    console.error(`[slack-mentions] Failed to generate answer: ${err.message}`);
+    answer = null;
+  }
+
+  // Step 2: Send the reply directly via Slack MCP
+  if (!answer || answer.length < 5) {
+    answer = `I'm not sure about that — let me look into it and get back to you.`;
+  }
+
+  // Truncate for Slack (4000 char limit)
+  if (answer.length > 3500) answer = answer.slice(0, 3500) + '...';
+
+  if (msg.channelId) {
+    try {
+      await slackMcp.callSlackMcp('slack_send_message', {
+        channel_id: msg.channelId,
+        thread_ts: threadTs,
+        message: answer,
+      });
+      console.log(`[slack-mentions] Reply sent to Slack thread ${threadTs}`);
+      return answer;
+    } catch (sendErr) {
+      console.error(`[slack-mentions] Failed to send reply to Slack: ${sendErr.message}`);
+      return null;
+    }
+  }
+  return answer;
+}
+
 function classifyMention(text) {
   const trimmed = (text || '').trim();
   const cleaned = trimmed.replace(/@wall-?e/gi, '').trim();
@@ -424,77 +483,42 @@ async function _processMention(msg, seenTs, stats) {
     return;
   }
 
-  if (kind === 'task') {
+  if (kind === 'task' || kind === 'question') {
+    stats.questionsFound += kind === 'question' ? 1 : 0;
+    stats.tasksCreated += kind === 'task' ? 1 : 0;
     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**CRITICAL INSTRUCTIONS — follow exactly:**\n1. Do focused research (max 3 search calls)\n2. Draft your response\n3. IMMEDIATELY reply in Slack — the reply is the #1 priority. Do NOT over-research.\n\nReply using mcp_call with:\n- server: slack\n- tool: slack_send_message\n- arguments: { "channel_id": "${msg.channelId}", "thread_ts": "${threadTs}", "message": "<your results>" }\n\nBetter to reply with what you know than to exhaust turns researching and never reply.`,
-        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)}...`);
+    console.log(`[slack-mentions] ${kind} detected: ${title.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);
-    }
+    // Phase 1: Generate answer directly and send it — no task intermediary.
+    // This is the most reliable approach: we control the chat call and send the
+    // reply ourselves, instead of hoping the task's chat engine will do it.
+    const reply = await generateAndSendReply(msg, threadTs, contextBlock, kind);
 
+    // Track as a completed task for history/dedup
     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**CRITICAL INSTRUCTIONS — follow exactly:**\n1. Do ONE focused search_memories call (max 2 searches total)\n2. Use the think tool to draft a concise answer\n3. IMMEDIATELY reply in Slack — do NOT do more research. The Slack reply is the #1 priority.\n\nReply using mcp_call with:\n- server: slack\n- tool: slack_send_message\n- arguments: { "channel_id": "${msg.channelId}", "thread_ts": "${threadTs}", "message": "<your answer>" }\n\nKeep the answer brief (2-4 sentences). Better to reply quickly with what you know than to research forever and never reply.`,
-        priority: 'high',
+        title: kind === 'question' ? `Answer Slack question: ${title}` : title,
+        description: `${kind === 'question' ? 'Question' : 'Task'} from ${OWNER_NAME} in Slack:\n\n${msg.content}${contextBlock}`,
+        priority: kind === 'question' ? 'high' : 'normal',
         type: 'once',
         execution: 'chat',
         source: 'slack',
         source_ref: sourceRef,
       });
-
+      // Mark completed/failed immediately since we handled it inline
+      brain.updateTask(id, {
+        status: reply ? 'completed' : 'failed',
+        result: (reply || 'Failed to generate or send reply').slice(0, 10000),
+        completed_at: new Date().toISOString(),
+        run_count: 1,
+      });
       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}`);
+      console.error(`[slack-mentions] Failed to create task record: ${taskErr.message}`);
     }
   }
 

package/template/website/index.html

@@ -231,7 +231,7 @@
       <a href="#how">Get Started</a>
       <a href="#architecture">Architecture</a>
       <a href="https://www.npmjs.com/package/create-walle">npm</a>
-      <a href="https://github.com/anthropics/claude-code">GitHub</a>
+      <a href="https://www.npmjs.com/package/create-walle?activeTab=versions">Changelog</a>
     </div>
   </div>
 </nav>
@@ -243,8 +243,8 @@
     Run Claude Code, Codex, Gemini, and Aider sessions side by side. Manage prompts,
     queue tasks, and let an AI agent build a second brain from your work life.
   </p>
-  <div class="install-box" onclick="navigator.clipboard.writeText('npx create-walle install ./my-agent');this.querySelector('.copy-hint').textContent='Copied!'">
-    <code>npx create-walle install ./my-agent</code>
+  <div class="install-box" onclick="navigator.clipboard.writeText('npx create-walle install ./walle');this.querySelector('.copy-hint').textContent='Copied!'">
+    <code>npx create-walle install ./walle</code>
     <span class="copy-hint">click to copy</span>
   </div>
   <div class="badge-row">
@@ -259,7 +259,7 @@
       <span class="dot r"></span><span class="dot y"></span><span class="dot g"></span>
       <span class="title mono">Terminal</span>
     </div>
-    <pre><span class="prompt">$</span> <span class="cmd">npx create-walle install ./my-agent</span>
+    <pre><span class="prompt">$</span> <span class="cmd">npx create-walle install ./walle</span>
 
 <span class="dim">  Installing CTM + Wall-E...</span>
 <span class="dim">  Auto-detected owner:</span> <span class="hi">Your Name</span>
@@ -365,7 +365,7 @@
   <div class="steps">
     <div class="step">
       <h3>Install</h3>
-      <p><code>npx create-walle install ./my-agent</code><br>Copies the project, installs deps, and starts the server.</p>
+      <p><code>npx create-walle install ./walle</code><br>Copies the project, installs deps, and starts the server.</p>
     </div>
     <div class="step">
       <h3>Open the browser</h3>