@aion0/forge 0.5.7 → 0.5.9

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;
 }
@@ -79,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
@@ -101,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;
@@ -224,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

@@ -206,8 +206,10 @@ function detectAgentLogChanges(workspaceId: string, targetAgentId: string, patte
   }
 }
 
+// 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 } {
-  // Find session file for this project
   const claudeHome = join(homedir(), '.claude', 'projects');
   const encoded = projectPath.replace(/\//g, '-');
   const sessionDir = join(claudeHome, encoded);
@@ -217,11 +219,9 @@ function detectSessionChanges(projectPath: string, pattern: string | undefined,
     let latestFile: string;
 
     if (sessionId) {
-      // Use specific session ID
       latestFile = join(sessionDir, `${sessionId}.jsonl`);
       if (!existsSync(latestFile)) return { changes: null, lineCount: prevLineCount };
     } else {
-      // Find most recently modified .jsonl file
       const files = readdirSync(sessionDir)
         .filter(f => f.endsWith('.jsonl'))
         .map(f => ({ name: f, mtime: statSync(join(sessionDir, f)).mtimeMs }))
@@ -229,7 +229,17 @@ function detectSessionChanges(projectPath: string, pattern: string | undefined,
       if (files.length === 0) return { changes: null, lineCount: prevLineCount };
       latestFile = join(sessionDir, files[0].name);
     }
-    // Only read new bytes since last check (efficient for large 70MB+ files)
+    // 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 }; }
@@ -256,17 +266,16 @@ function detectSessionChanges(projectPath: string, pattern: string | undefined,
       }
     }
 
+    // Only extract the LAST assistant/result text (not all entries)
     const entries: string[] = [];
-    for (const line of newLines) {
+    for (const line of [...newLines].reverse()) {
       try {
         const parsed = JSON.parse(line);
-        // Extract text content from various session JSONL formats
         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 (block.type === 'tool_use') text += `[tool: ${block.name}] `;
           }
         } else if (parsed.type === 'result' && parsed.result) {
           text = typeof parsed.result === 'string' ? parsed.result : JSON.stringify(parsed.result);
@@ -290,6 +299,7 @@ function detectSessionChanges(projectPath: string, pattern: string | undefined,
           text = text.slice(0, contextChars);
         }
         entries.push(text);
+        break; // only take the last matching entry (we're scanning in reverse)
       } catch {}
     }
 

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/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "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": [

package/qa/.forge/mcp.json

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