create-walle 0.9.0 → 0.9.3

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

@@ -622,6 +622,12 @@ function handleWalleApi(req, res, url) {
     try {
       const status = params.get('status') || undefined;
       const limit = parseLimit(params, 50);
+      // Load active watched threads from brain DB for Slack task enrichment
+      let watchedThreads = [];
+      try {
+        if (brain.listActiveSlackThreads) watchedThreads = brain.listActiveSlackThreads(2 * 60 * 60 * 1000);
+      } catch {}
+
       const data = brain.listTasks({ status, limit }).map(function(t) {
         if (t.started_at && t.completed_at) {
           // Normalize timestamps: append 'Z' if missing to ensure UTC parsing
@@ -630,6 +636,20 @@ function handleWalleApi(req, res, url) {
           const dur = new Date(c).getTime() - new Date(s).getTime();
           if (dur > 0 && dur < 86400000) t.last_duration_ms = dur; // sanity: max 24h
         }
+        // Enrich Slack tasks with watched thread info
+        if (t.source === 'slack' && t.id) {
+          const watched = watchedThreads.find(w => w.task_id === t.id);
+          if (watched) {
+            const expiresAt = new Date(new Date(watched.last_activity).getTime() + 2 * 60 * 60 * 1000);
+            t.slack_thread = {
+              channel_id: watched.channel_id,
+              thread_ts: watched.thread_ts,
+              last_activity: watched.last_activity,
+              expires_at: expiresAt.toISOString(),
+              active: expiresAt > new Date(),
+            };
+          }
+        }
         return t;
       });
       jsonResponse(res, { data });
@@ -668,6 +688,8 @@ function handleWalleApi(req, res, url) {
           due_at: body.due_at,
           skill: body.skill,
           skill_config: body.skill_config ? (typeof body.skill_config === 'string' ? body.skill_config : JSON.stringify(body.skill_config)) : undefined,
+          source: body.source,
+          source_ref: body.source_ref,
         });
         jsonResponse(res, { data: { id: result.id } }, 201);
       } catch (e) {
@@ -1224,6 +1246,26 @@ function handleWalleApi(req, res, url) {
     return true;
   }
 
+  // POST /api/wall-e/webhook — receive external events
+  if (p === '/api/wall-e/webhook' && m === 'POST') {
+    // Verify webhook secret if configured
+    const expectedToken = process.env.WALLE_WEBHOOK_SECRET;
+    if (expectedToken && req.headers['authorization'] !== `Bearer ${expectedToken}`) {
+      jsonResponse(res, { error: 'Unauthorized' }, 401);
+      return true;
+    }
+    readBody(req).then(body => {
+      if (!body.source || !body.event) {
+        return jsonResponse(res, { error: 'source and event are required' }, 400);
+      }
+      const eventBus = require('./events/event-bus');
+      const { event, source, ...payload } = body;
+      eventBus.emitWebhook(source, { event, ...payload });
+      jsonResponse(res, { ok: true, message: `Webhook received from ${source}` });
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
   // No matching route under /api/wall-e
   jsonResponse(res, { error: 'Not found' }, 404);
   return true;

package/template/wall-e/brain.js

@@ -77,6 +77,15 @@ function initDb(dbPath) {
     try { newDb.prepare("SELECT skill_config FROM tasks LIMIT 0").run(); } catch (_) {
       newDb.prepare("ALTER TABLE tasks ADD COLUMN skill_config TEXT").run();
     }
+    // Migration: add source/source_ref columns to tasks table
+    try { newDb.prepare("SELECT source FROM tasks LIMIT 0").run(); } catch (_) {
+      newDb.prepare("ALTER TABLE tasks ADD COLUMN source TEXT DEFAULT 'system'").run();
+    }
+    try { newDb.prepare("SELECT source_ref FROM tasks LIMIT 0").run(); } catch (_) {
+      newDb.prepare("ALTER TABLE tasks ADD COLUMN source_ref TEXT").run();
+    }
+    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 (_) {}
   } catch (err) {
     newDb.close();
     db = null;
@@ -379,12 +388,57 @@ function createTables() {
       result TEXT,
       error TEXT,
       checkpoint TEXT,
+      source TEXT DEFAULT 'system',
+      source_ref TEXT,
       created_at TEXT DEFAULT (datetime('now')),
       updated_at TEXT DEFAULT (datetime('now'))
     );
     CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
     CREATE INDEX IF NOT EXISTS idx_tasks_due ON tasks(due_at);
     CREATE INDEX IF NOT EXISTS idx_tasks_next ON tasks(next_run_at);
+    CREATE INDEX IF NOT EXISTS idx_tasks_source ON tasks(source);
+
+    CREATE TABLE IF NOT EXISTS initiative_log (
+      id TEXT PRIMARY KEY,
+      trigger TEXT NOT NULL,
+      state_snapshot TEXT,
+      reasoning TEXT,
+      decision TEXT NOT NULL,
+      decision_data TEXT,
+      autonomy_tier INTEGER,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_initiative_time ON initiative_log(created_at);
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      channel TEXT NOT NULL,
+      summary TEXT,
+      compacted_messages TEXT,
+      turn_count INTEGER DEFAULT 0,
+      token_estimate INTEGER DEFAULT 0,
+      metadata TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_sessions_channel ON sessions(channel, updated_at);
+
+    CREATE TABLE IF NOT EXISTS brain_metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS slack_threads (
+      id TEXT PRIMARY KEY,
+      channel_id TEXT NOT NULL,
+      thread_ts TEXT NOT NULL,
+      task_id TEXT,
+      session_id TEXT,
+      last_activity TEXT NOT NULL,
+      last_seen_ts TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_slack_threads_active ON slack_threads(last_activity);
   `);
 }
 
@@ -1085,14 +1139,21 @@ function updateSkillStats(skillId, success) {
 
 // ── Tasks ──
 
-function insertTask({ title, description, priority, type, execution, script, schedule, due_at, next_run_at, skill, skill_config }) {
+function insertTask({ title, description, priority, type, execution, script, schedule, due_at, next_run_at, skill, skill_config, source, source_ref }) {
+  // Dedup: skip if a task with the same title+source+source_ref already exists and isn't archived
+  if (title && source) {
+    const existing = source_ref
+      ? getDb().prepare(`SELECT id, status FROM tasks WHERE title = ? AND source = ? AND source_ref = ? AND status != 'archived' LIMIT 1`).get(title, source, source_ref)
+      : getDb().prepare(`SELECT id, status FROM tasks WHERE title = ? AND source = ? AND status NOT IN ('archived','completed') LIMIT 1`).get(title, source);
+    if (existing) return { id: existing.id, deduplicated: true };
+  }
   const id = uuidv4();
   getDb().prepare(`
-    INSERT INTO tasks (id, title, description, priority, type, execution, script, schedule, due_at, next_run_at, skill, skill_config)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO tasks (id, title, description, priority, type, execution, script, schedule, due_at, next_run_at, skill, skill_config, source, source_ref)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(id, title, description || null, priority || 'normal', type || 'once',
     execution || 'chat', script || null, schedule || null, due_at || null, next_run_at || due_at || null,
-    skill || null, skill_config || null);
+    skill || null, skill_config || null, source || 'system', source_ref || null);
   return { id };
 }
 
@@ -1110,7 +1171,7 @@ function listTasks({ status, limit } = {}) {
 }
 
 function updateTask(id, updates) {
-  const allowed = ['title', 'description', 'status', 'priority', 'type', 'execution', 'script', 'schedule', 'due_at', 'next_run_at', 'started_at', 'completed_at', 'last_run_at', 'run_count', 'result', 'error', 'checkpoint', 'skill', 'skill_config'];
+  const allowed = ['title', 'description', 'status', 'priority', 'type', 'execution', 'script', 'schedule', 'due_at', 'next_run_at', 'started_at', 'completed_at', 'last_run_at', 'run_count', 'result', 'error', 'checkpoint', 'skill', 'skill_config', 'source', 'source_ref'];
   const sets = [];
   const params = [];
   for (const [k, v] of Object.entries(updates)) {
@@ -1190,6 +1251,108 @@ function listOpenBriefingItems(skill) {
   ).all(skill);
 }
 
+// -- Sessions (context compaction) --
+
+function getSession(id) {
+  return getDb().prepare('SELECT * FROM sessions WHERE id = ?').get(id) || null;
+}
+
+function upsertSession({ id, channel, summary, compacted_messages, turn_count, token_estimate, metadata }) {
+  const now = new Date().toISOString();
+  getDb().prepare(`
+    INSERT INTO sessions (id, channel, summary, compacted_messages, turn_count, token_estimate, metadata, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      summary = excluded.summary,
+      compacted_messages = excluded.compacted_messages,
+      turn_count = excluded.turn_count,
+      token_estimate = excluded.token_estimate,
+      metadata = excluded.metadata,
+      updated_at = excluded.updated_at
+  `).run(id, channel || 'ctm', summary || null, compacted_messages || null,
+    turn_count || 0, token_estimate || 0, metadata || null, now, now);
+  return id;
+}
+
+function listSessions({ channel, limit } = {}) {
+  const params = [];
+  let sql = 'SELECT * FROM sessions';
+  if (channel) { sql += ' WHERE channel = ?'; params.push(channel); }
+  sql += ' ORDER BY updated_at DESC';
+  if (limit) { sql += ' LIMIT ?'; params.push(limit); }
+  return getDb().prepare(sql).all(...params);
+}
+
+function expireSessions(maxAgeHours = 24) {
+  const db = getDb();
+  const cutoff = new Date(Date.now() - maxAgeHours * 3600000).toISOString();
+  const result = db.prepare("DELETE FROM sessions WHERE updated_at < ?").run(cutoff);
+  return result.changes;
+}
+
+// -- Initiative Log CRUD --
+
+function insertInitiativeLog({ trigger, state_snapshot, reasoning, decision, decision_data, autonomy_tier }) {
+  if (!trigger) throw new Error('Initiative log requires trigger');
+  if (!decision) throw new Error('Initiative log requires decision');
+  const id = uuidv4();
+  getDb().prepare(
+    'INSERT INTO initiative_log (id, trigger, state_snapshot, reasoning, decision, decision_data, autonomy_tier) VALUES (?, ?, ?, ?, ?, ?, ?)'
+  ).run(id, trigger, state_snapshot || null, reasoning || null, decision, decision_data || null, autonomy_tier || 1);
+  return id;
+}
+
+function listInitiativeLogs({ limit, since } = {}) {
+  const params = [];
+  let sql = 'SELECT * FROM initiative_log';
+  if (since) { sql += ' WHERE created_at >= ?'; params.push(since); }
+  sql += ' ORDER BY created_at DESC';
+  if (limit) { sql += ' LIMIT ?'; params.push(limit); }
+  return getDb().prepare(sql).all(...params);
+}
+
+// -- Slack Threads CRUD --
+
+function upsertSlackThread({ channelId, threadTs, taskId, sessionId }) {
+  const id = `${channelId}:${threadTs}`;
+  const now = new Date().toISOString();
+  getDb().prepare(`
+    INSERT INTO slack_threads (id, channel_id, thread_ts, task_id, session_id, last_activity)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      task_id = excluded.task_id,
+      session_id = excluded.session_id,
+      last_activity = excluded.last_activity
+  `).run(id, channelId, threadTs, taskId || null, sessionId || null, now);
+  return id;
+}
+
+function getSlackThread(channelId, threadTs) {
+  return getDb().prepare('SELECT * FROM slack_threads WHERE id = ?').get(`${channelId}:${threadTs}`);
+}
+
+function listActiveSlackThreads(watchDurationMs) {
+  const cutoff = new Date(Date.now() - (watchDurationMs || 7200000)).toISOString();
+  return getDb().prepare('SELECT * FROM slack_threads WHERE last_activity >= ? ORDER BY last_activity DESC').all(cutoff);
+}
+
+function updateSlackThread(id, updates) {
+  const allowed = ['last_activity', 'last_seen_ts', 'task_id', 'session_id'];
+  const sets = [];
+  const vals = [];
+  for (const [k, v] of Object.entries(updates)) {
+    if (allowed.includes(k)) { sets.push(`${k} = ?`); vals.push(v); }
+  }
+  if (sets.length === 0) return;
+  vals.push(id);
+  getDb().prepare(`UPDATE slack_threads SET ${sets.join(', ')} WHERE id = ?`).run(...vals);
+}
+
+function deleteExpiredSlackThreads(watchDurationMs) {
+  const cutoff = new Date(Date.now() - (watchDurationMs || 7200000)).toISOString();
+  return getDb().prepare('DELETE FROM slack_threads WHERE last_activity < ?').run(cutoff).changes;
+}
+
 module.exports = {
   initDb,
   getDb,
@@ -1277,4 +1440,18 @@ module.exports = {
   updateBriefingItem,
   findBriefingItemByTitle,
   listOpenBriefingItems,
+  // Sessions (context compaction)
+  getSession,
+  upsertSession,
+  listSessions,
+  expireSessions,
+  // Initiative Log
+  insertInitiativeLog,
+  listInitiativeLogs,
+  // Slack Threads
+  upsertSlackThread,
+  getSlackThread,
+  listActiveSlackThreads,
+  updateSlackThread,
+  deleteExpiredSlackThreads,
 };

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

@@ -2,6 +2,7 @@
 const { execFile } = require('child_process');
 const { promisify } = require('util');
 const ChannelBase = require('./channel-base');
+const eventBus = require('../events/event-bus');
 
 const execFileAsync = promisify(execFile);
 
@@ -43,9 +44,10 @@ class IMessageChannel extends ChannelBase {
 
   async _checkMessages() {
     // Use AppleScript to get the latest message from the buddy
+    const sanitizedBuddy = String(this.buddyId).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
     const script = `
       tell application "Messages"
-        set targetBuddy to "${this.buddyId}"
+        set targetBuddy to "${sanitizedBuddy}"
         set latestMsg to ""
         set latestId to ""
         repeat with svc in services
@@ -76,6 +78,7 @@ class IMessageChannel extends ChannelBase {
       this.lastMessageId = msgId;
 
       console.log(`[imessage] New message from ${this.buddyId}: ${msgText.slice(0, 50)}...`);
+      eventBus.emitMessage('imessage', msgText, this.buddyId);
 
       if (this._onMessage) {
         const response = await this._onMessage(msgText, this.buddyId);

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

@@ -1,11 +1,12 @@
 'use strict';
 const ChannelBase = require('./channel-base');
+const eventBus = require('../events/event-bus');
 
 class SlackChannel extends ChannelBase {
   constructor(opts = {}) {
     super('slack_dm');
     this.botToken = opts.botToken || process.env.SLACK_BOT_TOKEN || null;
-    this.pollInterval = opts.pollInterval || 15000; // 15s
+    this.pollInterval = opts.pollInterval || 5000; // 5s
     this.lastTimestamp = null;
     this._pollTimer = null;
     this._onMessage = opts.onMessage || null;
@@ -70,6 +71,7 @@ class SlackChannel extends ChannelBase {
 
         this.lastTimestamp = msg.ts;
         console.log(`[slack_dm] New DM from ${msg.user}: ${(msg.text || '').slice(0, 50)}...`);
+        eventBus.emitMessage('slack_dm', msg.text, msg.user);
 
         if (this._onMessage && msg.text) {
           const response = await this._onMessage(msg.text, msg.user);