@aion0/forge 0.5.6 → 0.5.8

package/lib/workspace/persistence.ts

@@ -147,7 +147,6 @@ export function loadWorkspace(workspaceId: string): WorkspaceState | null {
       if ('status' in agentState && !('smithStatus' in agentState)) {
         const oldStatus = (agentState as any).status;
         (agentState as any).smithStatus = 'down';
-        (agentState as any).mode = (agentState as any).runMode || 'auto';
         (agentState as any).taskStatus = (oldStatus === 'running' || oldStatus === 'listening') ? 'idle' :
                        (oldStatus === 'interrupted') ? 'idle' :
                        (oldStatus === 'waiting_approval') ? 'idle' :

package/lib/workspace/types.ts

@@ -12,6 +12,8 @@ export interface WorkspaceAgentConfig {
   icon: string;
   // Node type: 'agent' (default) or 'input' (user-provided requirements)
   type?: 'agent' | 'input';
+  // Primary agent: one per workspace, terminal-only, root dir, fixed session
+  primary?: boolean;
   // Input node: append-only entries (latest is active, older are history)
   content?: string;                    // legacy single content (migrated to entries)
   entries?: InputEntry[];              // incremental input history
@@ -32,6 +34,12 @@ export interface WorkspaceAgentConfig {
   steps: AgentStep[];
   // Approval gate
   requiresApproval?: boolean;
+  // Persistent terminal: keep a tmux+claude session alive, inject messages directly
+  persistentSession?: boolean;
+  // Bound CLI session ID for this agent (like fixedSessionId but per-agent)
+  boundSessionId?: string;
+  // Skip dangerous permissions check (default true when persistentSession is enabled)
+  skipPermissions?: boolean;
   // Watch: autonomous periodic monitoring
   watch?: WatchConfig;
 }
@@ -39,20 +47,23 @@ export interface WorkspaceAgentConfig {
 // ─── Watch Config ─────────────────────────────────────────
 
 export interface WatchTarget {
-  type: 'directory' | 'git' | 'agent_output' | 'command';
-  path?: string;           // directory: relative path; agent_output: agent ID
-  pattern?: string;        // glob for directory, stdout pattern for command
+  type: 'directory' | 'git' | 'agent_output' | 'agent_log' | 'session' | 'command';
+  path?: string;           // directory: relative path; agent_output/agent_log: agent ID
+  pattern?: string;        // glob for directory, regex/keyword for agent_log, stdout pattern for command
   cmd?: string;            // shell command (type='command' only)
+  contextChars?: number;   // agent_log/session: chars to capture around match (default 500)
+  debounce?: number;       // seconds to wait after match before triggering (default 10)
 }
 
-export type WatchAction = 'log' | 'analyze' | 'approve';
+export type WatchAction = 'log' | 'analyze' | 'approve' | 'send_message';
 
 export interface WatchConfig {
   enabled: boolean;
   interval: number;        // check interval in seconds (default 60)
   targets: WatchTarget[];
-  action: WatchAction;     // log=report only, analyze=auto-execute, approve=pending user approval
+  action: WatchAction;     // log=report only, analyze=auto-execute, approve=pending user approval, send_message=send to target agent
   prompt?: string;         // custom prompt for analyze action (default: "Analyze the following changes...")
+  sendTo?: string;         // send_message: target agent ID
 }
 
 export type AgentBackendType = 'api' | 'cli';
@@ -76,16 +87,12 @@ export type SmithStatus = 'down' | 'active';
 /** Task layer: current work execution */
 export type TaskStatus = 'idle' | 'running' | 'done' | 'failed';
 
-/** Agent execution mode */
-export type AgentMode = 'auto' | 'manual';
-
 /** @deprecated Use SmithStatus + TaskStatus instead */
 export type AgentStatus = SmithStatus | TaskStatus | 'paused' | 'waiting_approval' | 'listening' | 'interrupted';
 
 export interface AgentState {
   // ─── Smith layer (daemon lifecycle) ─────
   smithStatus: SmithStatus;           // down=not started, active=listening on bus
-  mode: AgentMode;                    // auto=respond to messages, manual=user in terminal
 
   // ─── Task layer (current work) ──────────
   taskStatus: TaskStatus;             // idle/running/done/failed
@@ -98,7 +105,7 @@ export interface AgentState {
   lastCheckpoint?: number;
   cliSessionId?: string;
   currentMessageId?: string;          // bus message that triggered current/last task execution
-  tmuxSession?: string;               // tmux session name for manual terminal reattach
+  tmuxSession?: string;               // tmux session name (persistent or user-opened terminal)
   startedAt?: number;
   completedAt?: number;
   error?: string;
@@ -221,7 +228,7 @@ export interface AgentBackend {
 // ─── Worker Events ───────────────────────────────────────
 
 export type WorkerEvent =
-  | { type: 'smith_status'; agentId: string; smithStatus: SmithStatus; mode: AgentMode }
+  | { type: 'smith_status'; agentId: string; smithStatus: SmithStatus }
   | { type: 'task_status'; agentId: string; taskStatus: TaskStatus; error?: string }
   | { type: 'log'; agentId: string; entry: TaskLogEntry }
   | { type: 'step'; agentId: string; stepIndex: number; stepLabel: string }

package/lib/workspace/watch-manager.ts

@@ -7,8 +7,9 @@
  */
 
 import { EventEmitter } from 'node:events';
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync, readFileSync, openSync, readSync, fstatSync, closeSync } from 'node:fs';
 import { join, relative } from 'node:path';
+import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import type { WorkspaceAgentConfig, WatchTarget, WatchConfig } from './types';
 import { appendAgentLog } from './persistence';
@@ -19,6 +20,8 @@ interface WatchSnapshot {
   lastCheckTime: number;   // timestamp ms — only files modified after this are "changed"
   gitHash?: string;
   commandOutput?: string;
+  logLineCount?: number;   // last known line count in agent's logs.jsonl
+  sessionFileSize?: number; // last known file size of session JSONL (bytes)
 }
 
 interface WatchChange {
@@ -132,11 +135,196 @@ function detectCommandChanges(projectPath: string, target: WatchTarget, prevOutp
   }
 }
 
+function detectAgentLogChanges(workspaceId: string, targetAgentId: string, pattern: string | undefined, prevLineCount: number, contextChars = 500): { changes: WatchChange | null; lineCount: number } {
+  const logFile = join(homedir(), '.forge', 'workspaces', workspaceId, 'agents', targetAgentId, 'logs.jsonl');
+  if (!existsSync(logFile)) return { changes: null, lineCount: 0 };
+
+  try {
+    const lines = readFileSync(logFile, 'utf-8').split('\n').filter(Boolean);
+    const currentCount = lines.length;
+    if (currentCount <= prevLineCount) return { changes: null, lineCount: currentCount };
+
+    // Get new lines since last check
+    const newLines = lines.slice(prevLineCount);
+    const newEntries: string[] = [];
+
+    // Build matcher: try regex first, fallback to case-insensitive includes
+    let matcher: ((text: string) => boolean) | null = null;
+    if (pattern) {
+      try {
+        const re = new RegExp(pattern, 'i');
+        matcher = (text: string) => re.test(text);
+      } catch {
+        const lower = pattern.toLowerCase();
+        matcher = (text: string) => text.toLowerCase().includes(lower);
+      }
+    }
+
+    // Extract content around match (contextChars before + after match point)
+    const extractContext = (text: string): string => {
+      if (!pattern || text.length <= contextChars) return text.slice(0, contextChars);
+      // Find match position for context window
+      let matchIdx = 0;
+      try {
+        const re = new RegExp(pattern, 'i');
+        const m = re.exec(text);
+        if (m) matchIdx = m.index;
+      } catch {
+        matchIdx = text.toLowerCase().indexOf(pattern.toLowerCase());
+        if (matchIdx === -1) matchIdx = 0;
+      }
+      const half = Math.floor(contextChars / 2);
+      const start = Math.max(0, matchIdx - half);
+      const end = Math.min(text.length, start + contextChars);
+      return (start > 0 ? '...' : '') + text.slice(start, end) + (end < text.length ? '...' : '');
+    };
+
+    for (const line of newLines) {
+      try {
+        const entry = JSON.parse(line);
+        const content = entry.content || '';
+        if (matcher && !matcher(content)) continue;
+        newEntries.push(extractContext(content));
+      } catch {
+        if (matcher && !matcher(line)) continue;
+        newEntries.push(extractContext(line));
+      }
+    }
+
+    if (newEntries.length === 0) return { changes: null, lineCount: currentCount };
+
+    return {
+      changes: {
+        targetType: 'agent_log',
+        description: `${newEntries.length} new log entries${pattern ? ` matching "${pattern}"` : ''}`,
+        files: newEntries.slice(0, 10),
+      },
+      lineCount: currentCount,
+    };
+  } catch {
+    return { changes: null, lineCount: prevLineCount };
+  }
+}
+
+// Track which session file was used last (to detect file switch)
+const lastSessionFile = new Map<string, string>();
+
+function detectSessionChanges(projectPath: string, pattern: string | undefined, prevLineCount: number, contextChars = 500, sessionId?: string): { changes: WatchChange | null; lineCount: number } {
+  const claudeHome = join(homedir(), '.claude', 'projects');
+  const encoded = projectPath.replace(/\//g, '-');
+  const sessionDir = join(claudeHome, encoded);
+  if (!existsSync(sessionDir)) return { changes: null, lineCount: prevLineCount };
+
+  try {
+    let latestFile: string;
+
+    if (sessionId) {
+      latestFile = join(sessionDir, `${sessionId}.jsonl`);
+      if (!existsSync(latestFile)) return { changes: null, lineCount: prevLineCount };
+    } else {
+      const files = readdirSync(sessionDir)
+        .filter(f => f.endsWith('.jsonl'))
+        .map(f => ({ name: f, mtime: statSync(join(sessionDir, f)).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime);
+      if (files.length === 0) return { changes: null, lineCount: prevLineCount };
+      latestFile = join(sessionDir, files[0].name);
+    }
+    // Detect if session file changed (user started new session) → reset tracking
+    const cacheKey = `${projectPath}:${sessionId || 'latest'}`;
+    const prevFile = lastSessionFile.get(cacheKey);
+    if (prevFile && prevFile !== latestFile) {
+      // Session file switched — reset prevLineCount to read from start of new file
+      prevLineCount = 0;
+      console.log(`[watch] Session file switched: ${prevFile.split('/').pop()} → ${latestFile.split('/').pop()}`);
+    }
+    lastSessionFile.set(cacheKey, latestFile);
+
+    // Only read new bytes since last check (efficient for large files)
+    const fd = openSync(latestFile, 'r');
+    const fileSize = fstatSync(fd).size;
+    if (fileSize <= prevLineCount) { closeSync(fd); return { changes: null, lineCount: fileSize }; }
+
+    const readFrom = Math.max(0, prevLineCount > 0 ? prevLineCount - 1 : 0);
+    const readSize = Math.min(fileSize - readFrom, 500_000); // max 500KB per check
+    const buf = Buffer.alloc(readSize);
+    readSync(fd, buf, 0, readSize, readFrom);
+    closeSync(fd);
+
+    const tail = buf.toString('utf-8');
+    const newLines = tail.split('\n').filter(Boolean);
+    if (prevLineCount > 0 && newLines.length > 0) newLines.shift(); // skip partial first line
+
+    // Build matcher
+    let matcher: ((text: string) => boolean) | null = null;
+    if (pattern) {
+      try {
+        const re = new RegExp(pattern, 'i');
+        matcher = (text: string) => re.test(text);
+      } catch {
+        const lower = pattern.toLowerCase();
+        matcher = (text: string) => text.toLowerCase().includes(lower);
+      }
+    }
+
+    // Only extract the LAST assistant/result text (not all entries)
+    const entries: string[] = [];
+    for (const line of [...newLines].reverse()) {
+      try {
+        const parsed = JSON.parse(line);
+        let text = '';
+        if (parsed.type === 'assistant' && parsed.message?.content) {
+          for (const block of (Array.isArray(parsed.message.content) ? parsed.message.content : [parsed.message.content])) {
+            if (typeof block === 'string') text += block;
+            else if (block.type === 'text' && block.text) text += block.text;
+          }
+        } else if (parsed.type === 'result' && parsed.result) {
+          text = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
+        } else if (parsed.type === 'human' || parsed.type === 'user') {
+          const content = parsed.content || parsed.message?.content;
+          text = typeof content === 'string' ? content : '';
+        }
+
+        if (!text) continue;
+        if (matcher && !matcher(text)) continue;
+
+        // Context extraction around match
+        if (text.length > contextChars && pattern) {
+          let matchIdx = 0;
+          try { matchIdx = new RegExp(pattern, 'i').exec(text)?.index || 0; } catch {}
+          const half = Math.floor(contextChars / 2);
+          const start = Math.max(0, matchIdx - half);
+          const end = Math.min(text.length, start + contextChars);
+          text = (start > 0 ? '...' : '') + text.slice(start, end) + (end < text.length ? '...' : '');
+        } else {
+          text = text.slice(0, contextChars);
+        }
+        entries.push(text);
+        break; // only take the last matching entry (we're scanning in reverse)
+      } catch {}
+    }
+
+    if (entries.length === 0) return { changes: null, lineCount: fileSize };
+
+    return {
+      changes: {
+        targetType: 'session',
+        description: `${entries.length} new session entries${pattern ? ` matching "${pattern}"` : ''}`,
+        files: entries.slice(0, 10),
+      },
+      lineCount: fileSize, // actually bytes, reusing field name
+    };
+  } catch {
+    return { changes: null, lineCount: prevLineCount };
+  }
+}
+
 // ─── WatchManager class ──────────────────────────────────
 
 export class WatchManager extends EventEmitter {
   private timers = new Map<string, NodeJS.Timeout>();
   private snapshots = new Map<string, WatchSnapshot>();
+  private pendingAlert = new Map<string, { changes: WatchChange[]; summary: string; timestamp: number }>();
+  private debounceTimers = new Map<string, NodeJS.Timeout>();
 
   constructor(
     private workspaceId: string,
@@ -229,6 +417,37 @@ export class WatchManager extends EventEmitter {
           }
           break;
         }
+        case 'agent_log': {
+          if (target.path) {
+            const agentLabel = this.getAgents().get(target.path)?.config.label || target.path;
+            const { changes, lineCount } = detectAgentLogChanges(this.workspaceId, target.path, target.pattern, prev.logLineCount || 0, target.contextChars || 500);
+            newSnapshot.logLineCount = lineCount;
+            if (changes) allChanges.push({ ...changes, description: `${agentLabel} log: ${changes.description}` });
+          }
+          break;
+        }
+        case 'session': {
+          // Resolve session ID: explicit (cmd field) > agent's cliSessionId > latest file
+          let sessionId: string | undefined;
+          if (target.cmd) {
+            // Explicit session ID selected by user
+            sessionId = target.cmd;
+          } else if (target.path) {
+            // Agent selected — use its current cliSessionId
+            const agents = this.getAgents();
+            const targetAgent = agents.get(target.path);
+            if (targetAgent) {
+              sessionId = (targetAgent.state as any).cliSessionId;
+              if (!sessionId) {
+                console.log(`[watch] Agent ${targetAgent.config.label} has no cliSessionId — falling back to latest session file`);
+              }
+            }
+          }
+          const { changes, lineCount: newFileSize } = detectSessionChanges(this.projectPath, target.pattern, prev.sessionFileSize || 0, target.contextChars || 500, sessionId);
+          newSnapshot.sessionFileSize = newFileSize;
+          if (changes) allChanges.push(changes);
+          break;
+        }
         case 'command': {
           const { changes, commandOutput } = detectCommandChanges(this.projectPath, target, prev.commandOutput);
           newSnapshot.commandOutput = commandOutput;
@@ -259,10 +478,40 @@ export class WatchManager extends EventEmitter {
 
     console.log(`[watch] ${config.label}: detected ${allChanges.length} change(s)`);
 
+    // Get debounce from first target that has it, or default 10s
+    const debounceMs = (config.watch!.targets.find(t => t.debounce !== undefined)?.debounce ?? 10) * 1000;
+
+    if (debounceMs > 0) {
+      // Accumulate changes, reset timer each time
+      const existing = this.pendingAlert.get(agentId);
+      const merged = existing ? [...existing.changes, ...allChanges] : allChanges;
+      const mergedSummary = merged.map(c =>
+        `[${c.targetType}] ${c.description}${c.files.length ? '\n  ' + c.files.join('\n  ') : ''}`
+      ).join('\n');
+      this.pendingAlert.set(agentId, { changes: merged, summary: mergedSummary, timestamp: Date.now() });
+
+      // Clear previous debounce timer, set new one
+      const prevTimer = this.debounceTimers.get(agentId);
+      if (prevTimer) clearTimeout(prevTimer);
+
+      this.debounceTimers.set(agentId, setTimeout(() => {
+        const pending = this.pendingAlert.get(agentId);
+        if (!pending) return;
+        this.pendingAlert.delete(agentId);
+        this.debounceTimers.delete(agentId);
+        this.emitAlert(agentId, config, pending.changes, pending.summary);
+      }, debounceMs));
+
+      console.log(`[watch] ${config.label}: debouncing ${debounceMs / 1000}s...`);
+    } else {
+      this.emitAlert(agentId, config, allChanges, summary);
+    }
+  }
+
+  private emitAlert(agentId: string, config: WorkspaceAgentConfig, allChanges: WatchChange[], summary: string): void {
     const entry = { type: 'system' as const, subtype: 'watch_detected', content: `🔍 Watch detected changes:\n${summary}`, timestamp: new Date().toISOString() };
     appendAgentLog(this.workspaceId, agentId, entry).catch(() => {});
 
-    // Emit SSE event for UI
     this.emit('watch_alert', {
       type: 'watch_alert',
       agentId,

package/lib/workspace-standalone.ts

@@ -14,10 +14,10 @@
 
 import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
 import { readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { WorkspaceOrchestrator, type OrchestratorEvent } from './workspace/orchestrator';
-import { loadWorkspace, saveWorkspace } from './workspace/persistence';
+import { loadWorkspace, saveWorkspace, findWorkspaceByProject } from './workspace/persistence';
 import { installForgeSkills, applyProfileToProject } from './workspace/skill-installer';
 import {
   loadMemory, formatMemoryForDisplay, getMemoryStats,
@@ -30,7 +30,7 @@ import { execSync } from 'node:child_process';
 
 const PORT = Number(process.env.WORKSPACE_PORT) || 8405;
 const FORGE_PORT = Number(process.env.PORT) || 8403;
-const MAX_ACTIVE = 2;
+const MAX_ACTIVE = 5;
 
 // ─── State ───────────────────────────────────────────────
 
@@ -48,14 +48,6 @@ function loadOrchestrator(id: string): WorkspaceOrchestrator {
   const existing = orchestrators.get(id);
   if (existing) return existing;
 
-  // Enforce max active limit
-  if (orchestrators.size >= MAX_ACTIVE) {
-    const evicted = evictIdleWorkspace();
-    if (!evicted) {
-      throw new Error(`Maximum ${MAX_ACTIVE} active workspaces. Stop agents in another workspace first.`);
-    }
-  }
-
   const state = loadWorkspace(id);
   if (!state) throw new Error('Workspace not found');
 
@@ -285,12 +277,13 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
           return json(res, { ok: true, ...launchInfo });
         }
 
-        if (agentState.taskStatus === 'running') return jsonError(res, 'Cannot open terminal while agent is running. Wait for it to finish.');
-        const hasPending = orch.getBus().getPendingMessagesFor(agentId).length > 0;
-        if (hasPending) return jsonError(res, 'Agent has pending messages being processed. Wait for execution to complete.');
+        // Primary agent: always return its fixed session, no selection
+        if (agentConfig.primary && agentState.tmuxSession) {
+          return json(res, { ok: true, primary: true, tmuxSession: agentState.tmuxSession, fixedSession: true, ...launchInfo });
+        }
 
-        if (agentState.mode === 'manual') {
-          return json(res, { ok: true, mode: 'manual', alreadyManual: true, ...launchInfo });
+        if (agentState.tmuxSession) {
+          return json(res, { ok: true, alreadyOpen: true, tmuxSession: agentState.tmuxSession, ...launchInfo });
         }
 
         orch.setManualMode(agentId);
@@ -299,7 +292,8 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
 
         return json(res, {
           ok: true,
-          mode: 'manual',
+          primary: agentConfig.primary || undefined,
+          fixedSession: agentConfig.primary || undefined,
           skillsInstalled: result.installed,
           agentId,
           label: agentConfig.label,
@@ -308,7 +302,12 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
       }
       case 'close_terminal': {
         if (!agentId) return jsonError(res, 'agentId required');
-        orch.restartAgentDaemon(agentId);
+        if (body.kill) {
+          // Kill: clear tmuxSession → message loop falls back to headless (claude -p)
+          orch.clearTmuxSession(agentId);
+          console.log(`[workspace] ${agentId}: terminal killed, falling back to headless`);
+        }
+        // Suspend: tmuxSession stays, agent can reattach later
         return json(res, { ok: true });
       }
       case 'create_ticket': {
@@ -380,12 +379,20 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
         return json(res, { ok: true });
       }
       case 'delete_message': {
-        const { messageId } = body;
-        if (!messageId) return jsonError(res, 'messageId required');
-        orch.getBus().deleteMessage(messageId);
-        return json(res, { ok: true });
+        const { messageId, messageIds } = body;
+        const ids: string[] = messageIds || (messageId ? [messageId] : []);
+        if (ids.length === 0) return jsonError(res, 'messageId or messageIds required');
+        for (const id of ids) orch.getBus().deleteMessage(id);
+        // Push updated bus log to frontend
+        orch.emit('event', { type: 'bus_log_updated', log: orch.getBus().getLog() } as any);
+        return json(res, { ok: true, deleted: ids.length });
       }
       case 'start_daemon': {
+        // Check active daemon count before starting
+        const activeCount = Array.from(orchestrators.values()).filter(o => o.isDaemonActive()).length;
+        if (activeCount >= MAX_ACTIVE && !orch.isDaemonActive()) {
+          return jsonError(res, `Maximum ${MAX_ACTIVE} active daemons. Stop agents in another workspace first.`);
+        }
         orch.startDaemon().catch(err => {
           console.error('[workspace] startDaemon error:', err.message);
         });
@@ -637,9 +644,12 @@ async function handleSmith(id: string, body: any, res: ServerResponse): Promise<
 
     case 'sessions': {
       // List recent claude sessions for resume picker
-      // Uses the workspace's projectPath to find sessions in ~/.claude/projects/
+      // Uses the agent's workDir (or project root) to find sessions
       try {
-        const encoded = orch.projectPath.replace(/\//g, '-');
+        const agentConfig = agentId ? orch.getSnapshot().agents.find(a => a.id === agentId) : null;
+        const agentWorkDir = agentConfig?.workDir && agentConfig.workDir !== './' && agentConfig.workDir !== '.'
+          ? join(orch.projectPath, agentConfig.workDir) : orch.projectPath;
+        const encoded = resolve(agentWorkDir).replace(/\//g, '-');
         const sessDir = join(homedir(), '.claude', 'projects', encoded);
         const entries = readdirSync(sessDir);
         const files = entries
@@ -661,15 +671,33 @@ async function handleSmith(id: string, body: any, res: ServerResponse): Promise<
       const snapshot = orch.getSnapshot();
       const states = orch.getAllAgentStates();
       const agents = snapshot.agents.map(a => ({
-        id: a.id, label: a.label, icon: a.icon, type: a.type,
+        id: a.id, label: a.label, icon: a.icon, type: a.type, primary: a.primary || undefined,
         smithStatus: states[a.id]?.smithStatus || 'down',
-        mode: states[a.id]?.mode || 'auto',
         taskStatus: states[a.id]?.taskStatus || 'idle',
+        hasTmux: !!states[a.id]?.tmuxSession,
         currentStep: states[a.id]?.currentStep,
       }));
       return json(res, { agents });
     }
 
+    case 'primary_session': {
+      // Get the primary agent's tmux session + project-level fixed session
+      const primary = orch.getPrimaryAgent();
+      if (!primary) return json(res, { ok: false, error: 'No primary agent configured' });
+      let fixedSessionId: string | null = null;
+      try {
+        const { getFixedSession } = await import('./project-sessions.js');
+        fixedSessionId = getFixedSession(orch.projectPath) || null;
+      } catch {}
+      return json(res, {
+        ok: true,
+        agentId: primary.config.id,
+        label: primary.config.label,
+        tmuxSession: primary.state.tmuxSession || null,
+        fixedSessionId,
+      });
+    }
+
     default:
       return jsonError(res, `Unknown action: ${action}`);
   }
@@ -716,6 +744,28 @@ const server = createServer(async (req, res) => {
       });
     }
 
+    // Resolve projectPath → workspaceId + agentId (walks up directories)
+    if (path === '/resolve' && method === 'GET') {
+      const projectPath = query.get('projectPath') || '';
+      if (!projectPath) return jsonError(res, 'projectPath required');
+      // Walk up directories to find workspace
+      let dir = projectPath;
+      while (dir && dir !== '/') {
+        const ws = findWorkspaceByProject(dir);
+        if (ws) {
+          const primary = ws.agents?.find((a: any) => a.primary);
+          return json(res, {
+            workspaceId: ws.id,
+            projectPath: ws.projectPath,
+            projectName: ws.projectName,
+            primaryAgentId: primary?.id || null,
+          });
+        }
+        dir = dir.replace(/\/[^/]+$/, '') || '/';
+      }
+      return json(res, { workspaceId: null });
+    }
+
     // Active workspaces
     if (path === '/workspaces/active' && method === 'GET') {
       return json(res, {
@@ -809,6 +859,12 @@ process.on('unhandledRejection', (err) => {
 
 // ─── Start ───────────────────────────────────────────────
 
+// Start MCP Server alongside workspace daemon
+import { startMcpServer, setOrchestratorResolver, getMcpPort } from './forge-mcp-server.js';
+setOrchestratorResolver((id: string) => loadOrchestrator(id));
+const MCP_PORT = getMcpPort();
+startMcpServer(MCP_PORT).catch(err => console.error('[forge-mcp] Failed to start:', err));
+
 server.listen(PORT, () => {
-  console.log(`[workspace] Daemon started on http://0.0.0.0:${PORT} (max ${MAX_ACTIVE} workspaces)`);
+  console.log(`[workspace] Daemon started on http://0.0.0.0:${PORT} (max ${MAX_ACTIVE} workspaces, MCP on ${MCP_PORT})`);
 });

package/middleware.ts

@@ -1,6 +1,12 @@
 import { NextResponse, type NextRequest } from 'next/server';
 
 export function middleware(req: NextRequest) {
+  // Skip auth entirely in dev mode
+  const isDev = process.env.NODE_ENV !== 'production';
+  if (isDev) {
+    return NextResponse.next();
+  }
+
   const { pathname } = req.nextUrl;
 
   // Allow auth endpoints and static assets without login

package/next.config.ts

@@ -1,9 +1,17 @@
 import type { NextConfig } from 'next';
+import { networkInterfaces } from 'node:os';
 
 const terminalPort = parseInt(process.env.TERMINAL_PORT || '') || 3001;
 
+// Auto-detect local IPs for dev mode cross-origin access
+const localIPs = Object.values(networkInterfaces())
+  .flat()
+  .filter(i => i && !i.internal && i.family === 'IPv4')
+  .map(i => i!.address);
+
 const nextConfig: NextConfig = {
   serverExternalPackages: ['better-sqlite3'],
+  allowedDevOrigins: localIPs,
   async rewrites() {
     return [
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {
@@ -32,6 +32,7 @@
     "@ai-sdk/google": "^3.0.43",
     "@ai-sdk/openai": "^3.0.41",
     "@auth/core": "^0.34.3",
+    "@modelcontextprotocol/sdk": "^1.28.0",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-search": "^0.16.0",
     "@xterm/addon-unicode11": "^0.9.0",
@@ -48,7 +49,8 @@
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1",
     "ws": "^8.19.0",
-    "yaml": "^2.8.2"
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6"
   },
   "pnpm": {
     "onlyBuiltDependencies": [