@aion0/forge 0.1.9 → 0.2.0

package/lib/settings.ts

@@ -7,6 +7,7 @@ const SETTINGS_FILE = join(homedir(), '.forge', 'settings.yaml');
 
 export interface Settings {
   projectRoots: string[];       // Multiple project directories
+  docRoots: string[];           // Markdown document directories (e.g. Obsidian vaults)
   claudePath: string;           // Path to claude binary
   telegramBotToken: string;     // Telegram Bot API token
   telegramChatId: string;       // Telegram chat ID to send notifications to
@@ -18,6 +19,7 @@ export interface Settings {
 
 const defaults: Settings = {
   projectRoots: [],
+  docRoots: [],
   claudePath: '',
   telegramBotToken: '',
   telegramChatId: '',

package/lib/telegram-bot.ts

@@ -34,7 +34,10 @@ const chatNumberedTasks = new Map<number, Map<number, string>>();
 const chatNumberedSessions = new Map<number, Map<number, { projectName: string; sessionId: string }>>();
 const chatNumberedProjects = new Map<number, Map<number, string>>();
 // Track what the last numbered list was for
-const chatListMode = new Map<number, 'tasks' | 'projects' | 'sessions'>();
+const chatListMode = new Map<number, 'tasks' | 'projects' | 'sessions' | 'task-create' | 'peek'>();
+
+// Pending task creation: waiting for prompt text
+const pendingTaskProject = new Map<number, { name: string; path: string }>();  // chatId → project
 
 // Buffer for streaming logs
 const logBuffers = new Map<string, { entries: string[]; timer: ReturnType<typeof setTimeout> | null }>();
@@ -94,8 +97,12 @@ async function poll() {
         }
       }
     }
-  } catch (err) {
-    console.error('[telegram] Poll error:', err);
+  } catch (err: any) {
+    // Network errors (ECONNRESET, fetch failed) are normal during sleep/wake — silent retry
+    const isNetworkError = err?.cause?.code === 'ECONNRESET' || err?.message?.includes('fetch failed');
+    if (!isNetworkError) {
+      console.error('[telegram] Poll error:', err);
+    }
   }
 
   pollTimer = setTimeout(poll, 1000);
@@ -109,6 +116,20 @@ async function handleMessage(msg: any) {
   const text: string = msg.text.trim();
   const replyTo = msg.reply_to_message?.message_id;
 
+  // Check if waiting for task prompt
+  const pending = pendingTaskProject.get(chatId);
+  if (pending && !text.startsWith('/')) {
+    pendingTaskProject.delete(chatId);
+    const task = createTask({
+      projectName: pending.name,
+      projectPath: pending.path,
+      prompt: text,
+    });
+    const msgId = await send(chatId, `✅ Task ${task.id} created\n📁 ${task.projectName}\n\n${text.slice(0, 200)}`);
+    if (msgId) { taskMessageMap.set(msgId, task.id); taskChatMap.set(task.id, chatId); }
+    return;
+  }
+
   // Check if replying to a task message → follow-up
   if (replyTo && taskMessageMap.has(replyTo)) {
     const taskId = taskMessageMap.get(replyTo)!;
@@ -121,7 +142,25 @@ async function handleMessage(msg: any) {
     const num = parseInt(text);
     const mode = chatListMode.get(chatId);
 
-    if (mode === 'projects') {
+    if (mode === 'task-create') {
+      const projMap = chatNumberedProjects.get(chatId);
+      if (projMap?.has(num)) {
+        const projectName = projMap.get(num)!;
+        const projects = scanProjects();
+        const project = projects.find(p => p.name === projectName);
+        if (project) {
+          pendingTaskProject.set(chatId, { name: project.name, path: project.path });
+          await send(chatId, `📁 ${project.name}\n\nSend the task prompt:`);
+        }
+        return;
+      }
+    } else if (mode === 'peek') {
+      const projMap = chatNumberedProjects.get(chatId);
+      if (projMap?.has(num)) {
+        await handlePeek(chatId, projMap.get(num)!);
+        return;
+      }
+    } else if (mode === 'projects') {
       const projMap = chatNumberedProjects.get(chatId);
       if (projMap?.has(num)) {
         await sendSessionList(chatId, projMap.get(num)!);
@@ -145,6 +184,9 @@ async function handleMessage(msg: any) {
 
   // Commands
   if (text.startsWith('/')) {
+    // Any new command cancels pending states
+    pendingTaskProject.delete(chatId);
+
     const [cmd, ...args] = text.split(/\s+/);
     switch (cmd) {
       case '/start':
@@ -157,7 +199,11 @@ async function handleMessage(msg: any) {
         break;
       case '/new':
       case '/task':
-        await handleNewTask(chatId, args.join(' '));
+        if (args.length > 0) {
+          await handleNewTask(chatId, args.join(' '));
+        } else {
+          await startTaskCreation(chatId);
+        }
         break;
       case '/sessions':
       case '/s':
@@ -181,6 +227,17 @@ async function handleMessage(msg: any) {
       case '/unwatch':
         await handleUnwatch(chatId, args[0]);
         break;
+      case '/peek':
+        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 '/cancel':
         await handleCancel(chatId, args[0]);
         break;
@@ -188,7 +245,13 @@ async function handleMessage(msg: any) {
         await handleRetry(chatId, args[0]);
         break;
       case '/tunnel':
-        await handleTunnel(chatId, args[0], args[1], msg.message_id);
+        await handleTunnelStatus(chatId);
+        break;
+      case '/tunnel_start':
+        await handleTunnelStart(chatId);
+        break;
+      case '/tunnel_stop':
+        await handleTunnelStop(chatId);
         break;
       case '/tunnel_password':
         await handleTunnelPassword(chatId, args[0], msg.message_id);
@@ -228,9 +291,14 @@ async function sendHelp(chatId: number) {
     `/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\n` +
     `🔧 /cancel <id>  /retry <id>\n` +
     `/projects — list projects\n\n` +
-    `🌐 /tunnel [start|stop] — remote access\n` +
+    `🌐 /tunnel — tunnel status\n` +
+    `/tunnel_start — start tunnel\n` +
+    `/tunnel_stop — stop tunnel\n` +
     `/tunnel_password <pw> — get login password\n\n` +
     `Reply number to select`
   );
@@ -425,6 +493,167 @@ async function sendSessionContent(chatId: number, projectName: string, sessionId
   }
 }
 
+async function startPeekSelection(chatId: number) {
+  const projects = scanProjects();
+  if (projects.length === 0) {
+    await send(chatId, 'No projects configured.');
+    return;
+  }
+
+  // Filter to projects that have sessions
+  const withSessions = projects.filter(p => listClaudeSessions(p.name).length > 0);
+  if (withSessions.length === 0) {
+    await send(chatId, 'No projects with sessions found.');
+    return;
+  }
+
+  const numbered = new Map<number, string>();
+  const lines = withSessions.slice(0, 15).map((p, i) => {
+    numbered.set(i + 1, p.name);
+    const sessions = listClaudeSessions(p.name);
+    const latest = sessions[0];
+    const info = latest?.summary || latest?.firstPrompt?.slice(0, 40) || '';
+    return `${i + 1}. ${p.name}${info ? `\n   ${info}` : ''}`;
+  });
+
+  chatNumberedProjects.set(chatId, numbered);
+  chatListMode.set(chatId, 'peek');
+
+  await send(chatId, `👀 Peek — select project:\n\n${lines.join('\n')}`);
+}
+
+async function handlePeek(chatId: number, projectArg?: string, sessionArg?: string) {
+  const projects = scanProjects();
+
+  // If no project specified, use the most recent task's project
+  let projectName = projectArg;
+  let sessionId = sessionArg;
+
+  if (!projectName) {
+    // Find most recent running or done task
+    const tasks = listTasks();
+    const recent = tasks.find(t => t.status === 'running') || tasks[0];
+    if (recent) {
+      projectName = recent.projectName;
+    } else {
+      await send(chatId, 'No project specified and no recent tasks.\nUsage: /peek [project] [sessionId]');
+      return;
+    }
+  }
+
+  const project = projects.find(p => p.name === projectName || p.name.toLowerCase() === projectName!.toLowerCase());
+  if (!project) {
+    await send(chatId, `Project not found: ${projectName}`);
+    return;
+  }
+
+  // Find session
+  const sessions = listClaudeSessions(project.name);
+  if (sessions.length === 0) {
+    await send(chatId, `No sessions for ${project.name}`);
+    return;
+  }
+
+  const session = sessionId
+    ? sessions.find(s => s.sessionId.startsWith(sessionId!))
+    : sessions[0]; // most recent
+
+  if (!session) {
+    await send(chatId, `Session not found: ${sessionId}`);
+    return;
+  }
+
+  const filePath = getSessionFilePath(project.name, session.sessionId);
+  if (!filePath) {
+    await send(chatId, 'Session file not found');
+    return;
+  }
+
+  await send(chatId, `🔍 Loading ${project.name} / ${session.sessionId.slice(0, 8)}...`);
+
+  const entries = readSessionEntries(filePath);
+  if (entries.length === 0) {
+    await send(chatId, 'Session is empty');
+    return;
+  }
+
+  // Collect last N meaningful entries for raw display
+  const recentRaw: string[] = [];
+  let rawCount = 0;
+  for (let i = entries.length - 1; i >= 0 && rawCount < 8; i--) {
+    const e = entries[i];
+    if (e.type === 'user') {
+      recentRaw.unshift(`👤 ${e.content.slice(0, 300)}`);
+      rawCount++;
+    } else if (e.type === 'assistant_text') {
+      recentRaw.unshift(`🤖 ${e.content.slice(0, 300)}`);
+      rawCount++;
+    } else if (e.type === 'tool_use') {
+      recentRaw.unshift(`🔧 ${e.toolName || 'tool'}`);
+      rawCount++;
+    }
+  }
+
+  // Build context for AI summary (last ~50 entries)
+  const contextEntries: string[] = [];
+  let contextLen = 0;
+  const MAX_CONTEXT = 8000;
+  for (let i = entries.length - 1; i >= 0 && contextLen < MAX_CONTEXT; i--) {
+    const e = entries[i];
+    let line = '';
+    if (e.type === 'user') line = `User: ${e.content}`;
+    else if (e.type === 'assistant_text') line = `Assistant: ${e.content}`;
+    else if (e.type === 'tool_use') line = `Tool: ${e.toolName || 'tool'}`;
+    else continue;
+    if (contextLen + line.length > MAX_CONTEXT) break;
+    contextEntries.unshift(line);
+    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 {}
+
+  // Format output
+  const header = `📋 ${project.name} / ${session.sessionId.slice(0, 8)}\n${entries.length} entries${session.gitBranch ? ` • ${session.gitBranch}` : ''}`;
+
+  const summaryBlock = summary
+    ? `\n\n📝 Summary:\n${summary}`
+    : '';
+
+  const rawBlock = `\n\n--- Recent ---\n${recentRaw.join('\n\n')}`;
+
+  const fullText = header + summaryBlock + rawBlock;
+  const chunks = splitMessage(fullText, 4000);
+  for (const chunk of chunks) {
+    await send(chatId, chunk);
+  }
+}
+
 /**
  * Parse task creation input. Supports:
  *   project-name instructions
@@ -432,6 +661,25 @@ async function sendSessionContent(chatId: number, projectName: string, sessionId
  *   project-name -in 30m instructions
  *   project-name -at 2024-01-01T10:00 instructions
  */
+async function startTaskCreation(chatId: number) {
+  const projects = scanProjects();
+  if (projects.length === 0) {
+    await send(chatId, 'No projects configured. Add project roots in Settings.');
+    return;
+  }
+
+  const numbered = new Map<number, string>();
+  const lines = projects.slice(0, 15).map((p, i) => {
+    numbered.set(i + 1, p.name);
+    return `${i + 1}. ${p.name}`;
+  });
+
+  chatNumberedProjects.set(chatId, numbered);
+  chatListMode.set(chatId, 'task-create');
+
+  await send(chatId, `📝 New Task\n\nSelect project:\n${lines.join('\n')}`);
+}
+
 async function handleNewTask(chatId: number, input: string) {
   if (!input) {
     await send(chatId,
@@ -644,57 +892,64 @@ async function handleUnwatch(chatId: number, watcherId?: string) {
 
 // ─── Tunnel Commands ─────────────────────────────────────────
 
-async function handleTunnel(chatId: number, action?: string, password?: string, userMsgId?: number) {
+async function handleTunnelStatus(chatId: number) {
   const settings = loadSettings();
-  if (String(chatId) !== settings.telegramChatId) {
-    await send(chatId, '⛔ Unauthorized');
-    return;
-  }
+  if (String(chatId) !== settings.telegramChatId) { await send(chatId, '⛔ Unauthorized'); return; }
 
-  // start/stop require password
-  if (action === 'start' || action === 'stop') {
-    if (!settings.telegramTunnelPassword) {
-      await send(chatId, '⚠️ Set telegram tunnel password in Settings first.');
-      return;
-    }
-    if (!password || password !== settings.telegramTunnelPassword) {
-      await send(chatId, `⛔ Password required\nUsage: /tunnel ${action} <password>`);
-      return;
-    }
-    // Delete user's message containing password
-    if (userMsgId) deleteMessageLater(chatId, userMsgId, 0);
+  const status = getTunnelStatus();
+  if (status.status === 'running' && status.url) {
+    await sendHtml(chatId, `🌐 Tunnel running:\n<a href="${status.url}">${status.url}</a>\n\n/tunnel_stop — stop tunnel`);
+  } else if (status.status === 'starting') {
+    await send(chatId, '⏳ Tunnel is starting...');
+  } else {
+    await send(chatId, `🌐 Tunnel is ${status.status}\n\n/tunnel_start — start tunnel`);
   }
+}
+
+async function handleTunnelStart(chatId: number) {
+  const settings = loadSettings();
+  if (String(chatId) !== settings.telegramChatId) { await send(chatId, '⛔ Unauthorized'); return; }
+
+  // Check if tunnel is already running and still reachable
+  const status = getTunnelStatus();
+  if (status.status === 'running' && status.url) {
+    // Verify it's actually alive
+    let alive = false;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 8000);
+      const res = await fetch(status.url, { method: 'HEAD', signal: controller.signal, redirect: 'manual' });
+      clearTimeout(timeout);
+      alive = res.status > 0;
+    } catch {}
 
-  if (action === 'start') {
-    const status = getTunnelStatus();
-    if (status.status === 'running' && status.url) {
-      await send(chatId, `🌐 Tunnel already running:\n${status.url}`);
+    if (alive) {
+      await sendHtml(chatId, `🌐 Tunnel already running:\n<a href="${status.url}">${status.url}</a>`);
       return;
     }
-    await send(chatId, '🌐 Starting tunnel...');
-    const result = await startTunnel();
-    if (result.url) {
-      await send(chatId, '✅ Tunnel started:');
-      await sendHtml(chatId, `<a href="${result.url}">${result.url}</a>`);
-    } else {
-      await send(chatId, `❌ Failed: ${result.error}`);
-    }
-  } else if (action === 'stop') {
+    // Tunnel process alive but URL unreachable — kill and restart
+    await send(chatId, '🌐 Tunnel URL unreachable, restarting...');
     stopTunnel();
-    await send(chatId, '🛑 Tunnel stopped');
+  }
+
+  await send(chatId, '🌐 Starting tunnel...');
+  const result = await startTunnel();
+  if (result.url) {
+    await send(chatId, '✅ Tunnel started:');
+    await sendHtml(chatId, `<a href="${result.url}">${result.url}</a>`);
   } else {
-    // Status (no password needed)
-    const status = getTunnelStatus();
-    if (status.status === 'running' && status.url) {
-      await send(chatId, `🌐 Tunnel running:\n${status.url}\n\n/tunnel stop <pw> — stop tunnel`);
-    } else if (status.status === 'starting') {
-      await send(chatId, '⏳ Tunnel is starting...');
-    } else {
-      await send(chatId, `🌐 Tunnel is ${status.status}\n\n/tunnel start <pw> — start tunnel`);
-    }
+    await send(chatId, `❌ Failed: ${result.error}`);
   }
 }
 
+async function handleTunnelStop(chatId: number) {
+  const settings = loadSettings();
+  if (String(chatId) !== settings.telegramChatId) { await send(chatId, '⛔ Unauthorized'); return; }
+
+  stopTunnel();
+  await send(chatId, '🛑 Tunnel stopped');
+}
+
 async function handleTunnelPassword(chatId: number, password?: string, userMsgId?: number) {
   const settings = loadSettings();
   if (String(chatId) !== settings.telegramChatId) {
@@ -735,6 +990,167 @@ async function handleTunnelPassword(chatId: number, password?: string, userMsgId
   }
 }
 
+// ─── Docs ────────────────────────────────────────────────────
+
+async function handleDocs(chatId: number, input: string) {
+  const settings = loadSettings();
+  if (String(chatId) !== settings.telegramChatId) { await send(chatId, '⛔ Unauthorized'); return; }
+
+  const docRoots = (settings.docRoots || []).map((r: string) => r.replace(/^~/, require('os').homedir()));
+  if (docRoots.length === 0) {
+    await send(chatId, '⚠️ No document directories configured.\nAdd them in Settings → Document Roots');
+    return;
+  }
+
+  const docRoot = docRoots[0];
+  const { homedir: getHome } = require('os');
+  const { join, extname } = require('path');
+  const { existsSync, readFileSync, readdirSync } = require('fs');
+
+  // /docs <filename> — search and show file content
+  if (input.trim()) {
+    const query = input.trim().toLowerCase();
+
+    // Recursive search for matching .md files
+    const matches: string[] = [];
+    function searchDir(dir: string, depth: number) {
+      if (depth > 5 || matches.length >= 5) return;
+      try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+          const full = join(dir, entry.name);
+          if (entry.isDirectory()) {
+            searchDir(full, depth + 1);
+          } else if (entry.name.toLowerCase().includes(query) && extname(entry.name) === '.md') {
+            matches.push(full);
+          }
+        }
+      } catch {}
+    }
+    searchDir(docRoot, 0);
+
+    if (matches.length === 0) {
+      await send(chatId, `No docs matching "${input.trim()}"`);
+      return;
+    }
+
+    // Show first match
+    const filePath = matches[0];
+    const relPath = filePath.replace(docRoot + '/', '');
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      const preview = content.slice(0, 3500);
+      const truncated = content.length > 3500 ? '\n\n... (truncated)' : '';
+      await send(chatId, `📄 ${relPath}\n\n${preview}${truncated}`);
+      if (matches.length > 1) {
+        const others = matches.slice(1).map(m => `  ${m.replace(docRoot + '/', '')}`).join('\n');
+        await send(chatId, `Other matches:\n${others}`);
+      }
+    } catch {
+      await send(chatId, `Failed to read: ${relPath}`);
+    }
+    return;
+  }
+
+  // /docs — show summary of latest Claude session for docs
+  const hash = docRoot.replace(/\//g, '-');
+  const claudeDir = join(getHome(), '.claude', 'projects', hash);
+
+  if (!existsSync(claudeDir)) {
+    await send(chatId, `📖 Docs: ${docRoot.split('/').pop()}\n\nNo Claude sessions yet. Open Docs tab to start.`);
+    return;
+  }
+
+  // Find latest session
+  let latestFile = '';
+  let latestTime = 0;
+  try {
+    for (const f of readdirSync(claudeDir)) {
+      if (!f.endsWith('.jsonl')) continue;
+      const { statSync } = require('fs');
+      const stat = statSync(join(claudeDir, f));
+      if (stat.mtimeMs > latestTime) {
+        latestTime = stat.mtimeMs;
+        latestFile = f;
+      }
+    }
+  } catch {}
+
+  if (!latestFile) {
+    await send(chatId, `📖 Docs: ${docRoot.split('/').pop()}\n\nNo sessions found.`);
+    return;
+  }
+
+  const sessionId = latestFile.replace('.jsonl', '');
+  const filePath = join(claudeDir, latestFile);
+
+  // Read recent entries
+  let entries: string[] = [];
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(Boolean);
+    const recentLines = lines.slice(-30);
+
+    for (const line of recentLines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'human' || entry.role === 'user') {
+          const text = typeof entry.message === 'string' ? entry.message : entry.message?.content?.[0]?.text || '';
+          if (text) entries.push(`👤 ${text.slice(0, 200)}`);
+        } else if (entry.type === 'assistant' && entry.message?.content) {
+          for (const block of entry.message.content) {
+            if (block.type === 'text' && block.text) {
+              entries.push(`🤖 ${block.text.slice(0, 200)}`);
+            } else if (block.type === 'tool_use') {
+              entries.push(`🔧 ${block.name || 'tool'}`);
+            }
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+
+  const recent = entries.slice(-8).join('\n\n');
+  const header = `📖 Docs: ${docRoot.split('/').pop()}\n📋 Session: ${sessionId.slice(0, 12)}\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 summaryBlock = summary ? `\n📝 ${summary}\n` : '';
+  const fullText = header + summaryBlock + '\n--- Recent ---\n' + recent;
+
+  const chunks = splitMessage(fullText, 4000);
+  for (const chunk of chunks) {
+    await send(chatId, chunk);
+  }
+}
+
 // ─── Real-time Streaming ─────────────────────────────────────
 
 function bufferLogEntry(taskId: string, chatId: number, entry: TaskLogEntry) {
@@ -858,11 +1274,15 @@ async function setBotCommands(token: string) {
       body: JSON.stringify({
         commands: [
           { command: 'tasks', description: 'List tasks' },
-          { command: 'task', description: 'Create task: /task project prompt' },
+          { command: 'task', description: 'Create task (interactive or /task project prompt)' },
           { command: 'sessions', description: 'Browse sessions' },
           { command: 'projects', description: 'List projects' },
-          { command: 'tunnel', description: 'Tunnel status / start / stop' },
+          { 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: 'watch', description: 'Monitor session' },
           { command: 'watchers', description: 'List watchers' },
           { command: 'help', description: 'Show help' },