@aion0/forge 0.5.33 → 0.5.35

package/CLAUDE.md

@@ -60,6 +60,8 @@ When adding or changing a feature, check if `lib/help-docs/` needs updating. Eac
 - `08-rules.md` — CLAUDE.md templates
 - `09-issue-autofix.md` — GitHub issue scanner
 - `10-troubleshooting.md` — common issues
+- `11-workspace.md` — multi-agent workspace (smiths, daemon, request docs)
+- `12-usage.md` — token usage analytics and cost tracking
 If a feature change affects user-facing behavior, update the corresponding help doc in the same commit.
 
 ### Architecture

package/RELEASE_NOTES.md

@@ -1,8 +1,14 @@
-# Forge v0.5.33
+# Forge v0.5.35
 
-Released: 2026-04-10
+Released: 2026-04-11
 
-## Changes since v0.5.32
+## Changes since v0.5.34
 
+### Features
+- feat: workspace UX — refresh, bell, lock, mouse, terminal layout
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.32...v0.5.33
+### Other
+- feat(telegram): /i inject command for direct terminal input
+
+
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.34...v0.5.35

package/components/WorkspaceView.tsx

@@ -290,6 +290,21 @@ function useWorkspaceStream(workspaceId: string | null, onEvent?: (event: any) =
           setAgents(event.agents || []);
           setStates(event.agentStates || {});
           setBusLog(event.busLog || []);
+          // Seed logPreview from each agent's history (last 3 entries)
+          const initPreview: Record<string, string[]> = {};
+          for (const [agentId, st] of Object.entries(event.agentStates || {}) as [string, any][]) {
+            const hist: any[] = st?.history || [];
+            if (hist.length > 0) {
+              // Prefer the most recent step_summary or final_summary if present
+              const summary = [...hist].reverse().find(h => h?.subtype === 'step_summary' || h?.subtype === 'final_summary');
+              if (summary?.content) {
+                initPreview[agentId] = String(summary.content).split('\n').filter(l => l.trim()).slice(0, 4);
+              } else {
+                initPreview[agentId] = hist.slice(-3).map(h => h?.content).filter(Boolean).map(String);
+              }
+            }
+          }
+          setLogPreview(initPreview);
           if (event.daemonActive !== undefined) setDaemonActive(event.daemonActive);
           return;
         }
@@ -1994,6 +2009,30 @@ function getWsUrl() {
   return `${p}//${h}:${port + 1}`;
 }
 
+// ─── Bell notification (smith taskStatus changes) ────────
+
+const bellLastFired = new Map<string, number>();
+const BELL_COOLDOWN = 30000; // 30s cooldown per smith
+function fireSmithBell(label: string, status: 'done' | 'failed') {
+  const key = `${label}-${status}`;
+  const now = Date.now();
+  const last = bellLastFired.get(key) || 0;
+  if (now - last < BELL_COOLDOWN) return;
+  bellLastFired.set(key, now);
+  const title = status === 'done' ? 'Forge — Smith Done ✅' : 'Forge — Smith Failed ❌';
+  const body = `"${label}" task ${status === 'done' ? 'completed' : 'failed'}.`;
+  // Browser notification
+  if (typeof Notification !== 'undefined' && Notification.permission === 'granted') {
+    new Notification(title, { body, icon: '/icon.png' });
+  }
+  // Telegram + in-app via API (reuse terminal-bell endpoint)
+  fetch('/api/terminal-bell', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ tabLabel: `${label} (${status})` }),
+  }).catch(() => {});
+}
+
 // ─── Terminal Dock (right side panel with tabs) ──────────
 type TerminalEntry = { agentId: string; label: string; icon: string; cliId: string; cliCmd?: string; cliType?: string; workDir?: string; tmuxSession?: string; sessionName: string; resumeMode?: boolean; resumeSessionId?: string; profileEnv?: Record<string, string> };
 
@@ -2245,6 +2284,20 @@ function FloatingTerminal({ agentLabel, agentIcon, projectPath, agentCliId, cliC
   const [size, setSize] = useState({ w: 500, h: 300 });
   const [showCloseDialog, setShowCloseDialog] = useState(false);
   const [mouseOn, setMouseOn] = useState(true);
+  // Per-terminal "lock" — when locked, × button suspends directly (no kill option)
+  // Persisted by session name so it survives refresh
+  const lockKey = `forge.term.locked.${preferredSessionName || agentLabel}`;
+  const [locked, setLocked] = useState<boolean>(() => {
+    if (typeof window === 'undefined') return true;
+    // Default LOCKED — user must explicitly unlock to allow kill
+    const stored = localStorage.getItem(lockKey);
+    return stored === null ? true : stored === '1';
+  });
+  const toggleLock = () => {
+    const next = !locked;
+    setLocked(next);
+    try { localStorage.setItem(lockKey, next ? '1' : '0'); } catch {}
+  };
   const dragRef = useRef<{ startX: number; startY: number; origX: number; origY: number } | null>(null);
   const resizeRef = useRef<{ startX: number; startY: number; origW: number; origH: number } | null>(null);
 
@@ -2486,7 +2539,19 @@ function FloatingTerminal({ agentLabel, agentIcon, projectPath, agentCliId, cliC
         >
           🖱️ {mouseOn ? 'ON' : 'OFF'}
         </button>
-        <button onClick={() => setShowCloseDialog(true)} className="text-gray-500 hover:text-white text-sm shrink-0">✕</button>
+        <button
+          onClick={(e) => { e.stopPropagation(); toggleLock(); }}
+          onMouseDown={(e) => e.stopPropagation()}
+          className={`text-[9px] px-1.5 py-0.5 rounded border transition-colors ${locked ? 'border-yellow-500/60 text-yellow-400 bg-yellow-500/10' : 'border-gray-600 text-gray-500 bg-gray-800/50'}`}
+          title={locked ? 'Locked — × will only suspend (kill disabled). Click to unlock.' : 'Click to lock — prevents accidental kill, × always suspends'}
+        >
+          {locked ? '🔒' : '🔓'}
+        </button>
+        <button
+          onClick={() => setShowCloseDialog(true)}
+          className="text-gray-500 hover:text-white text-sm shrink-0"
+          title="Close terminal"
+        >✕</button>
       </div>
 
       {/* Terminal */}
@@ -2519,9 +2584,14 @@ function FloatingTerminal({ agentLabel, agentIcon, projectPath, agentCliId, cliC
       {showCloseDialog && (
         <div className="fixed inset-0 z-[60] flex items-center justify-center bg-black/50" onClick={() => setShowCloseDialog(false)}>
           <div className="bg-[#161b22] border border-[#30363d] rounded-lg p-4 shadow-xl max-w-sm" onClick={e => e.stopPropagation()}>
-            <h3 className="text-sm font-semibold text-white mb-2">Close Terminal — {agentLabel}</h3>
+            <h3 className="text-sm font-semibold text-white mb-2">
+              Close Terminal — {agentLabel}
+              {locked && <span className="ml-2 text-[9px] text-yellow-400">🔒 Locked</span>}
+            </h3>
             <p className="text-xs text-gray-400 mb-3">
-              This agent has an active terminal session.
+              {locked
+                ? 'Terminal is locked — kill is disabled. Click 🔒 in the header to unlock first.'
+                : 'This agent has an active terminal session.'}
             </p>
             <div className="flex gap-2">
               <button onClick={() => { setShowCloseDialog(false); onClose(false); }}
@@ -2529,17 +2599,20 @@ function FloatingTerminal({ agentLabel, agentIcon, projectPath, agentCliId, cliC
                 Suspend
                 <span className="block text-[9px] text-gray-500 mt-0.5">Hide panel, session keeps running</span>
               </button>
-              <button onClick={() => {
-                setShowCloseDialog(false);
-                if (wsRef.current?.readyState === WebSocket.OPEN && sessionNameRef.current) {
-                  wsRef.current.send(JSON.stringify({ type: 'kill', sessionName: sessionNameRef.current }));
-                }
-                onClose(true);
-              }}
-                className={`flex-1 px-3 py-1.5 text-[11px] rounded ${persistentSession ? 'bg-yellow-500/20 text-yellow-400 hover:bg-yellow-500/30' : 'bg-red-500/20 text-red-400 hover:bg-red-500/30'}`}>
-                {persistentSession ? 'Restart Session' : 'Kill Session'}
-                <span className={`block text-[9px] mt-0.5 ${persistentSession ? 'text-yellow-400/60' : 'text-red-400/60'}`}>
-                  {persistentSession ? 'Kill and restart with fresh env' : 'End session permanently'}
+              <button
+                disabled={locked}
+                onClick={() => {
+                  if (locked) return;
+                  setShowCloseDialog(false);
+                  if (wsRef.current?.readyState === WebSocket.OPEN && sessionNameRef.current) {
+                    wsRef.current.send(JSON.stringify({ type: 'kill', sessionName: sessionNameRef.current }));
+                  }
+                  onClose(true);
+                }}
+                className={`flex-1 px-3 py-1.5 text-[11px] rounded ${locked ? 'bg-gray-700/30 text-gray-500 cursor-not-allowed' : persistentSession ? 'bg-yellow-500/20 text-yellow-400 hover:bg-yellow-500/30' : 'bg-red-500/20 text-red-400 hover:bg-red-500/30'}`}>
+                {locked ? '🔒 Locked' : persistentSession ? 'Restart Session' : 'Kill Session'}
+                <span className={`block text-[9px] mt-0.5 ${locked ? 'text-gray-500' : persistentSession ? 'text-yellow-400/60' : 'text-red-400/60'}`}>
+                  {locked ? 'Unlock first to allow kill' : persistentSession ? 'Kill and restart with fresh env' : 'End session permanently'}
                 </span>
               </button>
             </div>
@@ -2650,6 +2723,8 @@ interface AgentNodeData {
   onSwitchSession: () => void;
   onSaveAsTemplate: () => void;
   mascotTheme: MascotTheme;
+  bellOn?: boolean;
+  onToggleBell?: () => void;
   onMarkIdle?: () => void;
   onMarkDone?: (notify: boolean) => void;
   onMarkFailed?: (notify: boolean) => void;
@@ -3148,7 +3223,7 @@ function WorkerMascot({ taskStatus, smithStatus, seed, accentColor, theme }: { t
 }
 
 function AgentFlowNode({ data }: NodeProps<Node<AgentNodeData>>) {
-  const { config, state, colorIdx, previewLines, projectPath, workspaceId, onRun, onPause, onStop, onRetry, onEdit, onRemove, onMessage, onApprove, onShowLog, onShowMemory, onShowInbox, onOpenTerminal, onSwitchSession, onSaveAsTemplate, mascotTheme, inboxPending = 0, inboxFailed = 0 } = data;
+  const { config, state, colorIdx, previewLines, projectPath, workspaceId, onRun, onPause, onStop, onRetry, onEdit, onRemove, onMessage, onApprove, onShowLog, onShowMemory, onShowInbox, onOpenTerminal, onSwitchSession, onSaveAsTemplate, mascotTheme, bellOn = false, onToggleBell, inboxPending = 0, inboxFailed = 0 } = data;
   const c = COLORS[colorIdx % COLORS.length];
   const smithStatus = state?.smithStatus || 'down';
   const taskStatus = state?.taskStatus || 'idle';
@@ -3285,12 +3360,17 @@ function AgentFlowNode({ data }: NodeProps<Node<AgentNodeData>>) {
           </span>
         <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); onShowInbox(); }}
           className="text-[9px] text-gray-600 hover:text-orange-400 px-1" title="Messages (inbox/outbox)">📨</button>
-        <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); onShowMemory(); }}
-          className="text-[9px] text-gray-600 hover:text-purple-400 px-1" title="Memory">🧠</button>
-        <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); onShowLog(); }}
-          className="text-[9px] text-gray-600 hover:text-gray-300 px-1" title="Logs">📋</button>
-        <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); onSaveAsTemplate(); }}
-          className="text-[9px] text-gray-600 hover:text-yellow-400 px-1" title="Save as template">💾</button>
+        <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); onToggleBell?.(); }}
+          className={`text-[9px] px-1 ${bellOn ? 'text-orange-400' : 'text-gray-600 hover:text-orange-400'}`}
+          title={bellOn ? 'Bell ON — notify when this smith finishes (click to disable)' : 'Bell OFF — click to enable task done/failed notifications'}>
+          {bellOn ? '🔔' : '🔕'}
+        </button>
+        <SmithMoreMenu
+          onShowMemory={onShowMemory}
+          onShowLog={onShowLog}
+          onSaveAsTemplate={onSaveAsTemplate}
+          onRefreshBus={async () => { if (workspaceId) try { await wsApi(workspaceId, 'refresh_bus'); } catch {} }}
+        />
         <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); onEdit(); }}
           className="text-[9px] text-gray-600 hover:text-blue-400 px-1">✏️</button>
         <button onPointerDown={e => e.stopPropagation()} onClick={e => { e.stopPropagation(); onRemove(); }}
@@ -3300,6 +3380,63 @@ function AgentFlowNode({ data }: NodeProps<Node<AgentNodeData>>) {
   );
 }
 
+// ─── Smith Node "More" Menu (⋯) ─────────────────────────
+
+function SmithMoreMenu({ onShowMemory, onShowLog, onSaveAsTemplate, onRefreshBus }: {
+  onShowMemory: () => void;
+  onShowLog: () => void;
+  onSaveAsTemplate: () => void;
+  onRefreshBus: () => void;
+}) {
+  const [open, setOpen] = useState(false);
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    const handler = (e: MouseEvent) => {
+      const target = e.target as unknown as globalThis.Node;
+      if (ref.current && !ref.current.contains(target)) setOpen(false);
+    };
+    window.addEventListener('mousedown', handler);
+    return () => window.removeEventListener('mousedown', handler);
+  }, [open]);
+
+  return (
+    <div ref={ref} className="relative">
+      <button
+        onPointerDown={e => e.stopPropagation()}
+        onClick={e => { e.stopPropagation(); setOpen(v => !v); }}
+        className="text-[10px] text-gray-600 hover:text-white px-1"
+        title="More actions"
+      >⋯</button>
+      {open && (
+        <div className="absolute right-0 top-full mt-1 z-50 bg-[#0d1117] border border-[#30363d] rounded shadow-xl py-1 min-w-[120px]">
+          <button
+            onPointerDown={e => e.stopPropagation()}
+            onClick={e => { e.stopPropagation(); setOpen(false); onShowMemory(); }}
+            className="w-full text-left text-[10px] px-2 py-1 hover:bg-[#161b22] text-gray-300 flex items-center gap-2"
+          >🧠 Memory</button>
+          <button
+            onPointerDown={e => e.stopPropagation()}
+            onClick={e => { e.stopPropagation(); setOpen(false); onShowLog(); }}
+            className="w-full text-left text-[10px] px-2 py-1 hover:bg-[#161b22] text-gray-300 flex items-center gap-2"
+          >📋 Logs</button>
+          <button
+            onPointerDown={e => e.stopPropagation()}
+            onClick={e => { e.stopPropagation(); setOpen(false); onRefreshBus(); }}
+            className="w-full text-left text-[10px] px-2 py-1 hover:bg-[#161b22] text-gray-300 flex items-center gap-2"
+          >🔄 Refresh state</button>
+          <button
+            onPointerDown={e => e.stopPropagation()}
+            onClick={e => { e.stopPropagation(); setOpen(false); onSaveAsTemplate(); }}
+            className="w-full text-left text-[10px] px-2 py-1 hover:bg-[#161b22] text-gray-300 flex items-center gap-2"
+          >💾 Save as template</button>
+        </div>
+      )}
+    </div>
+  );
+}
+
 const nodeTypes = { agent: AgentFlowNode, input: InputFlowNode };
 
 // ─── Main Workspace ──────────────────────────────────────
@@ -3417,6 +3554,52 @@ function WorkspaceViewInner({ projectPath, projectName, onClose }: {
   // Auto-open terminals removed — persistent sessions run in background tmux.
   // User opens terminal via ⌨️ button when needed.
 
+  // ─── Smith bell notifications (per-agent, persisted) ──
+  const [bellAgents, setBellAgents] = useState<Set<string>>(() => {
+    if (typeof window === 'undefined') return new Set();
+    try {
+      const raw = localStorage.getItem('forge.workspace.bellAgents');
+      return raw ? new Set(JSON.parse(raw)) : new Set();
+    } catch { return new Set(); }
+  });
+  const toggleBell = useCallback((agentId: string) => {
+    setBellAgents(prev => {
+      const next = new Set(prev);
+      if (next.has(agentId)) next.delete(agentId);
+      else {
+        next.add(agentId);
+        // Request browser notification permission on first enable
+        if (typeof Notification !== 'undefined' && Notification.permission === 'default') {
+          Notification.requestPermission().catch(() => {});
+        }
+      }
+      try { localStorage.setItem('forge.workspace.bellAgents', JSON.stringify([...next])); } catch {}
+      return next;
+    });
+  }, []);
+
+  // Watch taskStatus transitions and fire bell on running → done/failed
+  const prevTaskStatusRef = useRef<Record<string, string>>({});
+  useEffect(() => {
+    const prev = prevTaskStatusRef.current;
+    for (const agent of agents) {
+      const cur = states[agent.id]?.taskStatus;
+      const before = prev[agent.id];
+      if (cur && before === 'running' && (cur === 'done' || cur === 'failed')) {
+        if (bellAgents.has(agent.id)) {
+          fireSmithBell(agent.label, cur);
+        }
+      }
+    }
+    // Update snapshot for next tick
+    const snapshot: Record<string, string> = {};
+    for (const agent of agents) {
+      const s = states[agent.id]?.taskStatus;
+      if (s) snapshot[agent.id] = s;
+    }
+    prevTaskStatusRef.current = snapshot;
+  }, [states, agents, bellAgents]);
+
   // Rebuild nodes when agents/states/preview change — preserve existing positions + dimensions
   useEffect(() => {
     setRfNodes(prev => {
@@ -3468,6 +3651,8 @@ function WorkspaceViewInner({ projectPath, projectName, onClose }: {
             onPause: () => wsApi(workspaceId!, 'pause', { agentId: agent.id }),
             onStop: () => wsApi(workspaceId!, 'stop', { agentId: agent.id }),
             mascotTheme,
+            bellOn: bellAgents.has(agent.id),
+            onToggleBell: () => toggleBell(agent.id),
             onMarkIdle: () => wsApi(workspaceId!, 'mark_done', { agentId: agent.id, notify: false }),
             onMarkDone: (notify: boolean) => wsApi(workspaceId!, 'mark_done', { agentId: agent.id, notify }),
             onMarkFailed: (notify: boolean) => wsApi(workspaceId!, 'mark_failed', { agentId: agent.id, notify }),
@@ -3535,7 +3720,7 @@ function WorkspaceViewInner({ projectPath, projectName, onClose }: {
         };
       });
     });
-  }, [agents, states, logPreview, workspaceId, mascotTheme, savedPositions]); // eslint-disable-line react-hooks/exhaustive-deps
+  }, [agents, states, logPreview, workspaceId, mascotTheme, savedPositions, bellAgents]); // eslint-disable-line react-hooks/exhaustive-deps
 
   // Derive edges from dependsOn
   const rfEdges = useMemo(() => {

package/lib/help-docs/00-overview.md

@@ -2,6 +2,22 @@
 
 Forge is a self-hosted Vibe Coding platform for Claude Code. It provides a browser-based terminal, multi-agent workspace orchestration, AI task management, remote access, and mobile control via Telegram.
 
+## Main Features
+
+| Feature | Description |
+|---|---|
+| **Browser Terminal** | xterm.js + tmux persistence, split panes, mouse on/off toggle, auto-reconnect on disconnect |
+| **Projects** | File tree, Git operations, code search, per-project tabs, favorites |
+| **Workspace (Smiths)** | Multi-agent orchestration with DAG dependencies, message bus, request documents |
+| **Tasks** | Background AI task queue with hook-based completion notifications |
+| **Pipelines** | YAML-driven DAG workflows with scheduling and routing |
+| **Skills Marketplace** | Install/update Claude Code skills and slash commands per project |
+| **Usage Analytics** | Token/cost tracking by project, model, source with charts and heatmaps |
+| **Telegram Bot** | Mobile control — submit tasks, receive notifications |
+| **Remote Access** | One-click Cloudflare tunnel for remote browsing |
+| **GitHub Issue Auto-fix** | Scan issues, auto-fix, create PRs |
+| **Memory (optional)** | Code graph + knowledge via `@aion0/temper` MCP server |
+
 ## Quick Start
 
 ```bash

package/lib/help-docs/07-projects.md

@@ -40,6 +40,26 @@ Add project directories in Settings → **Project Roots** (e.g. `~/Projects`). F
 
 Click ★ next to a project to favorite it. Favorites appear at the top of the sidebar.
 
+## Sidebar & Navigation
+
+- **Collapse sidebar** (▶/◀ button): Narrow strip shows opened tabs at top (marked with green dot) and all other projects as initials below. Hover to show close (×) button on open tabs.
+- **Sidebar state is persisted** across browser refreshes via `localStorage`.
+- **Open projects** are marked with a green dot in the expanded sidebar; hover to reveal a close button.
+- **Close confirmation** prompts before closing a project tab to prevent accidental closes.
+- Up to **20 project tabs** stay mounted simultaneously (LRU eviction beyond that) — switching between recent projects is instant, terminal state is preserved.
+
+## Tree Views — Collapse All
+
+All hierarchical tree views have a `⇱` "Collapse all" button to quickly fold every folder:
+
+| Location | Button position |
+|---|---|
+| Project **Code** tab file tree | Right of "Files" label |
+| **Docs viewer** tree | Right of search box |
+| **Skills** panel file tree | Top of file tree |
+| **Workspace** sidebar | Header next to `+` |
+| **Session** list | Next to Batch button |
+
 ## Terminal
 
 ### Opening a Terminal

package/lib/help-docs/10-troubleshooting.md

@@ -39,6 +39,18 @@ rm ~/.forge/data/terminal-state.json
 # Restart server — tabs will be empty but tmux sessions survive
 ```
 
+### Terminal input is laggy
+Usually caused by high system load. Check:
+- System memory — if heavily swapping, kill some processes
+- Clean up old tmux sessions: `tmux list-sessions` then `tmux kill-session -t <name>`
+- Reduce polling: open tabs are limited to 20 by LRU eviction
+- Workspace terminals auto-reconnect on disconnect; no need to manually reopen
+
+### "Connection error" in workspace terminal
+The WebSocket dropped (system suspend, network blip). Forge auto-reconnects after 2s and re-attaches to the same tmux session. If it keeps happening:
+- Check `~/.forge/data/forge.log` for terminal-standalone errors
+- Restart: `forge server restart`
+
 ### gh CLI not authenticated (Issue Scanner)
 ```bash
 gh auth login

package/lib/help-docs/11-workspace.md

@@ -207,6 +207,24 @@ Agents use these MCP tools (via forge-mcp-server):
 | `mark_message_done` | Mark a processed message as done |
 | `check_outbox` | Check delivery status of sent messages |
 
+### Request vs Inbox — When to use which
+
+Every preset smith's role prompt includes a decision rule for this:
+
+**Use `create_request`** when:
+- Delegating substantive work (implement feature, write tests, do review)
+- Work has concrete deliverables and acceptance criteria
+- Work should flow through a pipeline (engineer → qa → reviewer)
+- The task needs to be tracked, claimed, and its status visible
+
+**Use `send_message`** when:
+- Asking a clarifying question
+- Quick status update or coordination
+- Reporting a bug back after review fails
+- No concrete deliverable
+
+**When unsure, prefer `create_request`** — a tracked artifact beats losing context in chat.
+
 ### Other
 
 | Tool | Description |
@@ -317,6 +335,31 @@ Click **⌨️** on any smith to open a terminal session:
 - Forge Skills available: `/forge-send`, `/forge-inbox`, `/forge-status`, `/forge-workspace-sync`
 - Session Picker: choose new session, continue existing, or browse all Claude sessions
 - Close terminal → smith returns to auto mode, pending messages resume
+- **Auto-reconnect**: If the WebSocket drops (e.g. system suspend, network blip), the terminal automatically reconnects after 2s and re-attaches to the same tmux session — conversation context preserved
+- **Mouse ON/OFF toggle** (🖱️ button in header): Toggle tmux mouse mode globally for all sessions
+  - **ON**: trackpad scroll, `Shift+drag` to select text
+  - **OFF**: drag to select text directly, `Ctrl+B [` to enter scroll mode
+  - Click to apply instantly (no restart needed)
+
+### Terminal Layout: Float vs Dock
+
+The workspace toolbar has a layout switcher: `⧉ Float` or `▤ Dock`.
+
+| Layout | Behavior |
+|---|---|
+| **Float** (default) | Each terminal is a draggable/resizable floating window positioned near its smith node |
+| **Dock** | All open terminals arranged in a fixed grid at the bottom of the workspace |
+
+Dock mode features:
+- Grid columns selector (1/2/3/4) — auto-expands based on open terminal count
+- 1 terminal with 4 columns → fills full width
+- 2 → half-half, 3 → thirds, 4 → quarters, 5+ → wraps to second row
+- Drag the top border to resize dock height
+- Layout preference persisted to localStorage
+
+### Smith Node Positions
+
+Drag smith nodes to reorganize the graph. Positions are **persisted to workspace state** and restored on reload. Auto-save debounces writes (500ms after drag stops).
 
 ## Watch (Autonomous Monitoring)
 
@@ -356,7 +399,7 @@ Agents can monitor file/git/command changes without message-driven triggers.
 
 Each smith can display an animated companion character next to its node.
 
-**Themes**: Stick figure, Cat, Dog, Pig, Emoji, Off (default)
+**Themes**: Stick figure, Cat, Pixel (8-bit RPG hero), Emoji, Off (default)
 
 - Theme picker in workspace header
 - Animates based on smith state (idle/running/done/failed/sleeping)
@@ -368,7 +411,7 @@ Each smith can display an animated companion character next to its node.
 | Action | Description |
 |--------|-------------|
 | **Start Daemon** | Launch all smiths, begin consuming messages |
-| **Stop Daemon** | Stop all smiths, kill workers |
+| **Stop Daemon** | Stop all smiths, kill workers. Preserves user's terminal conversation context (no `/clear` is sent). Tmux sessions attached to by a user are kept alive. |
 | **Run All** | Trigger all runnable agents once |
 | **Run** | Trigger specific agent |
 | **Pause/Resume** | Pause/resume message consumption for one agent |

package/lib/help-docs/12-usage.md

@@ -0,0 +1,103 @@
+# Usage Analytics
+
+Forge tracks Claude API token usage and estimated costs across all your projects.
+
+## Access
+
+Click **Usage** in the Dashboard top navigation.
+
+## Data Source
+
+Forge scans these sources on-demand (via **Scan Now** button) or automatically on startup:
+
+| Source | Location | What it tracks |
+|---|---|---|
+| `claude-code` | `~/.claude/projects/*/` | Interactive Claude Code sessions |
+| `forge-task` | `~/.forge/data/tasks.db` | Background tasks submitted through Forge |
+| `api-direct` | SDK/API calls logged by Forge | Direct API calls (rare) |
+
+Stored in `~/.forge/data/usage.db` (SQLite). Each row records: session_id, source, project, model, day, input/output/cache tokens, cost_usd, message_count.
+
+## Time Range Filter
+
+Buttons in the header: **7d / 30d / 90d / All** — filter all charts and tables.
+
+## Summary Cards
+
+| Card | Shows |
+|---|---|
+| **Total Cost** | Sum of `cost_usd` in the selected range + trend (↑/↓ vs previous half) |
+| **Daily Avg** | Total cost divided by days with activity |
+| **Tokens** | Total tokens (input + output + cache read), broken down below |
+| **Cache Hit** | `cacheRead / (input + cacheRead) × 100%` + cached tokens count |
+
+## Visualizations
+
+### Token Mix (stacked bar)
+A single horizontal bar showing the proportion of:
+- 🔵 Input tokens
+- 🟢 Output tokens
+- 🟣 Cache read tokens
+- 🟠 Cache create tokens
+
+Hover for tooltip.
+
+### Cost Trend (line chart)
+Line chart of daily cost over the selected range. Y-axis auto-scales to max cost. X-axis labels shown for ~7 date points.
+
+### Activity Heatmap
+GitHub-style 90-day grid: rows are weekdays (S/M/T/W/T/F/S), columns are weeks. Darker blue = higher cost. Hover a cell for exact date and cost.
+
+### Avg by Weekday
+Bar chart showing the average daily cost per weekday. Weekends highlighted in orange, weekdays in blue.
+
+### By Model / By Source (donut charts)
+Two side-by-side donut charts splitting total cost by model (Opus, Sonnet, Haiku) and by source (claude-code, forge-task, api-direct). Shows percentage + absolute cost per slice.
+
+### By Project (bar list)
+Top 20 projects ranked by cost. Each row shows project name, relative bar, cost, and session count.
+
+### Model Details (table)
+Per-model breakdown:
+- Input / Output tokens
+- Cost
+- Message count
+- Avg cost per message
+
+### Summary Stats (bottom 3 cards)
+- **Avg per session** — total cost / session count
+- **Avg per message** — total cost / message count
+- **Sessions per day** — session count / days with activity
+
+## Cost Calculation
+
+Estimates based on public Anthropic API pricing:
+
+| Model | Input | Output |
+|---|---|---|
+| Claude Opus 4 | $15/M | $75/M |
+| Claude Sonnet 4 | $3/M | $15/M |
+| Claude Haiku 4 | ~$0.80/M | ~$4/M |
+
+Cache reads are ~90% cheaper than regular inputs (~$0.30/M for Opus).
+
+> Actual cost may differ if you're on Claude Max/Pro subscription (fixed monthly), or using Bedrock/Vertex with different pricing.
+
+## Actions
+
+- **Scan Now** — Re-scans all JSONL session files and tasks.db, updates the database
+- **Time range** — 7/30/90/All days
+
+## Troubleshooting
+
+### Usage shows $0
+- No data yet — click **Scan Now**
+- Check `~/.claude/projects/` has JSONL session files
+- Check `~/.forge/data/tasks.db` exists and has rows
+- Check `~/.forge/data/usage.db` has data: `sqlite3 ~/.forge/data/usage.db 'SELECT COUNT(*) FROM token_usage'`
+
+### Wrong project name
+Usage scanner derives project name from directory path. Rename via scan refresh after moving projects.
+
+### Missing recent sessions
+Sessions in progress aren't tracked until the file is flushed. Click **Scan Now** to force a refresh.

package/lib/help-docs/CLAUDE.md

@@ -42,6 +42,7 @@ The token is valid for 24 hours. Store it in a variable and reuse for all API ca
 | `09-issue-autofix.md` | GitHub issue auto-fix pipeline |
 | `10-troubleshooting.md` | Common issues and solutions |
 | `11-workspace.md` | Workspace (Forge Smiths) — multi-agent orchestration, daemon, message bus, profiles |
+| `12-usage.md` | Token usage analytics — charts, heatmap, cost estimation, by model/project/source |
 
 ## Matching questions to docs
 
@@ -60,3 +61,6 @@ The token is valid for 24 hours. Store it in a variable and reuse for all API ca
 - Watch/monitor/detect/file changes/autonomous → `11-workspace.md`
 - Agent profile/env/model/cliType → `01-settings.md` + `11-workspace.md`
 - Agent log/logs/history/clear logs → `11-workspace.md`
+- Usage/cost/tokens/spending/billing/analytics → `12-usage.md`
+- Terminal dock/float/mouse toggle/reconnect → `07-projects.md` + `11-workspace.md`
+- Sidebar collapse/project tabs/favorites → `07-projects.md`

package/lib/telegram-bot.ts

@@ -32,7 +32,12 @@ 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' | 'task-create' | 'peek'>();
+const chatListMode = new Map<number, 'tasks' | 'projects' | 'sessions' | 'task-create' | 'peek' | 'inject-pick' | 'inject-typing'>();
+// Inject mode state — picked tmux session per chat
+const chatNumberedTmux = new Map<number, Map<number, string>>(); // num → tmux session name
+const chatInjectTarget = new Map<number, string>(); // chatId → tmux session name (currently selected)
+const chatInjectAutoClear = new Map<number, ReturnType<typeof setTimeout>>(); // auto-clear timers
+const INJECT_AUTO_CLEAR_MS = 3 * 60 * 1000; // 3 min idle → auto clear
 
 // Pending task creation: waiting for prompt text
 const pendingTaskProject = new Map<number, { name: string; path: string }>();  // chatId → project
@@ -178,6 +183,12 @@ async function handleMessage(msg: any) {
         await sendSessionContent(chatId, projectName, sessionId);
         return;
       }
+    } else if (mode === 'inject-pick') {
+      const tmuxMap = chatNumberedTmux.get(chatId);
+      if (tmuxMap?.has(num)) {
+        await pickInjectTarget(chatId, String(num));
+        return;
+      }
     } else {
       const taskMap = chatNumberedTasks.get(chatId);
       if (taskMap?.has(num)) {
@@ -259,6 +270,32 @@ async function handleMessage(msg: any) {
       case '/retry':
         await handleRetry(chatId, args[0]);
         break;
+      case '/inject':
+      case '/i':
+        if (args.length === 0) {
+          await startInjectFlow(chatId);
+        } else if (args.length === 1 && /^\d+$/.test(args[0])) {
+          // /i 1 — pick session number, prompt for text next
+          await pickInjectTarget(chatId, args[0]);
+        } else {
+          // /i 1 hello world — pick + send in one shot
+          if (/^\d+$/.test(args[0])) {
+            await pickInjectTarget(chatId, args[0]);
+            await handleInjectSend(chatId, args.slice(1).join(' '));
+          } else {
+            // No number — use last picked target
+            await handleInjectSend(chatId, args.join(' '));
+          }
+        }
+        break;
+      case '/iclear': {
+        chatInjectTarget.delete(chatId);
+        chatListMode.delete(chatId);
+        const t = chatInjectAutoClear.get(chatId);
+        if (t) { clearTimeout(t); chatInjectAutoClear.delete(chatId); }
+        await send(chatId, 'Inject target cleared.');
+        break;
+      }
       case '/tunnel':
         await handleTunnelStatus(chatId);
         break;
@@ -277,6 +314,12 @@ async function handleMessage(msg: any) {
     return;
   }
 
+  // Inject mode: if user picked a target, plain text goes to that tmux session
+  if (chatListMode.get(chatId) === 'inject-typing' && chatInjectTarget.has(chatId)) {
+    await handleInjectSend(chatId, text);
+    return;
+  }
+
   // Plain text — try to parse as "project: task" format
   const colonIdx = text.indexOf(':');
   if (colonIdx > 0 && colonIdx < 30) {
@@ -298,22 +341,22 @@ async function handleMessage(msg: any) {
 async function sendHelp(chatId: number) {
   await send(chatId,
     `🤖 Forge\n\n` +
-    `📋 /task — create task (interactive)\n` +
-    `/tasks — task list\n\n` +
+    `🎯 /i (or /inject) — type into a terminal & submit\n` +
+    `/iclear — clear inject target\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` +
+    `📋 /task — create background task\n` +
+    `/tasks — task list\n` +
     `🔧 /cancel <id>  /retry <id>\n` +
-    `/sessions — browse sessions\n` +
-    `/projects — list projects\n\n` +
+    `/projects — list projects\n` +
+    `🤖 /agents — list available agents\n\n` +
     `🌐 /tunnel — status\n` +
     `/tunnel_start / /tunnel_stop\n` +
     `/tunnel_code <admin_pw> — get session code\n\n` +
-    `🤖 /agents — list available agents\n` +
-    `Use @agent in /task to select (e.g. /task app @codex: review)\n\n` +
     `Reply number to select`
   );
 }
@@ -908,6 +951,234 @@ async function handleUnwatch(chatId: number, watcherId?: string) {
   await send(chatId, `🗑 Watcher ${watcherId} removed`);
 }
 
+// ─── Inject Commands ─────────────────────────────────────────
+
+/** Build a map of tmux session name → friendly label from terminal-state.json + workspace state */
+function getSessionLabels(): Record<string, string> {
+  const labels: Record<string, string> = {};
+  try {
+    const { join } = require('node:path');
+    const { homedir } = require('node:os');
+    const { readFileSync, existsSync, readdirSync } = require('node:fs');
+
+    // 1. terminal-state.json — vibecoding terminal tabs
+    const termState = join(homedir(), '.forge', 'data', 'terminal-state.json');
+    if (existsSync(termState)) {
+      try {
+        const state = JSON.parse(readFileSync(termState, 'utf-8'));
+        // sessionLabels (top-level map)
+        if (state.sessionLabels) {
+          for (const [name, label] of Object.entries(state.sessionLabels)) {
+            labels[name] = String(label);
+          }
+        }
+        // Walk tab trees and assign unique labels
+        // First collect all terminals per tab in order, so we can suffix duplicates
+        const collectTerminals = (node: any, acc: { name: string; proj: string | null }[]) => {
+          if (!node) return;
+          if (node.type === 'terminal' && node.sessionName) {
+            acc.push({ name: node.sessionName, proj: node.projectPath ? node.projectPath.split('/').pop() : null });
+          }
+          if (node.first) collectTerminals(node.first, acc);
+          if (node.second) collectTerminals(node.second, acc);
+        };
+        if (state.tabs) {
+          for (const tab of state.tabs) {
+            const terminals: { name: string; proj: string | null }[] = [];
+            collectTerminals(tab.tree, terminals);
+            const tabLabel = tab.label || 'Terminal';
+            terminals.forEach((t, idx) => {
+              if (labels[t.name]) return; // already labeled (e.g. workspace smith)
+              const base = t.proj || tabLabel;
+              // Disambiguate: append #N if multiple terminals share the same base in this tab
+              const sameBase = terminals.filter(o => (o.proj || tabLabel) === base);
+              if (sameBase.length > 1) {
+                const idxInBase = sameBase.findIndex(o => o.name === t.name) + 1;
+                labels[t.name] = `${base} #${idxInBase}`;
+              } else {
+                labels[t.name] = base;
+              }
+            });
+          }
+        }
+      } catch {}
+    }
+
+
+    // 2. Workspace state files — smith tmuxSession + agent label
+    const wsDir = join(homedir(), '.forge', 'workspaces');
+    if (existsSync(wsDir)) {
+      for (const wsId of readdirSync(wsDir)) {
+        const stateFile = join(wsDir, wsId, 'state.json');
+        if (!existsSync(stateFile)) continue;
+        try {
+          const ws = JSON.parse(readFileSync(stateFile, 'utf-8'));
+          const projectName = ws.projectName || '';
+          for (const [agentId, st] of Object.entries(ws.agentStates || {}) as any[]) {
+            if (st?.tmuxSession) {
+              const agent = (ws.agents || []).find((a: any) => a.id === agentId);
+              const label = agent?.label || agentId;
+              const icon = agent?.icon || '';
+              labels[st.tmuxSession] = `${icon} ${projectName ? `[${projectName}] ` : ''}${label}`.trim();
+            }
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+  return labels;
+}
+
+/** Capture the last non-empty line(s) of a tmux session for preview.
+ * @param maxLines max number of lines to return (1 for single-line list, more for detail view) */
+function getSessionPreview(sessionName: string, maxLines: number = 1): string {
+  try {
+    const { execSync } = require('node:child_process');
+    // Capture last screen, strip ANSI escapes, find last non-empty lines
+    const out = execSync(`tmux capture-pane -t "${sessionName}" -p -S -50 2>/dev/null`, {
+      encoding: 'utf-8',
+      timeout: 2000,
+    }) as string;
+    if (!out) return '';
+    // Strip ANSI escape codes
+    // eslint-disable-next-line no-control-regex
+    const clean = out.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+    const lines = clean.split('\n').map((l: string) => l.trim()).filter((l: string) => l.length > 0);
+    if (lines.length === 0) return '';
+    const tail = lines.slice(-maxLines);
+    if (maxLines === 1) {
+      const last = tail[0];
+      return last.length > 30 ? last.slice(0, 30) + '…' : last;
+    }
+    // Multi-line: truncate each line to 80 chars
+    return tail.map(l => l.length > 80 ? l.slice(0, 80) + '…' : l).join('\n');
+  } catch {
+    return '';
+  }
+}
+
+/** Schedule auto-clear of inject target after idle timeout */
+function scheduleInjectAutoClear(chatId: number) {
+  const existing = chatInjectAutoClear.get(chatId);
+  if (existing) clearTimeout(existing);
+  const timer = setTimeout(async () => {
+    chatInjectTarget.delete(chatId);
+    chatListMode.delete(chatId);
+    chatInjectAutoClear.delete(chatId);
+    try { await send(chatId, '⏰ Inject target auto-cleared (idle 3 min). Use /i to pick again.'); } catch {}
+  }, INJECT_AUTO_CLEAR_MS);
+  chatInjectAutoClear.set(chatId, timer);
+}
+
+/** List active tmux sessions and let user pick one to inject text into */
+async function startInjectFlow(chatId: number) {
+  const settings = loadSettings();
+  if (String(chatId) !== settings.telegramChatId) { await send(chatId, '⛔ Unauthorized'); return; }
+
+  try {
+    const { execSync } = require('node:child_process');
+    const out = execSync('tmux list-sessions -F "#{session_name}|#{session_attached}" 2>/dev/null', { encoding: 'utf-8', timeout: 3000 }).trim();
+    if (!out) {
+      await send(chatId, 'No active tmux sessions. Open a terminal in the browser first.');
+      return;
+    }
+    const sessions = (out as string).split('\n').map((line: string) => {
+      const [name, attached] = line.split('|');
+      return { name, attached: attached !== '0' };
+    }).filter((s: { name: string }) => s.name.startsWith('mw'));
+
+    if (sessions.length === 0) {
+      await send(chatId, 'No active Forge terminal sessions.');
+      return;
+    }
+
+    // Resolve friendly labels
+    const labelMap = getSessionLabels();
+
+    const tmuxMap = new Map<number, string>();
+    const lines = sessions.slice(0, 20).map((s: { name: string; attached: boolean }, i: number) => {
+      const num = i + 1;
+      tmuxMap.set(num, s.name);
+      const friendly = labelMap[s.name];
+      const display = friendly || s.name.replace(/^mw-?/, '');
+      const marker = s.attached ? '👁' : '⚫';
+      const preview = getSessionPreview(s.name);
+      const previewLine = preview ? `\n   └ ${preview}` : '';
+      return `${num}. ${marker} ${display}${previewLine}`;
+    });
+    chatNumberedTmux.set(chatId, tmuxMap);
+    chatListMode.set(chatId, 'inject-pick');
+
+    await send(chatId,
+      `🎯 Pick a terminal to inject text:\n\n${lines.join('\n')}\n\n` +
+      `👁 = attached, ⚫ = detached\n` +
+      `Reply with a number, or use /i <num> <text> for one-shot.\n` +
+      `Use /iclear to cancel.`
+    );
+  } catch (e: any) {
+    await send(chatId, `Error listing sessions: ${e.message}`);
+  }
+}
+
+/** After picking a session number, set it as the target and prompt for text */
+async function pickInjectTarget(chatId: number, numStr: string) {
+  const num = parseInt(numStr);
+  const tmuxMap = chatNumberedTmux.get(chatId);
+  if (!tmuxMap?.has(num)) {
+    await send(chatId, 'Invalid number. Use /i to refresh the list.');
+    return;
+  }
+  const sessionName = tmuxMap.get(num)!;
+  chatInjectTarget.set(chatId, sessionName);
+  chatListMode.set(chatId, 'inject-typing');
+  scheduleInjectAutoClear(chatId);
+  const labelMap = getSessionLabels();
+  const display = labelMap[sessionName] || sessionName.replace(/^mw-?/, '');
+  // Show last 8 lines of context so user knows what's in the terminal
+  const context = getSessionPreview(sessionName, 8);
+  const contextBlock = context ? `\n\n📺 Last output:\n\`\`\`\n${context}\n\`\`\`` : '';
+  await send(chatId,
+    `🎯 Target: ${display}${contextBlock}\n\n` +
+    `Send any text → typed + submitted in the terminal.\n` +
+    `Auto-clears after 3 min idle. Use /iclear to cancel.`
+  );
+}
+
+/** Send text to the currently selected tmux session */
+async function handleInjectSend(chatId: number, text: string) {
+  const settings = loadSettings();
+  if (String(chatId) !== settings.telegramChatId) { await send(chatId, '⛔ Unauthorized'); return; }
+
+  const sessionName = chatInjectTarget.get(chatId);
+  if (!sessionName) {
+    await send(chatId, 'No target selected. Use /i to pick a terminal first.');
+    return;
+  }
+  if (!text || !text.trim()) {
+    await send(chatId, 'Empty text. Send something to inject.');
+    return;
+  }
+
+  try {
+    const { execSync } = require('node:child_process');
+    // Paste text into the input then submit with Enter (like the user typed it and hit return)
+    const buf = require('node:os').tmpdir() + `/forge-inject-${Date.now()}.txt`;
+    require('node:fs').writeFileSync(buf, text);
+    execSync(`tmux load-buffer -t "${sessionName}" "${buf}" && tmux paste-buffer -t "${sessionName}" && sleep 0.2 && tmux send-keys -t "${sessionName}" Enter`, { timeout: 5000 });
+    require('node:fs').unlinkSync(buf);
+    const preview = text.length > 60 ? text.slice(0, 60) + '...' : text;
+    const labelMap = getSessionLabels();
+    const display = labelMap[sessionName] || sessionName.replace(/^mw-?/, '');
+    // Reset auto-clear timer on activity
+    scheduleInjectAutoClear(chatId);
+    await send(chatId, `✅ Sent to ${display}\n> ${preview}`);
+  } catch (e: any) {
+    await send(chatId, `❌ Inject failed: ${e.message}\nThe session may have closed. Use /i to pick another.`);
+    chatInjectTarget.delete(chatId);
+    chatListMode.delete(chatId);
+  }
+}
+
 // ─── Tunnel Commands ─────────────────────────────────────────
 
 async function handleTunnelStatus(chatId: number) {
@@ -1420,12 +1691,14 @@ 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: 'i', description: '🎯 Inject text into a terminal' },
+          { command: 'iclear', description: 'Clear inject target' },
           { 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: 'task', description: 'Create task (background)' },
+          { command: 'tasks', description: 'List tasks' },
           { command: 'tunnel', description: 'Tunnel status' },
           { command: 'tunnel_start', description: 'Start tunnel' },
           { command: 'tunnel_stop', description: 'Stop tunnel' },

package/lib/workspace/orchestrator.ts

@@ -3360,7 +3360,7 @@ Silently ingest this context. Do NOT respond — await an actual task.`;
   }
 
   /** Emit agents_changed so SSE pushes the updated list to frontend */
-  private emitAgentsChanged(): void {
+  emitAgentsChanged(): void {
     // Refresh topology cache so MCP queries always return current state
     this.rebuildTopo();
     const agents = Array.from(this.agents.values()).map(e => e.config);

package/lib/workspace-standalone.ts

@@ -203,6 +203,14 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
       case 'get_positions': {
         return json(res, { positions: orch.getNodePositions() });
       }
+      case 'refresh_bus': {
+        // Re-broadcast current bus log state — used by inbox refresh button
+        // when client state appears stale
+        orch.emit('event', { type: 'bus_log_updated', log: orch.getBusLog() } as any);
+        // Also re-emit agents_changed to refresh agent states
+        orch.emitAgentsChanged();
+        return json(res, { ok: true });
+      }
       case 'agent_done': {
         // Called by Claude Code Stop hook — agent finished a turn
         if (!agentId) return jsonError(res, 'agentId required');

package/package.json

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