@aion0/forge 0.1.8 → 0.1.10

package/CLAUDE.md

@@ -1,3 +1,46 @@
+## Project: Forge (@aion0/forge)
+
+### Dev Commands
+```bash
+# Development (hot-reload)
+pnpm dev
+
+# Production (local)
+pnpm build && pnpm start
+
+# Publish to npm (bump version in package.json first)
+npm publish --access public --otp=<code>
+
+# Install globally from local source (for testing)
+npm install -g /Users/zliu/IdeaProjects/my-workflow
+
+# Install from npm
+npm install -g @aion0/forge
+
+# Run via npm global install
+forge-server              # foreground (auto-builds if needed)
+forge-server --dev        # dev mode
+forge-server --background # background, logs to ~/.forge/forge.log
+forge-server --stop       # stop background server
+forge-server --rebuild    # force rebuild
+
+# CLI
+forge                     # help
+forge password            # show today's login password
+forge tasks               # list tasks
+forge task <project> "prompt"  # submit task
+
+# Terminal server runs on port 3001 (auto-started by Next.js)
+# Data directory: ~/.forge/
+# Config: ~/.forge/settings.yaml
+# Env: ~/.forge/.env.local
+```
+
+### Key Paths
+- Data: `~/.forge/` (settings, db, password, terminal-state, flows, bin)
+- npm package: `@aion0/forge`
+- GitHub: `github.com/aiwatching/forge`
+
 ## Obsidian Vault
 Location: /Users/zliu/MyDocuments/obsidian-project/Projects/Bastion
 When I ask about my notes, use bash to search and read files from this directory.

package/app/api/tasks/[id]/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server';
-import { getTask, cancelTask, deleteTask, retryTask } from '@/lib/task-manager';
+import { getTask, cancelTask, deleteTask, retryTask, updateTask } from '@/lib/task-manager';
 
 // Get task details (including full log)
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -28,6 +28,15 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
 }
 
+// Edit a queued task
+export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+  const updated = updateTask(id, body);
+  if (!updated) return NextResponse.json({ error: 'Cannot edit (only queued tasks)' }, { status: 400 });
+  return NextResponse.json(updated);
+}
+
 // Delete a task
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params;

package/components/NewTaskModal.tsx

@@ -17,29 +17,33 @@ interface SessionInfo {
   gitBranch?: string;
 }
 
+interface TaskData {
+  projectName: string;
+  prompt: string;
+  priority?: number;
+  conversationId?: string;
+  newSession?: boolean;
+  scheduledAt?: string;
+  mode?: TaskMode;
+  watchConfig?: WatchConfig;
+}
+
 export default function NewTaskModal({
   onClose,
   onCreate,
+  editTask,
 }: {
   onClose: () => void;
-  onCreate: (data: {
-    projectName: string;
-    prompt: string;
-    priority?: number;
-    conversationId?: string;
-    newSession?: boolean;
-    scheduledAt?: string;
-    mode?: TaskMode;
-    watchConfig?: WatchConfig;
-  }) => void;
+  onCreate: (data: TaskData) => void;
+  editTask?: { id: string; projectName: string; prompt: string; priority: number; mode: TaskMode };
 }) {
   const [projects, setProjects] = useState<Project[]>([]);
-  const [selectedProject, setSelectedProject] = useState('');
-  const [prompt, setPrompt] = useState('');
-  const [priority, setPriority] = useState(0);
+  const [selectedProject, setSelectedProject] = useState(editTask?.projectName || '');
+  const [prompt, setPrompt] = useState(editTask?.prompt || '');
+  const [priority, setPriority] = useState(editTask?.priority || 0);
 
   // Task mode
-  const [taskMode, setTaskMode] = useState<TaskMode>('prompt');
+  const [taskMode, setTaskMode] = useState<TaskMode>(editTask?.mode || 'prompt');
 
   // Monitor config
   const [watchCondition, setWatchCondition] = useState<WatchConfig['condition']>('change');
@@ -63,7 +67,7 @@ export default function NewTaskModal({
   useEffect(() => {
     fetch('/api/projects').then(r => r.json()).then((p: Project[]) => {
       setProjects(p);
-      if (p.length > 0) setSelectedProject(p[0].name);
+      if (!selectedProject && p.length > 0) setSelectedProject(p[0].name);
     });
   }, []);
 
@@ -135,7 +139,7 @@ export default function NewTaskModal({
     <div className="fixed inset-0 bg-black/60 flex items-center justify-center z-50" onClick={onClose}>
       <div className="bg-[var(--bg-secondary)] border border-[var(--border)] rounded-lg w-[560px] max-h-[80vh] overflow-auto" onClick={e => e.stopPropagation()}>
         <div className="p-4 border-b border-[var(--border)]">
-          <h2 className="text-sm font-semibold">New Task</h2>
+          <h2 className="text-sm font-semibold">{editTask ? 'Edit Task' : 'New Task'}</h2>
           <p className="text-[11px] text-[var(--text-secondary)] mt-0.5">
             Submit a task for Claude Code to work on autonomously
           </p>
@@ -446,7 +450,7 @@ export default function NewTaskModal({
               disabled={!selectedProject || (taskMode === 'prompt' && !prompt.trim()) || (taskMode === 'monitor' && !selectedSessionId)}
               className="text-xs px-4 py-1.5 bg-[var(--accent)] text-white rounded hover:opacity-90 disabled:opacity-50"
             >
-              {taskMode === 'monitor' ? 'Start Monitor' : scheduleMode === 'now' ? 'Submit Task' : 'Schedule Task'}
+              {editTask ? 'Save & Restart' : taskMode === 'monitor' ? 'Start Monitor' : scheduleMode === 'now' ? 'Submit Task' : 'Schedule Task'}
             </button>
           </div>
         </form>

package/components/TaskDetail.tsx

@@ -2,6 +2,7 @@
 
 import { useState, useEffect, useRef } from 'react';
 import MarkdownContent from './MarkdownContent';
+import NewTaskModal from './NewTaskModal';
 import type { Task, TaskLogEntry } from '@/src/types';
 
 export default function TaskDetail({
@@ -18,6 +19,7 @@ export default function TaskDetail({
   const [tab, setTab] = useState<'log' | 'diff' | 'result'>('log');
   const [expandedTools, setExpandedTools] = useState<Set<number>>(new Set());
   const [followUpText, setFollowUpText] = useState('');
+  const [editing, setEditing] = useState(false);
   const logEndRef = useRef<HTMLDivElement>(null);
 
   // SSE stream for running tasks
@@ -90,6 +92,9 @@ export default function TaskDetail({
             <span className="text-[10px] text-[var(--text-secondary)] font-mono">{task.id}</span>
           </div>
           <div className="flex items-center gap-2">
+            <button onClick={() => setEditing(true)} className="text-[10px] px-2 py-0.5 text-[var(--accent)] border border-[var(--accent)]/30 rounded hover:bg-[var(--accent)] hover:text-white">
+              Edit
+            </button>
             {(liveStatus === 'running' || liveStatus === 'queued') && (
               <button onClick={() => handleAction('cancel')} className="text-[10px] px-2 py-0.5 text-[var(--red)] border border-[var(--red)]/30 rounded hover:bg-[var(--red)] hover:text-white">
                 Cancel
@@ -223,6 +228,22 @@ export default function TaskDetail({
           </p>
         </div>
       )}
+
+      {editing && (
+        <NewTaskModal
+          editTask={{ id: task.id, projectName: task.projectName, prompt: task.prompt, priority: task.priority, mode: task.mode }}
+          onClose={() => setEditing(false)}
+          onCreate={async (data) => {
+            await fetch(`/api/tasks/${task.id}`, {
+              method: 'PATCH',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ ...data, restart: true }),
+            });
+            setEditing(false);
+            onRefresh();
+          }}
+        />
+      )}
     </div>
   );
 }

package/components/WebTerminal.tsx

@@ -478,6 +478,7 @@ const WebTerminal = forwardRef<WebTerminalHandle>(function WebTerminal(_props, r
 
         {/* Toolbar */}
         <div className="flex items-center gap-1 px-2 ml-auto">
+          <span className="text-[9px] text-gray-600 mr-2">Shift+drag to copy</span>
           <button onClick={() => onSplit('vertical')} className="text-[10px] px-2 py-0.5 text-gray-400 hover:text-white hover:bg-[#2a2a4a] rounded">
             Split Right
           </button>
@@ -828,7 +829,7 @@ const MemoTerminalPane = memo(function TerminalPane({
         background: '#1a1a2e',
         foreground: '#e0e0e0',
         cursor: '#7c5bf0',
-        selectionBackground: '#7c5bf044',
+        selectionBackground: '#7c5bf066',
         black: '#1a1a2e',
         red: '#ff6b6b',
         green: '#69db7c',

package/lib/cloudflared.ts

@@ -150,6 +150,7 @@ export async function startTunnel(localPort: number = 3000): Promise<{ url?: str
           state.url = urlMatch[1];
           state.status = 'running';
           console.log(`[cloudflared] Tunnel URL: ${state.url}`);
+          startHealthCheck();
           if (!resolved) {
             resolved = true;
             resolve({ url: state.url });
@@ -198,6 +199,7 @@ export async function startTunnel(localPort: number = 3000): Promise<{ url?: str
 }
 
 export function stopTunnel() {
+  stopHealthCheck();
   if (state.process) {
     state.process.kill('SIGTERM');
     state.process = null;
@@ -216,3 +218,92 @@ export function getTunnelStatus() {
     log: state.log.slice(-20),
   };
 }
+
+// ─── Tunnel health check ──────────────────────────────────────
+
+let healthCheckTimer: ReturnType<typeof setInterval> | null = null;
+let consecutiveFailures = 0;
+const MAX_FAILURES = 3;
+const HEALTH_CHECK_INTERVAL = 60_000; // 60s
+
+async function checkTunnelHealth() {
+  if (state.status !== 'running' || !state.url) return;
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    const res = await fetch(state.url, {
+      method: 'HEAD',
+      signal: controller.signal,
+      redirect: 'manual',
+    });
+    clearTimeout(timeout);
+
+    // Any response (including 302 to login) means tunnel is alive
+    if (res.status > 0) {
+      if (consecutiveFailures > 0) {
+        pushLog(`[health] Tunnel recovered after ${consecutiveFailures} failures`);
+      }
+      consecutiveFailures = 0;
+      return;
+    }
+  } catch {
+    // fetch failed — tunnel likely down
+  }
+
+  consecutiveFailures++;
+  pushLog(`[health] Tunnel unreachable (${consecutiveFailures}/${MAX_FAILURES})`);
+
+  if (consecutiveFailures >= MAX_FAILURES) {
+    pushLog('[health] Tunnel appears dead — restarting...');
+    state.status = 'error';
+    state.error = 'Tunnel unreachable — restarting';
+
+    // Kill old process and restart
+    if (state.process) {
+      state.process.kill('SIGTERM');
+      state.process = null;
+    }
+    state.url = null;
+    consecutiveFailures = 0;
+
+    // Restart after a short delay
+    setTimeout(async () => {
+      const result = await startTunnel();
+      if (result.url) {
+        pushLog(`[health] Tunnel restarted: ${result.url}`);
+        // Notify via Telegram if configured
+        try {
+          const { loadSettings } = await import('./settings');
+          const settings = loadSettings();
+          if (settings.telegramBotToken && settings.telegramChatId) {
+            await fetch(`https://api.telegram.org/bot${settings.telegramBotToken}/sendMessage`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                chat_id: settings.telegramChatId,
+                text: `🔄 Tunnel restarted\n\nNew URL: ${result.url}`,
+                disable_web_page_preview: true,
+              }),
+            });
+          }
+        } catch {}
+      } else {
+        pushLog(`[health] Tunnel restart failed: ${result.error}`);
+      }
+    }, 3000);
+  }
+}
+
+export function startHealthCheck() {
+  if (healthCheckTimer) return;
+  healthCheckTimer = setInterval(checkTunnelHealth, HEALTH_CHECK_INTERVAL);
+}
+
+export function stopHealthCheck() {
+  if (healthCheckTimer) {
+    clearInterval(healthCheckTimer);
+    healthCheckTimer = null;
+  }
+  consecutiveFailures = 0;
+}

package/lib/task-manager.ts

@@ -133,6 +133,35 @@ export function deleteTask(id: string): boolean {
   return true;
 }
 
+export function updateTask(id: string, updates: { prompt?: string; projectName?: string; projectPath?: string; priority?: number; restart?: boolean }): Task | null {
+  const task = getTask(id);
+  if (!task) return null;
+
+  // If running, cancel first
+  if (task.status === 'running') cancelTask(id);
+
+  const fields: string[] = [];
+  const values: any[] = [];
+  if (updates.prompt !== undefined) { fields.push('prompt = ?'); values.push(updates.prompt); }
+  if (updates.projectName !== undefined) { fields.push('project_name = ?'); values.push(updates.projectName); }
+  if (updates.projectPath !== undefined) { fields.push('project_path = ?'); values.push(updates.projectPath); }
+  if (updates.priority !== undefined) { fields.push('priority = ?'); values.push(updates.priority); }
+
+  // Reset to queued so it runs again
+  if (updates.restart) {
+    fields.push("status = 'queued'", 'started_at = NULL', 'completed_at = NULL', 'error = NULL', "log = '[]'", 'result_summary = NULL', 'git_diff = NULL', 'cost_usd = NULL');
+  }
+
+  if (fields.length === 0) return task;
+
+  values.push(id);
+  db().prepare(`UPDATE tasks SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+
+  if (updates.restart) ensureRunnerStarted();
+
+  return getTask(id);
+}
+
 export function retryTask(id: string): Task | null {
   const task = getTask(id);
   if (!task) return null;
@@ -506,21 +535,43 @@ function startMonitorTask(task: Task) {
     }, 30_000);
   }
 
+  // Notification throttling: batch updates and send at most once per interval
+  const notifyInterval = (config.notifyIntervalSeconds || 60) * 1000;
+  let lastNotifyTime = 0;
+  let pendingContext: string[] = [];
+  let notifyTimer: ReturnType<typeof setTimeout> | null = null;
+
+  function scheduleNotify(context: string, immediate?: boolean) {
+    pendingContext.push(context);
+    if (immediate) {
+      flushNotify();
+      return;
+    }
+    if (notifyTimer) return; // already scheduled
+    const elapsed = Date.now() - lastNotifyTime;
+    const delay = Math.max(0, notifyInterval - elapsed);
+    notifyTimer = setTimeout(flushNotify, delay);
+  }
+
+  function flushNotify() {
+    if (notifyTimer) { clearTimeout(notifyTimer); notifyTimer = null; }
+    if (pendingContext.length === 0) return;
+    const summary = pendingContext.length === 1
+      ? pendingContext[0]
+      : `${pendingContext.length} updates:\n\n${pendingContext.slice(-5).join('\n\n')}`;
+    pendingContext = [];
+    lastNotifyTime = Date.now();
+    triggerMonitorAction(task, summary);
+  }
+
   // Tail the file for changes (uses fs.watch + 5s polling fallback)
   const stopTail = tailSessionFile(fp, (newEntries) => {
     lastActivityTime = Date.now();
     lastEntryCount += newEntries.length;
-    // Monitor entries tracked in task log only
-
-    appendLog(task.id, {
-      type: 'system', subtype: 'text',
-      content: `+${newEntries.length} entries (${lastEntryCount} total)`,
-      timestamp: new Date().toISOString(),
-    });
 
     // Check conditions
     if (config.condition === 'change') {
-      triggerMonitorAction(task, summarizeNewEntries(newEntries));
+      scheduleNotify(summarizeNewEntries(newEntries));
       if (!config.repeat) stopMonitor(task.id);
     }
 
@@ -528,7 +579,7 @@ function startMonitorTask(task: Task) {
       const kw = config.keyword.toLowerCase();
       const matched = newEntries.find(e => e.content.toLowerCase().includes(kw));
       if (matched) {
-        triggerMonitorAction(task, `Keyword "${config.keyword}" found: ${matched.content.slice(0, 200)}`);
+        scheduleNotify(`Keyword "${config.keyword}" found: ${matched.content.slice(0, 200)}`, true);
         if (!config.repeat) stopMonitor(task.id);
       }
     }
@@ -538,7 +589,7 @@ function startMonitorTask(task: Task) {
         e.type === 'system' && e.content.toLowerCase().includes('error')
       );
       if (errors.length > 0) {
-        triggerMonitorAction(task, `Error detected: ${errors[0].content.slice(0, 200)}`);
+        scheduleNotify(`Error detected: ${errors[0].content.slice(0, 200)}`, true);
         if (!config.repeat) stopMonitor(task.id);
       }
     }
@@ -554,7 +605,7 @@ function startMonitorTask(task: Task) {
           // Wait a bit to see if more entries come
           setTimeout(() => {
             if (Date.now() - lastActivityTime > 30_000) {
-              triggerMonitorAction(task, `Session appears complete.\n\nLast: ${lastAssistant.content.slice(0, 300)}`);
+              scheduleNotify(`Session appears complete.\n\nLast: ${lastAssistant.content.slice(0, 300)}`, true);
               if (!config.repeat) stopMonitor(task.id);
             }
           }, 35_000);
@@ -573,6 +624,7 @@ function startMonitorTask(task: Task) {
   const cleanup = () => {
     stopTail();
     if (idleTimer) clearInterval(idleTimer);
+    flushNotify(); // send any remaining batched notifications
   };
 
   activeMonitors.set(task.id, cleanup);

package/lib/telegram-bot.ts

@@ -94,8 +94,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);
@@ -188,7 +192,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);
@@ -230,7 +240,9 @@ async function sendHelp(chatId: number) {
     `📝 Submit task:\nproject-name: your instructions\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`
   );
@@ -644,57 +656,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`);
   }
+}
 
-  if (action === 'start') {
-    const status = getTunnelStatus();
-    if (status.status === 'running' && status.url) {
-      await send(chatId, `🌐 Tunnel already running:\n${status.url}`);
+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 (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) {
@@ -861,7 +880,9 @@ async function setBotCommands(token: string) {
           { command: 'task', description: 'Create task: /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: 'watch', description: 'Monitor session' },
           { command: 'watchers', description: 'List watchers' },

package/package.json

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

package/src/types/index.ts

@@ -86,6 +86,7 @@ export interface WatchConfig {
   actionPrompt?: string;     // message to send or task prompt
   actionProject?: string;    // for 'task' action
   repeat?: boolean;          // keep watching after trigger (default false)
+  notifyIntervalSeconds?: number; // min seconds between notifications (default 60)
 }
 
 export interface Task {