@aion0/forge 0.5.8 → 0.5.12

package/lib/workspace/orchestrator.ts

@@ -61,11 +61,17 @@ export class WorkspaceOrchestrator extends EventEmitter {
   private agents = new Map<string, { config: WorkspaceAgentConfig; worker: AgentWorker | null; state: AgentState }>();
   private bus: AgentBus;
   private watchManager: WatchManager;
+  private sessionMonitor: import('./session-monitor').SessionFileMonitor | null = null;
   private approvalQueue = new Set<string>();
   private daemonActive = false;
   private createdAt = Date.now();
   private healthCheckTimer: NodeJS.Timeout | null = null;
 
+  /** Emit a log event (auto-persisted via constructor listener) */
+  emitLog(agentId: string, entry: any): void {
+    this.emit('event', { type: 'log', agentId, entry } as any);
+  }
+
   constructor(workspaceId: string, projectPath: string, projectName: string) {
     super();
     this.workspaceId = workspaceId;
@@ -73,6 +79,13 @@ export class WorkspaceOrchestrator extends EventEmitter {
     this.projectName = projectName;
     this.bus = new AgentBus();
     this.watchManager = new WatchManager(workspaceId, projectPath, () => this.agents as any);
+
+    // Auto-persist all log events to disk (so LogPanel can read them)
+    this.on('event', (event: any) => {
+      if (event.type === 'log' && event.agentId && event.entry) {
+        appendAgentLog(this.workspaceId, event.agentId, event.entry).catch(() => {});
+      }
+    });
     // Handle watch events
     this.watchManager.on('watch_alert', (event) => {
       this.emit('event', event);
@@ -358,7 +371,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
       const workerState = entry.worker?.getState();
       // Merge: worker state for task/smith, entry.state for mode (orchestrator controls mode)
       result[id] = workerState
-        ? { ...workerState, tmuxSession: entry.state.tmuxSession, currentMessageId: entry.state.currentMessageId }
+        ? { ...workerState, taskStatus: entry.state.taskStatus, tmuxSession: entry.state.tmuxSession, currentMessageId: entry.state.currentMessageId }
         : entry.state;
     }
     return result;
@@ -912,6 +925,9 @@ export class WorkspaceOrchestrator extends EventEmitter {
     // Start watch loops for agents with watch config
     this.watchManager.start();
 
+    // Start session file monitors for agents with known session IDs
+    this.startSessionMonitors().catch(err => console.error('[session-monitor] Failed to start:', err.message));
+
     // Start health check — monitor all agents every 10s, auto-heal
     this.startHealthCheck();
 
@@ -1049,14 +1065,26 @@ export class WorkspaceOrchestrator extends EventEmitter {
         entry.worker = null;
       }
 
-      // 3. Kill tmux session
+      // 3. Kill tmux session (skip if user is attached to it)
       if (entry.state.tmuxSession) {
-        try { execSync(`tmux kill-session -t "${entry.state.tmuxSession}" 2>/dev/null`, { timeout: 3000 }); } catch {}
+        let isAttached = false;
+        try {
+          const info = execSync(`tmux display-message -t "${entry.state.tmuxSession}" -p "#{session_attached}" 2>/dev/null`, { timeout: 3000, encoding: 'utf-8' }).trim();
+          isAttached = info !== '0';
+        } catch {}
+        if (isAttached) {
+          console.log(`[daemon] ${entry.config.label}: tmux session attached by user, not killing`);
+        } else {
+          try { execSync(`tmux kill-session -t "${entry.state.tmuxSession}" 2>/dev/null`, { timeout: 3000 }); } catch {}
+        }
         entry.state.tmuxSession = undefined;
       }
 
-      // 4. Set smith down
+      // 4. Set smith down, reset running tasks
       entry.state.smithStatus = 'down';
+      if (entry.state.taskStatus === 'running') {
+        entry.state.taskStatus = 'idle';
+      }
       entry.state.error = undefined;
       this.updateAgentLiveness(id);
       this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'down' } satisfies WorkerEvent);
@@ -1069,11 +1097,100 @@ export class WorkspaceOrchestrator extends EventEmitter {
     this.emitAgentsChanged();
     this.watchManager.stop();
     this.stopAllTerminalMonitors();
+    if (this.sessionMonitor) { this.sessionMonitor.stopAll(); this.sessionMonitor = null; }
     this.stopHealthCheck();
     this.forgeActedMessages.clear();
     console.log('[workspace] Daemon stopped');
   }
 
+  // ─── Session File Monitor ──────────────────────────────
+
+  private async startSessionMonitors(): Promise<void> {
+    console.log('[session-monitor] Initializing...');
+    const { SessionFileMonitor } = await import('./session-monitor');
+    this.sessionMonitor = new SessionFileMonitor();
+
+    // Listen for state changes from session file monitor
+    this.sessionMonitor.on('stateChange', (event: any) => {
+      const entry = this.agents.get(event.agentId);
+      if (!entry) {
+        console.log(`[session-monitor] stateChange: agent ${event.agentId} not found in map`);
+        return;
+      }
+      console.log(`[session-monitor] stateChange: ${entry.config.label} ${event.state} (current taskStatus=${entry.state.taskStatus})`);
+
+      if (event.state === 'running' && entry.state.taskStatus !== 'running') {
+        entry.state.taskStatus = 'running';
+        console.log(`[session-monitor] → emitting task_status=running for ${entry.config.label}`);
+        this.emit('event', { type: 'task_status', agentId: event.agentId, taskStatus: 'running' } as any);
+        this.emitAgentsChanged();
+      }
+
+      if (event.state === 'done' && entry.state.taskStatus === 'running') {
+        entry.state.taskStatus = 'done';
+        this.emit('event', { type: 'task_status', agentId: event.agentId, taskStatus: 'done' } as any);
+        console.log(`[session-monitor] ${event.agentId}: done — ${event.detail || 'turn completed'}`);
+        this.handleAgentDone(event.agentId, entry, event.detail);
+        this.emitAgentsChanged();
+      }
+    });
+
+    // Start monitors for all agents with known session IDs
+    for (const [id, entry] of this.agents) {
+      if (entry.config.type === 'input') continue;
+      await this.startAgentSessionMonitor(id, entry.config);
+    }
+  }
+
+  private async startAgentSessionMonitor(agentId: string, config: WorkspaceAgentConfig): Promise<void> {
+    if (!this.sessionMonitor) return;
+
+    // Determine session file path
+    let sessionId: string | undefined;
+
+    if (config.primary) {
+      try {
+        const mod = await import('../project-sessions');
+        sessionId = (mod as any).getFixedSession(this.projectPath);
+        console.log(`[session-monitor] ${config.label}: primary fixedSession=${sessionId || 'NONE'}`);
+      } catch (err: any) {
+        console.log(`[session-monitor] ${config.label}: failed to get fixedSession: ${err.message}`);
+      }
+    } else {
+      sessionId = config.boundSessionId;
+      console.log(`[session-monitor] ${config.label}: boundSession=${sessionId || 'NONE'}`);
+    }
+
+    if (!sessionId) {
+      // Try to auto-bind from session files on disk
+      try {
+        const sessionDir = this.getCliSessionDir(config.workDir);
+        if (existsSync(sessionDir)) {
+          const files = require('node:fs').readdirSync(sessionDir).filter((f: string) => f.endsWith('.jsonl'));
+          if (files.length > 0) {
+            const sorted = files
+              .map((f: string) => ({ name: f, mtime: require('node:fs').statSync(join(sessionDir, f)).mtimeMs }))
+              .sort((a: any, b: any) => b.mtime - a.mtime);
+            sessionId = sorted[0].name.replace('.jsonl', '');
+            if (!config.primary) {
+              config.boundSessionId = sessionId;
+              this.saveNow();
+              console.log(`[session-monitor] ${config.label}: auto-bound to ${sessionId}`);
+            }
+          }
+        }
+      } catch {}
+      if (!sessionId) {
+        console.log(`[session-monitor] ${config.label}: no sessionId, skipping`);
+        return;
+      }
+    }
+
+    const { SessionFileMonitor } = await import('./session-monitor');
+    const filePath = SessionFileMonitor.resolveSessionPath(this.projectPath, config.workDir, sessionId);
+    this.sessionMonitor.startMonitoring(agentId, filePath);
+  }
+
   // ─── Health Check — auto-heal agents ─────────────────
 
   private startHealthCheck(): void {
@@ -1171,10 +1288,18 @@ export class WorkspaceOrchestrator extends EventEmitter {
       if (msg.type === 'ack' || msg.from === '_forge') continue;
       if (this.forgeActedMessages.has(msg.id)) continue;
 
-      // Case 1: Message done but no reply from target → ask target to send summary
+      // Case 1: Message done but no reply from target → ask target to send summary (once per pair)
+      // Skip notification-only messages that don't need replies
       if (msg.status === 'done') {
+        const action = msg.payload?.action;
+        if (action === 'upstream_complete' || action === 'task_complete' || action === 'ack') { this.forgeActedMessages.add(msg.id); continue; }
+        if (msg.from === '_system' || msg.from === '_watch') { this.forgeActedMessages.add(msg.id); continue; }
         const age = now - msg.timestamp;
-        if (age < 30_000) continue; // give 30s grace period
+        if (age < 30_000) continue;
+
+        // Dedup by target→sender pair (only nudge once per relationship)
+        const nudgeKey = `nudge-${msg.to}->${msg.from}`;
+        if (this.forgeActedMessages.has(nudgeKey)) { this.forgeActedMessages.add(msg.id); continue; }
 
         const hasReply = log.some(r =>
           r.from === msg.to && r.to === msg.from &&
@@ -1189,7 +1314,8 @@ export class WorkspaceOrchestrator extends EventEmitter {
               content: `[IMPORTANT] You finished a task requested by ${senderLabel} but did not send them the results. You MUST call the MCP tool "send_message" (NOT the forge-send skill) with to="${senderLabel}" and include a summary of what you did and the outcome. Do not do any other work until you have sent this reply.`,
             });
             this.forgeActedMessages.add(msg.id);
-            console.log(`[forge-agent] Nudged ${targetEntry.config.label} to reply to ${senderLabel}`);
+            this.forgeActedMessages.add(nudgeKey);
+            console.log(`[forge-agent] Nudged ${targetEntry.config.label} to reply to ${senderLabel} (once)`);
           }
         }
       }
@@ -1752,16 +1878,36 @@ export class WorkspaceOrchestrator extends EventEmitter {
       .slice(-1)[0]?.content || '';
 
     const content = files.length > 0
-      ? `${completedLabel} completed: ${files.length} files changed. ${summary.slice(0, 200)}`
-      : `${completedLabel} completed. ${summary.slice(0, 300) || 'Check upstream outputs for updates.'}`;
+      ? `${completedLabel} completed: ${files.length} files changed. ${summary.slice(0, 200)}. If you are currently processing a task or have seen this before, ignore this notification.`
+      : `${completedLabel} completed. ${summary.slice(0, 300) || 'If you are currently processing a task or have seen this before, ignore this notification.'}`;
 
-    // Find all downstream agents that depend on this one
+    // Find all downstream agents — skip if already sent upstream_complete recently (60s)
+    const now = Date.now();
     let sent = 0;
     for (const [id, entry] of this.agents) {
       if (id === completedAgentId) continue;
       if (entry.config.type === 'input') continue;
       if (!entry.config.dependsOn.includes(completedAgentId)) continue;
 
+      // Dedup: skip if upstream_complete was sent to this target within last 60s
+      const recentDup = this.bus.getLog().some(m =>
+        m.from === completedAgentId && m.to === id &&
+        m.payload?.action === 'upstream_complete' &&
+        now - m.timestamp < 60_000
+      );
+      if (recentDup) {
+        console.log(`[bus] ${completedLabel} → ${entry.config.label}: upstream_complete skipped (sent <60s ago)`);
+        continue;
+      }
+
+      // Merge: auto-complete older pending upstream_complete from same sender
+      for (const m of this.bus.getLog()) {
+        if (m.from === completedAgentId && m.to === id && m.status === 'pending' && m.payload?.action === 'upstream_complete') {
+          m.status = 'done' as any;
+          this.emit('event', { type: 'bus_message_status', messageId: m.id, status: 'done' } as any);
+        }
+      }
+
       this.bus.send(completedAgentId, id, 'notify', {
         action: 'upstream_complete',
         content,
@@ -1818,8 +1964,10 @@ export class WorkspaceOrchestrator extends EventEmitter {
     }
 
     // Check if tmux session already exists
+    let sessionAlreadyExists = false;
     try {
       execSync(`tmux has-session -t "${sessionName}" 2>/dev/null`, { timeout: 3000 });
+      sessionAlreadyExists = true;
       console.log(`[daemon] ${config.label}: persistent session already exists (${sessionName})`);
     } catch {
       // Create new tmux session and start the CLI agent
@@ -1880,12 +2028,12 @@ export class WorkspaceOrchestrator extends EventEmitter {
         const unsetCmd = profileVarsToReset.map(v => `unset ${v}`).join(' && ');
         execSync(`tmux send-keys -t "${sessionName}" '${unsetCmd}' Enter`, { timeout: 5000 });
 
-        // Set FORGE env vars + profile env vars
-        const forgeVars = `export FORGE_WORKSPACE_ID="${this.workspaceId}" FORGE_AGENT_ID="${config.id}" FORGE_PORT="${Number(process.env.PORT) || 8403}"`;
+        // Set FORGE env vars (short, separate command)
+        execSync(`tmux send-keys -t "${sessionName}" 'export FORGE_WORKSPACE_ID="${this.workspaceId}" FORGE_AGENT_ID="${config.id}" FORGE_PORT="${Number(process.env.PORT) || 8403}"' Enter`, { timeout: 5000 });
+
+        // Set profile env vars if any (separate command to avoid truncation)
         if (envExports) {
-          execSync(`tmux send-keys -t "${sessionName}" '${forgeVars} && ${envExports.replace(/ && $/, '')}' Enter`, { timeout: 5000 });
-        } else {
-          execSync(`tmux send-keys -t "${sessionName}" '${forgeVars}' Enter`, { timeout: 5000 });
+          execSync(`tmux send-keys -t "${sessionName}" '${envExports.replace(/ && $/, '')}' Enter`, { timeout: 5000 });
         }
 
         // Build CLI start command
@@ -1952,7 +2100,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
             if (entry) {
               entry.state.error = `Terminal failed: ${errorMsg}. Falling back to headless mode.`;
               entry.state.tmuxSession = undefined; // clear so message loop uses headless (claude -p)
-              this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'error', content: `Terminal startup failed: ${errorMsg}. Auto-fallback to headless (claude -p).`, timestamp: new Date().toISOString() } } as any);
+              this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'error', content: `Terminal startup failed: ${errorMsg}. Auto-fallback to headless.`, timestamp: new Date().toISOString() } } as any);
               this.emitAgentsChanged();
             }
             // Kill the failed tmux session
@@ -2000,6 +2148,31 @@ export class WorkspaceOrchestrator extends EventEmitter {
       this.saveNow();
       this.emitAgentsChanged();
     }
+
+    // Ensure boundSessionId is set (required for session monitor + --resume)
+    if (!config.primary && !config.boundSessionId) {
+      const bindDelay = sessionAlreadyExists ? 500 : 5000;
+      setTimeout(() => {
+        try {
+          const sessionDir = this.getCliSessionDir(config.workDir);
+          if (existsSync(sessionDir)) {
+            const { readdirSync, statSync: statS } = require('node:fs');
+            const files = readdirSync(sessionDir).filter((f: string) => f.endsWith('.jsonl'));
+            if (files.length > 0) {
+              const latest = files
+                .map((f: string) => ({ name: f, mtime: statS(join(sessionDir, f)).mtimeMs }))
+                .sort((a: any, b: any) => b.mtime - a.mtime)[0];
+              config.boundSessionId = latest.name.replace('.jsonl', '');
+              this.saveNow();
+              console.log(`[daemon] ${config.label}: bound to session ${config.boundSessionId}`);
+              this.startAgentSessionMonitor(agentId, config);
+            } else {
+              console.log(`[daemon] ${config.label}: no session files yet, will bind on next check`);
+            }
+          }
+        } catch {}
+      }, bindDelay);
+    }
   }
 
   /** Inject text into an agent's persistent terminal session */
@@ -2209,8 +2382,23 @@ export class WorkspaceOrchestrator extends EventEmitter {
       // requiresApproval is handled at message arrival time (routeMessageToAgent),
       // not in the message loop. Approved messages come through as normal 'pending'.
 
+      // Dedup: if multiple upstream_complete from same sender are pending, keep only latest
+      const allRaw = this.bus.getPendingMessagesFor(agentId).filter(m => m.from !== agentId && m.type !== 'ack');
+      const upstreamSeen = new Set<string>();
+      for (let i = allRaw.length - 1; i >= 0; i--) {
+        const m = allRaw[i];
+        if (m.payload?.action === 'upstream_complete') {
+          const key = `upstream-${m.from}`;
+          if (upstreamSeen.has(key)) {
+            m.status = 'done' as any;
+            this.emit('event', { type: 'bus_message_status', messageId: m.id, status: 'done' } as any);
+          }
+          upstreamSeen.add(key);
+        }
+      }
+
       // Find next pending message, applying causedBy rules
-      const allPending = this.bus.getPendingMessagesFor(agentId).filter(m => m.from !== agentId && m.type !== 'ack');
+      const allPending = allRaw.filter(m => m.status === 'pending');
       const pending = allPending.filter(m => {
         // Tickets: accepted but check retry limit
         if (m.category === 'ticket') {
@@ -2283,7 +2471,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
       } else {
         entry.worker!.setProcessingMessage(nextMsg.id);
         entry.worker!.wake({ type: 'bus_message', messages: [logEntry] });
-        this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'execution_method', content: '⚡ Executed via claude -p', timestamp: new Date().toISOString() } } as any);
+        this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'execution_method', content: `⚡ Executed via headless (agent: ${entry.config.agentId || 'claude'})`, timestamp: new Date().toISOString() } } as any);
       }
     };
 

package/lib/workspace/session-monitor.ts

@@ -0,0 +1,210 @@
+/**
+ * Session File Monitor — detects agent running/idle state by watching
+ * Claude Code's .jsonl session files.
+ *
+ * How it works:
+ * - Each agent has a known session file path (boundSessionId/fixedSessionId/--session-id)
+ * - Monitor checks file mtime every 3s
+ * - mtime changing → agent is running (LLM streaming, tool use, etc.)
+ * - mtime stable for IDLE_THRESHOLD → check last lines for 'result' entry → done
+ * - No session file → idle (not started)
+ *
+ * Works for both terminal and headless modes — both write the same .jsonl format.
+ */
+
+import { statSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { EventEmitter } from 'node:events';
+
+export type SessionMonitorState = 'idle' | 'running' | 'done';
+
+export interface SessionMonitorEvent {
+  agentId: string;
+  state: SessionMonitorState;
+  sessionFile: string;
+  detail?: string; // e.g., result summary
+}
+
+const POLL_INTERVAL = 1000;    // check every 1s (need to catch short executions)
+const IDLE_THRESHOLD = 10000;  // 10s of no file change → check for done
+const STABLE_THRESHOLD = 20000; // 20s of no change → force done
+
+export class SessionFileMonitor extends EventEmitter {
+  private timers = new Map<string, NodeJS.Timeout>();
+  private lastMtime = new Map<string, number>();
+  private lastSize = new Map<string, number>();
+  private lastStableTime = new Map<string, number>();
+  private currentState = new Map<string, SessionMonitorState>();
+
+  /**
+   * Start monitoring a session file for an agent.
+   * @param agentId - Agent identifier
+   * @param sessionFilePath - Full path to the .jsonl session file
+   */
+  startMonitoring(agentId: string, sessionFilePath: string): void {
+    this.stopMonitoring(agentId);
+    this.currentState.set(agentId, 'idle');
+    this.lastStableTime.set(agentId, Date.now());
+
+    const timer = setInterval(() => {
+      this.checkFile(agentId, sessionFilePath);
+    }, POLL_INTERVAL);
+    timer.unref();
+    this.timers.set(agentId, timer);
+
+    console.log(`[session-monitor] Started monitoring ${agentId}: ${sessionFilePath}`);
+  }
+
+  /**
+   * Stop monitoring an agent's session file.
+   */
+  stopMonitoring(agentId: string): void {
+    const timer = this.timers.get(agentId);
+    if (timer) clearInterval(timer);
+    this.timers.delete(agentId);
+    this.lastMtime.delete(agentId);
+    this.lastSize.delete(agentId);
+    this.lastStableTime.delete(agentId);
+    this.currentState.delete(agentId);
+  }
+
+  /**
+   * Stop all monitors.
+   */
+  stopAll(): void {
+    for (const [id] of this.timers) {
+      this.stopMonitoring(id);
+    }
+  }
+
+  /**
+   * Get current state for an agent.
+   */
+  getState(agentId: string): SessionMonitorState {
+    return this.currentState.get(agentId) || 'idle';
+  }
+
+  /**
+   * Resolve session file path for a project + session ID.
+   */
+  static resolveSessionPath(projectPath: string, workDir: string | undefined, sessionId: string): string {
+    const fullPath = workDir && workDir !== './' && workDir !== '.'
+      ? join(projectPath, workDir) : projectPath;
+    const encoded = resolve(fullPath).replace(/\//g, '-');
+    return join(homedir(), '.claude', 'projects', encoded, `${sessionId}.jsonl`);
+  }
+
+  private initialized = new Set<string>();
+  private checkFile(agentId: string, filePath: string): void {
+    try {
+      const stat = statSync(filePath);
+      const mtime = stat.mtimeMs;
+      const size = stat.size;
+
+      // First poll: just record baseline, don't trigger state change
+      if (!this.initialized.has(agentId)) {
+        this.initialized.add(agentId);
+        this.lastMtime.set(agentId, mtime);
+        this.lastSize.set(agentId, size);
+        this.lastStableTime.set(agentId, Date.now());
+        console.log(`[session-monitor] ${agentId}: baseline mtime=${mtime} size=${size}`);
+        return;
+      }
+
+      const prevMtime = this.lastMtime.get(agentId) || 0;
+      const prevSize = this.lastSize.get(agentId) || 0;
+      const prevState = this.currentState.get(agentId) || 'idle';
+      const now = Date.now();
+
+      this.lastMtime.set(agentId, mtime);
+      this.lastSize.set(agentId, size);
+
+      // File changed (mtime or size different) → running
+      if (mtime !== prevMtime || size !== prevSize) {
+        this.lastStableTime.set(agentId, now);
+        if (prevState !== 'running') {
+          this.setState(agentId, 'running', filePath);
+        }
+        return;
+      }
+
+      // File unchanged — how long has it been stable?
+      const stableFor = now - (this.lastStableTime.get(agentId) || now);
+
+      if (prevState === 'running') {
+        if (stableFor >= IDLE_THRESHOLD) {
+          // Check if session file has a 'result' entry at the end
+          const resultInfo = this.checkForResult(filePath);
+          if (resultInfo) {
+            this.setState(agentId, 'done', filePath, resultInfo);
+            return;
+          }
+        }
+        if (stableFor >= STABLE_THRESHOLD) {
+          // Force done after 30s even without result entry
+          this.setState(agentId, 'done', filePath, 'stable timeout');
+          return;
+        }
+      }
+    } catch (err: any) {
+      if (!this.initialized.has(`err-${agentId}`)) {
+        this.initialized.add(`err-${agentId}`);
+        console.log(`[session-monitor] ${agentId}: checkFile error — ${err.message}`);
+      }
+    }
+  }
+
+  /**
+   * Check the last few lines of the session file for a 'result' type entry.
+   * Claude Code writes this when a turn completes.
+   */
+  private checkForResult(filePath: string): string | null {
+    try {
+      // Read last 4KB of the file
+      const stat = statSync(filePath);
+      const readSize = Math.min(4096, stat.size);
+      const fd = require('node:fs').openSync(filePath, 'r');
+      const buf = Buffer.alloc(readSize);
+      require('node:fs').readSync(fd, buf, 0, readSize, Math.max(0, stat.size - readSize));
+      require('node:fs').closeSync(fd);
+
+      const tail = buf.toString('utf-8');
+      const lines = tail.split('\n').filter(l => l.trim());
+
+      // Scan last lines for result entry
+      for (let i = lines.length - 1; i >= Math.max(0, lines.length - 10); i--) {
+        try {
+          const entry = JSON.parse(lines[i]);
+          // Claude Code writes result entries with these fields
+          if (entry.type === 'result' || entry.result || entry.duration_ms !== undefined) {
+            const summary = entry.result?.slice?.(0, 200) || entry.summary?.slice?.(0, 200) || '';
+            return summary || 'completed';
+          }
+          // Also check for assistant message without tool_use (model stopped)
+          if (entry.type === 'assistant' && entry.message?.content) {
+            const content = entry.message.content;
+            const hasToolUse = Array.isArray(content)
+              ? content.some((b: any) => b.type === 'tool_use')
+              : false;
+            if (!hasToolUse) {
+              return 'model stopped (no tool_use)';
+            }
+          }
+        } catch {} // skip non-JSON lines
+      }
+    } catch {}
+    return null;
+  }
+
+  private setState(agentId: string, state: SessionMonitorState, filePath: string, detail?: string): void {
+    const prev = this.currentState.get(agentId);
+    if (prev === state) return;
+
+    this.currentState.set(agentId, state);
+    const event: SessionMonitorEvent = { agentId, state, sessionFile: filePath, detail };
+    this.emit('stateChange', event);
+    console.log(`[session-monitor] ${agentId}: ${prev} → ${state}${detail ? ` (${detail})` : ''}`);
+  }
+}

package/lib/workspace/types.ts

@@ -47,7 +47,7 @@ export interface WorkspaceAgentConfig {
 // ─── Watch Config ─────────────────────────────────────────
 
 export interface WatchTarget {
-  type: 'directory' | 'git' | 'agent_output' | 'agent_log' | 'session' | 'command';
+  type: 'directory' | 'git' | 'agent_output' | 'agent_log' | 'session' | 'command' | 'agent_status';
   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)

package/lib/workspace/watch-manager.ts

@@ -21,6 +21,7 @@ interface WatchSnapshot {
   gitHash?: string;
   commandOutput?: string;
   logLineCount?: number;   // last known line count in agent's logs.jsonl
+  agentStatus?: string;    // last known taskStatus of monitored agent
   sessionFileSize?: number; // last known file size of session JSONL (bytes)
 }
 
@@ -454,6 +455,28 @@ export class WatchManager extends EventEmitter {
           if (changes) allChanges.push(changes);
           break;
         }
+        case 'agent_status': {
+          // Monitor another agent's task status (running → done/failed)
+          const targetAgentId = target.path; // path = agent ID to monitor
+          if (targetAgentId) {
+            const agents = this.getAgents();
+            const targetEntry = agents.get(targetAgentId);
+            if (targetEntry) {
+              const currentStatus = targetEntry.state.taskStatus;
+              const prevStatus = prev.agentStatus;
+              newSnapshot.agentStatus = currentStatus;
+              if (prevStatus && prevStatus !== currentStatus) {
+                const label = targetEntry.config.label;
+                // Match pattern if specified (e.g., "done" or "failed")
+                const pattern = target.pattern;
+                if (!pattern || currentStatus.match(new RegExp(pattern, 'i'))) {
+                  allChanges.push({ targetType: 'agent_status', description: `Agent ${label} status: ${prevStatus} → ${currentStatus}`, files: [] });
+                }
+              }
+            }
+          }
+          break;
+        }
       }
     }
 

package/lib/workspace-standalone.ts

@@ -259,7 +259,6 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
       }
       case 'open_terminal': {
         if (!agentId) return jsonError(res, 'agentId required');
-        if (!orch.isDaemonActive()) return jsonError(res, 'Start daemon first before opening terminal');
         const agentState = orch.getAgentState(agentId);
         const agentConfig = orch.getSnapshot().agents.find(a => a.id === agentId);
         if (!agentState || !agentConfig) return jsonError(res, 'Agent not found', 404);
@@ -387,6 +386,15 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
         orch.emit('event', { type: 'bus_log_updated', log: orch.getBus().getLog() } as any);
         return json(res, { ok: true, deleted: ids.length });
       }
+      case 'message_done': {
+        const { messageId } = body;
+        if (!messageId) return jsonError(res, 'messageId required');
+        const msg = orch.getBus().getLog().find(m => m.id === messageId);
+        if (!msg) return jsonError(res, 'Message not found');
+        msg.status = 'done';
+        orch.emit('event', { type: 'bus_message_status', messageId, status: 'done' } as any);
+        return json(res, { ok: true });
+      }
       case 'start_daemon': {
         // Check active daemon count before starting
         const activeCount = Array.from(orchestrators.values()).filter(o => o.isDaemonActive()).length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.5.8",
+  "version": "0.5.12",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {
@@ -10,9 +10,9 @@
     "forge": "npx tsx cli/mw.ts"
   },
   "bin": {
-    "forge": "./cli/mw.ts",
-    "forge-server": "./bin/forge-server.mjs",
-    "mw": "./cli/mw.ts"
+    "forge": "cli/mw.ts",
+    "forge-server": "bin/forge-server.mjs",
+    "mw": "cli/mw.ts"
   },
   "keywords": [
     "ai",

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"
+    }
+  }
+}