@aion0/forge 0.5.7 → 0.5.8

package/.forge/mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "forge": {
+      "type": "sse",
+      "url": "http://localhost:8406/sse?workspaceId=656c9e65-9d73-4cb6-a065-60d966e1fc78"
+    }
+  }
+}

package/RELEASE_NOTES.md

@@ -1,11 +1,134 @@
-# Forge v0.5.7
+# Forge v0.5.8
 
-Released: 2026-03-29
+Released: 2026-03-30
 
-## Changes since v0.5.6
+## Changes since v0.5.7
+
+### Features
+- feat: Restart Session button for persistentSession agents
+- feat: boundSessionId drives non-primary terminal open flow
+- feat: boundSessionId per agent — each agent has its own last session
+- feat: execution mode determined by config, not runtime tmux state
+- feat: /resolve API for workspace lookup + skills use env var → API fallback
+- feat: switch session button (▾) for non-primary agents with active terminal
+- feat: auto-fallback to headless when terminal startup fails
+- feat: Forge agent monitors all inbox states
+- feat: Forge agent — autonomous bus monitor with periodic scanning
+- feat: Forge agent auto-requests summary when agent completes without reply
+- feat: nudge sender when target agent completes — inject hint into terminal
+- feat: restore auto-reply on completion + keep check_outbox as supplement
+- feat: auto-reply to message sender on completion + check_outbox tool
+- feat: add MCP Server to monitor panel and status script
+- feat: get_agents tool + fuzzy send_message matching
+- feat: inject FORGE env vars at all terminal launch points
+- feat: --mcp-config injected at all claude terminal launch points
+- feat: Forge MCP Server — replace HTTP skills with native tool calls
+- feat: open terminal button on session list items
+- feat: detect CLI startup failures in persistent sessions
+- feat: all terminal entry points use fixedSessionId via --resume
+- feat: bind button on sessions list to set fixedSessionId
+- feat: click-to-change session binding in project header
+- feat: show bound session in project header and session list
+- feat: session picker dropdown for fixedSessionId binding
+- feat: session list shows full ID on expand with copy button
+- feat: show and edit fixedSessionId in agent config modal
+- feat: primary agent setup prompt for new and existing workspaces
+- feat: primary agent checkbox in agent config modal
+- feat: terminal dock — inline right panel with tabs and resizable width
+- feat: VibeCoding uses workspace primary agent's fixed session
+- feat: fixed CLI session binding for primary agent
+- feat: primary agent — terminal-only, fixed session, root directory
+- feat: persistent terminal session per agent
+- feat: watch send_message auto-detects tmux sessions (workspace + VibeCoding)
+- feat: watch send_message injects directly into terminal session
+
+### Bug Fixes
+- fix: unset profile env vars before setting new ones on agent switch
+- fix: normalize workDir paths before encoding session directory
+- fix: session list uses agent's workDir, not project root
+- fix: clear boundSessionId on agent change even without tmux session
+- fix: kill terminal and clear boundSessionId when agent CLI changes
+- fix: rename "Keep terminal session alive" to "Terminal mode"
+- fix: codex skipPermissionsFlag back to --full-auto
+- fix: codex skip flag + -c only when sessions exist
+- fix: set FORGE env vars as separate tmux command before CLI start
+- fix: set FORGE env vars in tmux, skills use env vars not curl lookup
+- fix: mark forge skills as FALLBACK so MCP tools take priority
+- fix: nudge explicitly says use MCP tool, not forge-send skill
+- fix: skills prefer MCP tools, fix subdirectory workspace lookup
+- fix: show headless after Kill, terminal (pending) only before daemon start
+- fix: Suspend vs Kill terminal behavior
+- fix: Forge agent nudge uses stronger language to trigger send_message
+- fix: always resolve agent launch info before opening terminal
+- fix: bus log updates immediately after message delete (no refresh needed)
+- fix: stop daemon kills tmux sessions + Forge agent only scans new messages
+- fix: enlarge session switch button (▾) for easier clicking
+- fix: terminal button visible during running state (was hidden)
+- fix: daemon persistent session uses -c for non-primary agents
+- fix: restore -c flag for non-primary agents to resume latest session
+- fix: Forge agent processes historical pending/running, skips done/failed
+- fix: Forge agent only scans messages after daemon start, ignores history
+- fix: Forge agent restarts message loop for stuck pending messages
+- fix: add skipPermissions to FloatingTerminalInline (was missing)
+- fix: pass skipPermissions to FloatingTerminal, add --dangerously-skip-permissions
+- fix: block terminal open when daemon not started
+- fix: re-open terminal when agent config changes (close old first)
+- fix: don't use claude -c for workspace agents (subdirs may have no session)
+- fix: MCP monitor shows port not pid, add separator after Tunnel
+- fix: add type:'sse' to MCP config (required by Claude Code schema)
+- fix: MCP server port 7830 → 8406 (follows 8403/8404/8405 sequence)
+- fix: MCP agentId resolved by server, not hardcoded in all URLs
+- fix: MAX_ACTIVE limits daemon start, not workspace loading
+- fix: increase MAX_ACTIVE workspaces from 2 to 5
+- fix: move all session action buttons to second row (right-aligned)
+- fix: skip message loop when persistent session fails to start
+- fix: only primary agent uses fixedSession, others use -c or session dialog
+- fix: refresh fixed session display after bind via window event
+- fix: resolveFixedSession auto-binds latest session when not set
+- fix: add error logging to session bind button for debugging
+- fix: session list uses disk files as source of truth, not stale index
+- fix: bind button always visible, set session when none bound
+- fix: limit fixedSessionId auto-bind to only 3 entry points
+- fix: show bind button even when no session is bound yet
+- fix: auto-bind fixedSessionId at Next.js API layer
+- fix: ensure primary session binding at all entry points
+- fix: auto-bind fixedSessionId on agent add and config update
+- fix: show terminal (pending) for persistentSession agents without tmux yet
+- fix: replace nested button with div+span in terminal dock tabs
+- fix: don't auto-open terminal UI on workspace load
+- fix: session binding edge cases
+- fix: auto-bind latest CLI session on upgrade instead of creating new
+- fix: persistent session starts claude with -c (resume last session)
+- fix: verify stored tmuxSession is alive before using, fallback to find
+- fix: findTmuxSession reads terminal-state.json for VibeCoding sessions
+- fix: session watch detects file switch (new session created)
+- fix: getAllAgentStates preserves tmuxSession + currentMessageId
+- fix: persistent session emits state update so frontend knows tmuxSession
+- fix: watch send_message sends configured prompt only + auto-Enter
+- fix: open terminal attaches to existing tmux session regardless of mode
+- fix: session watch only sends last matching entry, not all content
+- fix: remove .js extension from dynamic import for Next.js compat
+- fix: workspace terminal defaults to resume last session (-c)
+- fix: updateAgentConfig rebuilds worker + emits status update
+- fix: CLI backend auto-finds latest session when no sessionId
+
+### Performance
+- perf: cache session binding check, defer SessionView loading
+
+### Refactoring
+- refactor: MCP context via URL params, remove FORGE env var injection
+- refactor: fixedSessionId is project-level, not workspace/agent-level
+- refactor: remove manual/auto mode, unify message execution via tmuxSession
+
+### Documentation
+- revert auto-resume + document persistent terminal session plan
 
 ### Other
-- v0.5.6: watch enhancements, skills UI, dev mode fixes
+- revert: remove orchestrator auto-reply, let agent decide via MCP
+- cleanup: remove fixedSessionId from agent config and workspace state
+- simplify: remove auto-detect session binding complexity
+- revert: restore floating terminal windows, remove dock panel
+- revert auto-resume + document persistent terminal session plan
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.6...v0.5.7
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.7...v0.5.8

package/app/api/monitor/route.ts

@@ -24,6 +24,17 @@ export async function GET() {
   const workspace = countProcess('workspace-standalone');
   const tunnel = countProcess('cloudflared tunnel');
 
+  // MCP Server (runs inside workspace process, check /health endpoint)
+  let mcpStatus = { running: false, sessions: 0 };
+  try {
+    const mcpPort = Number(process.env.MCP_PORT) || 8406;
+    const mcpRes = run(`curl -s http://localhost:${mcpPort}/health 2>/dev/null`);
+    if (mcpRes.includes('"ok":true')) {
+      const data = JSON.parse(mcpRes);
+      mcpStatus = { running: true, sessions: data.sessions || 0 };
+    }
+  } catch {}
+
   // Tunnel URL
   let tunnelUrl = '';
   try {
@@ -55,6 +66,7 @@ export async function GET() {
       telegram: { running: telegram.count > 0, pid: telegram.pid, startedAt: telegram.startedAt },
       workspace: { running: workspace.count > 0, pid: workspace.pid, startedAt: workspace.startedAt },
       tunnel: { running: tunnel.count > 0, pid: tunnel.pid, url: tunnelUrl, startedAt: tunnel.startedAt },
+      mcp: { running: mcpStatus.running, port: 8406, sessions: mcpStatus.sessions },
     },
     sessions,
     uptime: uptime.replace(/.*up\s+/, '').replace(/,\s+\d+ user.*/, '').trim(),

package/app/api/project-sessions/route.ts

@@ -0,0 +1,61 @@
+import { NextResponse } from 'next/server';
+import { getFixedSession, setFixedSession, clearFixedSession, getAllFixedSessions } from '@/lib/project-sessions';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+// GET: get fixed session for a project, or all bindings
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const projectPath = url.searchParams.get('projectPath');
+  if (projectPath) {
+    // Also ensure mcp.json exists when querying
+    ensureMcpConfig(projectPath);
+    return NextResponse.json({ projectPath, fixedSessionId: getFixedSession(projectPath) || null });
+  }
+  return NextResponse.json(getAllFixedSessions());
+}
+
+// POST: set fixed session or ensure MCP config
+export async function POST(req: Request) {
+  const body = await req.json();
+  const { projectPath, fixedSessionId, action } = body;
+  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
+
+  // Ensure MCP config action
+  if (action === 'ensure_mcp') {
+    ensureMcpConfig(projectPath);
+    return NextResponse.json({ ok: true });
+  }
+
+  if (!fixedSessionId) {
+    clearFixedSession(projectPath);
+    return NextResponse.json({ ok: true, cleared: true });
+  }
+  setFixedSession(projectPath, fixedSessionId);
+  return NextResponse.json({ ok: true, projectPath, fixedSessionId });
+}
+
+/** Generate .forge/mcp.json in the project directory with workspace context baked in */
+function ensureMcpConfig(projectPath: string): void {
+  try {
+    const forgeDir = join(projectPath, '.forge');
+    const configPath = join(forgeDir, 'mcp.json');
+    const mcpPort = Number(process.env.MCP_PORT) || 8406;
+
+    // Resolve workspace + primary agent for this project
+    let wsParam = '';
+    try {
+      const { findWorkspaceByProject } = require('@/lib/workspace');
+      const ws = findWorkspaceByProject(projectPath);
+      if (ws) {
+        wsParam = `?workspaceId=${ws.id}`;
+      }
+    } catch {}
+
+    const config = { mcpServers: { forge: { type: 'sse', url: `http://localhost:${mcpPort}/sse${wsParam}` } } };
+
+    // Always rewrite (workspace context may have changed)
+    mkdirSync(forgeDir, { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+  } catch {}
+}

package/app/api/workspace/route.ts

@@ -71,7 +71,7 @@ export async function POST(req: Request) {
         dependsOn: agent.dependsOn.map((d: string) => idMap.get(d) || d),
         entries: agent.type === 'input' ? [] : undefined,
       });
-      state.agentStates[idMap.get(agent.id) || agent.id] = { smithStatus: 'down', mode: 'auto', taskStatus: 'idle', history: [], artifacts: [] };
+      state.agentStates[idMap.get(agent.id) || agent.id] = { smithStatus: 'down', taskStatus: 'idle', history: [], artifacts: [] };
     }
     if (template.nodePositions) {
       for (const [oldId, pos] of Object.entries(template.nodePositions)) {

package/check-forge-status.sh

@@ -41,6 +41,15 @@ else
   echo "  ○ Workspace       stopped"
 fi
 
+# MCP Server (runs inside workspace-standalone)
+mcp_status=$(curl -s http://localhost:8406/health 2>/dev/null)
+if echo "$mcp_status" | grep -q '"ok":true'; then
+  sessions=$(echo "$mcp_status" | python3 -c "import sys,json; print(json.load(sys.stdin).get('sessions',0))" 2>/dev/null)
+  echo "  ● MCP Server      running (port: 8406, sessions: $sessions)"
+else
+  echo "  ○ MCP Server      stopped"
+fi
+
 # Cloudflare Tunnel
 count=$(ps aux | grep 'cloudflared tunnel' | grep -v grep | wc -l | tr -d ' ')
 pid=$(ps aux | grep 'cloudflared tunnel' | grep -v grep | awk '{print $2}' | head -1)

package/components/MonitorPanel.tsx

@@ -9,6 +9,7 @@ interface MonitorData {
     telegram: { running: boolean; pid: string; startedAt?: string };
     workspace: { running: boolean; pid: string; startedAt?: string };
     tunnel: { running: boolean; pid: string; url: string };
+    mcp: { running: boolean; port: number; sessions: number };
   };
   sessions: { name: string; created: string; attached: boolean; windows: number }[];
   uptime: string;
@@ -64,9 +65,23 @@ export default function MonitorPanel({ onClose }: { onClose: () => void }) {
                     )}
                   </div>
                 ))}
+                {/* MCP Server — separate row (no pid, uses port + sessions) */}
+                <div className="flex items-center gap-2 text-xs">
+                  <span className={data.processes.mcp?.running ? 'text-green-400' : 'text-gray-500'}>●</span>
+                  <span className="text-[var(--text-primary)] w-28">MCP Server</span>
+                  {data.processes.mcp?.running ? (
+                    <>
+                      <span className="text-[var(--text-secondary)] font-mono text-[10px]">port: {data.processes.mcp.port}</span>
+                      <span className="text-gray-500 font-mono text-[9px]">{data.processes.mcp.sessions} session(s)</span>
+                    </>
+                  ) : (
+                    <span className="text-gray-500 text-[10px]">stopped</span>
+                  )}
+                </div>
                 {data.processes.tunnel.running && data.processes.tunnel.url && (
                   <div className="pl-6 text-[10px] text-[var(--accent)] truncate">{data.processes.tunnel.url}</div>
                 )}
+                <div className="border-t border-[var(--border)] my-1" />
               </div>
             </div>
 

package/components/ProjectDetail.tsx

@@ -82,6 +82,9 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
   const [pipelineBindings, setPipelineBindings] = useState<{ id: number; workflowName: string; enabled: boolean; config: any; lastRunAt: string | null; nextRunAt: string | null }[]>([]);
   const [pipelineRuns, setPipelineRuns] = useState<{ id: string; workflowName: string; pipelineId: string; status: string; summary: string; dedupKey: string | null; createdAt: string }[]>([]);
   const [availableWorkflows, setAvailableWorkflows] = useState<{ name: string; description?: string; builtin?: boolean; type?: string }[]>([]);
+  const [boundSession, setBoundSession] = useState<{ sessionId: string } | null>(null);
+  const [showSessionPicker, setShowSessionPicker] = useState(false);
+  const [availableSessions, setAvailableSessions] = useState<{ id: string; modified: string; size: number }[]>([]);
   const [expandedRunId, setExpandedRunId] = useState<string | null>(null);
   const [expandedPipeline, setExpandedPipeline] = useState<any>(null);
   const [showAddPipeline, setShowAddPipeline] = useState(false);
@@ -401,7 +404,26 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
     // Fetch git info and file tree in parallel
     fetchGitInfo();
     fetchTree();
-  }, [projectPath, fetchGitInfo, fetchTree]);
+    // Fetch project-level fixed session
+    fetchBoundSession();
+  }, [projectPath, fetchGitInfo, fetchTree]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const fetchBoundSession = useCallback(() => {
+    fetch(`/api/project-sessions?projectPath=${encodeURIComponent(projectPath)}`)
+      .then(r => r.json())
+      .then(data => {
+        if (data?.fixedSessionId) setBoundSession({ sessionId: data.fixedSessionId });
+        else setBoundSession(null);
+      })
+      .catch(() => {});
+  }, [projectPath]);
+
+  // Listen for session binding changes (from SessionView or other components)
+  useEffect(() => {
+    const handler = () => fetchBoundSession();
+    window.addEventListener('forge:session-bound', handler);
+    return () => window.removeEventListener('forge:session-bound', handler);
+  }, [fetchBoundSession]);
 
   // Lazy load tab-specific data only when switching to that tab
   useEffect(() => {
@@ -443,11 +465,78 @@ export default memo(function ProjectDetail({ projectPath, projectName, hasGit }:
             </button>
           </div>
         </div>
-        <div className="text-[9px] text-[var(--text-secondary)] mt-0.5">
-          {projectPath}
+        <div className="text-[9px] text-[var(--text-secondary)] mt-0.5 flex items-center gap-2 flex-wrap">
+          <span>{projectPath}</span>
           {gitInfo?.remote && (
-            <span className="ml-2">{gitInfo.remote.replace(/^https?:\/\//, '').replace(/^git@github\.com:/, 'github.com/').replace(/\.git$/, '')}</span>
+            <span>{gitInfo.remote.replace(/^https?:\/\//, '').replace(/^git@github\.com:/, 'github.com/').replace(/\.git$/, '')}</span>
           )}
+          {/* Fixed session: show current or "set session" */}
+          <span className="inline-flex items-center gap-1 px-1.5 py-0 rounded bg-[#f0883e]/10 text-[#f0883e] relative">
+            {boundSession?.sessionId ? (
+              <>
+                <span className="text-[8px]">session:</span>
+                <button onClick={() => {
+                  fetch(`/api/claude-sessions/${encodeURIComponent(projectName)}`)
+                    .then(r => r.json())
+                    .then(data => { if (Array.isArray(data)) setAvailableSessions(data.map((s: any) => ({ id: s.sessionId || s.id, modified: s.modified || '', size: s.size || 0 }))); })
+                    .catch(() => {});
+                  setShowSessionPicker(!showSessionPicker);
+                }}
+                  className="font-mono text-[8px] hover:text-white underline decoration-dotted" title="Click to change">
+                  {boundSession.sessionId.slice(0, 8)}
+                </button>
+                <button onClick={() => navigator.clipboard.writeText(boundSession.sessionId)}
+                  className="text-[7px] hover:text-white" title={boundSession.sessionId}>copy</button>
+              </>
+            ) : (
+              <button onClick={() => {
+                fetch(`/api/claude-sessions/${encodeURIComponent(projectName)}`)
+                  .then(r => r.json())
+                  .then(data => { if (Array.isArray(data)) setAvailableSessions(data.map((s: any) => ({ id: s.sessionId || s.id, modified: s.modified || '', size: s.size || 0 }))); })
+                  .catch(() => {});
+                setShowSessionPicker(!showSessionPicker);
+              }}
+                className="text-[8px] hover:text-white underline decoration-dotted">
+                set session
+              </button>
+            )}
+            {/* Session picker dropdown */}
+            {showSessionPicker && (
+              <div className="absolute top-full left-0 mt-1 z-50 bg-[var(--bg-primary)] border border-[var(--border)] rounded-lg shadow-xl p-2 min-w-[280px]"
+                onClick={e => e.stopPropagation()}>
+                <div className="text-[9px] text-[var(--text-secondary)] mb-1.5 font-medium">{boundSession?.sessionId ? 'Change session' : 'Select session'}</div>
+                <div className="max-h-48 overflow-y-auto space-y-1">
+                  {availableSessions.map(s => (
+                    <button key={s.id} onClick={async () => {
+                      try {
+                        await fetch('/api/project-sessions', {
+                          method: 'POST',
+                          headers: { 'Content-Type': 'application/json' },
+                          body: JSON.stringify({ projectPath, fixedSessionId: s.id }),
+                        });
+                        setBoundSession({ sessionId: s.id });
+                        window.dispatchEvent(new Event('forge:session-bound'));
+                      } catch {}
+                      setShowSessionPicker(false);
+                    }}
+                      className={`w-full text-left px-2 py-1.5 rounded text-[9px] flex items-center gap-2 ${
+                        s.id === boundSession?.sessionId
+                          ? 'bg-[#f0883e]/20 text-[#f0883e]'
+                          : 'hover:bg-[var(--bg-secondary)] text-[var(--text-secondary)]'
+                      }`}>
+                      <span className="font-mono">{s.id.slice(0, 8)}</span>
+                      {s.id === boundSession?.sessionId && <span className="text-[7px]">current</span>}
+                      {s.modified && <span className="text-[8px] opacity-60">{(() => { const d = Date.now() - new Date(s.modified).getTime(); return d < 3600000 ? `${Math.floor(d/60000)}m ago` : d < 86400000 ? `${Math.floor(d/3600000)}h ago` : new Date(s.modified).toLocaleDateString(); })()}</span>}
+                      {s.size > 0 && <span className="text-[8px] opacity-60">{s.size < 1048576 ? `${(s.size/1024).toFixed(0)}KB` : `${(s.size/1048576).toFixed(1)}MB`}</span>}
+                    </button>
+                  ))}
+                  {availableSessions.length === 0 && <div className="text-[9px] text-[var(--text-secondary)] px-2 py-1">No sessions found</div>}
+                </div>
+                <button onClick={() => setShowSessionPicker(false)}
+                  className="w-full mt-1.5 text-[8px] text-[var(--text-secondary)] hover:text-[var(--text-primary)] pt-1 border-t border-[var(--border)]">Close</button>
+              </div>
+            )}
+          </span>
         </div>
         {/* Tab switcher */}
         <div className="flex items-center gap-2 mt-1.5">
@@ -1464,7 +1553,12 @@ function AgentTerminalButton({ projectPath, projectName }: { projectPath: string
               </button>
 
               {sessions.length > 0 && (
-                <button onClick={() => openWithAgent(launchDialog.agentId, true, undefined, launchDialog.env, launchDialog.model)}
+                <button onClick={async () => {
+                  // Use fixedSession if available, otherwise latest session
+                  const { resolveFixedSession } = await import('@/lib/session-utils');
+                  const fixedId = await resolveFixedSession(projectPath);
+                  openWithAgent(launchDialog.agentId, true, fixedId || sessions[0].id, launchDialog.env, launchDialog.model);
+                }}
                   className="w-full text-left px-3 py-2 rounded border border-[#30363d] hover:border-[#3fb950] hover:bg-[#161b22] transition-colors">
                   <div className="text-xs text-white font-semibold">Resume Latest</div>
                   <div className="text-[9px] text-gray-500">{sessions[0].id.slice(0, 8)} · {formatTime(sessions[0].modified)} · {formatSize(sessions[0].size)}</div>

package/components/SessionView.tsx

@@ -58,6 +58,8 @@ export default function SessionView({
   const [batchMode, setBatchMode] = useState(false);
   const [selectedIds, setSelectedIds] = useState<Map<string, Set<string>>>(new Map());
   const bottomRef = useRef<HTMLDivElement>(null);
+  // Project-level fixed session binding
+  const [boundSessions, setBoundSessions] = useState<Record<string, { sessionId: string }>>({});
 
   // Load cached sessions tree
   const loadTree = useCallback(async (force = false) => {
@@ -84,6 +86,21 @@ export default function SessionView({
     } catch {}
   }, []);
 
+  // Load project-level fixed session bindings
+  const loadBoundSessions = useCallback(async () => {
+    try {
+      const res = await fetch('/api/project-sessions');
+      const all = await res.json(); // { "/path/to/project": "session-uuid", ... }
+      const bound: Record<string, { sessionId: string }> = {};
+      for (const p of projects) {
+        if (all[p.path]) {
+          bound[p.name] = { sessionId: all[p.path] };
+        }
+      }
+      setBoundSessions(bound);
+    } catch {}
+  }, [projects]);
+
   useEffect(() => {
     // In single-project mode: load cached first (fast), then sync in background
     if (singleProject) {
@@ -92,7 +109,10 @@ export default function SessionView({
       loadTree(true);
     }
     loadWatchers();
-  }, [loadTree, loadWatchers, singleProject]);
+    // Defer bound session loading to avoid blocking initial render
+    const t = setTimeout(loadBoundSessions, 500);
+    return () => clearTimeout(t);
+  }, [loadTree, loadWatchers, loadBoundSessions, singleProject]);
 
   // Auto-expand project if only one or if pre-selected
   useEffect(() => {
@@ -403,32 +423,60 @@ export default function SessionView({
                         {s.summary || s.firstPrompt?.slice(0, 40) || s.sessionId.slice(0, 8)}
                       </span>
                       {isWatched && <span className="text-[8px] text-[var(--accent)]">👁</span>}
-                      {/* Hover actions — hide in batch mode */}
+                    </div>
+                    <div className="flex items-center gap-2 mt-0.5">
+                      <span className="text-[8px] text-[var(--text-secondary)] font-mono">{s.sessionId.slice(0, 8)}</span>
+                      {boundSessions[project]?.sessionId === s.sessionId && (
+                        <span className="text-[7px] px-1 py-0 rounded bg-[#f0883e]/20 text-[#f0883e] font-medium">bound</span>
+                      )}
+                      {s.gitBranch && <span className="text-[8px] text-[var(--accent)]">{s.gitBranch}</span>}
+                      {s.modified && (
+                        <span className="text-[8px] text-[var(--text-secondary)]">
+                          {timeAgo(s.modified)}
+                        </span>
+                      )}
+                      {/* Actions — right side */}
                       {!batchMode && (
-                        <span className="hidden group-hover:flex items-center gap-0.5 shrink-0">
+                        <span className="hidden group-hover:flex items-center gap-0.5 ml-auto shrink-0">
+                          <button
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              const pp = projects.find(p => p.name === project)?.path || '';
+                              if (pp && onOpenInTerminal) onOpenInTerminal(s.sessionId, pp);
+                              else if (pp) window.dispatchEvent(new CustomEvent('forge:open-terminal', { detail: { projectPath: pp, projectName: project, agentId: 'claude', resumeMode: true, sessionId: s.sessionId } }));
+                            }}
+                            className="text-[8px] px-1 py-0.5 rounded bg-green-500/10 text-green-400 hover:bg-green-500/20"
+                            title="Open this session in terminal"
+                          >open</button>
+                          {boundSessions[project]?.sessionId !== s.sessionId && (
+                            <button
+                              onClick={async (e) => {
+                                e.stopPropagation();
+                                const pp = projects.find(p => p.name === project)?.path || '';
+                                if (!pp) return;
+                                const res = await fetch('/api/project-sessions', {
+                                  method: 'POST', headers: { 'Content-Type': 'application/json' },
+                                  body: JSON.stringify({ projectPath: pp, fixedSessionId: s.sessionId }),
+                                });
+                                if (res.ok) {
+                                  setBoundSessions(prev => ({ ...prev, [project]: { sessionId: s.sessionId } }));
+                                  window.dispatchEvent(new Event('forge:session-bound'));
+                                }
+                              }}
+                              className="text-[8px] px-1 py-0.5 rounded bg-[#f0883e]/10 text-[#f0883e] hover:bg-[#f0883e]/20"
+                              title="Set as fixed session"
+                            >bind</button>
+                          )}
                           <button
                             onClick={(e) => { e.stopPropagation(); createMonitorTask(project, s.sessionId); }}
                             className="text-[8px] px-1 py-0.5 rounded bg-[var(--accent)]/10 text-[var(--accent)] hover:bg-[var(--accent)]/20"
-                            title="Create monitor task (notify via Telegram)"
-                          >
-                            monitor
-                          </button>
+                            title="Monitor via Telegram"
+                          >monitor</button>
                           <button
                             onClick={(e) => { e.stopPropagation(); deleteSessionById(project, s.sessionId); }}
                             className="text-[8px] px-1 py-0.5 rounded bg-red-500/10 text-red-400 hover:bg-red-500/20"
                             title="Delete session"
-                          >
-                            del
-                          </button>
-                        </span>
-                      )}
-                    </div>
-                    <div className="flex items-center gap-2 mt-0.5">
-                      <span className="text-[8px] text-[var(--text-secondary)] font-mono">{s.sessionId.slice(0, 8)}</span>
-                      {s.gitBranch && <span className="text-[8px] text-[var(--accent)]">{s.gitBranch}</span>}
-                      {s.modified && (
-                        <span className="text-[8px] text-[var(--text-secondary)]">
-                          {timeAgo(s.modified)}
+                          >del</button>
                         </span>
                       )}
                     </div>