@aion0/forge 0.2.4 → 0.2.6

package/lib/task-manager.ts

@@ -39,6 +39,9 @@ function db() {
   return getDb(getDbPath());
 }
 
+// Per-task model overrides (used by pipeline to set pipelineModel)
+export const taskModelOverrides = new Map<string, string>();
+
 // ─── CRUD ────────────────────────────────────────────────────
 
 export function createTask(opts: {
@@ -239,6 +242,12 @@ function executeTask(task: Task): Promise<void> {
 
     const args = ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions'];
 
+    // Use model override if set, otherwise fall back to taskModel setting
+    const model = taskModelOverrides.get(task.id) || settings.taskModel;
+    if (model && model !== 'default') {
+      args.push('--model', model);
+    }
+
     // Resume specific session to continue the conversation
     if (task.conversationId) {
       args.push('--resume', task.conversationId);
@@ -254,7 +263,7 @@ function executeTask(task: Task): Promise<void> {
 
     // Resolve the actual claude CLI script path (claude is a symlink to a .js file)
     const resolvedClaude = resolveClaudePath(claudePath);
-    console.log(`[task] ${task.projectName}: "${task.prompt.slice(0, 60)}..."`);
+    console.log(`[task] ${task.projectName} [${model || 'default'}]: "${task.prompt.slice(0, 60)}..."`);
 
     const child = spawn(resolvedClaude.cmd, [...resolvedClaude.prefix, ...args], {
       cwd: task.projectPath,
@@ -266,6 +275,7 @@ function executeTask(task: Task): Promise<void> {
     let resultText = '';
     let totalCost = 0;
     let sessionId = '';
+    let modelUsed = '';
 
     child.on('error', (err) => {
       console.error(`[task-runner] Spawn error:`, err.message);
@@ -296,6 +306,9 @@ function executeTask(task: Task): Promise<void> {
           }
 
           if (parsed.session_id) sessionId = parsed.session_id;
+          if (parsed.type === 'system' && parsed.subtype === 'init' && parsed.model) {
+            modelUsed = parsed.model;
+          }
           if (parsed.type === 'result') {
             resultText = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
             totalCost = parsed.total_cost_usd || 0;
@@ -381,6 +394,12 @@ function executeTask(task: Task): Promise<void> {
  * Sends a visible bell character so the user knows to resume.
  */
 function notifyTerminalSession(task: Task, status: 'done' | 'failed', sessionId?: string) {
+  // Skip pipeline tasks — they have their own notification system
+  try {
+    const { pipelineTaskIds } = require('./pipeline');
+    if (pipelineTaskIds.has(task.id)) return;
+  } catch {}
+
   try {
     const out = execSync(
       `tmux list-sessions -F "#{session_name}" 2>/dev/null`,

package/lib/telegram-bot.ts

@@ -1,5 +1,5 @@
 /**
- * Telegram Bot — remote interface for My Workflow.
+ * Telegram Bot — remote interface for Forge.
  *
  * Optimized for mobile:
  * - /tasks shows numbered list, reply with number to see details
@@ -19,8 +19,8 @@ import type { Task, TaskLogEntry } from '@/src/types';
 // Prevent duplicate polling and state loss across hot-reloads
 const globalKey = Symbol.for('mw-telegram-state');
 const g = globalThis as any;
-if (!g[globalKey]) g[globalKey] = { polling: false, pollTimer: null, lastUpdateId: 0 };
-const botState: { polling: boolean; pollTimer: ReturnType<typeof setTimeout> | null; lastUpdateId: number } = g[globalKey];
+if (!g[globalKey]) g[globalKey] = { polling: false, pollTimer: null, lastUpdateId: 0, taskListenerAttached: false, pollActive: false, processedMsgIds: new Set<number>(), pollGeneration: 0 };
+const botState: { polling: boolean; pollTimer: ReturnType<typeof setTimeout> | null; lastUpdateId: number; taskListenerAttached: boolean; pollActive: boolean; processedMsgIds: Set<number>; pollGeneration: number } = g[globalKey];
 
 // Track which Telegram message maps to which task (for reply-based interaction)
 const taskMessageMap = new Map<number, string>(); // messageId → taskId
@@ -46,64 +46,110 @@ const logBuffers = new Map<string, { entries: string[]; timer: ReturnType<typeof
 // ─── Start/Stop ──────────────────────────────────────────────
 
 export function startTelegramBot() {
-  if (botState.polling) return;
   const settings = loadSettings();
   if (!settings.telegramBotToken || !settings.telegramChatId) return;
 
+  // Kill any existing poll loop (handles hot-reload creating duplicates)
+  if (botState.polling) {
+    botState.pollGeneration++;
+    if (botState.pollTimer) { clearTimeout(botState.pollTimer); botState.pollTimer = null; }
+    botState.pollActive = false;
+  }
+
   botState.polling = true;
   console.log('[telegram] Bot started');
 
   // Set bot command menu
   setBotCommands(settings.telegramBotToken);
 
-  // Listen for task events → stream to Telegram
-  onTaskEvent((taskId, event, data) => {
-    const settings = loadSettings();
-    if (!settings.telegramBotToken || !settings.telegramChatId) return;
-    const chatId = Number(settings.telegramChatId);
+  // Listen for task events → stream to Telegram (only once)
+  if (!botState.taskListenerAttached) {
+    botState.taskListenerAttached = true;
+    onTaskEvent((taskId, event, data) => {
+      const settings = loadSettings();
+      if (!settings.telegramBotToken || !settings.telegramChatId) return;
 
-    if (event === 'log') {
-      bufferLogEntry(taskId, chatId, data as TaskLogEntry);
-    } else if (event === 'status') {
-      handleStatusChange(taskId, chatId, data as string);
-    }
-  });
+      // Skip pipeline tasks — they have their own notification
+      try {
+        const { pipelineTaskIds } = require('./pipeline');
+        if (pipelineTaskIds.has(taskId)) return;
+      } catch {}
 
-  poll();
+      const chatId = Number(settings.telegramChatId.split(',')[0].trim());
+
+      if (event === 'log') {
+        bufferLogEntry(taskId, chatId, data as TaskLogEntry);
+      } else if (event === 'status') {
+        handleStatusChange(taskId, chatId, data as string);
+      }
+    });
+  }
+
+  // Skip stale updates on startup — set offset to -1 to get only new messages
+  if (botState.lastUpdateId === 0) {
+    fetch(`https://api.telegram.org/bot${settings.telegramBotToken}/getUpdates?offset=-1`)
+      .then(r => r.json())
+      .then(data => {
+        if (data.ok && data.result?.length > 0) {
+          botState.lastUpdateId = data.result[data.result.length - 1].update_id;
+        }
+        poll();
+      })
+      .catch(() => poll());
+  } else {
+    poll();
+  }
 }
 
 export function stopTelegramBot() {
   botState.polling = false;
+  botState.pollActive = false;
   if (botState.pollTimer) { clearTimeout(botState.pollTimer); botState.pollTimer = null; }
 }
 
 // ─── Polling ─────────────────────────────────────────────────
 
+function schedulePoll(delay: number = 1000) {
+  if (botState.pollTimer) clearTimeout(botState.pollTimer);
+  botState.pollTimer = setTimeout(poll, delay);
+}
+
 async function poll() {
-  if (!botState.polling) return;
+  const myGeneration = botState.pollGeneration;
+
+  // Prevent concurrent polls
+  if (!botState.polling || botState.pollActive) return;
+  botState.pollActive = true;
 
   try {
     const settings = loadSettings();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 35000);
+
     const url = `https://api.telegram.org/bot${settings.telegramBotToken}/getUpdates?offset=${botState.lastUpdateId + 1}&timeout=30`;
-    const res = await fetch(url);
+    const res = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeout);
+
     const data = await res.json();
 
-    if (data.ok && data.result) {
+    if (data.ok && data.result && data.result.length > 0) {
+      console.log(`[telegram] Poll got ${data.result.length} updates, lastId=${botState.lastUpdateId}`);
       for (const update of data.result) {
+        if (update.update_id <= botState.lastUpdateId) continue;
         botState.lastUpdateId = update.update_id;
         if (update.message?.text) {
+          console.log(`[telegram] Processing msg ${update.message.message_id}: ${update.message.text.slice(0, 30)}`);
           await handleMessage(update.message);
         }
       }
     }
-  } catch (err: any) {
-    const isNetworkError = err?.cause?.code === 'ECONNRESET' || err?.message?.includes('fetch failed');
-    if (!isNetworkError) {
-      console.error('[telegram] Poll error:', err);
-    }
+  } catch {
+    // Network errors during sleep/wake — silent
   }
 
-  botState.pollTimer = setTimeout(poll, 1000);
+  botState.pollActive = false;
+  // Only continue polling if this is still the current generation
+  if (botState.polling && myGeneration === botState.pollGeneration) schedulePoll(1000);
 }
 
 // ─── Message Handler ─────────────────────────────────────────
@@ -119,6 +165,16 @@ async function handleMessage(msg: any) {
   }
 
   // Message received (logged silently)
+  // Dedup: skip if we already processed this message
+  const msgId = msg.message_id;
+  if (botState.processedMsgIds.has(msgId)) return;
+  botState.processedMsgIds.add(msgId);
+  // Keep set size bounded
+  if (botState.processedMsgIds.size > 200) {
+    const oldest = [...botState.processedMsgIds].slice(0, 100);
+    oldest.forEach(id => botState.processedMsgIds.delete(id));
+  }
+
   const text: string = msg.text.trim();
   const replyTo = msg.reply_to_message?.message_id;
 
@@ -232,28 +288,30 @@ async function handleMessage(msg: any) {
         await sendProjectList(chatId);
         break;
       case '/watch':
-        await handleWatch(chatId, args[0], args[1]);
-        break;
-      case '/watchers':
       case '/w':
-        await sendWatcherList(chatId);
+        if (args.length > 0) {
+          await handleWatch(chatId, args[0], args[1]);
+        } else {
+          await sendWatcherList(chatId);
+        }
         break;
       case '/unwatch':
         await handleUnwatch(chatId, args[0]);
         break;
+      case '/docs':
+      case '/doc':
+        await handleDocs(chatId, args.join(' '));
+        break;
       case '/peek':
+      case '/sessions':
+      case '/s':
         if (args.length > 0) {
           await handlePeek(chatId, args[0], args[1]);
         } else {
           await startPeekSelection(chatId);
         }
         break;
-      case '/docs':
-      case '/doc':
-        await handleDocs(chatId, args.join(' '));
-        break;
       case '/note':
-      case '/docs_write':
         await handleDocsWrite(chatId, args.join(' '));
         break;
       case '/cancel':
@@ -301,23 +359,19 @@ async function handleMessage(msg: any) {
 async function sendHelp(chatId: number) {
   await send(chatId,
     `🤖 Forge\n\n` +
-    `📋 /tasks — numbered task list\n` +
-    `/tasks running — filter by status\n` +
-    `🔍 /sessions — browse session content\n` +
-    `/sessions <project> — sessions for project\n\n` +
-    `👁 /watch <project> [sessionId] — monitor session\n` +
-    `/watchers — list active watchers\n` +
-    `/unwatch <id> — stop watching\n\n` +
-    `📝 Submit task:\nproject-name: your instructions\n\n` +
-    `👀 /peek [project] [sessionId] — session summary\n` +
-    `📖 /docs — docs session summary\n` +
-    `/docs <filename> — view doc file\n` +
-    `📝 /note — quick note to docs claude\n\n` +
+    `📋 /task — create task (interactive)\n` +
+    `/tasks — task list\n\n` +
+    `👀 /sessions — session summary (select project)\n` +
+    `📖 /docs — docs summary / view file\n` +
+    `📝 /note — quick note to docs\n\n` +
+    `👁 /watch <project> — monitor session\n` +
+    `/watch — list watchers\n` +
+    `/unwatch <id> — stop\n\n` +
     `🔧 /cancel <id>  /retry <id>\n` +
+    `/sessions — browse sessions\n` +
     `/projects — list projects\n\n` +
-    `🌐 /tunnel — tunnel status\n` +
-    `/tunnel_start — start tunnel\n` +
-    `/tunnel_stop — stop tunnel\n` +
+    `🌐 /tunnel — status\n` +
+    `/tunnel_start / /tunnel_stop\n` +
     `/tunnel_password <pw> — get login password\n\n` +
     `Reply number to select`
   );
@@ -629,39 +683,16 @@ async function handlePeek(chatId: number, projectArg?: string, sessionArg?: stri
     contextLen += line.length;
   }
 
-  // AI summary
-  let summary = '';
-  try {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (apiKey) {
-      const res = await fetch('https://api.anthropic.com/v1/messages', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-api-key': apiKey,
-          'anthropic-version': '2023-06-01',
-        },
-        body: JSON.stringify({
-          model: 'claude-haiku-4-5-20251001',
-          max_tokens: 500,
-          messages: [{
-            role: 'user',
-            content: `Summarize this Claude Code session in 2-3 sentences. What was the user trying to do? What's the current status? Answer in the same language as the session content.\n\n${contextEntries.join('\n')}`,
-          }],
-        }),
-      });
-      if (res.ok) {
-        const data = await res.json();
-        summary = data.content?.[0]?.text || '';
-      }
-    }
-  } catch {}
+  const telegramModel = loadSettings().telegramModel || 'sonnet';
+  const summary = contextEntries.length > 3
+    ? await aiSummarize(contextEntries.join('\n'), 'Summarize this Claude Code session in 2-3 sentences. What was the user working on? What is the current status? Answer in the same language as the content.')
+    : '';
 
   // Format output
-  const header = `📋 ${project.name} / ${session.sessionId.slice(0, 8)}\n${entries.length} entries${session.gitBranch ? ` • ${session.gitBranch}` : ''}`;
+  const header = `📋 ${project.name} / ${session.sessionId.slice(0, 8)}\n${entries.length} entries${session.gitBranch ? ` • ${session.gitBranch}` : ''}${summary ? ` • AI: ${telegramModel}` : ''}`;
 
   const summaryBlock = summary
-    ? `\n\n📝 Summary:\n${summary}`
+    ? `\n\n📝 Summary (${telegramModel}):\n${summary}`
     : '';
 
   const rawBlock = `\n\n--- Recent ---\n${recentRaw.join('\n\n')}`;
@@ -1009,6 +1040,47 @@ async function handleTunnelPassword(chatId: number, password?: string, userMsgId
   }
 }
 
+// ─── AI Summarize (using Claude Code subscription) ───────────
+
+async function aiSummarize(content: string, instruction: string): Promise<string> {
+  try {
+    const settings = loadSettings();
+    const claudePath = settings.claudePath || process.env.CLAUDE_PATH || 'claude';
+    const model = settings.telegramModel || 'sonnet';
+    const { execSync } = require('child_process');
+    const { realpathSync } = require('fs');
+
+    // Resolve claude path
+    let cmd = claudePath;
+    try {
+      const which = execSync(`which ${claudePath}`, { encoding: 'utf-8' }).trim();
+      cmd = realpathSync(which);
+    } catch {}
+
+    const args = ['-p', '--model', model, '--max-turns', '1'];
+    const prompt = `${instruction}\n\nContent:\n${content.slice(0, 8000)}`;
+
+    let execCmd: string;
+    if (cmd.endsWith('.js') || cmd.endsWith('.mjs')) {
+      execCmd = `${process.execPath} ${cmd} ${args.join(' ')}`;
+    } else {
+      execCmd = `${cmd} ${args.join(' ')}`;
+    }
+
+    const result = execSync(execCmd, {
+      input: prompt,
+      encoding: 'utf-8',
+      timeout: 30000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, CLAUDECODE: undefined },
+    }).trim();
+
+    return result.slice(0, 1000);
+  } catch {
+    return '';
+  }
+}
+
 // ─── Docs ────────────────────────────────────────────────────
 
 async function handleDocs(chatId: number, input: string) {
@@ -1130,38 +1202,14 @@ async function handleDocs(chatId: number, input: string) {
   } catch {}
 
   const recent = entries.slice(-8).join('\n\n');
-  const header = `📖 Docs: ${docRoot.split('/').pop()}\n📋 Session: ${sessionId.slice(0, 12)}\n`;
+  const header = `📖 Docs: ${docRoot.split('/').pop()}\n📋 Session: ${sessionId.slice(0, 12)}${summary ? ` • AI: ${tModel}` : ''}\n`;
 
-  // Try AI summary if available
-  let summary = '';
-  try {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (apiKey && entries.length > 2) {
-      const contextText = entries.slice(-15).join('\n');
-      const res = await fetch('https://api.anthropic.com/v1/messages', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-api-key': apiKey,
-          'anthropic-version': '2023-06-01',
-        },
-        body: JSON.stringify({
-          model: 'claude-haiku-4-5-20251001',
-          max_tokens: 300,
-          messages: [{
-            role: 'user',
-            content: `Summarize this Claude Code session in 2-3 sentences. What was the user working on? What's the current status? Answer in the same language as the content.\n\n${contextText}`,
-          }],
-        }),
-      });
-      if (res.ok) {
-        const data = await res.json();
-        summary = data.content?.[0]?.text || '';
-      }
-    }
-  } catch {}
+  const tModel = loadSettings().telegramModel || 'sonnet';
+  const summary = entries.length > 3
+    ? await aiSummarize(entries.slice(-15).join('\n'), 'Summarize this Claude Code session in 2-3 sentences. What was the user working on? What is the current status? Answer in the same language as the content.')
+    : '';
+  const summaryBlock = summary ? `\n📝 (${tModel}) ${summary}\n` : '';
 
-  const summaryBlock = summary ? `\n📝 ${summary}\n` : '';
   const fullText = header + summaryBlock + '\n--- Recent ---\n' + recent;
 
   const chunks = splitMessage(fullText, 4000);
@@ -1365,19 +1413,16 @@ async function setBotCommands(token: string) {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
         commands: [
+          { command: 'task', description: 'Create task' },
           { command: 'tasks', description: 'List tasks' },
-          { command: 'task', description: 'Create task (interactive or /task project prompt)' },
-          { command: 'sessions', description: 'Browse sessions' },
-          { command: 'projects', description: 'List projects' },
+          { command: 'sessions', description: 'Session summary (AI)' },
+          { command: 'docs', description: 'Docs summary / view file' },
+          { command: 'note', description: 'Quick note to docs' },
+          { command: 'watch', description: 'Monitor session / list watchers' },
           { command: 'tunnel', description: 'Tunnel status' },
           { command: 'tunnel_start', description: 'Start tunnel' },
           { command: 'tunnel_stop', description: 'Stop tunnel' },
           { command: 'tunnel_password', description: 'Get login password' },
-          { command: 'peek', description: 'Session summary (AI + recent)' },
-          { command: 'docs', description: 'Docs session summary / view file' },
-          { command: 'note', description: 'Quick note to docs Claude' },
-          { command: 'watch', description: 'Monitor session' },
-          { command: 'watchers', description: 'List watchers' },
           { command: 'help', description: 'Show help' },
         ],
       }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {

package/tsconfig.json

@@ -33,7 +33,8 @@
     "**/*.ts",
     "**/*.tsx",
     ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts"
+    ".next/dev/types/**/*.ts",
+    ".next/dev/dev/types/**/*.ts"
   ],
   "exclude": [
     "node_modules"