@aion0/forge 0.5.7 → 0.5.9

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,15 @@
-# Forge v0.5.7
+# Forge v0.5.9
 
-Released: 2026-03-29
+Released: 2026-03-30
 
-## Changes since v0.5.6
+## Changes since v0.5.8
 
-### Other
-- v0.5.6: watch enhancements, skills UI, dev mode fixes
+### Features
+- feat: terminal floats below agent node, follows on drag/zoom
 
+### Bug Fixes
+- fix: revise dedup to not block legitimate messages
+- fix: reduce duplicate messages in workspace agent communication
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.6...v0.5.7
+
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.8...v0.5.9

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>

package/components/WebTerminal.tsx

@@ -310,11 +310,13 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
   // ─── Imperative handle for parent ─────────────────────
 
   useImperativeHandle(ref, () => ({
-    openSessionInTerminal(sessionId: string, projectPath: string) {
+    async openSessionInTerminal(sessionId: string, projectPath: string) {
       const tree = makeTerminal(undefined, projectPath);
       const paneId = firstTerminalId(tree);
       const sf = skipPermissions ? ' --dangerously-skip-permissions' : '';
-      const cmd = `cd "${projectPath}" && claude --resume ${sessionId}${sf}\n`;
+      let mcpFlag = '';
+      try { const { getMcpFlag } = await import('@/lib/session-utils'); mcpFlag = await getMcpFlag(projectPath); } catch {}
+      const cmd = `cd "${projectPath}" && claude --resume ${sessionId}${sf}${mcpFlag}\n`;
       pendingCommands.set(paneId, cmd);
       const projectName = projectPath.split('/').pop() || 'Terminal';
       const newTab: TabState = {
@@ -334,12 +336,21 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
       const knownClis = ['claude', 'codex', 'aider'];
       const agentCmd = knownClis.includes(agent) ? agent : 'claude';
 
-      // Resume flag from user's choice
+      // Resume flag: explicit sessionId > fixedSession (set async below) > -c
       let resumeFlag = '';
       if (agentCmd === 'claude') {
         if (sessionId) resumeFlag = ` --resume ${sessionId}`;
         else if (resumeMode) resumeFlag = ' -c';
       }
+      // Override with fixedSession if available (async, patched before command is sent)
+      let fixedSessionPending: Promise<void> | null = null;
+      if (agentCmd === 'claude' && !sessionId && projectPath) {
+        fixedSessionPending = import('@/lib/session-utils').then(({ resolveFixedSession }) =>
+          resolveFixedSession(projectPath).then(fixedId => {
+            if (fixedId) resumeFlag = ` --resume ${fixedId}`;
+          })
+        ).catch(() => {});
+      }
 
       // Model flag from profile
       const modelFlag = profileEnv?.CLAUDE_MODEL ? ` --model ${profileEnv.CLAUDE_MODEL}` : '';
@@ -368,6 +379,15 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
         if (skipPermissions && agentCmd === 'claude') sf = ' --dangerously-skip-permissions';
       }
 
+      // Wait for fixedSession resolution before building command
+      if (fixedSessionPending) await fixedSessionPending;
+
+      // MCP + env vars for claude-code agents
+      let mcpFlag = '';
+      if (agentCmd === 'claude' && projectPath) {
+        try { const { getMcpFlag } = await import('@/lib/session-utils'); mcpFlag = await getMcpFlag(projectPath); } catch {}
+      }
+
       let targetTabId: number | null = null;
 
       setTabs(prev => {
@@ -378,7 +398,7 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
         }
         const tree = makeTerminal(undefined, projectPath);
         const paneId = firstTerminalId(tree);
-        pendingCommands.set(paneId, `${envPrefix}cd "${projectPath}" && ${agentCmd}${resumeFlag}${modelFlag}${sf}\n`);
+        pendingCommands.set(paneId, `${envPrefix}cd "${projectPath}" && ${agentCmd}${resumeFlag}${modelFlag}${sf}${mcpFlag}\n`);
         const newTab: TabState = {
           id: nextId++,
           label: projectName,
@@ -898,13 +918,13 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
                                             // Model flag (claude-code only)
                                             const modelFlag = info.supportsSession && profileEnv.CLAUDE_MODEL ? ` --model ${profileEnv.CLAUDE_MODEL}` : '';
 
-                                            // Resume flag (claude-code only)
+                                            // Resume flag: use fixedSession if available, else -c
                                             let resumeFlag = '';
                                             if (info.supportsSession) {
                                               try {
-                                                const sRes = await fetch(`/api/claude-sessions/${encodeURIComponent(p.name)}`);
-                                                const sData = await sRes.json();
-                                                if (Array.isArray(sData) && sData.length > 0) resumeFlag = ' -c';
+                                                const { resolveFixedSession, buildResumeFlag } = await import('@/lib/session-utils');
+                                                const fixedId = await resolveFixedSession(p.path);
+                                                resumeFlag = buildResumeFlag(fixedId, true);
                                               } catch {}
                                             }
 
@@ -917,7 +937,13 @@ const WebTerminal = forwardRef<WebTerminalHandle, WebTerminalProps>(function Web
                                               sf = cfg?.skipPermissionsFlag ? ` ${cfg.skipPermissionsFlag}` : (cliCmd === 'claude' ? ' --dangerously-skip-permissions' : '');
                                             }
 
-                                            cmd = `${envExports}cd "${p.path}" && ${cliCmd}${resumeFlag}${modelFlag}${sf}\n`;
+                                            // MCP + env vars
+                                            let mcpFlag = '';
+                                            if (cliCmd === 'claude') {
+                                              try { const { getMcpFlag } = await import('@/lib/session-utils'); mcpFlag = await getMcpFlag(p.path); } catch {}
+                                            }
+
+                                            cmd = `${envExports}cd "${p.path}" && ${cliCmd}${resumeFlag}${modelFlag}${sf}${mcpFlag}\n`;
                                           } catch {
                                             cmd = `cd "${p.path}" && ${a.id}\n`;
                                           }
@@ -1448,29 +1474,18 @@ const MemoTerminalPane = memo(function TerminalPane({
             // Auto-run claude for project tabs (only if no pendingCommand already set)
             if (isNewlyCreated && projectPathRef.current && !pendingCommands.has(id)) {
               isNewlyCreated = false;
-              // Check if project has existing claude sessions to decide -c flag
               const pp = projectPathRef.current;
-              const pName = pp.replace(/\/+$/, '').split('/').pop() || '';
-              fetch(`/api/claude-sessions/${encodeURIComponent(pName)}`)
-                .then(r => r.json())
-                .then(sData => {
-                  const hasSession = Array.isArray(sData) ? sData.length > 0 : false;
-                  const resumeFlag = hasSession ? ' -c' : '';
-                  const skipFlag = skipPermRef.current ? ' --dangerously-skip-permissions' : '';
-                  setTimeout(() => {
-                    if (!disposed && ws?.readyState === WebSocket.OPEN) {
-                      ws.send(JSON.stringify({ type: 'input', data: `cd "${pp}" && claude${resumeFlag}${skipFlag}\n` }));
-                    }
-                  }, 300);
-                })
-                .catch(() => {
+              import('@/lib/session-utils').then(({ resolveFixedSession, buildResumeFlag, getMcpFlag }) => {
+                Promise.all([resolveFixedSession(pp), getMcpFlag(pp)]).then(([fixedId, mcpFlag]) => {
+                  const resumeFlag = buildResumeFlag(fixedId, true);
                   const skipFlag = skipPermRef.current ? ' --dangerously-skip-permissions' : '';
                   setTimeout(() => {
                     if (!disposed && ws?.readyState === WebSocket.OPEN) {
-                      ws.send(JSON.stringify({ type: 'input', data: `cd "${pp}" && claude${skipFlag}\n` }));
+                      ws.send(JSON.stringify({ type: 'input', data: `cd "${pp}" && claude${resumeFlag}${skipFlag}${mcpFlag}\n` }));
                     }
                   }, 300);
                 });
+              });
             }
             isNewlyCreated = false;
             // Force tmux to redraw by toggling size, then send reset