create-walle 0.9.3 → 0.9.4

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

@@ -647,6 +647,9 @@ function handleApi(req, res, url) {
   if (url.pathname === '/api/sessions/rename' && req.method === 'POST') {
     return apiRenameSession(req, res);
   }
+  if (url.pathname === '/api/sessions/attach' && req.method === 'POST') {
+    return apiAttachSession(req, res);
+  }
   // --- Service control endpoints ---
   if (url.pathname === '/api/services/status' && req.method === 'GET') {
     return apiServicesStatus(req, res);
@@ -1451,6 +1454,9 @@ function apiRenameSession(req, res) {
       const trimmed = title.trim().slice(0, 120);
       dbModule.setSessionTitle(sessionId, trimmed, true);
 
+      // Update startup_tasks so the label survives CTM restart
+      try { dbModule.updateStartupTaskLabel(sessionId, trimmed); } catch {}
+
       // Update in-memory session if active
       const session = sessions.get(sessionId);
       if (session) {
@@ -1954,21 +1960,29 @@ class VTermScreen {
 }
 
 function checkAutoApproval(sessionId, session, data) {
-  // Accumulate output using virtual terminal screen
+  // Accumulate output — defer expensive VTermScreen.feed() until we actually check
   let buf = autoApprovalBuffers.get(sessionId);
   if (!buf) {
-    buf = { vterm: new VTermScreen(), lastCheck: 0, cooldown: 0, reviewing: false };
+    buf = { vterm: new VTermScreen(), lastCheck: 0, cooldown: 0, reviewing: false, pending: '' };
     autoApprovalBuffers.set(sessionId, buf);
   }
-  buf.vterm.feed(data);
+  buf.pending += data;
+  // Cap pending buffer to avoid unbounded growth
+  if (buf.pending.length > 32768) buf.pending = buf.pending.slice(-16384);
 
-  // Throttle checks
+  // Throttle checks — only do heavy VTermScreen processing every 500ms
   const now = Date.now();
   if (now - buf.lastCheck < 500) return;
   if (now < buf.cooldown) return;
   if (buf.reviewing) return; // AI review in progress
   buf.lastCheck = now;
 
+  // Feed accumulated data to VTermScreen in one batch (much cheaper than per-chunk)
+  if (buf.pending) {
+    buf.vterm.feed(buf.pending);
+    buf.pending = '';
+  }
+
   // Read the virtual screen as text
   const clean = buf.vterm.getText();
 
@@ -1997,6 +2011,7 @@ function checkAutoApproval(sessionId, session, data) {
       console.log(`[shadow-approver] handleApprovalCheck result: handled=${handled}`);
       if (handled) {
         buf.vterm = new VTermScreen();
+        buf.pending = '';
         buf.cooldown = Date.now() + 3000;
       }
     })
@@ -2152,6 +2167,13 @@ function handleCreate(ws, msg) {
     }
   }
 
+  // If a user-renamed title exists in the DB (e.g. from a previous session that was
+  // renamed before CTM restart), prefer it over the stale startup_tasks label
+  const existingTitle = dbModule.getSessionTitle(id);
+  if (existingTitle && existingTitle.userRenamed && existingTitle.title) {
+    label = existingTitle.title;
+  }
+
   let ptyProcess;
   try {
     ptyProcess = pty.spawn(cmd, args, {
@@ -2182,19 +2204,40 @@ function handleCreate(ws, msg) {
   // 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.
-    // Do NOT strip \e[2J or \e[?1049h/l — those are needed for Claude Code's TUI rendering.
-    const cleanData = data.replace(/\x1b\[3J/g, '');
+  // Output batching — coalesce rapid PTY chunks into fewer WS messages.
+  // During Claude Code streaming, PTY fires 100s of chunks/sec. Sending each
+  // as a separate WS message causes client-side JSON parse + dispatch overhead
+  // that creates input lag. Batching at ~16ms (one animation frame) reduces
+  // message count 10-50x with imperceptible latency increase.
+  let outputBuf = '';
+  let outputFlushTimer = null;
+
+  function flushOutput() {
+    outputFlushTimer = null;
+    if (!outputBuf) return;
+    const batch = outputBuf;
+    outputBuf = '';
     // Keep scrollback (limit to ~50KB)
-    session.scrollback.push(cleanData);
+    session.scrollback.push(batch);
     if (session.scrollback.length > 500) session.scrollback.shift();
 
-    const payload = JSON.stringify({ type: 'output', id, data: cleanData });
+    const payload = JSON.stringify({ type: 'output', id, data: batch });
     for (const client of session.clients) {
       if (client.readyState === 1) client.send(payload);
     }
+  }
+
+  ptyProcess.onData((data) => {
+    session.lastActivity = Date.now();
+    // Only strip \e[3J (Erase Scrollback) — it destroys scroll history on replay.
+    // Do NOT strip \e[2J or \e[?1049h/l — those are needed for Claude Code's TUI rendering.
+    const cleanData = data.indexOf('\x1b[3J') >= 0 ? data.replace(/\x1b\[3J/g, '') : data;
+
+    // Batch output for WS delivery
+    outputBuf += cleanData;
+    if (!outputFlushTimer) {
+      outputFlushTimer = setTimeout(flushOutput, 16);
+    }
 
     // Feed output to queue engine for completion detection
     queueEngine.feedOutput(id, data);
@@ -2207,6 +2250,8 @@ function handleCreate(ws, msg) {
   });
 
   ptyProcess.onExit(({ exitCode, signal }) => {
+    // Flush any remaining buffered output before sending exit
+    if (outputFlushTimer) { clearTimeout(outputFlushTimer); flushOutput(); }
     const payload = JSON.stringify({ type: 'exit', id, exitCode, signal });
     for (const client of session.clients) {
       if (client.readyState === 1) client.send(payload);
@@ -2222,15 +2267,142 @@ function handleCreate(ws, msg) {
   // Wire up queue engine hooks if a queue exists for this session
   setupQueueForSession(id);
 
-  // If the client provided an explicit label (e.g. prompt title), persist it
-  if (msg.label) {
-    dbModule.setSessionTitle(id, label, false);
+  // Persist label to session_titles if the client provided one explicitly.
+  // Skip if the DB already has a user-renamed title (avoids overwriting renames on restart)
+  if (msg.label && !(existingTitle && existingTitle.userRenamed)) {
+    dbModule.setSessionTitle(id, label, true);
   }
 
   if (ws) ws.send(JSON.stringify({ type: 'created', id, pid: ptyProcess.pid, label, cwd }));
   broadcastSessionList();
 }
 
+function apiAttachSession(req, res) {
+  let body = '';
+  req.on('data', chunk => { body += chunk; if (body.length > 1e6) req.destroy(); });
+  req.on('end', () => {
+    try {
+      const { session_id, cwd: rawCwd } = JSON.parse(body);
+      if (!session_id) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'session_id required' }));
+        return;
+      }
+
+      const tabId = crypto.randomUUID();
+      const cwdDir = (rawCwd || process.env.HOME).replace(/^~/, process.env.HOME);
+      const env = { ...process.env };
+      delete env.CLAUDECODE;
+
+      // Restore .jsonl from .bak if needed (Claude Code migrates sessions to directory format)
+      const claudeProjectsDir = path.join(process.env.HOME, '.claude', 'projects');
+      try {
+        for (const entry of fs.readdirSync(claudeProjectsDir)) {
+          const jsonl = path.join(claudeProjectsDir, entry, `${session_id}.jsonl`);
+          const bak = jsonl + '.bak';
+          if (!fs.existsSync(jsonl) && fs.existsSync(bak)) {
+            fs.copyFileSync(bak, jsonl);
+            break;
+          }
+        }
+      } catch { /* ignore — best effort */ }
+
+      let ptyProcess;
+      try {
+        ptyProcess = pty.spawn('claude', ['--resume', session_id], {
+          name: 'xterm-256color',
+          cols: 120, rows: 30,
+          cwd: cwdDir,
+          env,
+        });
+      } catch (e) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Failed to spawn: ' + e.message }));
+        return;
+      }
+
+      const label = 'Attached: ' + session_id.slice(0, 8) + '...';
+      const session = {
+        id: tabId,
+        label,
+        cmd: 'claude',
+        args: ['--resume', session_id],
+        cwd: cwdDir,
+        pid: ptyProcess.pid,
+        ptyProcess,
+        clients: [],
+        scrollback: [],
+        createdAt: Date.now(),
+        lastActivity: Date.now(),
+      };
+
+      sessions.set(tabId, session);
+
+      // Persist to startup_tasks for crash-safe restore
+      try { dbModule.addStartupTask(tabId, label, 'claude', ['--resume', session_id], cwdDir); } catch {}
+
+      // Output batching (same as main session path)
+      let outputBuf2 = '';
+      let outputFlushTimer2 = null;
+      function flushOutput2() {
+        outputFlushTimer2 = null;
+        if (!outputBuf2) return;
+        const batch = outputBuf2;
+        outputBuf2 = '';
+        session.scrollback.push(batch);
+        if (session.scrollback.length > 500) session.scrollback.shift();
+        const payload = JSON.stringify({ type: 'output', id: tabId, data: batch });
+        for (const client of session.clients) {
+          if (client.readyState === 1) client.send(payload);
+        }
+      }
+
+      ptyProcess.onData((data) => {
+        session.lastActivity = Date.now();
+        const cleanData = data.indexOf('\x1b[3J') >= 0 ? data.replace(/\x1b\[3J/g, '') : data;
+        outputBuf2 += cleanData;
+        if (!outputFlushTimer2) {
+          outputFlushTimer2 = setTimeout(flushOutput2, 16);
+        }
+
+        // Feed output to queue engine for completion detection
+        queueEngine.feedOutput(tabId, data);
+
+        // Feed output to auto-approval engine
+        checkAutoApproval(tabId, session, data);
+
+        // Feed output to idle/waiting-for-input detection
+        checkIdleNotify(tabId, session, data);
+      });
+
+      ptyProcess.onExit(({ exitCode, signal }) => {
+        if (outputFlushTimer2) { clearTimeout(outputFlushTimer2); flushOutput2(); }
+        const payload = JSON.stringify({ type: 'exit', id: tabId, exitCode, signal });
+        for (const client of session.clients) {
+          if (client.readyState === 1) client.send(payload);
+        }
+        sessions.delete(tabId);
+        try { dbModule.removeStartupTask(tabId); } catch {}
+        queueEngine.onSessionExit(tabId);
+        cleanAutoApprovalBuffer(tabId);
+        cleanIdleNotify(tabId);
+        broadcastSessionList();
+      });
+
+      // Wire up queue engine hooks if a queue exists for this session
+      setupQueueForSession(tabId);
+
+      broadcastSessionList();
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, tab_id: tabId, session_id }));
+    } catch (e) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+  });
+}
+
 function handleAttach(ws, msg) {
   const session = sessions.get(msg.id);
   if (!session) {
@@ -2291,6 +2463,9 @@ function handleRename(ws, msg) {
   // Persist to DB with user_renamed flag
   dbModule.setSessionTitle(id, trimmed, true);
 
+  // Update startup_tasks so the label survives CTM restart
+  try { dbModule.updateStartupTaskLabel(id, trimmed); } catch {}
+
   ws.send(JSON.stringify({ type: 'renamed', id, label: trimmed }));
   broadcastSessionList();
 }

package/template/docs/site/api/README.md

@@ -97,6 +97,152 @@ Brain statistics — memory counts by source, knowledge counts, people count.
 
 ---
 
+## Wall-E Skills
+
+### GET /api/wall-e/skills
+
+List all skills. DB skills are merged with filesystem metadata (tags, source, config schema, requires, version, execution type, author, permissions, directory path).
+
+**Query params:**
+- `enabled` — `1` or `0` to filter by enabled status
+
+### POST /api/wall-e/skills
+
+Create a skill in the database (without filesystem SKILL.md).
+
+**Body:**
+```json
+{
+  "name": "my-skill",
+  "description": "What it does",
+  "trigger_type": "manual",
+  "prompt_template": "Instructions..."
+}
+```
+
+### PUT /api/wall-e/skills/:id
+
+Update a skill's fields (name, description, trigger_type, trigger_config, prompt_template, enabled, config_values).
+
+### DELETE /api/wall-e/skills/:id
+
+Delete a skill and its execution history. For user-created skills, also deletes the `~/.wall-e/skills/<name>/` directory. Bundled skills cannot be deleted (disable them instead).
+
+### POST /api/wall-e/skills/:id/run
+
+Run a skill. Tries DB skill first, then falls back to filesystem skill by name.
+
+**Response:**
+```json
+{ "data": { "success": true, "memoriesCreated": 3, "toolCalls": 2, "duration": 4500 } }
+```
+
+### GET /api/wall-e/skills/:id/executions
+
+List execution history for a skill.
+
+**Query params:**
+- `limit` (default: 20)
+
+### PUT /api/wall-e/skills/:id/config
+
+Save user config overrides for a skill. Body is a JSON object of key-value pairs matching the SKILL.md config schema.
+
+### GET /api/wall-e/skills/:id/source
+
+Read the raw SKILL.md content for a skill.
+
+**Response:**
+```json
+{ "data": { "content": "---\nname: ...", "path": "/abs/path/SKILL.md", "source": "bundled" } }
+```
+
+### PUT /api/wall-e/skills/:id/source
+
+Rewrite the SKILL.md file for a user-created skill. Bundled skills return 403.
+
+**Body:**
+```json
+{ "content": "---\nname: my-skill\n..." }
+```
+
+### POST /api/wall-e/skills/create-file
+
+Create a new skill directory + SKILL.md file in `~/.wall-e/skills/` and register it in the database.
+
+**Body:**
+```json
+{
+  "name": "my-new-skill",
+  "description": "Description",
+  "execution": "agent",
+  "trigger_type": "manual",
+  "tags": ["data", "sync"],
+  "instructions": "# My Skill\n\nDo the thing."
+}
+```
+
+Or provide raw SKILL.md content:
+```json
+{ "name": "my-skill", "content": "---\nname: my-skill\n---\n# Instructions" }
+```
+
+### GET /api/wall-e/skills/:id/export
+
+Export a skill as a JSON bundle containing the SKILL.md and all associated files.
+
+**Response:**
+```json
+{
+  "data": {
+    "name": "my-skill",
+    "skill_md": "---\nname: ...",
+    "files": { "run.js": "const brain = ..." }
+  }
+}
+```
+
+### POST /api/wall-e/skills/import
+
+Import a skill from a JSON bundle. Creates the skill directory in `~/.wall-e/skills/` and registers in DB.
+
+**Body:** Same format as export response's `data` field.
+
+### POST /api/wall-e/skills/:id/validate
+
+Run pre-flight validation on a skill's `requires` field.
+
+**Response:**
+```json
+{
+  "data": {
+    "valid": false,
+    "missing": [
+      { "type": "bin", "name": "npx", "suggestion": "Install npx or add it to PATH" },
+      { "type": "env", "name": "SLACK_TOKEN", "suggestion": "Set SLACK_TOKEN in .env or environment" }
+    ]
+  }
+}
+```
+
+### GET /api/wall-e/skills/templates
+
+List available starter skill templates.
+
+### GET /api/wall-e/skills/installed
+
+List filesystem-based skills (all sources: bundled, user, workspace, registry).
+
+### GET /api/wall-e/skills/search?q=...
+
+Search skills by name, description, and tags.
+
+### GET /api/wall-e/skills/suggestions
+
+Discover skills from Claude Code's MCP servers and installed skills.
+
+---
+
 ## Sessions
 
 ### GET /api/sessions

package/template/docs/site/skills/README.md

@@ -66,11 +66,76 @@ Full-text search across all memories using SQLite FTS5. Available as a tool in W
 
 ---
 
+## Skill Management GUI
+
+The Skills tab in the Wall-E dashboard provides a full management interface:
+
+### Analytics Bar
+A summary row at the top showing total skills (by source), enabled count, skills run in the last 24 hours, overall success rate, and a count of currently failing skills (clickable to filter).
+
+### Search, Filter & Sort
+- **Search** — real-time filter on name, description, and tags
+- **Category pills** — derived from skill `tags[]` (e.g. sync, data, coding, communication)
+- **Status filter** — All / Enabled / Disabled / Failing
+- **Sort** — Name, Last Run, Success Rate, Run Count
+
+### Skill Cards
+Each skill is displayed as a card with:
+- Left color stripe: green (healthy + enabled), amber (enabled + failing), gray (disabled)
+- Name, version badge, source badge (bundled/user/workspace), execution type badge (agent/script)
+- Tag pills, 2-line description, stats row (success rate bar, run count, last run, result dot)
+- Run button, toggle switch, overflow menu (View Details, Edit, Export, Delete)
+
+### Detail Panel
+Click any card to open a right-side slide-over with five tabs:
+
+| Tab | Contents |
+|-----|----------|
+| **Overview** | Full description, metadata grid (version, author, source, execution, trigger, path), tags, permissions, pre-flight requirements validation, statistics |
+| **Config** | Auto-generated form from SKILL.md config schema — text inputs, number inputs, toggles, selects — with save button |
+| **History** | Execution log table: timestamp, status, duration, memories created, error |
+| **Source** | Read-only SKILL.md content, monospace formatted |
+| **Logs** | Last execution's tool_calls and tool_results, plus error stack if applicable |
+
+### Pre-Flight Validation
+Skills with a `requires` field are validated before execution:
+- `bins: [node, npx]` — checks binary availability via `which`
+- `env: [SLACK_TOKEN]` — checks environment variables
+- `mcp: [slack]` — checks MCP server configuration
+
+The Overview tab shows a live validation result with actionable suggestions for any missing requirements.
+
+---
+
 ## Creating Custom Skills
 
-Skills are defined as `SKILL.md` files with YAML frontmatter. Place them in `wall-e/skills/_bundled/your-skill/`.
+### From the UI
+
+Click **"+ New Skill"** in the Skills tab toolbar. You can:
+
+1. **Pick a template** — Data Fetcher, Script Runner, Periodic Checker, or Manual Action
+2. **Fill in the form** — name, description, execution type, trigger, tags, instructions
+3. **Toggle to Raw mode** — edit the full SKILL.md directly
 
-### Minimal Example
+Skills are saved to `~/.wall-e/skills/<name>/SKILL.md` and auto-registered in the database.
+
+### From the Filesystem
+
+Create a directory with a `SKILL.md` file:
+
+```
+~/.wall-e/skills/my-skill/
+  SKILL.md
+  run.js        # (optional, for script skills)
+```
+
+Wall-E auto-discovers skills from these directories (highest precedence first):
+1. **Workspace** — `.wall-e/skills/` in the current project
+2. **User** — `~/.wall-e/skills/`
+3. **Bundled** — `wall-e/skills/_bundled/`
+4. **Registry** — `~/.wall-e/registry-skills/`
+
+### SKILL.md Format
 
 ```yaml
 ---
@@ -81,14 +146,24 @@ execution: script
 entry: run.js
 trigger:
   type: interval
-  schedule: "every 1h"
-tags: [custom]
+  interval_ms: 3600000
+tags: [custom, sync]
+requires:
+  bins: [node]
+  env: [MY_API_KEY]
+config:
+  target:
+    type: string
+    description: "URL to fetch"
+  verbose:
+    type: boolean
+    default: false
 permissions:
   - brain:write
 ---
 # My Skill
 
-Additional documentation here.
+Additional documentation and agent instructions here.
 ```
 
 ### Execution Modes
@@ -97,6 +172,19 @@ Additional documentation here.
 
 **Agent mode** (`execution: agent`): LLM-driven. The markdown body of SKILL.md becomes the agent's prompt. Use for summarization, synthesis, and tasks requiring judgment.
 
+### Config Schema
+
+Define typed config fields in SKILL.md frontmatter:
+
+| Type | UI Element |
+|------|-----------|
+| `string` | Text input |
+| `string` + `enum` | Select dropdown |
+| `boolean` | Toggle switch |
+| `number` | Number input |
+
+Users configure values in the Config tab of the detail panel. Saved values are stored per-skill in the database and merged with SKILL.md defaults at execution time.
+
 ### Script Pattern
 
 ```javascript
@@ -127,9 +215,15 @@ console.log(JSON.stringify({ inserted: 1 }));
 brain.closeDb();
 ```
 
+### Export / Import
+
+- **Export**: From the overflow menu on any card, or from the detail panel. Downloads a JSON bundle containing the SKILL.md and all associated files.
+- **Import**: Click "Import" in the toolbar, select a `.json` bundle file. The skill is created in `~/.wall-e/skills/` and auto-registered.
+
 ### Key Conventions
 
 - **Deduplication**: Always use `source` + `source_id` for dedup. Check existing before inserting.
 - **Exit codes**: 0 = success, 1 = failure, 2 = partial success (checkpoint saved)
 - **Checkpoints**: Emit `CHECKPOINT:value` lines to stdout for resumable tasks
 - **Config**: Passed via `WALL_E_SKILL_CONFIG` env var (JSON string)
+- **Deletion**: User-created skills can be deleted from the UI (removes directory + DB entry). Bundled skills can only be disabled.

package/template/package.json

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

package/template/wall-e/agent.js

@@ -3,11 +3,13 @@ const ingest = require('./loops/ingest');
 const think = require('./loops/think');
 const reflect = require('./loops/reflect');
 const { runDueSkills } = require('./skills/skill-planner');
+const { loadAllSkills } = require('./skills/skill-loader');
 const { runDueTasks, recoverInterruptedTasks } = require('./loops/tasks');
 const CtmAdapter = require('./adapters/ctm');
 const SlackAdapter = require('./adapters/slack');
 const IMessageChannel = require('./channels/imessage-channel');
 const SlackChannel = require('./channels/slack-channel');
+const TelegramChannel = require('./channels/telegram-channel');
 const { chat: walleChat } = require('./chat');
 const fs = require('fs');
 const path = require('path');
@@ -62,6 +64,7 @@ function loadOrCreateConfig() {
     channels: {
       imessage: { enabled: false, buddy_id: '' },
       slack_dm: { enabled: false, bot_token: '' },
+      telegram: { enabled: false, bot_token: '', owner_chat_id: null },
     },
   };
   fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
@@ -106,6 +109,43 @@ function bootstrapSkills() {
   console.log('[wall-e] Bootstrapped initial skills');
 }
 
+/**
+ * Ensure all bundled filesystem skills are registered in the DB.
+ * bootstrapSkills() only runs on first boot (empty DB), so new bundled skills
+ * added later never get registered. This syncs any missing ones on every startup.
+ */
+function syncBundledSkills() {
+  const filesystemSkills = loadAllSkills();
+  const dbSkills = brain.listSkills({});
+  const dbNames = new Set(dbSkills.map(s => s.name));
+
+  let added = 0;
+  for (const skill of filesystemSkills) {
+    if (dbNames.has(skill.name)) continue;
+
+    const triggerType = (skill.trigger && skill.trigger.type) || skill.execution || 'manual';
+    const triggerConfig = skill.trigger && skill.trigger.interval_ms
+      ? JSON.stringify({ interval_ms: skill.trigger.interval_ms })
+      : null;
+
+    brain.insertSkill({
+      name: skill.name,
+      description: skill.description || '',
+      trigger_type: triggerType,
+      trigger_config: triggerConfig,
+      prompt_template: skill.execution === 'script'
+        ? `INTERNAL_SKILL:${skill.name}`
+        : skill.instructions || '',
+    });
+    added++;
+    console.log(`[wall-e] Registered bundled skill: ${skill.name}`);
+  }
+
+  if (added > 0) {
+    console.log(`[wall-e] Synced ${added} new bundled skill(s) to DB`);
+  }
+}
+
 function bootstrapTasks() {
   const existing = brain.listTasks({ limit: 1 });
   if (existing.length > 0) return;
@@ -128,6 +168,7 @@ async function main() {
   brain.initDb();
   brain.startDailyBackup();
   bootstrapSkills();
+  syncBundledSkills();
   bootstrapTasks();
 
   // Set owner from config
@@ -179,6 +220,19 @@ async function main() {
     console.log('[wall-e] Slack DM channel enabled');
   }
 
+  if (config.channels?.telegram?.enabled && config.channels?.telegram?.bot_token) {
+    const tg = new TelegramChannel({
+      botToken: config.channels.telegram.bot_token,
+      ownerChatId: config.channels.telegram.owner_chat_id,
+      onMessage: async (text, sender) => {
+        const result = await walleChat(text, { channel: 'telegram' });
+        return result.reply;
+      },
+    });
+    channels.push(tg);
+    console.log('[wall-e] Telegram channel enabled');
+  }
+
   // Start all channels
   for (const ch of channels) {
     ch.start().catch(err => console.error(`[wall-e] Channel ${ch.name} start failed:`, err.message));