create-walle 0.9.3 → 0.9.4

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

@@ -5,6 +5,34 @@ const path = require('path');
 const DATA_DIR = process.env.WALL_E_DATA_DIR || path.join(process.env.HOME, '.walle', 'data');
 const BRAIN_DB_PATH = path.join(DATA_DIR, 'wall-e-brain.db');
 
+// Build a SKILL.md from structured form data
+function buildSkillMd(body) {
+  const lines = ['---'];
+  lines.push(`name: ${body.name}`);
+  if (body.description) lines.push(`description: ${body.description}`);
+  if (body.version) lines.push(`version: ${body.version}`);
+  if (body.author) lines.push(`author: ${body.author}`);
+  lines.push(`execution: ${body.execution || 'agent'}`);
+  if (body.entry) lines.push(`entry: ${body.entry}`);
+  lines.push('trigger:');
+  lines.push(`  type: ${body.trigger_type || 'manual'}`);
+  if (body.interval_ms) lines.push(`  interval_ms: ${body.interval_ms}`);
+  if (body.tags && body.tags.length) lines.push(`tags: [${body.tags.join(', ')}]`);
+  if (body.config_schema) {
+    lines.push('config:');
+    for (const [k, v] of Object.entries(body.config_schema)) {
+      lines.push(`  ${k}:`);
+      if (v.type) lines.push(`    type: ${v.type}`);
+      if (v.description) lines.push(`    description: "${v.description}"`);
+      if (v.default !== undefined) lines.push(`    default: ${v.default}`);
+    }
+  }
+  lines.push('---');
+  lines.push('');
+  lines.push(body.instructions || `# ${body.name}\n\nDescribe what this skill does.`);
+  return lines.join('\n');
+}
+
 let readDb = null;
 
 function getReadDb() {
@@ -561,6 +589,61 @@ function handleWalleApi(req, res, url) {
     return true;
   }
 
+  // POST /api/wall-e/chat/clear — clear all messages in a session (for branch switching)
+  if (p === '/api/wall-e/chat/clear' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        brain.clearChatSession(body.session_id || 'default');
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // POST /api/wall-e/chat/insert — insert a single chat message (for branch sync)
+  if (p === '/api/wall-e/chat/insert' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        brain.insertChatMessage({
+          role: body.role,
+          content: body.content,
+          session_id: body.session_id || 'default',
+          channel: body.channel || 'ctm',
+        });
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // GET /api/wall-e/chat/branches — load branch data for a session
+  if (p === '/api/wall-e/chat/branches' && m === 'GET') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    const sid = url.searchParams.get('session_id') || 'default';
+    try {
+      jsonResponse(res, { data: brain.loadChatBranches(sid) });
+    } catch (e) { jsonResponse(res, { error: e.message }, 500); }
+    return true;
+  }
+
+  // POST /api/wall-e/chat/branches — save branch data for a session
+  if (p === '/api/wall-e/chat/branches' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        brain.saveChatBranches(body.session_id || 'default', body.branches || {}, body.active || {}, body.history || []);
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) { jsonResponse(res, { error: e.message }, 500); }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
   // GET /api/wall-e/backups — list brain backups
   if (p === '/api/wall-e/backups' && m === 'GET') {
     if (!brain) return jsonResponse(res, { error: 'Brain not available' }, 503), true;
@@ -958,11 +1041,54 @@ function handleWalleApi(req, res, url) {
 
   // GET /api/wall-e/skills
   if (p === '/api/wall-e/skills' && m === 'GET') {
-    if (!brain) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
     try {
       const enabled = params.get('enabled');
       const filter = enabled !== null ? { enabled: parseInt(enabled) } : {};
-      const data = brain.listSkills(filter);
+
+      // Auto-register any filesystem skills not yet in the DB
+      try {
+        const { loadAllSkills, reloadSkills } = require('./skills/skill-loader');
+        reloadSkills(); // clear cache so new dirs are picked up
+        const fsSkills = loadAllSkills();
+        const dbSkills = brain.listSkills({});
+        const dbNames = new Set(dbSkills.map(s => s.name));
+        for (const skill of fsSkills) {
+          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 || '',
+          });
+        }
+      } catch (syncErr) {
+        console.warn('[api-walle] Skill sync error:', syncErr.message);
+      }
+
+      const dbSkills = brain.listSkills(filter);
+      // Merge filesystem metadata (tags, source, config, requires, version, execution) into DB skills
+      const { findSkill } = require('./skills/skill-loader');
+      const data = dbSkills.map(s => {
+        const fs = findSkill(s.name);
+        if (!fs) return s;
+        return Object.assign({}, s, {
+          tags: fs.tags || [],
+          source: fs.source || 'bundled',
+          config_schema: fs.config || {},
+          requires: fs.requires || {},
+          version: fs.version || '0.0.0',
+          execution: fs.execution || 'agent',
+          author: fs.author || null,
+          permissions: fs.permissions || [],
+          skill_dir: fs.dir || null,
+        });
+      });
       jsonResponse(res, { data });
     } catch (e) {
       jsonResponse(res, { error: e.message }, 500);
@@ -1088,7 +1214,7 @@ function handleWalleApi(req, res, url) {
   // GET /api/wall-e/skills/:id/executions
   const skillExecMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)\/executions$/);
   if (skillExecMatch && m === 'GET') {
-    if (!brain) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
     try {
       const limit = parseLimit(params, 20);
       const data = brain.listSkillExecutions({ skill_id: skillExecMatch[1], limit });
@@ -1146,6 +1272,250 @@ function handleWalleApi(req, res, url) {
     return true;
   }
 
+  // DELETE /api/wall-e/skills/:id
+  const skillDeleteMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)$/);
+  if (skillDeleteMatch && m === 'DELETE') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const skill = brain.deleteSkill(skillDeleteMatch[1]);
+      // If user-created skill, also delete the directory
+      if (skill) {
+        const { findSkill } = require('./skills/skill-loader');
+        const fsSkill = findSkill(skill.name);
+        if (fsSkill && fsSkill.source === 'user' && fsSkill.dir) {
+          try {
+            const fs = require('fs');
+            fs.rmSync(fsSkill.dir, { recursive: true, force: true });
+          } catch (rmErr) {
+            console.warn('[api-walle] Could not delete skill dir:', rmErr.message);
+          }
+        }
+        const { reloadSkills } = require('./skills/skill-loader');
+        reloadSkills();
+      }
+      jsonResponse(res, { data: { ok: true, deleted: skill?.name } });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 400);
+    }
+    return true;
+  }
+
+  // PUT /api/wall-e/skills/:id/config — save user config overrides
+  const skillConfigMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)\/config$/);
+  if (skillConfigMatch && m === 'PUT') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        brain.updateSkill(skillConfigMatch[1], {
+          config_values: typeof body === 'string' ? body : JSON.stringify(body)
+        });
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // GET /api/wall-e/skills/:id/source — read raw SKILL.md content
+  const skillSourceReadMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)\/source$/);
+  if (skillSourceReadMatch && m === 'GET') {
+    try {
+      // Try by DB id first, then by name
+      let skillName = skillSourceReadMatch[1];
+      if (brain && ensureBrainInit()) {
+        const dbSkill = brain.getSkill(skillName);
+        if (dbSkill) skillName = dbSkill.name;
+      }
+      const { findSkill } = require('./skills/skill-loader');
+      const fsSkill = findSkill(skillName);
+      if (!fsSkill) return jsonResponse(res, { error: 'Skill not found' }, 404), true;
+      const fs = require('fs');
+      const content = fs.readFileSync(fsSkill.filePath, 'utf8');
+      jsonResponse(res, { data: { content, path: fsSkill.filePath, source: fsSkill.source } });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // PUT /api/wall-e/skills/:id/source — rewrite SKILL.md file
+  const skillSourceWriteMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)\/source$/);
+  if (skillSourceWriteMatch && m === 'PUT') {
+    readBody(req).then(body => {
+      try {
+        let skillName = skillSourceWriteMatch[1];
+        if (brain && ensureBrainInit()) {
+          const dbSkill = brain.getSkill(skillName);
+          if (dbSkill) skillName = dbSkill.name;
+        }
+        const { findSkill, reloadSkills } = require('./skills/skill-loader');
+        const fsSkill = findSkill(skillName);
+        if (!fsSkill) return jsonResponse(res, { error: 'Skill not found' }, 404);
+        if (fsSkill.source === 'bundled') return jsonResponse(res, { error: 'Cannot edit bundled skills' }, 403);
+        const fs = require('fs');
+        fs.writeFileSync(fsSkill.filePath, body.content, 'utf8');
+        reloadSkills();
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // POST /api/wall-e/skills/create-file — create new skill directory + SKILL.md
+  if (p === '/api/wall-e/skills/create-file' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        const fs = require('fs');
+        const path = require('path');
+        const { USER_DIR, reloadSkills, parseSkillMd } = require('./skills/skill-loader');
+        if (!body.name) return jsonResponse(res, { error: 'name is required' }, 400);
+        const slug = body.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+        const skillDir = path.join(USER_DIR, slug);
+        if (fs.existsSync(skillDir)) return jsonResponse(res, { error: 'Skill directory already exists' }, 409);
+        fs.mkdirSync(skillDir, { recursive: true });
+        const content = body.content || buildSkillMd(body);
+        fs.writeFileSync(path.join(skillDir, 'SKILL.md'), content, 'utf8');
+        reloadSkills();
+        // Auto-register in DB
+        const parsed = parseSkillMd(content);
+        const triggerType = (parsed?.meta?.trigger?.type) || body.trigger_type || 'manual';
+        const result = brain.insertSkill({
+          name: body.name,
+          description: body.description || parsed?.meta?.description || '',
+          trigger_type: triggerType,
+          prompt_template: parsed?.body || body.instructions || '',
+        });
+        jsonResponse(res, { data: { id: result.id, dir: skillDir } }, 201);
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // GET /api/wall-e/skills/:id/export — export skill as JSON bundle
+  const skillExportMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)\/export$/);
+  if (skillExportMatch && m === 'GET') {
+    try {
+      let skillName = skillExportMatch[1];
+      if (brain && ensureBrainInit()) {
+        const dbSkill = brain.getSkill(skillName);
+        if (dbSkill) skillName = dbSkill.name;
+      }
+      const { findSkill } = require('./skills/skill-loader');
+      const fsSkill = findSkill(skillName);
+      if (!fsSkill) return jsonResponse(res, { error: 'Skill not found' }, 404), true;
+      const fs = require('fs');
+      const path = require('path');
+      const bundle = { name: fsSkill.name, skill_md: fs.readFileSync(fsSkill.filePath, 'utf8'), files: {} };
+      // Include other files in the skill directory
+      const entries = fs.readdirSync(fsSkill.dir);
+      for (const entry of entries) {
+        if (entry === 'SKILL.md') continue;
+        const fp = path.join(fsSkill.dir, entry);
+        const stat = fs.statSync(fp);
+        if (stat.isFile() && stat.size < 512 * 1024) {
+          bundle.files[entry] = fs.readFileSync(fp, 'utf8');
+        }
+      }
+      jsonResponse(res, { data: bundle });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/skills/import — import skill from JSON bundle
+  if (p === '/api/wall-e/skills/import' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        const fs = require('fs');
+        const path = require('path');
+        const { USER_DIR, reloadSkills, parseSkillMd } = require('./skills/skill-loader');
+        if (!body.skill_md) return jsonResponse(res, { error: 'skill_md is required' }, 400);
+        const parsed = parseSkillMd(body.skill_md);
+        if (!parsed || !parsed.meta || !parsed.meta.name) return jsonResponse(res, { error: 'Invalid SKILL.md' }, 400);
+        const slug = parsed.meta.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+        const skillDir = path.join(USER_DIR, slug);
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, 'SKILL.md'), body.skill_md, 'utf8');
+        if (body.files) {
+          for (const [fname, fcontent] of Object.entries(body.files)) {
+            const safeName = path.basename(fname);
+            fs.writeFileSync(path.join(skillDir, safeName), fcontent, 'utf8');
+          }
+        }
+        reloadSkills();
+        const triggerType = (parsed.meta.trigger?.type) || 'manual';
+        const result = brain.insertSkill({
+          name: parsed.meta.name,
+          description: parsed.meta.description || '',
+          trigger_type: triggerType,
+          prompt_template: parsed.body || '',
+        });
+        jsonResponse(res, { data: { id: result.id, name: parsed.meta.name, dir: skillDir } }, 201);
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // GET /api/wall-e/skills/templates — list available starter templates
+  if (p === '/api/wall-e/skills/templates' && m === 'GET') {
+    try {
+      const fs = require('fs');
+      const tplDir = path.join(__dirname, 'skills', '_templates');
+      const templates = [];
+      if (fs.existsSync(tplDir)) {
+        for (const file of fs.readdirSync(tplDir)) {
+          if (!file.endsWith('.md')) continue;
+          const content = fs.readFileSync(path.join(tplDir, file), 'utf8');
+          const { parseSkillMd } = require('./skills/skill-loader');
+          const parsed = parseSkillMd(content);
+          templates.push({
+            id: file.replace('.md', ''),
+            name: parsed?.meta?.name || file.replace('.md', ''),
+            description: parsed?.meta?.description || '',
+            execution: parsed?.meta?.execution || 'agent',
+            trigger: parsed?.meta?.trigger?.type || 'manual',
+            content,
+          });
+        }
+      }
+      jsonResponse(res, { data: templates });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/skills/:id/validate — pre-flight validation
+  const skillValidateMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)\/validate$/);
+  if (skillValidateMatch && m === 'POST') {
+    try {
+      let skillName = skillValidateMatch[1];
+      if (brain && ensureBrainInit()) {
+        const dbSkill = brain.getSkill(skillName);
+        if (dbSkill) skillName = dbSkill.name;
+      }
+      const { findSkill } = require('./skills/skill-loader');
+      const fsSkill = findSkill(skillName);
+      if (!fsSkill) return jsonResponse(res, { error: 'Skill not found' }, 404), true;
+      const { validateSkillRequirements } = require('./skills/skill-validator');
+      const result = validateSkillRequirements(fsSkill);
+      jsonResponse(res, { data: result });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
   // --- Slack Ingest ---
 
   // GET /api/wall-e/slack-ingest/progress
@@ -1266,6 +1636,85 @@ function handleWalleApi(req, res, url) {
     return true;
   }
 
+  // POST /api/wall-e/coding — start a coding task
+  if (p === '/api/wall-e/coding' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        if (!body.request) {
+          jsonResponse(res, { error: 'request field is required' }, 400);
+          return;
+        }
+        const result = brain.insertTask({
+          title: (body.request || '').slice(0, 100),
+          description: `Coding request: ${body.request}`,
+          priority: body.priority || 'normal',
+          type: 'once',
+          execution: 'skill',
+          skill: 'coding-agent',
+          skill_config: JSON.stringify({
+            request: body.request,
+            cwd: body.cwd || process.cwd(),
+            options: body.options || { delivery: 'commit' },
+          }),
+          source: 'api',
+          source_ref: '',
+        });
+        jsonResponse(res, { ok: true, task_id: result.id });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 500));
+    return true;
+  }
+
+  // GET /api/wall-e/config — read wall-e-config.json
+  if (p === '/api/wall-e/config' && m === 'GET') {
+    try {
+      const fs = require('fs');
+      const cfgPath = require('path').join(__dirname, 'wall-e-config.json');
+      if (!fs.existsSync(cfgPath)) return jsonResponse(res, { data: {} }), true;
+      const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+      // Redact tokens — only send whether they're set (show last 4 chars if long enough)
+      const safe = JSON.parse(JSON.stringify(cfg));
+      const redact = (t) => t && t.length > 8 ? '••••' + t.slice(-4) : '••••';
+      if (safe.channels?.telegram?.bot_token) safe.channels.telegram.bot_token = redact(safe.channels.telegram.bot_token);
+      if (safe.channels?.slack_dm?.bot_token) safe.channels.slack_dm.bot_token = redact(safe.channels.slack_dm.bot_token);
+      return jsonResponse(res, { data: safe }), true;
+    } catch (e) {
+      return jsonResponse(res, { error: e.message }, 500), true;
+    }
+  }
+
+  // PUT /api/wall-e/config — update wall-e-config.json (partial merge)
+  if (p === '/api/wall-e/config' && m === 'PUT') {
+    return readBody(req).then(body => {
+      try {
+        const fs = require('fs');
+        const cfgPath = require('path').join(__dirname, 'wall-e-config.json');
+        let cfg = {};
+        if (fs.existsSync(cfgPath)) cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+        // Deep merge channels
+        if (body.channels) {
+          if (!cfg.channels) cfg.channels = {};
+          for (const [ch, val] of Object.entries(body.channels)) {
+            if (!cfg.channels[ch]) cfg.channels[ch] = {};
+            for (const [k, v] of Object.entries(val)) {
+              // Skip redacted token values (don't overwrite real token with masked one)
+              if (typeof v === 'string' && v.startsWith('••••')) continue;
+              cfg.channels[ch][k] = v;
+            }
+          }
+        }
+        fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+        jsonResponse(res, { ok: true, message: 'Config saved. Restart Wall-E for changes to take effect.' });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 500));
+    return true;
+  }
+
   // No matching route under /api/wall-e
   jsonResponse(res, { error: 'Not found' }, 404);
   return true;

package/template/wall-e/brain.js

@@ -86,6 +86,10 @@ function initDb(dbPath) {
     }
     try { newDb.prepare("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_tasks_source'").get() ||
       newDb.prepare("CREATE INDEX IF NOT EXISTS idx_tasks_source ON tasks(source)").run(); } catch (_) {}
+    // Migration: add config_values column to skills table
+    try { newDb.prepare("SELECT config_values FROM skills LIMIT 0").run(); } catch (_) {
+      newDb.prepare("ALTER TABLE skills ADD COLUMN config_values TEXT").run();
+    }
   } catch (err) {
     newDb.close();
     db = null;
@@ -317,6 +321,13 @@ function createTables() {
     CREATE INDEX IF NOT EXISTS idx_chat_messages_session ON chat_messages(session_id, created_at);
     CREATE INDEX IF NOT EXISTS idx_chat_messages_time ON chat_messages(created_at);
 
+    CREATE TABLE IF NOT EXISTS chat_branches (
+      session_id TEXT PRIMARY KEY,
+      branches TEXT NOT NULL DEFAULT '{}',
+      active TEXT NOT NULL DEFAULT '{}',
+      history TEXT NOT NULL DEFAULT '[]'
+    );
+
     CREATE TABLE IF NOT EXISTS skills (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL UNIQUE,
@@ -1048,6 +1059,28 @@ function clearChatSession(session_id) {
   getDb().prepare('DELETE FROM chat_messages WHERE session_id = ?').run(session_id);
 }
 
+// ── Chat Branches (ChatGPT-style edit/resend) ──
+
+function saveChatBranches(session_id, branches, active, history) {
+  getDb().prepare(`
+    INSERT INTO chat_branches (session_id, branches, active, history)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(session_id) DO UPDATE SET branches = excluded.branches, active = excluded.active, history = excluded.history
+  `).run(session_id, JSON.stringify(branches), JSON.stringify(active), JSON.stringify(history || []));
+}
+
+function loadChatBranches(session_id) {
+  const row = getDb().prepare('SELECT branches, active, history FROM chat_branches WHERE session_id = ?').get(session_id);
+  if (!row) return { branches: {}, active: {}, history: [] };
+  try {
+    return {
+      branches: JSON.parse(row.branches),
+      active: JSON.parse(row.active),
+      history: JSON.parse(row.history || '[]'),
+    };
+  } catch (e) { return { branches: {}, active: {}, history: [] }; }
+}
+
 // -- Skills CRUD --
 
 function insertSkill({ name, description, tool_definitions, trigger_type, trigger_config, prompt_template }) {
@@ -1081,7 +1114,7 @@ function listSkills({ enabled } = {}) {
   return getDb().prepare('SELECT * FROM skills ORDER BY name').all();
 }
 
-const SKILL_ALLOWED_FIELDS = ['name', 'description', 'tool_definitions', 'trigger_type', 'trigger_config', 'prompt_template', 'enabled'];
+const SKILL_ALLOWED_FIELDS = ['name', 'description', 'tool_definitions', 'trigger_type', 'trigger_config', 'prompt_template', 'enabled', 'config_values'];
 
 function updateSkill(id, updates) {
   if (!updates || typeof updates !== 'object') throw new Error('Updates must be an object');
@@ -1137,6 +1170,14 @@ function updateSkillStats(skillId, success) {
   if (result.changes === 0) throw new Error(`Skill not found: ${skillId}`);
 }
 
+function deleteSkill(id) {
+  const skill = getDb().prepare('SELECT * FROM skills WHERE id = ?').get(id);
+  if (!skill) throw new Error(`Skill not found: ${id}`);
+  getDb().prepare('DELETE FROM skill_executions WHERE skill_id = ?').run(id);
+  getDb().prepare('DELETE FROM skills WHERE id = ?').run(id);
+  return skill;
+}
+
 // ── Tasks ──
 
 function insertTask({ title, description, priority, type, execution, script, schedule, due_at, next_run_at, skill, skill_config, source, source_ref }) {
@@ -1412,6 +1453,8 @@ module.exports = {
   searchChatMessages,
   deleteChatMessages,
   clearChatSession,
+  saveChatBranches,
+  loadChatBranches,
   // Backup
   createBackup,
   listBackups,
@@ -1423,6 +1466,7 @@ module.exports = {
   getSkillByName,
   listSkills,
   updateSkill,
+  deleteSkill,
   insertSkillExecution,
   listSkillExecutions,
   updateSkillStats,

package/template/wall-e/channels/telegram-channel.js

@@ -0,0 +1,96 @@
+'use strict';
+const { Bot } = require('grammy');
+const ChannelBase = require('./channel-base');
+const eventBus = require('../events/event-bus');
+
+class TelegramChannel extends ChannelBase {
+  constructor(opts = {}) {
+    super('telegram');
+    this.botToken = opts.botToken || process.env.TELEGRAM_BOT_TOKEN || null;
+    this.ownerChatId = opts.ownerChatId ? Number(opts.ownerChatId) : null;
+    this._onMessage = opts.onMessage || null;
+    this._bot = null;
+  }
+
+  async start() {
+    if (!this.botToken) {
+      console.log('[telegram] No bot token configured, skipping');
+      return;
+    }
+
+    this._bot = new Bot(this.botToken);
+
+    // Setup helper — tells the user their chat ID for config
+    this._bot.command('whoami', (ctx) => {
+      ctx.reply(`Your chat ID: ${ctx.from.id}`);
+    });
+
+    // Text message handler
+    this._bot.on('message:text', async (ctx) => {
+      const senderId = ctx.from.id;
+      const text = ctx.message.text;
+
+      // Owner-only gate (both should be Numbers, but coerce for safety)
+      if (this.ownerChatId && Number(senderId) !== Number(this.ownerChatId)) {
+        await ctx.reply('This is a private assistant.');
+        return;
+      }
+
+      console.log(`[telegram] Message from ${senderId}: ${text.slice(0, 50)}...`);
+      eventBus.emitMessage('telegram', text, String(senderId));
+
+      if (this._onMessage) {
+        try {
+          const response = await this._onMessage(text, String(senderId));
+          if (response) {
+            // Telegram has a 4096 char limit per message — split if needed
+            const MAX_LEN = 4096;
+            if (response.length <= MAX_LEN) {
+              await ctx.reply(response);
+            } else {
+              for (let i = 0; i < response.length; i += MAX_LEN) {
+                await ctx.reply(response.slice(i, i + MAX_LEN));
+              }
+            }
+          }
+        } catch (err) {
+          console.error('[telegram] onMessage error:', err.message);
+          await ctx.reply('Sorry, something went wrong processing your message.');
+        }
+      }
+    });
+
+    // Error handler
+    this._bot.catch((err) => {
+      console.error('[telegram] Bot error:', err.message);
+    });
+
+    // Start long polling (non-blocking)
+    this._bot.start({
+      onStart: () => {
+        this.running = true;
+        console.log('[telegram] Bot started (long polling)');
+      },
+    });
+  }
+
+  async stop() {
+    this.running = false;
+    if (this._bot) {
+      await this._bot.stop();
+      console.log('[telegram] Bot stopped');
+    }
+  }
+
+  async send(chatId, message) {
+    if (!this._bot) return;
+    try {
+      await this._bot.api.sendMessage(chatId, message);
+      console.log(`[telegram] Sent message to ${chatId}`);
+    } catch (err) {
+      console.error('[telegram] Send error:', err.message);
+    }
+  }
+}
+
+module.exports = TelegramChannel;