@aion0/forge 0.5.7 → 0.5.8

package/lib/workspace/orchestrator.ts

@@ -11,14 +11,15 @@
  */
 
 import { EventEmitter } from 'node:events';
-import { readFileSync, existsSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { readFileSync, existsSync, writeFileSync, unlinkSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { resolve, join } from 'node:path';
+import { homedir } from 'node:os';
 import type {
   WorkspaceAgentConfig,
   AgentState,
   SmithStatus,
   TaskStatus,
-  AgentMode,
   WorkerEvent,
   BusMessage,
   Artifact,
@@ -200,6 +201,14 @@ export class WorkspaceOrchestrator extends EventEmitter {
     return check(agentB);
   }
 
+  /** Get the primary agent for this workspace (if any) */
+  getPrimaryAgent(): { config: WorkspaceAgentConfig; state: AgentState } | null {
+    for (const [, entry] of this.agents) {
+      if (entry.config.primary) return entry;
+    }
+    return null;
+  }
+
   addAgent(config: WorkspaceAgentConfig): void {
     const conflict = this.validateOutputs(config);
     if (conflict) throw new Error(conflict);
@@ -208,20 +217,37 @@ export class WorkspaceOrchestrator extends EventEmitter {
     const cycleErr = this.detectCycle(config.id, config.dependsOn);
     if (cycleErr) throw new Error(cycleErr);
 
+    // Primary agent validation
+    this.validatePrimaryRules(config);
+
     const state: AgentState = {
       smithStatus: 'down',
-      mode: 'auto',
       taskStatus: 'idle',
       history: [],
       artifacts: [],
     };
+    // Primary agent: force terminal-only, root dir
+    if (config.primary) {
+      config.persistentSession = true;
+      config.workDir = './';
+    }
     this.agents.set(config.id, { config, worker: null, state });
+    // If daemon active, start persistent session + worker
+    if (this.daemonActive && config.type !== 'input' && config.persistentSession) {
+      this.enterDaemonListening(config.id);
+      const entry = this.agents.get(config.id)!;
+      entry.state.smithStatus = 'active';
+      this.ensurePersistentSession(config.id, config).then(() => {
+        this.startMessageLoop(config.id);
+      });
+    }
     this.saveNow();
     this.emitAgentsChanged();
   }
 
   removeAgent(id: string): void {
     const entry = this.agents.get(id);
+    if (entry?.config.primary) throw new Error('Cannot remove the primary agent');
     if (entry?.worker) {
       entry.worker.stop();
     }
@@ -240,6 +266,28 @@ export class WorkspaceOrchestrator extends EventEmitter {
     this.emitAgentsChanged();
   }
 
+  /** Validate primary agent rules */
+  private validatePrimaryRules(config: WorkspaceAgentConfig, excludeId?: string): void {
+    if (config.primary) {
+      // Only one primary allowed
+      for (const [id, entry] of this.agents) {
+        if (id !== excludeId && entry.config.primary) {
+          throw new Error(`Only one primary agent allowed. "${entry.config.label}" is already primary.`);
+        }
+      }
+    }
+    // Non-primary agents cannot use root directory if a primary exists
+    if (!config.primary && config.type !== 'input') {
+      const workDir = config.workDir?.replace(/\/+$/, '') || '';
+      if (!workDir || workDir === '.' || workDir === './') {
+        const primary = this.getPrimaryAgent();
+        if (primary && primary.config.id !== excludeId) {
+          throw new Error(`Root directory is reserved for primary agent "${primary.config.label}". Choose a subdirectory.`);
+        }
+      }
+    }
+  }
+
   updateAgentConfig(id: string, config: WorkspaceAgentConfig): void {
     const entry = this.agents.get(id);
     if (!entry) return;
@@ -247,22 +295,57 @@ export class WorkspaceOrchestrator extends EventEmitter {
     if (conflict) throw new Error(conflict);
     const cycleErr = this.detectCycle(id, config.dependsOn);
     if (cycleErr) throw new Error(cycleErr);
+    this.validatePrimaryRules(config, id);
+    // Primary agent: force terminal-only, root dir
+    if (config.primary) {
+      config.persistentSession = true;
+      config.workDir = './';
+    }
     if (entry.worker && entry.state.taskStatus === 'running') {
       entry.worker.stop();
     }
+
+    // If agent CLI changed (claude→codex, etc.), kill old terminal and clear bound session
+    const agentChanged = entry.config.agentId !== config.agentId;
+    if (agentChanged) {
+      console.log(`[workspace] ${config.label}: agent changed ${entry.config.agentId} → ${config.agentId}`);
+      if (entry.state.tmuxSession) {
+        try { execSync(`tmux kill-session -t "${entry.state.tmuxSession}" 2>/dev/null`, { timeout: 3000 }); } catch {}
+        console.log(`[workspace] ${config.label}: killed tmux session ${entry.state.tmuxSession}`);
+      }
+      entry.state.tmuxSession = undefined;
+      config.boundSessionId = undefined;
+    }
+
     entry.config = config;
     // Reset status but keep history/artifacts (don't wipe logs)
     entry.state.taskStatus = 'idle';
     entry.state.error = undefined;
+    if (entry.worker) {
+      entry.worker.removeAllListeners();
+      entry.worker.stop();
+    }
     entry.worker = null;
-    // Restart watch if config changed
+
     if (this.daemonActive) {
+      // Rebuild worker + message loop
+      this.enterDaemonListening(id);
+      entry.state.smithStatus = 'active';
+      // Restart watch if config changed
       this.watchManager.startWatch(id, config);
+      // Create persistent session if configured (before message loop so inject works)
+      if (config.persistentSession) {
+        this.ensurePersistentSession(id, config).then(() => {
+          this.startMessageLoop(id);
+        });
+      } else {
+        this.startMessageLoop(id);
+      }
     }
     this.saveNow();
     this.emitAgentsChanged();
-    // Push status update so frontend reflects the reset
     this.emit('event', { type: 'task_status', agentId: id, taskStatus: 'idle' } satisfies WorkerEvent);
+    this.emit('event', { type: 'smith_status', agentId: id, smithStatus: entry.state.smithStatus } as any);
   }
 
   getAgentState(id: string): Readonly<AgentState> | undefined {
@@ -275,7 +358,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, mode: entry.state.mode }
+        ? { ...workerState, tmuxSession: entry.state.tmuxSession, currentMessageId: entry.state.currentMessageId }
         : entry.state;
     }
     return result;
@@ -341,7 +424,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
         console.log(`[workspace] Killed tmux session ${entry.state.tmuxSession}`);
       } catch {} // session might already be dead
     }
-    entry.state = { smithStatus: 'down', mode: 'auto', taskStatus: 'idle', history: entry.state.history, artifacts: [] };
+    entry.state = { smithStatus: 'down', taskStatus: 'idle', history: entry.state.history, artifacts: [] };
     this.emit('event', { type: 'task_status', agentId, taskStatus: 'idle' } satisfies WorkerEvent);
     this.emitAgentsChanged();
     this.saveNow();
@@ -359,7 +442,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
       console.log(`[workspace] Resetting ${entry.config.label} (${id}) to idle (upstream ${agentId} changed)`);
       if (entry.worker) entry.worker.stop();
       entry.worker = null;
-      entry.state = { smithStatus: entry.state.smithStatus, mode: entry.state.mode, taskStatus: 'idle', history: entry.state.history, artifacts: [], cliSessionId: entry.state.cliSessionId };
+      entry.state = { smithStatus: entry.state.smithStatus, taskStatus: 'idle', history: entry.state.history, artifacts: [], cliSessionId: entry.state.cliSessionId };
       this.emit('event', { type: 'task_status', agentId: id, taskStatus: 'idle' } satisfies WorkerEvent);
       this.resetDownstream(id, visited);
     }
@@ -418,11 +501,10 @@ export class WorkspaceOrchestrator extends EventEmitter {
       if (entry.worker) entry.worker.stop();
       entry.worker = null;
       if (!resumeFromCheckpoint) {
-        entry.state = { smithStatus: entry.state.smithStatus, mode: entry.state.mode, taskStatus: 'idle', history: entry.state.history, artifacts: [], cliSessionId: entry.state.cliSessionId };
+        entry.state = { smithStatus: entry.state.smithStatus, taskStatus: 'idle', history: entry.state.history, artifacts: [], cliSessionId: entry.state.cliSessionId };
       } else {
         entry.state.taskStatus = 'idle';
         entry.state.error = undefined;
-        entry.state.mode = 'auto';
       }
     }
 
@@ -603,7 +685,6 @@ export class WorkspaceOrchestrator extends EventEmitter {
       entry.worker = null;
       entry.state = {
         smithStatus: entry.state.smithStatus,
-        mode: entry.state.mode,
         taskStatus: 'idle',
         history: [],
         artifacts: [],
@@ -614,7 +695,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
     // Ensure smith is active when daemon starts this agent
     if (this.daemonActive && entry.state.smithStatus !== 'active') {
       entry.state.smithStatus = 'active';
-      this.emit('event', { type: 'smith_status', agentId, smithStatus: 'active', mode: entry.state.mode } satisfies WorkerEvent);
+      this.emit('event', { type: 'smith_status', agentId, smithStatus: 'active' } satisfies WorkerEvent);
     }
 
     const { config } = entry;
@@ -706,7 +787,6 @@ export class WorkspaceOrchestrator extends EventEmitter {
       }
       if (event.type === 'smith_status') {
         entry.state.smithStatus = event.smithStatus;
-        entry.state.mode = event.mode;
       }
       if (event.type === 'log') {
         appendAgentLog(this.workspaceId, agentId, event.entry).catch(() => {});
@@ -793,29 +873,42 @@ export class WorkspaceOrchestrator extends EventEmitter {
 
         // 3. Set smith status to active
         entry.state.smithStatus = 'active';
-        entry.state.mode = 'auto';
         entry.state.error = undefined;
 
-        // 4. Start message consumption loop
-        this.startMessageLoop(id);
+        // 4. Start message loop (delayed for persistent session agents — session must exist first)
+        if (!entry.config.persistentSession) {
+          this.startMessageLoop(id);
+        }
 
         // 5. Update liveness for bus routing
         this.updateAgentLiveness(id);
 
         // 6. Notify frontend
-        this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'active', mode: 'auto' } satisfies WorkerEvent);
+        this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'active' } satisfies WorkerEvent);
 
         started++;
         console.log(`[daemon] ✓ ${entry.config.label}: active (task=${entry.state.taskStatus})`);
       } catch (err: any) {
         entry.state.smithStatus = 'down';
         entry.state.error = `Failed to start: ${err.message}`;
-        this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'down', mode: 'auto' } satisfies WorkerEvent);
+        this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'down' } satisfies WorkerEvent);
         failed++;
         console.error(`[daemon] ✗ ${entry.config.label}: failed — ${err.message}`);
       }
     }
 
+    // Create persistent terminal sessions, then start their message loops
+    for (const [id, entry] of this.agents) {
+      if (entry.config.type === 'input' || !entry.config.persistentSession) continue;
+      await this.ensurePersistentSession(id, entry.config);
+      // Only start message loop if session was created successfully
+      if (entry.state.smithStatus === 'active') {
+        this.startMessageLoop(id);
+      } else {
+        console.log(`[daemon] ${entry.config.label}: skipped message loop (smith=${entry.state.smithStatus})`);
+      }
+    }
+
     // Start watch loops for agents with watch config
     this.watchManager.start();
 
@@ -912,7 +1005,6 @@ export class WorkspaceOrchestrator extends EventEmitter {
       }
       if (event.type === 'smith_status') {
         entry.state.smithStatus = event.smithStatus;
-        entry.state.mode = event.mode;
       }
       if (event.type === 'log') {
         appendAgentLog(this.workspaceId, agentId, event.entry).catch(() => {});
@@ -957,11 +1049,17 @@ export class WorkspaceOrchestrator extends EventEmitter {
         entry.worker = null;
       }
 
-      // 3. Set smith down
+      // 3. Kill tmux session
+      if (entry.state.tmuxSession) {
+        try { execSync(`tmux kill-session -t "${entry.state.tmuxSession}" 2>/dev/null`, { timeout: 3000 }); } catch {}
+        entry.state.tmuxSession = undefined;
+      }
+
+      // 4. Set smith down
       entry.state.smithStatus = 'down';
       entry.state.error = undefined;
       this.updateAgentLiveness(id);
-      this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'down', mode: entry.state.mode } satisfies WorkerEvent);
+      this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'down' } satisfies WorkerEvent);
 
       console.log(`[daemon] ■ ${entry.config.label}: stopped`);
     }
@@ -970,7 +1068,9 @@ export class WorkspaceOrchestrator extends EventEmitter {
     this.bus.markAllRunningAsFailed();
     this.emitAgentsChanged();
     this.watchManager.stop();
+    this.stopAllTerminalMonitors();
     this.stopHealthCheck();
+    this.forgeActedMessages.clear();
     console.log('[workspace] Daemon stopped');
   }
 
@@ -994,14 +1094,13 @@ export class WorkspaceOrchestrator extends EventEmitter {
 
     for (const [id, entry] of this.agents) {
       if (entry.config.type === 'input') continue;
-      if (entry.state.mode === 'manual') continue;
 
       // Check 1: Worker should exist for all active agents
       if (!entry.worker) {
         console.log(`[health] ${entry.config.label}: no worker — recreating`);
         this.enterDaemonListening(id);
         entry.state.smithStatus = 'active';
-        this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'active', mode: entry.state.mode } as any);
+        this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'active' } as any);
         continue;
       }
 
@@ -1009,7 +1108,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
       if (entry.state.smithStatus !== 'active') {
         console.log(`[health] ${entry.config.label}: smith=${entry.state.smithStatus} — setting active`);
         entry.state.smithStatus = 'active';
-        this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'active', mode: entry.state.mode } as any);
+        this.emit('event', { type: 'smith_status', agentId: id, smithStatus: 'active' } as any);
       }
 
       // Check 3: Message loop should be running
@@ -1032,7 +1131,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
       }
 
       // Check 5: Pending messages but agent idle — try wake
-      if (entry.state.taskStatus !== 'running' && entry.state.mode === 'auto') {
+      if (entry.state.taskStatus !== 'running') {
         const pending = this.bus.getPendingMessagesFor(id).filter(m => m.from !== id && m.type !== 'ack');
         if (pending.length > 0 && entry.worker.isListening()) {
           // Message loop should handle this, but if it didn't, log it
@@ -1042,6 +1141,115 @@ export class WorkspaceOrchestrator extends EventEmitter {
           }
         }
       }
+
+      // Check 6: persistentSession agent without tmux → auto-restart terminal
+      if (entry.config.persistentSession && !entry.state.tmuxSession) {
+        console.log(`[health] ${entry.config.label}: persistentSession but no tmux — restarting terminal`);
+        this.ensurePersistentSession(id, entry.config).catch(err => {
+          console.error(`[health] ${entry.config.label}: failed to restart terminal: ${err.message}`);
+        });
+      }
+    }
+
+    // ── Forge Agent: autonomous bus monitor ──
+    this.runForgeAgentCheck();
+  }
+
+  // Track which messages Forge agent already acted on (avoid duplicate nudges)
+  private forgeActedMessages = new Set<string>();
+  private forgeAgentStartTime = 0;
+
+  /** Forge agent scans bus for actionable states (only recent messages) */
+  private runForgeAgentCheck(): void {
+    if (!this.forgeAgentStartTime) this.forgeAgentStartTime = Date.now();
+    const log = this.bus.getLog();
+    const now = Date.now();
+
+    // Only scan messages from after daemon start (skip all history)
+    for (const msg of log) {
+      if (msg.timestamp < this.forgeAgentStartTime) continue;
+      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
+      if (msg.status === 'done') {
+        const age = now - msg.timestamp;
+        if (age < 30_000) continue; // give 30s grace period
+
+        const hasReply = log.some(r =>
+          r.from === msg.to && r.to === msg.from &&
+          r.timestamp > msg.timestamp && r.type !== 'ack'
+        );
+        if (!hasReply) {
+          const senderLabel = this.agents.get(msg.from)?.config.label || msg.from;
+          const targetEntry = this.agents.get(msg.to);
+          if (targetEntry && targetEntry.state.smithStatus === 'active') {
+            this.bus.send('_forge', msg.to, 'notify', {
+              action: 'info_request',
+              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}`);
+          }
+        }
+      }
+
+      // Case 2: Message running too long (>5min) → log warning
+      if (msg.status === 'running') {
+        const age = now - msg.timestamp;
+        if (age > 300_000 && !this.forgeActedMessages.has(`running-${msg.id}`)) {
+          const targetLabel = this.agents.get(msg.to)?.config.label || msg.to;
+          console.log(`[forge-agent] Warning: ${targetLabel} has been running message ${msg.id.slice(0, 8)} for ${Math.round(age / 60000)}min`);
+          this.emit('event', { type: 'log', agentId: msg.to, entry: { type: 'system', subtype: 'warning', content: `Message running for ${Math.round(age / 60000)}min — may be stuck`, timestamp: new Date().toISOString() } } as any);
+          this.forgeActedMessages.add(`running-${msg.id}`);
+        }
+      }
+
+      // Case 3: Pending too long (>2min) → try to restart message loop
+      if (msg.status === 'pending') {
+        const age = now - msg.timestamp;
+        if (age > 120_000 && !this.forgeActedMessages.has(`pending-${msg.id}`)) {
+          const targetEntry = this.agents.get(msg.to);
+          const targetLabel = targetEntry?.config.label || msg.to;
+
+          // If agent is active but not running a task, restart message loop
+          if (targetEntry && targetEntry.state.smithStatus === 'active' && targetEntry.state.taskStatus !== 'running') {
+            if (!this.messageLoopTimers.has(msg.to)) {
+              this.startMessageLoop(msg.to);
+              console.log(`[forge-agent] Restarted message loop for ${targetLabel} (pending ${Math.round(age / 60000)}min)`);
+            } else {
+              console.log(`[forge-agent] ${targetLabel} has pending message ${msg.id.slice(0, 8)} for ${Math.round(age / 60000)}min — loop running but not consuming`);
+            }
+          }
+
+          this.emit('event', { type: 'log', agentId: msg.to, entry: { type: 'system', subtype: 'warning', content: `Pending message from ${this.agents.get(msg.from)?.config.label || msg.from} waiting for ${Math.round(age / 60000)}min`, timestamp: new Date().toISOString() } } as any);
+          this.forgeActedMessages.add(`pending-${msg.id}`);
+        }
+      }
+
+      // Case 4: Failed → notify sender so they know
+      if (msg.status === 'failed' && !this.forgeActedMessages.has(`failed-${msg.id}`)) {
+        const senderEntry = this.agents.get(msg.from);
+        const targetLabel = this.agents.get(msg.to)?.config.label || msg.to;
+        if (senderEntry && msg.from !== '_forge' && msg.from !== '_system') {
+          this.bus.send('_forge', msg.from, 'notify', {
+            action: 'update_notify',
+            content: `Your message to ${targetLabel} has failed. You may want to retry or take a different approach.`,
+          });
+          console.log(`[forge-agent] Notified ${senderEntry.config.label} that message to ${targetLabel} failed`);
+        }
+        this.forgeActedMessages.add(`failed-${msg.id}`);
+      }
+
+      // Case 5: Pending approval too long (>5min) → log reminder
+      if (msg.status === 'pending_approval') {
+        const age = now - msg.timestamp;
+        if (age > 300_000 && !this.forgeActedMessages.has(`approval-${msg.id}`)) {
+          const targetLabel = this.agents.get(msg.to)?.config.label || msg.to;
+          this.emit('event', { type: 'log', agentId: msg.to, entry: { type: 'system', subtype: 'warning', content: `Message awaiting approval for ${Math.round(age / 60000)}min — requires manual action`, timestamp: new Date().toISOString() } } as any);
+          this.forgeActedMessages.add(`approval-${msg.id}`);
+        }
+      }
     }
   }
 
@@ -1058,8 +1266,8 @@ export class WorkspaceOrchestrator extends EventEmitter {
 
     if (action === 'analyze') {
       // Auto-wake agent to analyze changes (skip if busy/manual)
-      if (entry.state.mode === 'manual' || entry.state.taskStatus === 'running') {
-        console.log(`[watch] ${entry.config.label}: skipped analyze (mode=${entry.state.mode} task=${entry.state.taskStatus})`);
+      if (entry.state.taskStatus === 'running') {
+        console.log(`[watch] ${entry.config.label}: skipped analyze (task=${entry.state.taskStatus})`);
         return;
       }
       if (!entry.worker?.isListening()) {
@@ -1103,23 +1311,46 @@ export class WorkspaceOrchestrator extends EventEmitter {
         return;
       }
 
-      // Skip if target already has a pending/running message from this watch
+      const prompt = entry.config.watch?.prompt;
+      // For terminal injection: send the configured prompt directly (pattern is the trigger, not the payload)
+      // If no prompt configured, send the summary
+      const message = prompt || summary;
+
+      // Try to inject directly into an open terminal session
+      // Verify stored session is alive, clear if dead
+      if (targetEntry.state.tmuxSession) {
+        try { execSync(`tmux has-session -t "${targetEntry.state.tmuxSession}" 2>/dev/null`, { timeout: 3000 }); }
+        catch { targetEntry.state.tmuxSession = undefined; }
+      }
+      const tmuxSession = targetEntry.state.tmuxSession || this.findTmuxSession(targetEntry.config.label);
+      if (tmuxSession) {
+        try {
+          const tmpFile = `/tmp/forge-watch-${Date.now()}.txt`;
+          writeFileSync(tmpFile, message);
+          execSync(`tmux load-buffer ${tmpFile}`, { timeout: 5000 });
+          execSync(`tmux paste-buffer -t "${tmuxSession}" && sleep 0.2 && tmux send-keys -t "${tmuxSession}" Enter`, { timeout: 5000 });
+          try { unlinkSync(tmpFile); } catch {}
+          console.log(`[watch] ${entry.config.label} → ${targetEntry.config.label}: injected into terminal (${tmuxSession})`);
+        } catch (err: any) {
+          console.error(`[watch] Terminal inject failed: ${err.message}, falling back to bus`);
+          this.bus.send(agentId, targetId, 'notify', { action: 'watch_alert', content: message });
+        }
+        return;
+      }
+
+      // No terminal open — send via bus (will start new session)
       const hasPendingFromWatch = this.bus.getLog().some(m =>
         m.from === agentId && m.to === targetId &&
         (m.status === 'pending' || m.status === 'running' || m.status === 'pending_approval') &&
         m.type !== 'ack'
       );
       if (hasPendingFromWatch) {
-        console.log(`[watch] ${entry.config.label}: skipping send — target ${targetEntry.config.label} still processing previous message`);
+        console.log(`[watch] ${entry.config.label}: skipping bus send — target still processing`);
         return;
       }
 
-      const prompt = entry.config.watch?.prompt || 'Watch detected changes, please review:';
-      this.bus.send(agentId, targetId, 'notify', {
-        action: 'watch_alert',
-        content: `${prompt}\n\n${summary}`,
-      });
-      console.log(`[watch] ${entry.config.label} → ${targetEntry.config.label}: sent watch alert`);
+      this.bus.send(agentId, targetId, 'notify', { action: 'watch_alert', content: message });
+      console.log(`[watch] ${entry.config.label} → ${targetEntry.config.label}: sent via bus`);
     }
   }
 
@@ -1189,44 +1420,51 @@ export class WorkspaceOrchestrator extends EventEmitter {
     this.emitAgentsChanged();
   }
 
-  /** Switch an agent to manual mode (user operates in terminal) */
+  clearTmuxSession(agentId: string): void {
+    const entry = this.agents.get(agentId);
+    if (!entry) return;
+    entry.state.tmuxSession = undefined;
+    this.saveNow();
+    this.emitAgentsChanged();
+  }
+
+  /** Record that an agent has an open terminal (tmux session tracking) */
   setManualMode(agentId: string): void {
     const entry = this.agents.get(agentId);
     if (!entry) return;
-    entry.state.mode = 'manual';
-    this.emit('event', { type: 'smith_status', agentId, smithStatus: entry.state.smithStatus, mode: 'manual' } satisfies WorkerEvent);
+    // tmuxSession is set separately when terminal opens
     this.emitAgentsChanged();
     this.saveNow();
-    console.log(`[workspace] Agent "${entry.config.label}" switched to manual mode`);
+    console.log(`[workspace] Agent "${entry.config.label}" terminal opened`);
   }
 
-  /** Re-enter daemon mode for an agent after manual terminal is closed */
+  /** Called when agent's terminal is closed */
   restartAgentDaemon(agentId: string): void {
     if (!this.daemonActive) return;
     const entry = this.agents.get(agentId);
     if (!entry || entry.config.type === 'input') return;
 
-    entry.state.mode = 'auto';
     entry.state.error = undefined;
+    // Don't clear tmuxSession here — it may still be alive (persistent session)
+    // Terminal close just means the UI panel is closed, not necessarily tmux killed
 
-    // Recreate worker if needed (resetAgent kills worker)
+    // Recreate worker if needed
     if (!entry.worker) {
       this.enterDaemonListening(agentId);
       this.startMessageLoop(agentId);
     }
 
     entry.state.smithStatus = 'active';
-    this.emit('event', { type: 'smith_status', agentId, smithStatus: 'active', mode: 'auto' } satisfies WorkerEvent);
+    this.emit('event', { type: 'smith_status', agentId, smithStatus: 'active' } satisfies WorkerEvent);
     this.emitAgentsChanged();
   }
 
-  /** Complete a manual agent — called by forge-done skill from terminal */
+  /** Complete an agent from terminal — called by forge-done skill */
   completeManualAgent(agentId: string, changedFiles: string[]): void {
     const entry = this.agents.get(agentId);
     if (!entry) return;
 
     entry.state.taskStatus = 'done';
-    entry.state.mode = 'auto'; // clear manual mode
     entry.state.completedAt = Date.now();
     entry.state.artifacts = changedFiles.map(f => ({ type: 'file' as const, path: f }));
 
@@ -1322,13 +1560,12 @@ export class WorkspaceOrchestrator extends EventEmitter {
     this.agents.clear();
     this.daemonActive = false; // Reset daemon — user must click Start Daemon again after restart
     for (const config of data.agents) {
-      const state = data.agentStates[config.id] || { smithStatus: 'down' as const, mode: 'auto' as const, taskStatus: 'idle' as const, history: [], artifacts: [] };
+      const state = data.agentStates[config.id] || { smithStatus: 'down' as const, taskStatus: 'idle' as const, history: [], artifacts: [] };
 
       // Migrate old format if loading from pre-two-layer state
       if ('status' in state && !('smithStatus' in state)) {
         const oldStatus = (state as any).status;
         (state as any).smithStatus = 'down';
-        (state as any).mode = (state as any).runMode || 'auto';
         (state as any).taskStatus = (oldStatus === 'running' || oldStatus === 'listening') ? 'idle' :
                        (oldStatus === 'interrupted') ? 'idle' :
                        (oldStatus === 'waiting_approval') ? 'idle' :
@@ -1496,20 +1733,9 @@ export class WorkspaceOrchestrator extends EventEmitter {
     const causedBy = this.buildCausedBy(agentId, entry);
     const processedMsg = causedBy ? this.bus.getLog().find(m => m.id === causedBy.messageId) : null;
 
-    if (processedMsg && !this.isUpstream(processedMsg.from, agentId)) {
-      // Processed a message from downstream — no extra reply needed.
-      // The original message is already marked done via markMessageDone().
-      // Sender can check their outbox message status. Only broadcast to downstream.
-      const senderLabel = this.agents.get(processedMsg.from)?.config.label || processedMsg.from;
-      console.log(`[bus] ${entry.config.label}: processed request from ${senderLabel} — marked done, no reply`);
-      // Still broadcast to own downstream (e.g., QA processed Engineer's msg → notify Reviewer)
-      this.broadcastCompletion(agentId, causedBy);
-    } else {
-      // Normal upstream completion or initial execution → broadcast to all downstream
-      this.broadcastCompletion(agentId, causedBy);
-      // notifyDownstreamForRevalidation removed — causes duplicate messages and re-execution loops
-      // Downstream agents that already completed will be handled in future iteration mode
-    }
+    this.broadcastCompletion(agentId, causedBy);
+    // Note: Forge agent (runForgeAgentCheck) monitors for missing replies
+    // and nudges agents to send summaries. No action needed here.
 
     this.emitWorkspaceStatus();
     this.checkWorkspaceComplete?.();
@@ -1552,6 +1778,305 @@ export class WorkspaceOrchestrator extends EventEmitter {
 
   // ─── Agent liveness ─────────────────────────────────────
 
+  /** Find an active tmux session for an agent by checking naming conventions */
+  // ─── Persistent Terminal Sessions ────────────────────────
+
+  /** Resolve the CLI session directory for a given project path */
+  private getCliSessionDir(workDir?: string): string {
+    const projectPath = workDir && workDir !== './' && workDir !== '.'
+      ? join(this.projectPath, workDir) : this.projectPath;
+    const encoded = resolve(projectPath).replace(/\//g, '-');
+    return join(homedir(), '.claude', 'projects', encoded);
+  }
+
+  /** Create a persistent tmux session with the CLI agent */
+  private async ensurePersistentSession(agentId: string, config: WorkspaceAgentConfig): Promise<void> {
+    const safeName = (s: string) => s.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').slice(0, 20);
+    const sessionName = `mw-forge-${safeName(this.projectName)}-${safeName(config.label)}`;
+
+    // Pre-flight: check project's .claude/settings.json is valid
+    const workDir = config.workDir && config.workDir !== './' && config.workDir !== '.'
+      ? `${this.projectPath}/${config.workDir}` : this.projectPath;
+    const projectSettingsFile = join(workDir, '.claude', 'settings.json');
+    if (existsSync(projectSettingsFile)) {
+      try {
+        const raw = readFileSync(projectSettingsFile, 'utf-8');
+        JSON.parse(raw);
+      } catch (err: any) {
+        const errorMsg = `Invalid .claude/settings.json: ${err.message}`;
+        console.error(`[daemon] ${config.label}: ${errorMsg}`);
+        const entry = this.agents.get(agentId);
+        if (entry) {
+          entry.state.error = errorMsg;
+          entry.state.smithStatus = 'down';
+          this.emit('event', { type: 'smith_status', agentId, smithStatus: 'down' } as any);
+          this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'error', content: `⚠️ ${errorMsg}`, timestamp: new Date().toISOString() } } as any);
+          this.emitAgentsChanged();
+        }
+        return;
+      }
+    }
+
+    // Check if tmux session already exists
+    try {
+      execSync(`tmux has-session -t "${sessionName}" 2>/dev/null`, { timeout: 3000 });
+      console.log(`[daemon] ${config.label}: persistent session already exists (${sessionName})`);
+    } catch {
+      // Create new tmux session and start the CLI agent
+      try {
+        // Resolve agent launch info
+        let cliCmd = 'claude';
+        let cliType = 'claude-code';
+        let supportsSession = true;
+        let skipPermissionsFlag = '--dangerously-skip-permissions';
+        let envExports = '';
+        let modelFlag = '';
+        try {
+          const { resolveTerminalLaunch, listAgents } = await import('../agents/index') as any;
+          const info = resolveTerminalLaunch(config.agentId);
+          cliCmd = info.cliCmd || 'claude';
+          cliType = info.cliType || 'claude-code';
+          supportsSession = info.supportsSession ?? true;
+          const agents = listAgents();
+          const agentDef = agents.find((a: any) => a.id === config.agentId);
+          if (agentDef?.skipPermissionsFlag) skipPermissionsFlag = agentDef.skipPermissionsFlag;
+          if (info.env) {
+            envExports = Object.entries(info.env)
+              .filter(([k]) => k !== 'CLAUDE_MODEL')
+              .map(([k, v]) => `export ${k}="${v}"`)
+              .join(' && ');
+            if (envExports) envExports += ' && ';
+          }
+          if (info.model) modelFlag = ` --model ${info.model}`;
+        } catch {}
+
+        // Generate MCP config for Claude Code agents
+        let mcpConfigFlag = '';
+        if (cliType === 'claude-code') {
+          try {
+            const mcpPort = Number(process.env.MCP_PORT) || 8406;
+            const mcpConfigPath = join(workDir, '.forge', 'mcp.json');
+            const mcpConfig = {
+              mcpServers: {
+                forge: {
+                  type: 'sse',
+                  url: `http://localhost:${mcpPort}/sse?workspaceId=${this.workspaceId}&agentId=${config.id}`,
+                },
+              },
+            };
+            const { mkdirSync: mkdirS } = await import('node:fs');
+            mkdirS(join(workDir, '.forge'), { recursive: true });
+            writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+            mcpConfigFlag = ` --mcp-config "${mcpConfigPath}"`;
+          } catch (err: any) {
+            console.log(`[daemon] ${config.label}: MCP config generation failed: ${err.message}`);
+          }
+        }
+
+        execSync(`tmux new-session -d -s "${sessionName}" -c "${workDir}"`, { timeout: 5000 });
+
+        // Reset profile env vars (unset any leftover from previous agent) then set new ones
+        const profileVarsToReset = ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'ANTHROPIC_SMALL_FAST_MODEL', 'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC', 'DISABLE_TELEMETRY', 'DISABLE_ERROR_REPORTING', 'DISABLE_AUTOUPDATER', 'DISABLE_NON_ESSENTIAL_MODEL_CALLS', 'CLAUDE_MODEL'];
+        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}"`;
+        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 });
+        }
+
+        // Build CLI start command
+        const parts: string[] = [];
+        let cmd = cliCmd;
+
+        // Session resume: use bound session ID (primary from project-sessions, others from config)
+        if (supportsSession) {
+          let sessionId: string | undefined;
+
+          if (config.primary) {
+            try {
+              const { getFixedSession } = await import('../project-sessions') as any;
+              sessionId = getFixedSession(this.projectPath);
+            } catch {}
+          } else {
+            sessionId = config.boundSessionId;
+          }
+
+          if (sessionId) {
+            const sessionFile = join(this.getCliSessionDir(config.workDir), `${sessionId}.jsonl`);
+            if (existsSync(sessionFile)) {
+              cmd += ` --resume ${sessionId}`;
+            } else {
+              console.log(`[daemon] ${config.label}: bound session ${sessionId} missing, starting fresh`);
+            }
+          }
+          // No bound session → start fresh (no -c, avoids "No conversation found")
+        }
+        if (modelFlag) cmd += modelFlag;
+        if (config.skipPermissions !== false && skipPermissionsFlag) cmd += ` ${skipPermissionsFlag}`;
+        if (mcpConfigFlag) cmd += mcpConfigFlag;
+        parts.push(cmd);
+
+        const startCmd = parts.join(' && ');
+        execSync(`tmux send-keys -t "${sessionName}" '${startCmd}' Enter`, { timeout: 5000 });
+
+        console.log(`[daemon] ${config.label}: persistent session created (${sessionName}) [${cliType}: ${cliCmd}]`);
+
+        // Verify CLI started successfully (check after 3s if process is still alive)
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        try {
+          const paneContent = execSync(`tmux capture-pane -t "${sessionName}" -p -S -20`, { timeout: 3000, encoding: 'utf-8' });
+          // Check for common startup errors
+          const errorPatterns = [
+            /error.*settings\.json/i,
+            /invalid.*json/i,
+            /SyntaxError/i,
+            /ENOENT.*settings/i,
+            /failed to parse/i,
+            /could not read/i,
+            /fatal/i,
+            /No conversation found/i,
+            /could not connect/i,
+            /ECONNREFUSED/i,
+          ];
+          const hasError = errorPatterns.some(p => p.test(paneContent));
+          if (hasError) {
+            const errorLines = paneContent.split('\n').filter(l => /error|invalid|syntax|fatal|failed|No conversation|ECONNREFUSED/i.test(l)).slice(0, 3);
+            const errorMsg = errorLines.join(' ').slice(0, 200) || 'CLI failed to start (check project settings)';
+            console.error(`[daemon] ${config.label}: CLI startup error detected: ${errorMsg}`);
+
+            const entry = this.agents.get(agentId);
+            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.emitAgentsChanged();
+            }
+            // Kill the failed tmux session
+            try { execSync(`tmux kill-session -t "${sessionName}" 2>/dev/null`, { timeout: 3000 }); } catch {}
+            return;
+          }
+        } catch {}
+        // Auto-bind session: if no boundSessionId, detect new session file after 5s
+        if (!config.primary && !config.boundSessionId && supportsSession) {
+          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}: auto-bound to session ${config.boundSessionId}`);
+                }
+              }
+            } catch {}
+          }, 5000);
+        }
+      } catch (err: any) {
+        console.error(`[daemon] ${config.label}: failed to create persistent session: ${err.message}`);
+        const entry = this.agents.get(agentId);
+        if (entry) {
+          entry.state.error = `Failed to create terminal: ${err.message}`;
+          entry.state.smithStatus = 'down';
+          this.emit('event', { type: 'smith_status', agentId, smithStatus: 'down' } as any);
+          this.emitAgentsChanged();
+        }
+        return;
+      }
+    }
+
+    // Store tmux session name in agent state
+    const entry = this.agents.get(agentId);
+    if (entry) {
+      entry.state.tmuxSession = sessionName;
+      this.saveNow();
+      this.emitAgentsChanged();
+    }
+  }
+
+  /** Inject text into an agent's persistent terminal session */
+  injectIntoSession(agentId: string, text: string): boolean {
+    const entry = this.agents.get(agentId);
+    // Verify stored session is alive
+    if (entry?.state.tmuxSession) {
+      try { execSync(`tmux has-session -t "${entry.state.tmuxSession}" 2>/dev/null`, { timeout: 3000 }); }
+      catch { entry.state.tmuxSession = undefined; }
+    }
+    const tmuxSession = entry?.state.tmuxSession || this.findTmuxSession(entry?.config.label || '');
+    if (!tmuxSession) return false;
+    // Cache found session for future use
+    if (entry && !entry.state.tmuxSession) entry.state.tmuxSession = tmuxSession;
+
+    try {
+      const tmpFile = `/tmp/forge-inject-${Date.now()}.txt`;
+      writeFileSync(tmpFile, text);
+      execSync(`tmux load-buffer ${tmpFile}`, { timeout: 5000 });
+      execSync(`tmux paste-buffer -t "${tmuxSession}"`, { timeout: 5000 });
+      execSync(`tmux send-keys -t "${tmuxSession}" Enter`, { timeout: 5000 });
+      try { unlinkSync(tmpFile); } catch {}
+      return true;
+    } catch (err: any) {
+      console.error(`[inject] Failed for ${tmuxSession}: ${err.message}`);
+      return false;
+    }
+  }
+
+  /** Check if agent has a persistent session available */
+  hasPersistentSession(agentId: string): boolean {
+    const entry = this.agents.get(agentId);
+    if (!entry) return false;
+    if (entry.state.tmuxSession) return true;
+    return !!this.findTmuxSession(entry.config.label);
+  }
+
+  private findTmuxSession(agentLabel: string): string | null {
+    const safeName = (s: string) => s.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').slice(0, 20);
+    const projectSafe = safeName(this.projectName);
+    const agentSafe = safeName(agentLabel);
+
+    // Try workspace naming: mw-forge-{project}-{agent}
+    const wsName = `mw-forge-${projectSafe}-${agentSafe}`;
+    try { execSync(`tmux has-session -t "${wsName}" 2>/dev/null`, { timeout: 3000 }); return wsName; } catch {}
+
+    // Try VibeCoding naming: mw-{project}
+    const vcName = `mw-${projectSafe}`;
+    try { execSync(`tmux has-session -t "${vcName}" 2>/dev/null`, { timeout: 3000 }); return vcName; } catch {}
+
+    // Search terminal-state.json for project matching tmux session
+    try {
+      const statePath = join(homedir(), '.forge', 'data', 'terminal-state.json');
+      if (existsSync(statePath)) {
+        const termState = JSON.parse(readFileSync(statePath, 'utf-8'));
+        for (const tab of termState.tabs || []) {
+          if (tab.projectPath === this.projectPath) {
+            const findSession = (tree: any): string | null => {
+              if (tree?.type === 'terminal' && tree.sessionName) return tree.sessionName;
+              for (const child of tree?.children || []) {
+                const found = findSession(child);
+                if (found) return found;
+              }
+              return null;
+            };
+            const sess = findSession(tab.tree);
+            if (sess) {
+              try { execSync(`tmux has-session -t "${sess}" 2>/dev/null`, { timeout: 3000 }); return sess; } catch {}
+            }
+          }
+        }
+      }
+    } catch {}
+
+    return null;
+  }
+
   private updateAgentLiveness(agentId: string): void {
     const entry = this.agents.get(agentId);
     if (!entry) {
@@ -1616,13 +2141,6 @@ export class WorkspaceOrchestrator extends EventEmitter {
     // ── Store message in agent history ──
     target.state.history.push(logEntry);
 
-    // ── Manual mode → store in inbox (user handles in terminal) ──
-    if (target.state.mode === 'manual') {
-      ackAndDeliver();
-      console.log(`[bus] ${target.config.label}: received ${action} in manual mode — stored in inbox`);
-      return;
-    }
-
     // ── requiresApproval → set pending_approval on arrival ──
     if (target.config.requiresApproval) {
       msg.status = 'pending_approval';
@@ -1654,29 +2172,40 @@ export class WorkspaceOrchestrator extends EventEmitter {
       // (loop stays alive so it works when smith comes back)
       if (entry.state.smithStatus !== 'active') return;
 
-      // Skip if manual (user in terminal) or running (already busy)
-      if (entry.state.mode === 'manual') return;
+      // Skip if already busy
       if (entry.state.taskStatus === 'running') return;
 
-      // Skip if no worker ready — recreate if needed
-      if (!entry.worker) {
-        if (this.daemonActive) {
-          console.log(`[inbox] ${entry.config.label}: no worker, recreating...`);
-          this.enterDaemonListening(agentId);
-        }
-        return;
-      }
-      if (!entry.worker.isListening()) {
-        if (++debugTick % 15 === 0) {
-          console.log(`[inbox] ${entry.config.label}: not listening (smith=${entry.state.smithStatus} task=${entry.state.taskStatus})`);
-        }
-        return;
-      }
-
       // Skip if any message is already running for this agent
       const hasRunning = this.bus.getLog().some(m => m.to === agentId && m.status === 'running' && m.type !== 'ack');
       if (hasRunning) return;
 
+      // Execution path determined by config, not runtime tmux state
+      const isTerminalMode = entry.config.persistentSession;
+      if (isTerminalMode) {
+        // Terminal mode: need tmux session. If missing, skip this tick (health check will restart it)
+        if (!entry.state.tmuxSession) {
+          if (++debugTick % 15 === 0) {
+            console.log(`[inbox] ${entry.config.label}: terminal mode but no tmux session — waiting for auto-restart`);
+          }
+          return;
+        }
+      } else {
+        // Headless mode: need worker ready
+        if (!entry.worker) {
+          if (this.daemonActive) {
+            console.log(`[inbox] ${entry.config.label}: no worker, recreating...`);
+            this.enterDaemonListening(agentId);
+          }
+          return;
+        }
+        if (!entry.worker.isListening()) {
+          if (++debugTick % 15 === 0) {
+            console.log(`[inbox] ${entry.config.label}: not listening (smith=${entry.state.smithStatus} task=${entry.state.taskStatus})`);
+          }
+          return;
+        }
+      }
+
       // requiresApproval is handled at message arrival time (routeMessageToAgent),
       // not in the message loop. Approved messages come through as normal 'pending'.
 
@@ -1733,8 +2262,29 @@ export class WorkspaceOrchestrator extends EventEmitter {
         timestamp: new Date(nextMsg.timestamp).toISOString(),
       };
 
-      entry.worker.setProcessingMessage(nextMsg.id);
-      entry.worker.wake({ type: 'bus_message', messages: [logEntry] });
+      // Terminal mode → inject; headless → worker (claude -p)
+      if (isTerminalMode) {
+        const injected = this.injectIntoSession(agentId, nextMsg.payload.content || nextMsg.payload.action);
+        if (injected) {
+          this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'execution_method', content: '📺 Injected into terminal, monitoring for completion...', timestamp: new Date().toISOString() } } as any);
+          console.log(`[inbox] ${entry.config.label}: injected into terminal, starting completion monitor`);
+          entry.state.currentMessageId = nextMsg.id;
+          this.monitorTerminalCompletion(agentId, nextMsg.id, entry.state.tmuxSession!);
+        } else {
+          // Terminal inject failed — clear dead session, message stays pending
+          // Health check will auto-restart the terminal session
+          entry.state.tmuxSession = undefined;
+          nextMsg.status = 'pending' as any; // revert to pending for retry
+          this.emit('event', { type: 'bus_message_status', messageId: nextMsg.id, status: 'pending' } as any);
+          this.emit('event', { type: 'log', agentId, entry: { type: 'system', subtype: 'warning', content: '⚠️ Terminal session down — waiting for auto-restart, message will retry', timestamp: new Date().toISOString() } } as any);
+          console.log(`[inbox] ${entry.config.label}: terminal inject failed, cleared session — waiting for health check restart`);
+          this.emitAgentsChanged();
+        }
+      } 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);
+      }
     };
 
     // Check every 2 seconds
@@ -1761,6 +2311,108 @@ export class WorkspaceOrchestrator extends EventEmitter {
     }
   }
 
+  // ─── Terminal completion monitor ──────────────────────
+  private terminalMonitors = new Map<string, NodeJS.Timeout>();
+
+  /**
+   * Monitor a tmux session for completion after injecting a message.
+   * Detects CLI prompt patterns (❯, $, >) indicating the agent is idle.
+   * Requires 2 consecutive prompt detections (10s) to confirm completion.
+   */
+  private monitorTerminalCompletion(agentId: string, messageId: string, tmuxSession: string): void {
+    // Stop any existing monitor for this agent
+    const existing = this.terminalMonitors.get(agentId);
+    if (existing) clearInterval(existing);
+
+    // Prompt patterns that indicate the CLI is idle and waiting for input
+    // Claude Code: ❯  Codex: >  Aider: >  Generic shell: $ #
+    const PROMPT_PATTERNS = [
+      /^❯\s*$/,          // Claude Code idle prompt
+      /^>\s*$/,           // Codex / generic prompt
+      /^\$\s*$/,          // Shell prompt
+      /^#\s*$/,           // Root shell prompt
+      /^aider>\s*$/,      // Aider prompt
+    ];
+
+    let promptCount = 0;
+    let started = false;
+    const CONFIRM_CHECKS = 2;    // 2 consecutive prompt detections = done
+    const CHECK_INTERVAL = 5000; // 5s between checks
+
+    const timer = setInterval(() => {
+      try {
+        const output = execSync(`tmux capture-pane -t "${tmuxSession}" -p -S -30`, { timeout: 3000, encoding: 'utf-8' });
+
+        // Strip ANSI escape sequences for clean matching
+        const clean = output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+        // Get last few non-empty lines
+        const lines = clean.split('\n').map(l => l.trim()).filter(Boolean);
+        const tail = lines.slice(-5);
+
+        // First check: detect that agent started working (output changed from inject)
+        if (!started && lines.length > 3) {
+          started = true;
+        }
+        if (!started) return;
+
+        // Check if any of the last lines match a prompt pattern
+        const hasPrompt = tail.some(line => PROMPT_PATTERNS.some(p => p.test(line)));
+
+        if (hasPrompt) {
+          promptCount++;
+          if (promptCount >= CONFIRM_CHECKS) {
+            clearInterval(timer);
+            this.terminalMonitors.delete(agentId);
+
+            // Extract output summary (skip prompt lines)
+            const contentLines = lines.filter(l => !PROMPT_PATTERNS.some(p => p.test(l)));
+            const summary = contentLines.slice(-15).join('\n');
+
+            // Mark message done
+            const msg = this.bus.getLog().find(m => m.id === messageId);
+            if (msg && msg.status !== 'done') {
+              msg.status = 'done' as any;
+              this.emit('event', { type: 'bus_message_status', messageId, status: 'done' } as any);
+            }
+
+            // Emit output to log panel
+            this.emit('event', { type: 'log', agentId, entry: { type: 'assistant', subtype: 'terminal_output', content: `📺 Terminal completed:\n${summary.slice(0, 500)}`, timestamp: new Date().toISOString() } } as any);
+
+            // Trigger downstream notifications
+            const entry = this.agents.get(agentId);
+            if (entry) {
+              entry.state.currentMessageId = undefined;
+              this.handleAgentDone(agentId, entry, summary.slice(0, 300));
+            }
+            console.log(`[terminal-monitor] ${agentId}: prompt detected, completed`);
+          }
+        } else {
+          promptCount = 0; // reset — still working
+        }
+      } catch {
+        // Session died
+        clearInterval(timer);
+        this.terminalMonitors.delete(agentId);
+        const msg = this.bus.getLog().find(m => m.id === messageId);
+        if (msg && msg.status !== 'done' && msg.status !== 'failed') {
+          msg.status = 'failed' as any;
+          this.emit('event', { type: 'bus_message_status', messageId, status: 'failed' } as any);
+        }
+        const entry = this.agents.get(agentId);
+        if (entry) entry.state.currentMessageId = undefined;
+        console.error(`[terminal-monitor] ${agentId}: session died, marked message failed`);
+      }
+    }, CHECK_INTERVAL);
+    timer.unref();
+    this.terminalMonitors.set(agentId, timer);
+  }
+
+  /** Stop all terminal monitors (on daemon stop) */
+  private stopAllTerminalMonitors(): void {
+    for (const [, timer] of this.terminalMonitors) clearInterval(timer);
+    this.terminalMonitors.clear();
+  }
+
   /** Check if all agents are done and no pending work remains */
   private checkWorkspaceComplete(): void {
     let allDone = true;