@aion0/forge 0.5.26 → 0.5.28

package/.forge/worktrees/pipeline-4dd8dc2d/src/types/index.ts

@@ -0,0 +1,129 @@
+export type MemoryStrategy = 'none' | 'sliding_window' | 'full' | 'full_with_summary' | 'external';
+
+export type SessionStatus = 'running' | 'idle' | 'paused' | 'archived' | 'error';
+
+export type ProviderName = 'anthropic' | 'google' | 'openai' | 'grok';
+
+export interface ProviderConfig {
+  name: ProviderName;
+  displayName: string;
+  apiKey?: string;
+  defaultModel: string;
+  models: string[];
+  enabled: boolean;
+}
+
+export interface MemoryConfig {
+  strategy: MemoryStrategy;
+  windowSize?: number;       // for sliding_window
+  compressAfter?: number;    // for full — compress after N messages
+  summaryModel?: string;     // model to use for summarization
+}
+
+export interface SessionTemplate {
+  id: string;
+  name: string;
+  description: string;
+  provider: ProviderName;
+  model?: string;
+  fallbackProvider?: ProviderName;
+  memory: MemoryConfig;
+  systemPrompt: string;
+  context?: {
+    files?: string[];
+  };
+  commands?: Record<string, { description: string; action: string; prompt?: string }>;
+  ui?: {
+    icon?: string;
+    color?: string;
+    pinned?: boolean;
+  };
+}
+
+export interface Message {
+  id: number;
+  sessionId: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  provider: ProviderName;
+  model: string;
+  tokenCount?: number;
+  createdAt: string;
+}
+
+export interface Session {
+  id: string;
+  name: string;
+  templateId: string;
+  provider: ProviderName;
+  model: string;
+  status: SessionStatus;
+  memory: MemoryConfig;
+  systemPrompt: string;
+  messageCount: number;
+  createdAt: string;
+  updatedAt: string;
+  lastMessage?: string;
+}
+
+export interface UsageRecord {
+  provider: ProviderName;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cost: number;
+  date: string;
+}
+
+export type TaskStatus = 'queued' | 'running' | 'done' | 'failed' | 'cancelled';
+export type TaskMode = 'prompt' | 'monitor' | 'shell';
+
+export interface WatchConfig {
+  condition: 'change' | 'idle' | 'complete' | 'error' | 'keyword';
+  keyword?: string;          // for 'keyword' condition
+  idleMinutes?: number;      // for 'idle' condition (default 10)
+  action: 'notify' | 'message' | 'task';
+  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 {
+  id: string;
+  projectName: string;
+  projectPath: string;
+  prompt: string;
+  mode: TaskMode;
+  status: TaskStatus;
+  priority: number;
+  conversationId?: string;
+  watchConfig?: WatchConfig;
+  log: TaskLogEntry[];
+  resultSummary?: string;
+  gitDiff?: string;
+  gitBranch?: string;
+  costUSD?: number;
+  error?: string;
+  createdAt: string;
+  startedAt?: string;
+  completedAt?: string;
+  scheduledAt?: string;
+}
+
+export interface TaskLogEntry {
+  type: 'system' | 'assistant' | 'result';
+  subtype?: string;
+  content: string;
+  tool?: string;
+  timestamp: string;
+}
+
+export interface AppConfig {
+  dataDir: string;
+  providers: Record<ProviderName, ProviderConfig>;
+  server: {
+    host: string;
+    port: number;
+  };
+}

package/.forge/worktrees/pipeline-4dd8dc2d/start.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# start.sh — Start Forge locally (kill old processes, build, start)
+#
+# Usage:
+#   ./start.sh          # production mode
+#   ./start.sh dev      # dev mode (hot-reload)
+
+# Kill all old forge processes
+pkill -f 'telegram-standalone' 2>/dev/null
+pkill -f 'terminal-standalone' 2>/dev/null
+pkill -f 'workspace-standalone' 2>/dev/null
+pkill -f 'cloudflared tunnel' 2>/dev/null
+# Wait for workspace daemon port to be released
+for i in 1 2 3; do
+  lsof -ti:${WORKSPACE_PORT:-8405} >/dev/null 2>&1 || break
+  sleep 1
+done
+pkill -f 'next-server' 2>/dev/null
+pkill -f 'next start' 2>/dev/null
+pkill -f 'next dev' 2>/dev/null
+sleep 1
+
+export PORT=${PORT:-8403}
+export TERMINAL_PORT=${TERMINAL_PORT:-8404}
+export WORKSPACE_PORT=${WORKSPACE_PORT:-8405}
+
+if [ "$1" = "dev" ]; then
+  export FORGE_DEV=1
+  pnpm dev
+else
+  pnpm build && pnpm start
+fi

package/.forge/worktrees/pipeline-4dd8dc2d/templates/smith-lead.json

@@ -0,0 +1,45 @@
+{
+  "name": "Lead",
+  "icon": "👑",
+  "description": "Primary coordinator — SOP-driven requirement intake, delegation, gap coverage, and quality gate",
+  "config": {
+    "label": "Lead",
+    "icon": "👑",
+    "backend": "cli",
+    "agentId": "claude",
+    "primary": true,
+    "persistentSession": true,
+    "workDir": "./",
+    "outputs": ["docs/lead/"],
+    "plugins": ["playwright", "shell-command"],
+    "role": "You are the Lead — primary coordinator of this workspace.\n\nYour context automatically includes a \"Workspace Team\" section showing all agents, their roles, status, and missing standard roles. Read it before every action.\n\n## SOP: Requirement Intake\n\nWhen you receive a requirement (from user input or inbox message):\n\n```\n1. Read the Workspace Team section in your context\n2. Classify the requirement:\n   - Single task → one request document\n   - Multi-module → break into independent request documents, group in a batch\n3. Route based on available roles:\n\n   HAS Architect?\n   └─ YES → create_request with full description → Architect breaks it down further\n   └─ NO → you break it down yourself, then:\n\n        HAS Engineer?\n        └─ YES → create_request for each module (status: open)\n                 Engineers claim via claim_request\n        └─ NO → implement it yourself in src/\n                 Record files_changed in docs/lead/impl-notes.md\n\n4. After implementation (by you or Engineer):\n\n   HAS QA?\n   └─ YES → update_response(section: engineer) triggers auto-notify to QA\n   └─ NO → you test it:\n          - Read acceptance_criteria from the request\n          - Write tests in tests/ or run manually\n          - Record results: update_response(section: qa, result: passed/failed)\n\n5. After testing:\n\n   HAS Reviewer?\n   └─ YES → auto-notified when QA passes\n   └─ NO → you review it:\n          - Check code quality, security, PRD compliance\n          - Record: update_response(section: review, result: approved/changes_requested)\n          - If changes_requested → send_message to Engineer or fix yourself\n```\n\n## SOP: Monitoring & Coordination\n\nWhile work is in progress:\n\n```\n1. get_status → check all agents' smith/task status\n2. list_requests → check request progress\n\nIF agent taskStatus = failed:\n   → Read their error from get_status\n   → send_message asking what went wrong\n   → If no response or unfixable: handle the request yourself\n\nIF agent taskStatus = running for too long:\n   → send_message to check progress\n\nIF request stuck in one status:\n   → Check which agent should be handling it\n   → send_message to nudge, or cover it yourself\n\nIF multiple Engineers exist and request unclaimed:\n   → send_message to available Engineer suggesting they claim_request\n```\n\n## SOP: Quality Gate (before declaring done)\n\n```\n1. list_requests(batch: current_batch)\n2. ALL requests status = done?\n   └─ NO → identify stuck ones, apply Monitoring SOP\n   └─ YES → continue\n3. Any request with review.result = changes_requested?\n   └─ YES → verify changes were made, re-review if no Reviewer\n4. Any request with qa.result = failed?\n   └─ YES → verify fix was applied, re-test if no QA\n5. Write summary to docs/lead/delivery-summary.md:\n   - Requirements covered\n   - Requests created and their final status\n   - Roles you covered due to gaps\n   - Any open issues\n```\n\n## Gap Coverage Reference\n\nWhen you cover a missing role, follow that role's standards:\n\n| Missing Role | What You Do | Output |\n|---|---|---|\n| PM/Architect | Break requirements into modules with acceptance_criteria | request documents via create_request |\n| Engineer | Read request → implement in src/ → update_response(section: engineer) | source code + files_changed |\n| QA | Read acceptance_criteria → write/run tests → update_response(section: qa) | test results in tests/ or docs/qa/ |\n| Reviewer | Read code changes → check quality/security → update_response(section: review) | review findings |\n\n## Rules\n\n- Workspace Team is in your context — don't call get_agents redundantly at start, just read it\n- DO call get_agents/get_status when you need live status updates mid-task\n- Every delegated task MUST go through request documents (create_request) — never just send_message with vague instructions\n- Each request needs concrete acceptance_criteria that QA can verify\n- Do NOT duplicate work an active agent is already doing — check status first\n- When covering a gap, be thorough — don't half-do it just because it's not your \"main\" role",
+    "steps": [
+      {
+        "id": "intake",
+        "label": "Intake & Analyze",
+        "prompt": "Read the Workspace Team section in your context. Identify: (1) which standard roles are present and missing, (2) incoming requirements from upstream input or inbox. For each requirement, decide scope: single task or multi-module. List what you will delegate vs handle yourself."
+      },
+      {
+        "id": "delegate",
+        "label": "Create Requests & Route",
+        "prompt": "For each module/task: create_request with title, description, acceptance_criteria, and batch name. If Architect exists, create high-level requests for them to break down. If only Engineers exist, create implementation-ready requests. If no one to delegate to, note which requests you will implement yourself. Verify with list_requests that all were created."
+      },
+      {
+        "id": "cover-gaps",
+        "label": "Cover Missing Roles",
+        "prompt": "Handle all work for missing roles. If no Engineer: implement code, then update_response(section: engineer). If no QA: write/run tests against acceptance_criteria, then update_response(section: qa). If no Reviewer: review code changes for quality and security, then update_response(section: review). Use get_status between tasks to check if other agents have completed their work."
+      },
+      {
+        "id": "monitor",
+        "label": "Monitor & Unblock",
+        "prompt": "Run get_status and list_requests. For each stuck/failed agent: diagnose and send_message to unblock, or take over the request yourself. For unclaimed requests: nudge available agents. Continue until all requests show progress."
+      },
+      {
+        "id": "gate",
+        "label": "Quality Gate & Summary",
+        "prompt": "list_requests for the current batch. Verify ALL requests are status=done with review.result=approved and qa.result=passed. If any are not: apply gap coverage. Write docs/lead/delivery-summary.md with: requirements covered, request statuses, roles you covered, open issues."
+      }
+    ]
+  },
+  "exportedAt": 1743724800000
+}

package/.forge/worktrees/pipeline-4dd8dc2d/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    ".next/dev/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/RELEASE_NOTES.md

@@ -1,36 +1,17 @@
-# Forge v0.5.26
+# Forge v0.5.28
 
-Released: 2026-04-06
+Released: 2026-04-09
 
-## Changes since v0.5.25
-
-### Features
-- feat: add review-mr as builtin pipeline
-- feat: all pipeline steps use worktree, no shell mode exception
-- feat: pipeline steps auto-use git worktree for isolated execution
+## Changes since v0.5.27
 
 ### Bug Fixes
-- fix: pipeline tasks use same model as normal tasks, no pipelineModel override
-- fix: task model selection — treat 'default' as fall-through
-- fix: ignore stdin + parse worktree field in pipeline nodes
-- fix: spawn claude without shell, resolve path via which
-- fix: remove shell: '/bin/zsh' from claude spawn to prevent arg interpretation
-- fix: all pipeline steps use worktree, shell gets env vars
-- fix: all pipeline steps use worktree, shell gets env vars
-- fix: shell/plugin pipeline steps skip worktree, run in project dir
-- fix: only auto-worktree for agent/prompt mode, not shell steps
-- fix: resolve rebase conflicts and fix anti-loop guard in messaging
-
-### Documentation
-- docs: update pipeline help with worktree env vars for shell steps
+- fix: restore notification polling for Telegram, add Suspense wrappers
 
-### Other
-- try some fixes 2
-- try some fixes
-- daemon is exclusive writer of state.json
-- skip auth in dev mode
-- fix terminal copy/paste and selection
-- add noreply and inbox to workspace messaging
+### Performance
+- perf: notifications fetch on-demand instead of polling
+- perf: remove task completion polling (replaced by hook stop)
+- perf: reduce polling frequency and lazy-load non-essential components
+- perf: async terminal-cwd to avoid blocking event loop
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.25...v0.5.26
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.27...v0.5.28

package/app/api/terminal-bell/route.ts

@@ -4,16 +4,20 @@ import { addNotification } from '@/lib/notifications';
 
 export async function POST(req: Request) {
   const { tabLabel } = await req.json();
-
   const label = tabLabel || 'Terminal';
 
+  // Check settings — terminal bell notifications can be disabled
+  const settings = loadSettings();
+  if ((settings as any).terminalBellEnabled === false) {
+    return NextResponse.json({ ok: true, skipped: true });
+  }
+
   // In-app notification
   try {
     addNotification('terminal_bell', `Terminal idle: ${label}`, `Claude appears to have finished in "${label}".`);
   } catch {}
 
   // Telegram notification
-  const settings = loadSettings();
   const { telegramBotToken, telegramChatId } = settings;
   if (telegramBotToken && telegramChatId) {
     try {

package/app/api/terminal-cwd/route.ts

@@ -1,5 +1,8 @@
 import { NextResponse } from 'next/server';
-import { execSync } from 'node:child_process';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
 
 export async function GET(req: Request) {
   const { searchParams } = new URL(req.url);
@@ -8,11 +11,11 @@ export async function GET(req: Request) {
     return NextResponse.json({ path: null });
   }
   try {
-    const cwd = execSync(`tmux display-message -p -t ${session} '#{pane_current_path}'`, {
+    const { stdout } = await execAsync(`tmux display-message -p -t ${session} '#{pane_current_path}'`, {
       encoding: 'utf-8',
       timeout: 3000,
-    }).trim();
-    return NextResponse.json({ path: cwd || null });
+    });
+    return NextResponse.json({ path: stdout.trim() || null });
   } catch {
     return NextResponse.json({ path: null });
   }

package/components/CodeViewer.tsx

@@ -224,8 +224,8 @@ export default function CodeViewer({ terminalRef }: { terminalRef: React.RefObje
     };
 
     fetchCwd();
-    // Poll cwd every 5s (user might cd to a different directory)
-    const timer = setInterval(fetchCwd, 5000);
+    // Poll cwd every 15s (user might cd to a different directory)
+    const timer = setInterval(fetchCwd, 15000);
     return () => { cancelled = true; clearInterval(timer); };
   }, [activeSession]);
 
@@ -247,35 +247,7 @@ export default function CodeViewer({ terminalRef }: { terminalRef: React.RefObje
     fetchDir();
   }, [currentDir]);
 
-  // Poll for task completions in the current project
-  useEffect(() => {
-    if (!currentDir) return;
-    const dirName = currentDir.split('/').pop() || '';
-    const check = async () => {
-      try {
-        const res = await fetch('/api/tasks?status=done');
-        const tasks = await res.json();
-        if (!Array.isArray(tasks) || tasks.length === 0) return;
-        const latest = tasks.find((t: any) => t.projectPath === currentDir || t.projectName === dirName);
-        if (latest && latest.id !== lastTaskCheckRef.current && latest.completedAt) {
-          // Only notify if completed in the last 30s
-          const age = Date.now() - new Date(latest.completedAt).getTime();
-          if (age < 30_000) {
-            lastTaskCheckRef.current = latest.id;
-            setTaskNotification({
-              id: latest.id,
-              status: latest.status,
-              prompt: latest.prompt,
-              sessionId: latest.conversationId,
-            });
-            setTimeout(() => setTaskNotification(null), 15_000);
-          }
-        }
-      } catch {}
-    };
-    const timer = setInterval(check, 5000);
-    return () => clearInterval(timer);
-  }, [currentDir]);
+  // Task completion is notified via hook stop — no polling needed
 
   // Build git status map for tree coloring
   const gitMap: GitStatusMap = new Map(gitChanges.map(g => [g.path, g.status]));

package/components/Dashboard.tsx

@@ -2,9 +2,9 @@
 
 import { useState, useEffect, useCallback, useRef, lazy, Suspense } from 'react';
 import { signOut } from 'next-auth/react';
-import TaskBoard from './TaskBoard';
-import TaskDetail from './TaskDetail';
-import TunnelToggle from './TunnelToggle';
+const TaskBoard = lazy(() => import('./TaskBoard'));
+const TaskDetail = lazy(() => import('./TaskDetail'));
+const TunnelToggle = lazy(() => import('./TunnelToggle'));
 import type { Task } from '@/src/types';
 import type { WebTerminalHandle } from './WebTerminal';
 
@@ -181,7 +181,7 @@ export default function Dashboard({ user }: { user: any }) {
     return () => clearInterval(id);
   }, []);
 
-  // Notification polling
+  // Notifications: poll unread count at 30s, full fetch when panel opens
   const fetchNotifications = useCallback(() => {
     fetch('/api/notifications').then(r => r.json()).then(data => {
       setNotifications(data.notifications || []);
@@ -191,10 +191,15 @@ export default function Dashboard({ user }: { user: any }) {
 
   useEffect(() => {
     fetchNotifications();
-    const id = setInterval(fetchNotifications, 10000);
+    const id = setInterval(fetchNotifications, 30000);
     return () => clearInterval(id);
   }, [fetchNotifications]);
 
+  // Refresh full list when notification panel opens
+  useEffect(() => {
+    if (showNotifications) fetchNotifications();
+  }, [showNotifications, fetchNotifications]);
+
   // Heartbeat for online user tracking
   useEffect(() => {
     const ping = () => {
@@ -204,26 +209,35 @@ export default function Dashboard({ user }: { user: any }) {
         .catch(() => {});
     };
     ping();
-    const id = setInterval(ping, 15_000); // every 15s
+    const id = setInterval(ping, 60_000); // every 60s
     return () => clearInterval(id);
   }, []);
 
   const fetchData = useCallback(async () => {
     try {
-      const [tasksRes, statusRes, projectsRes] = await Promise.all([
-        fetch('/api/tasks'),
-        fetch('/api/status'),
-        fetch('/api/projects'),
-      ]);
-      if (tasksRes.ok) setTasks(await tasksRes.json());
-      if (statusRes.ok) { const s = await statusRes.json(); setProviders(s.providers); setUsage(s.usage); }
-      if (projectsRes.ok) setProjects(await projectsRes.json());
+      // Only fetch what's needed for current view
+      const fetches: Promise<void>[] = [
+        fetch('/api/projects').then(async r => { if (r.ok) setProjects(await r.json()); }),
+      ];
+      // Tasks + status only when relevant tabs are active
+      if (viewMode === 'tasks' || viewMode === 'terminal') {
+        fetches.push(
+          fetch('/api/tasks').then(async r => { if (r.ok) setTasks(await r.json()); }),
+        );
+      }
+      if (viewMode === 'usage') {
+        fetches.push(
+          fetch('/api/status').then(async r => { if (r.ok) { const s = await r.json(); setProviders(s.providers); setUsage(s.usage); } }),
+        );
+      }
+      await Promise.all(fetches);
     } catch {}
-  }, []);
+  }, [viewMode]);
 
   useEffect(() => {
     fetchData();
-    const interval = setInterval(fetchData, 5000);
+    // Poll less aggressively: 10s instead of 5s
+    const interval = setInterval(fetchData, 10000);
     return () => clearInterval(interval);
   }, [fetchData]);
 
@@ -421,7 +435,7 @@ export default function Dashboard({ user }: { user: any }) {
                 : 'border-[var(--border)] text-[var(--text-secondary)] hover:text-[var(--text-primary)] hover:border-[var(--text-secondary)]'
             }`}
           >Usage</button>
-          <TunnelToggle />
+          <Suspense fallback={null}><TunnelToggle /></Suspense>
           {onlineCount.total > 0 && (
             <span className="text-[10px] text-[var(--text-secondary)] flex items-center gap-1" title={`${onlineCount.total} online${onlineCount.remote > 0 ? `, ${onlineCount.remote} remote` : ''}`}>
               <span className="text-green-500">●</span>
@@ -596,13 +610,13 @@ export default function Dashboard({ user }: { user: any }) {
           <>
             {/* Left — Task list */}
             <aside className="w-72 border-r border-[var(--border)] flex flex-col shrink-0">
-              <TaskBoard tasks={tasks} activeId={activeTaskId} onSelect={setActiveTaskId} onRefresh={fetchData} />
+              <Suspense fallback={null}><TaskBoard tasks={tasks} activeId={activeTaskId} onSelect={setActiveTaskId} onRefresh={fetchData} /></Suspense>
             </aside>
 
             {/* Center — Task detail / empty state */}
             <main className="flex-1 flex flex-col min-w-0">
               {activeTask ? (
-                <TaskDetail
+                <Suspense fallback={null}><TaskDetail
                   task={activeTask}
                   onRefresh={fetchData}
                   onFollowUp={async (data) => {
@@ -615,7 +629,7 @@ export default function Dashboard({ user }: { user: any }) {
                     setActiveTaskId(newTask.id);
                     fetchData();
                   }}
-                />
+                /></Suspense>
               ) : (
                 <div className="flex-1 flex items-center justify-center text-[var(--text-secondary)]">
                   <div className="text-center space-y-2">

package/components/WebTerminal.tsx

@@ -67,7 +67,9 @@ async function loadSharedState(): Promise<{ tabs: TabState[]; activeTabId: numbe
     if (!res.ok) return null;
     const d = await res.json();
     if (d && Array.isArray(d.tabs) && d.tabs.length > 0 && typeof d.activeTabId === 'number') {
-      return { tabs: d.tabs, activeTabId: d.activeTabId, sessionLabels: d.sessionLabels || {} };
+      // Always start with bell disabled — user can enable manually per tab
+      const tabs = d.tabs.map((t: any) => ({ ...t, bellEnabled: false }));
+      return { tabs, activeTabId: d.activeTabId, sessionLabels: d.sessionLabels || {} };
     }
     return null;
   } catch {
@@ -165,6 +167,38 @@ function collectAllSessionNames(tabs: TabState[]): string[] {
   return tabs.flatMap(t => collectSessionNames(t.tree));
 }
 
+// ─── Mouse Toggle Button ─────────────────────────────────────
+
+function MouseToggle() {
+  const [mouseOn, setMouseOn] = useState(true);
+
+  const toggle = () => {
+    const next = !mouseOn;
+    try {
+      const wsUrl = getWsUrl();
+      const ws = new WebSocket(wsUrl);
+      ws.onopen = () => {
+        ws.send(JSON.stringify({ type: 'tmux-mouse', mouse: next }));
+        setTimeout(() => ws.close(), 300);
+      };
+      ws.onerror = () => ws.close();
+    } catch {}
+    setMouseOn(next);
+  };
+
+  return (
+    <div className="flex items-center gap-1 mr-2">
+      <span className="text-[8px] text-gray-600">
+        {mouseOn ? 'scroll: trackpad · copy: Shift+drag' : 'scroll: Ctrl+B [ · copy: drag'}
+      </span>
+      <button onClick={toggle} title={mouseOn ? 'Click to disable mouse (easier text select)' : 'Click to enable mouse (trackpad scroll)'}
+        className={`text-[9px] px-1.5 py-0.5 rounded border transition-colors ${mouseOn ? 'border-green-600/40 text-green-400 bg-green-500/10' : 'border-gray-600 text-gray-500'}`}>
+        🖱️ {mouseOn ? 'ON' : 'OFF'}
+      </button>
+    </div>
+  );
+}
+
 // ─── Pending commands for new terminal panes ────────────────
 
 const pendingCommands = new Map<number, string>();
@@ -736,7 +770,7 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
 
         {/* Toolbar */}
         <div className="flex items-center gap-1 px-2 ml-auto">
-          <span className="text-[9px] text-gray-600 mr-2">Ctrl+Shift+C/V to copy/paste</span>
+          <MouseToggle />
           <button onClick={() => onSplit('vertical')} className="text-[10px] px-2 py-0.5 text-gray-400 hover:text-white hover:bg-[var(--term-border)] rounded">
             Split Right
           </button>

package/lib/terminal-standalone.ts

@@ -271,9 +271,9 @@ wss.on('connection', (ws: WebSocket) => {
       term = null;
     }
 
-    // Ensure mouse mode is off and scrollback is set (for old sessions too)
+    // Ensure mouse mode is on (enables trackpad scrolling) and scrollback is set
     try {
-      execSync(`${TMUX} set-option -t ${name} mouse off 2>/dev/null`);
+      execSync(`${TMUX} set-option -t ${name} mouse on 2>/dev/null`);
       execSync(`${TMUX} set-option -t ${name} history-limit 50000 2>/dev/null`);
     } catch {}
 
@@ -384,6 +384,23 @@ wss.on('connection', (ws: WebSocket) => {
           break;
         }
 
+        case 'tmux-mouse': {
+          // Toggle mouse for ALL tmux sessions (global + per-session)
+          const val = parsed.mouse ? 'on' : 'off';
+          try {
+            execSync(`${TMUX} set -g mouse ${val}`, { timeout: 3000 });
+            // Also apply to every existing session (overrides per-session setting)
+            const sessions = listTmuxSessions();
+            for (const s of sessions) {
+              try { execSync(`${TMUX} set-option -t "${s.name}" mouse ${val}`, { timeout: 1000 }); } catch {}
+            }
+            ws.send(JSON.stringify({ type: 'tmux-mouse-result', ok: true, mouse: parsed.mouse }));
+          } catch (e: any) {
+            ws.send(JSON.stringify({ type: 'tmux-mouse-result', ok: false, error: e.message }));
+          }
+          break;
+        }
+
         case 'load-state': {
           const state = loadTerminalState();
           ws.send(JSON.stringify({ type: 'terminal-state', data: state }));

package/package.json

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