create-walle 0.9.0 → 0.9.3

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

@@ -213,19 +213,22 @@
   .prompt-item.active { background: var(--bg-lighter); border-left-color: var(--accent); }
   .prompt-item.pinned { border-left-color: var(--yellow); }
   .prompt-item.active.pinned { border-left-color: var(--yellow); }
-  .prompt-item.drag-over { border-top: 2px solid var(--accent); }
+  .prompt-item.drag-over-top { box-shadow: 0 -2px 0 0 var(--accent); }
+  .prompt-item.drag-over-bottom { box-shadow: 0 2px 0 0 var(--accent); }
+  .prompt-item.dragging { opacity: 0.35; }
   .prompt-item .drag-handle {
     cursor: grab;
     color: var(--fg-dim);
-    opacity: 0;
-    font-size: 10px;
-    padding: 2px 0;
+    opacity: 0.25;
+    font-size: 12px;
+    padding: 4px 2px;
     flex-shrink: 0;
     user-select: none;
-    transition: opacity 0.1s;
+    transition: opacity 0.15s, color 0.15s;
   }
-  .prompt-item:hover .drag-handle { opacity: 0.5; }
-  .prompt-item .drag-handle:hover { opacity: 1; }
+  .prompt-item:hover .drag-handle { opacity: 0.6; }
+  .prompt-item .drag-handle:hover { opacity: 1; color: var(--accent); }
+  .prompt-item .drag-handle:active { cursor: grabbing; }
   .prompt-item .prompt-content { flex: 1; min-width: 0; }
   .prompt-item .prompt-title {
     font-weight: 500;
@@ -288,17 +291,21 @@
     transition: all 0.1s;
   }
   .folder-item .folder-actions .act-btn:hover { background: var(--bg); color: var(--fg); }
-  .folder-item.drag-over { border-top: 2px solid var(--accent); }
+  .folder-item.drag-over-top { box-shadow: 0 -2px 0 0 var(--accent); }
+  .folder-item.drag-over-bottom { box-shadow: 0 2px 0 0 var(--accent); }
+  .folder-item.dragging { opacity: 0.35; }
   .folder-item .drag-handle {
     cursor: grab;
     color: var(--fg-dim);
-    opacity: 0;
-    font-size: 10px;
+    opacity: 0.25;
+    font-size: 12px;
     flex-shrink: 0;
     user-select: none;
+    transition: opacity 0.15s, color 0.15s;
   }
-  .folder-item:hover .drag-handle { opacity: 0.5; }
-  .folder-item .drag-handle:hover { opacity: 1; }
+  .folder-item:hover .drag-handle { opacity: 0.6; }
+  .folder-item .drag-handle:hover { opacity: 1; color: var(--accent); }
+  .folder-item .drag-handle:active { cursor: grabbing; }
   .folder-rename-input {
     background: var(--bg);
     color: var(--fg);
@@ -2333,6 +2340,7 @@ function renderFolderTree() {
     html += `<div class="folder-item ${state.currentFolderId === f.id ? 'active' : ''}"
       data-folder-id="${f.id}" draggable="true"
       ondragstart="onFolderDragStart(event, ${f.id})"
+      ondragend="onFolderDragEnd(event)"
       ondragover="onFolderDragOver(event)"
       ondragleave="onFolderDragLeave(event)"
       ondrop="onFolderDrop(event, ${f.id})"
@@ -2397,31 +2405,50 @@ function onFolderDragStart(e, id) {
   dragFolderId = id;
   e.dataTransfer.effectAllowed = 'move';
   e.dataTransfer.setData('text/plain', id);
+  const item = e.target.closest('.folder-item');
+  if (item) requestAnimationFrame(() => item.classList.add('dragging'));
 }
 
 function onFolderDragOver(e) {
   e.preventDefault();
+  document.querySelectorAll('.folder-item.drag-over-top, .folder-item.drag-over-bottom').forEach(el => {
+    el.classList.remove('drag-over-top', 'drag-over-bottom');
+  });
   const item = e.target.closest('.folder-item[data-folder-id]');
-  if (item) item.classList.add('drag-over');
+  if (item) {
+    const rect = item.getBoundingClientRect();
+    const isTop = e.clientY < rect.top + rect.height / 2;
+    item.classList.add(isTop ? 'drag-over-top' : 'drag-over-bottom');
+  }
 }
 
 function onFolderDragLeave(e) {
   const item = e.target.closest('.folder-item[data-folder-id]');
-  if (item) item.classList.remove('drag-over');
+  if (item) item.classList.remove('drag-over-top', 'drag-over-bottom');
 }
 
 async function onFolderDrop(e, targetId) {
   e.preventDefault();
-  const item = e.target.closest('.folder-item[data-folder-id]');
-  if (item) item.classList.remove('drag-over');
+  document.querySelectorAll('.folder-item.drag-over-top, .folder-item.drag-over-bottom, .folder-item.dragging').forEach(el => {
+    el.classList.remove('drag-over-top', 'drag-over-bottom', 'dragging');
+  });
   if (dragFolderId === null || dragFolderId === targetId) return;
 
+  const item = e.target.closest('.folder-item[data-folder-id]');
+  let dropAfter = false;
+  if (item) {
+    const rect = item.getBoundingClientRect();
+    dropAfter = e.clientY >= rect.top + rect.height / 2;
+  }
+
   const ids = state.folders.map(f => f.id);
   const fromIdx = ids.indexOf(dragFolderId);
-  const toIdx = ids.indexOf(targetId);
+  let toIdx = ids.indexOf(targetId);
   if (fromIdx === -1 || toIdx === -1) return;
 
   ids.splice(fromIdx, 1);
+  toIdx = ids.indexOf(targetId);
+  if (dropAfter) toIdx++;
   ids.splice(toIdx, 0, dragFolderId);
 
   await fetch(API('/folders/reorder'), {
@@ -2433,6 +2460,12 @@ async function onFolderDrop(e, targetId) {
   dragFolderId = null;
 }
 
+function onFolderDragEnd(e) {
+  document.querySelectorAll('.folder-item.dragging, .folder-item.drag-over-top, .folder-item.drag-over-bottom').forEach(el => {
+    el.classList.remove('dragging', 'drag-over-top', 'drag-over-bottom');
+  });
+}
+
 function renderPromptList() {
   const list = document.getElementById('prompt-list');
   if (state.prompts.length === 0) {
@@ -2448,6 +2481,7 @@ function renderPromptList() {
     return `<div class="prompt-item ${isActive ? 'active' : ''} ${p.starred ? 'starred' : ''} ${isPinned ? 'pinned' : ''}"
       data-id="${p.id}" draggable="true"
       ondragstart="onPromptDragStart(event, ${p.id})"
+      ondragend="onPromptDragEnd(event)"
       ondragover="onPromptDragOver(event)"
       ondragleave="onPromptDragLeave(event)"
       ondrop="onPromptDrop(event, ${p.id})"
@@ -2511,38 +2545,56 @@ function onPromptDragStart(e, id) {
   dragPromptId = id;
   e.dataTransfer.effectAllowed = 'move';
   e.dataTransfer.setData('text/plain', id);
-  e.target.style.opacity = '0.5';
-  setTimeout(() => { e.target.style.opacity = ''; }, 0);
+  const item = e.target.closest('.prompt-item');
+  if (item) requestAnimationFrame(() => item.classList.add('dragging'));
 }
 
 function onPromptDragOver(e) {
   e.preventDefault();
   e.dataTransfer.dropEffect = 'move';
+  // Clear previous indicators
+  document.querySelectorAll('.prompt-item.drag-over-top, .prompt-item.drag-over-bottom').forEach(el => {
+    el.classList.remove('drag-over-top', 'drag-over-bottom');
+  });
   const item = e.target.closest('.prompt-item');
-  if (item) item.classList.add('drag-over');
+  if (item) {
+    const rect = item.getBoundingClientRect();
+    const isTop = e.clientY < rect.top + rect.height / 2;
+    item.classList.add(isTop ? 'drag-over-top' : 'drag-over-bottom');
+  }
 }
 
 function onPromptDragLeave(e) {
   const item = e.target.closest('.prompt-item');
-  if (item) item.classList.remove('drag-over');
+  if (item) item.classList.remove('drag-over-top', 'drag-over-bottom');
 }
 
 async function onPromptDrop(e, targetId) {
   e.preventDefault();
-  const item = e.target.closest('.prompt-item');
-  if (item) item.classList.remove('drag-over');
+  document.querySelectorAll('.prompt-item.drag-over-top, .prompt-item.drag-over-bottom, .prompt-item.dragging').forEach(el => {
+    el.classList.remove('drag-over-top', 'drag-over-bottom', 'dragging');
+  });
   if (dragPromptId === null || dragPromptId === targetId) return;
 
-  // Reorder in local state
+  // Determine if dropping above or below target
+  const item = e.target.closest('.prompt-item');
+  let dropAfter = false;
+  if (item) {
+    const rect = item.getBoundingClientRect();
+    dropAfter = e.clientY >= rect.top + rect.height / 2;
+  }
+
   const ids = state.prompts.map(p => p.id);
   const fromIdx = ids.indexOf(dragPromptId);
-  const toIdx = ids.indexOf(targetId);
+  let toIdx = ids.indexOf(targetId);
   if (fromIdx === -1 || toIdx === -1) return;
 
   ids.splice(fromIdx, 1);
+  // Adjust index after removal
+  toIdx = ids.indexOf(targetId);
+  if (dropAfter) toIdx++;
   ids.splice(toIdx, 0, dragPromptId);
 
-  // Save to server
   await fetch(API('/prompts/reorder'), {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -2552,6 +2604,12 @@ async function onPromptDrop(e, targetId) {
   dragPromptId = null;
 }
 
+function onPromptDragEnd(e) {
+  document.querySelectorAll('.prompt-item.dragging, .prompt-item.drag-over-top, .prompt-item.drag-over-bottom').forEach(el => {
+    el.classList.remove('dragging', 'drag-over-top', 'drag-over-bottom');
+  });
+}
+
 function selectFolder(id) {
   state.currentFolderId = id;
   renderFolderTree();

package/template/claude-task-manager/public/walle-icon.svg

@@ -0,0 +1,45 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 120 120">
+  <defs>
+    <linearGradient id="body" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#e0af68"/>
+      <stop offset="100%" stop-color="#d49a4e"/>
+    </linearGradient>
+    <linearGradient id="eye-bg" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" stop-color="#c0caf5"/>
+      <stop offset="100%" stop-color="#a9b1d6"/>
+    </linearGradient>
+  </defs>
+  <!-- Body/head - compact cube shape -->
+  <rect x="20" y="38" width="80" height="58" rx="10" fill="url(#body)"/>
+  <!-- Treads -->
+  <rect x="14" y="92" width="36" height="16" rx="8" fill="#565f89"/>
+  <rect x="70" y="92" width="36" height="16" rx="8" fill="#565f89"/>
+  <!-- Tread detail lines -->
+  <line x1="22" y1="100" x2="42" y2="100" stroke="#3b4261" stroke-width="1.5" stroke-linecap="round"/>
+  <line x1="78" y1="100" x2="98" y2="100" stroke="#3b4261" stroke-width="1.5" stroke-linecap="round"/>
+  <!-- Binocular eyes - the iconic WALL-E feature -->
+  <!-- Left eye housing -->
+  <circle cx="44" cy="42" r="18" fill="#565f89"/>
+  <circle cx="44" cy="42" r="14" fill="url(#eye-bg)"/>
+  <circle cx="44" cy="42" r="8" fill="#1a1b26"/>
+  <circle cx="44" cy="39" r="3" fill="#7aa2f7" opacity="0.9"/>
+  <!-- Right eye housing -->
+  <circle cx="76" cy="42" r="18" fill="#565f89"/>
+  <circle cx="76" cy="42" r="14" fill="url(#eye-bg)"/>
+  <circle cx="76" cy="42" r="8" fill="#1a1b26"/>
+  <circle cx="76" cy="39" r="3" fill="#7aa2f7" opacity="0.9"/>
+  <!-- Eye bridge/connector -->
+  <rect x="56" y="36" width="8" height="12" rx="2" fill="#565f89"/>
+  <!-- Neck/periscope -->
+  <rect x="56" y="24" width="8" height="16" rx="2" fill="#565f89"/>
+  <!-- Solar panel detail on body -->
+  <rect x="30" y="56" width="60" height="4" rx="2" fill="#c49340" opacity="0.6"/>
+  <rect x="30" y="64" width="60" height="4" rx="2" fill="#c49340" opacity="0.6"/>
+  <rect x="30" y="72" width="60" height="4" rx="2" fill="#c49340" opacity="0.6"/>
+  <!-- Arms (small) -->
+  <rect x="8" y="58" width="14" height="6" rx="3" fill="#565f89"/>
+  <rect x="98" y="58" width="14" height="6" rx="3" fill="#565f89"/>
+  <!-- Hand grippers -->
+  <circle cx="8" cy="61" r="4" fill="#3b4261"/>
+  <circle cx="112" cy="61" r="4" fill="#3b4261"/>
+</svg>

package/template/claude-task-manager/server.js

@@ -2112,7 +2112,8 @@ function handleCreate(ws, msg) {
   // If a session with this ID is still alive (e.g. resume of a stale entry), attach instead
   const existing = sessions.get(id);
   if (existing && existing.ptyProcess) {
-    return handleAttach(ws, { id });
+    if (ws) return handleAttach(ws, { id });
+    return; // No client to attach — session already running
   }
 
   const cwd = (msg.cwd || process.env.HOME).replace(/^~/, process.env.HOME);
@@ -2158,7 +2159,7 @@ function handleCreate(ws, msg) {
       cols, rows, cwd, env,
     });
   } catch (e) {
-    ws.send(JSON.stringify({ type: 'error', message: `Failed to spawn: ${e.message}` }));
+    if (ws) ws.send(JSON.stringify({ type: 'error', message: `Failed to spawn: ${e.message}` }));
     return;
   }
 
@@ -2170,7 +2171,7 @@ function handleCreate(ws, msg) {
     cwd,
     pid: ptyProcess.pid,
     ptyProcess,
-    clients: [ws],
+    clients: ws ? [ws] : [],
     scrollback: [],
     createdAt: Date.now(),
     lastActivity: Date.now(),
@@ -2178,6 +2179,9 @@ function handleCreate(ws, msg) {
 
   sessions.set(id, session);
 
+  // Persist to startup_tasks for crash-safe restore
+  try { dbModule.addStartupTask(id, label, cmd, args, cwd); } catch {}
+
   ptyProcess.onData((data) => {
     session.lastActivity = Date.now();
     // Only strip \e[3J (Erase Scrollback) — it destroys scroll history on replay.
@@ -2208,6 +2212,7 @@ function handleCreate(ws, msg) {
       if (client.readyState === 1) client.send(payload);
     }
     sessions.delete(id);
+    try { dbModule.removeStartupTask(id); } catch {}
     queueEngine.onSessionExit(id);
     cleanAutoApprovalBuffer(id);
     cleanIdleNotify(id);
@@ -2222,7 +2227,7 @@ function handleCreate(ws, msg) {
     dbModule.setSessionTitle(id, label, false);
   }
 
-  ws.send(JSON.stringify({ type: 'created', id, pid: ptyProcess.pid, label, cwd }));
+  if (ws) ws.send(JSON.stringify({ type: 'created', id, pid: ptyProcess.pid, label, cwd }));
   broadcastSessionList();
 }
 
@@ -2369,6 +2374,7 @@ setInterval(async () => {
 // --- Graceful Shutdown ---
 function shutdown() {
   console.log('\n  Shutting down...');
+  // startup_tasks table is already up-to-date (written in real-time), no save needed
   dbModule.checkpointWal();
   dbModule.closeDb();
   for (const [id, session] of sessions) {
@@ -2402,7 +2408,10 @@ function apiServicesStatus(req, res) {
   });
 }
 
+let _walleIntentionallyStopped = false;
+
 function apiStopWalle(req, res) {
+  _walleIntentionallyStopped = true;
   execFile('lsof', ['-ti', ':' + WALLE_PORT], (err, stdout) => {
     const pids = (stdout || '').trim().split('\n').filter(Boolean);
     if (pids.length === 0) {
@@ -2419,6 +2428,7 @@ function apiStopWalle(req, res) {
 }
 
 function apiStartWalle(req, res) {
+  _walleIntentionallyStopped = false;
   const walleDir = path.join(__dirname, '..', 'wall-e');
   const agentScript = path.join(walleDir, 'agent.js');
   // Check if already running
@@ -2459,6 +2469,18 @@ function _restartWalleQuiet() {
 }
 
 function apiRestartCtm(req, res) {
+  const reqUrl = new URL(req.url, 'http://localhost');
+  const force = reqUrl.searchParams.get('force') === 'true';
+  const activeCount = sessions.size;
+  if (activeCount > 0 && !force) {
+    res.writeHead(409, { 'Content-Type': 'application/json' });
+    return res.end(JSON.stringify({
+      ok: false,
+      error: `Blocked: ${activeCount} active session(s) would be killed. Use ?force=true to override, or use the dev instance (bash bin/dev.sh) for testing.`,
+      active_sessions: activeCount
+    }));
+  }
+
   res.writeHead(200, { 'Content-Type': 'application/json' });
   res.end(JSON.stringify({ ok: true, message: 'CTM server restarting...' }));
 
@@ -2605,6 +2627,30 @@ const setup = require('../bin/setup');
 // Auto-detect owner and create .env if missing (no interactive prompts)
 setup.runIfNeeded();
 
+// Restore sessions BEFORE listening — prevents race where clients connect
+// and get an empty session list before startup_tasks sessions are restored.
+try {
+  const tasks = dbModule.listStartupTasks();
+  if (tasks.length > 0) {
+    console.log(`  Restoring ${tasks.length} session(s)...`);
+    // Clear table first — handleCreate will re-insert each session
+    dbModule.clearStartupTasks();
+    for (const t of tasks) {
+      try {
+        handleCreate(null, {
+          id: t.session_id, label: t.label, cmd: t.cmd,
+          args: t.args, cwd: t.cwd,
+        });
+        console.log(`    ✓ ${t.label || t.session_id.slice(0, 8)}`);
+      } catch (e) {
+        console.log(`    ✗ ${t.label}: ${e.message}`);
+      }
+    }
+  }
+} catch (e) {
+  console.log(`  Failed to restore sessions: ${e.message}`);
+}
+
 server.listen(PORT, HOST, () => {
   console.log(`\n  Claude Task Manager running at:`);
   console.log(`  Local:  http://localhost:${PORT}/`);
@@ -2617,4 +2663,23 @@ server.listen(PORT, HOST, () => {
   } else {
     console.log('');
   }
+
+  // Wall-E watchdog — auto-restart if it dies unexpectedly.
+  // _walleIntentionallyStopped is set by apiStopWalle, cleared by apiStartWalle.
+  setInterval(() => {
+    if (_walleIntentionallyStopped) return;
+    execFile('lsof', ['-ti', ':' + WALLE_PORT], (err, stdout) => {
+      const pids = (stdout || '').trim().split('\n').filter(Boolean);
+      if (pids.length > 0) return; // Still alive
+      // Wall-E is not running and wasn't intentionally stopped — restart
+      const walleDir = path.join(__dirname, '..', 'wall-e');
+      const agentScript = path.join(walleDir, 'agent.js');
+      const child = require('child_process').spawn(
+        process.execPath, [agentScript],
+        { cwd: walleDir, detached: true, stdio: 'ignore', env: { ...process.env, WALL_E_PORT: String(WALLE_PORT) } }
+      );
+      child.unref();
+      console.log('[watchdog] Wall-E died unexpectedly, restarted (PID ' + child.pid + ')');
+    });
+  }, 30000);
 });

package/template/docs/openclaw-vs-walle-comparison.md

@@ -0,0 +1,103 @@
+# OpenClaw vs. Wall-E: Intelligence Comparison
+
+*Date: 2026-04-03*
+
+## The Fundamental Architectural Difference
+
+**OpenClaw is a *routing plane*. Wall-E is a *cognitive loop*.**
+
+They solve different problems, and that shapes everything about how "intelligent" they feel.
+
+| | OpenClaw | Wall-E |
+|---|---|---|
+| **Core metaphor** | Gateway / message router | Digital twin / brain |
+| **Intelligence source** | Claude (or any LLM) on every turn | Claude for extraction + pre-computed brain state |
+| **Proactivity** | Cron jobs -> spawn agent turn | Ingest/think/reflect loops + skill planner |
+| **Memory** | Vector embeddings + session transcripts | SPO knowledge triples + raw memories + FTS |
+| **Identity** | Configurable name/emoji prefix | Deep identity from 28k+ ingested memories |
+| **Channels** | 23+ messaging platforms | iMessage, Slack DM, CTM chat |
+| **Architecture** | ~200k+ lines TypeScript monorepo | ~10k lines Node.js |
+
+## Where OpenClaw Feels "Smarter"
+
+### 1. The Gateway is the brain -- every message gets a full Claude turn
+
+OpenClaw's Pi agent runtime (`pi-embedded-runner.ts`) runs a full LLM call for every single incoming message. The agent has access to tools (bash, file read/write, web search, canvas, image gen, cron management, subagent spawning, session management) and Claude decides what to do. This means:
+
+- It can reason about *anything* in real-time
+- It can chain tool calls naturally (search -> read -> respond)
+- It doesn't need pre-computed knowledge -- it reasons on the fly
+
+Wall-E, by contrast, pre-computes knowledge in batch loops (think every 2 min, reflect every hour). The chat handler builds a static system prompt from brain state. This means Wall-E's "intelligence" at chat time is limited to what's already been extracted and stored.
+
+### 2. Subagent orchestration
+
+OpenClaw can spawn child agents (`subagent-spawn.ts`) -- isolated sessions with their own tools, models, and timeouts. This enables multi-step autonomous workflows where one agent delegates to another. Wall-E has no equivalent -- it's a single-threaded daemon.
+
+### 3. Cron = proactive muscle
+
+OpenClaw's cron system (`server-cron.ts`) spawns full agent turns on a schedule. The agent gets the same tools as a chat turn -- so a cron job can browse the web, check APIs, write files, and send messages autonomously.
+
+Wall-E's `runDueSkills()` is similar in concept but far simpler -- it runs predefined prompt templates through Claude tool-use. The prompts are static, not adaptive.
+
+### 4. Compaction and context management
+
+OpenClaw has a sophisticated compaction system (`compaction.ts`) that progressively summarizes conversation history, preserves identifiers and decisions, drops old chunks first, and handles tool-result pairing. This means long conversations stay coherent.
+
+Wall-E has no compaction -- chat context is built fresh each time from brain state. Long conversations will eventually hit token limits and simply fail.
+
+### 5. Memory search with embeddings
+
+OpenClaw's `memory-search.ts` uses hybrid search: vector embeddings + full-text with MMR (Maximal Marginal Relevance) and temporal decay. This means it can find semantically relevant memories, not just keyword matches.
+
+Wall-E uses BM25 full-text search only (via SQLite FTS5). Good for exact matches, but misses semantic connections.
+
+## Where Wall-E Has Unique Strengths
+
+### 1. Deep identity model
+
+Wall-E has something OpenClaw doesn't: a *persistent cognitive identity*. The knowledge triples (subject-predicate-object), relationship graph with trust levels, behavioral patterns, and 28k+ memories create a model of *who Juncao is*. The system prompt in `chat.js` includes actual Slack messages as voice samples, people interaction summaries, and topic frequencies.
+
+OpenClaw's identity is a configurable name/emoji + optional SOUL.md persona file. It has no self-model.
+
+### 2. The think loop is genuine cognition
+
+Wall-E's `think.js` does something unique: it takes raw memories and *extracts structured knowledge* (SPO triples), detects contradictions between new and existing knowledge, and generates questions when it's uncertain. This is closer to how a brain actually learns -- not just retrieving, but *processing and integrating*.
+
+OpenClaw has no equivalent batch learning process.
+
+### 3. Autonomy tiers
+
+Wall-E's graduated trust system (Tier 1-4 per domain, with demotion on rejection) is a thoughtful approach to autonomous action. OpenClaw has approval mechanisms, but they're per-tool policy, not a learned trust model.
+
+## Why Wall-E Feels "Pulled Back"
+
+### 1. Static system prompt, no dynamic reasoning chain
+
+Wall-E builds one big system prompt with everything pre-loaded (knowledge, people, memories, skills). Claude sees a snapshot, not a live workspace. OpenClaw's agent gets tools and *discovers* what it needs on each turn.
+
+### 2. No autonomous action loop
+
+Wall-E's daemon loops (ingest/think/reflect) are *passive processing*. They crunch data but never take initiative. The skill planner runs due skills on a timer, but the skills are pre-defined prompt templates. There's no "look at what's happening and decide to do something" loop.
+
+OpenClaw's cron + subagent spawning means it can proactively decide "it's Monday morning, let me check your calendar, summarize your Slack, and send you a briefing."
+
+### 3. No multi-turn tool orchestration
+
+Wall-E's chat does tool-use (search_memories, run_skill, mcp_call), but each chat turn is essentially independent. There's no concept of a long-running task that spans multiple turns. OpenClaw's session model preserves full conversation state and allows agent turns to build on each other.
+
+### 4. No event-driven triggers
+
+Wall-E runs on fixed timers. OpenClaw can react to webhooks, channel events, and cron triggers. If someone mentions you in Slack, OpenClaw can immediately spawn a response. Wall-E would only notice on its next poll cycle.
+
+## Key Upgrades to Make Wall-E More Proactive
+
+1. **Event-driven wake**: Instead of polling every 60s, react to channel events immediately.
+2. **Autonomous reasoning turn**: Periodic "what should I do?" turn where Wall-E decides whether to take action.
+3. **Persistent conversation context**: Maintain session state with compaction instead of fresh system prompt each time.
+4. **Dynamic tool discovery**: Let Wall-E discover what it needs via tool calls instead of pre-loading everything.
+5. **Background tasks / subagents**: Spawn long-running tasks that run independently.
+
+## Summary
+
+OpenClaw is a mature *infrastructure* project -- it solves the "connect to everything, route to Claude, let Claude figure it out" problem extremely well. Wall-E is a more ambitious *cognitive* project -- it's trying to actually *be* you, not just respond on your behalf. The gap is that Wall-E has the brain but not the muscles. It knows you deeply but doesn't act on that knowledge. The fix isn't to copy OpenClaw's architecture wholesale, but to give Wall-E's brain an *agency layer* -- the ability to decide, act, and iterate autonomously.

package/template/package.json

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

package/template/wall-e/agent.js

@@ -12,6 +12,14 @@ const { chat: walleChat } = require('./chat');
 const fs = require('fs');
 const path = require('path');
 
+// Prevent unhandled errors from silently killing the daemon
+process.on('uncaughtException', (err) => {
+  console.error('[wall-e] UNCAUGHT EXCEPTION (keeping alive):', err);
+});
+process.on('unhandledRejection', (reason) => {
+  console.error('[wall-e] UNHANDLED REJECTION (keeping alive):', reason);
+});
+
 const CONFIG_PATH = path.join(__dirname, 'wall-e-config.json');
 const MIN_INTERVAL_MS = 10000; // 10 seconds minimum
 const MAX_INTERVAL_MS = 3600000; // 1 hour maximum
@@ -21,6 +29,7 @@ let ingestRunning = false;
 let thinkRunning = false;
 let reflectRunning = false;
 let skillsRunning = false;
+let initiativeRunning = false;
 let shuttingDown = false;
 
 function loadOrCreateConfig() {
@@ -284,7 +293,54 @@ async function main() {
     }
   }, taskMs);
 
-  console.log(`[wall-e] Daemon running. Ingest every ${ingestMs / 1000}s, Think every ${thinkMs / 1000}s, Reflect every ${reflectMs / 1000}s, Skills every ${skillMs / 1000}s, Tasks every ${taskMs / 1000}s.`);
+  // Initiative loop — autonomous reasoning
+  const initiativeMs = clampInterval(config.intervals?.initiative_ms, 300000); // 5min default
+  const initiativeLoop = setInterval(async () => {
+    if (initiativeRunning || shuttingDown) return;
+    initiativeRunning = true;
+    try {
+      const { runInitiativeLoop } = require('./loops/initiative');
+      const result = await runInitiativeLoop();
+      if (result.decision !== 'noop' && result.decision !== 'observed') {
+        console.log(`[wall-e] Initiative: ${result.decision} — ${result.reasoning?.slice(0, 100)}`);
+      }
+    } catch (err) {
+      console.error('[wall-e] Initiative error:', err.message);
+    } finally {
+      initiativeRunning = false;
+    }
+  }, initiativeMs);
+
+  // Event-driven initiative wake — respond to important events immediately
+  const eventBus = require('./events/event-bus');
+  let lastInitiativeWake = 0;
+  const INITIATIVE_DEBOUNCE_MS = 30000; // Don't wake more than once per 30s
+
+  function wakeInitiative(reason) {
+    const now = Date.now();
+    if (now - lastInitiativeWake < INITIATIVE_DEBOUNCE_MS) return;
+    if (initiativeRunning || shuttingDown) return;
+    lastInitiativeWake = now;
+
+    console.log(`[wall-e] Initiative wake: ${reason}`);
+    initiativeRunning = true;
+    const { runInitiativeLoop } = require('./loops/initiative');
+    runInitiativeLoop({ trigger: reason }).then(result => {
+      if (result.decision !== 'noop' && result.decision !== 'observed') {
+        console.log(`[wall-e] Initiative (event): ${result.decision} — ${result.reasoning?.slice(0, 100)}`);
+      }
+    }).catch(err => {
+      console.error('[wall-e] Initiative wake error:', err.message);
+    }).finally(() => {
+      initiativeRunning = false;
+    });
+  }
+
+  eventBus.on('message', (evt) => wakeInitiative(`message from ${evt.channel}`));
+  eventBus.on('high_importance', (evt) => wakeInitiative('high importance memory'));
+  eventBus.on('webhook', (evt) => wakeInitiative(`webhook from ${evt.source}`));
+
+  console.log(`[wall-e] Daemon running. Ingest every ${ingestMs / 1000}s, Think every ${thinkMs / 1000}s, Reflect every ${reflectMs / 1000}s, Skills every ${skillMs / 1000}s, Tasks every ${taskMs / 1000}s, Initiative every ${initiativeMs / 1000}s.`);
   console.log('[wall-e] Press Ctrl+C to stop.');
 
   // Graceful shutdown — wait for in-flight operations
@@ -297,6 +353,10 @@ async function main() {
     clearInterval(reflectLoop);
     clearInterval(skillsLoop);
     clearInterval(tasksLoop);
+    clearInterval(initiativeLoop);
+
+    // Remove event listeners
+    eventBus.removeAllListeners();
 
     // Stop all channels
     for (const ch of channels) {
@@ -305,10 +365,10 @@ async function main() {
 
     // Wait up to 5s for in-flight operations
     const deadline = Date.now() + 5000;
-    while ((ingestRunning || thinkRunning || reflectRunning || skillsRunning || tasksRunning) && Date.now() < deadline) {
+    while ((ingestRunning || thinkRunning || reflectRunning || skillsRunning || tasksRunning || initiativeRunning) && Date.now() < deadline) {
       await new Promise(r => setTimeout(r, 100));
     }
-    if (ingestRunning || thinkRunning || reflectRunning || skillsRunning) {
+    if (ingestRunning || thinkRunning || reflectRunning || skillsRunning || tasksRunning || initiativeRunning) {
       console.warn('[wall-e] Force closing with operations still in-flight');
     }