@aion0/forge 0.5.26 → 0.5.27

package/.forge/worktrees/pipeline-4dd8dc2d/lib/workspace-standalone.ts

@@ -0,0 +1,978 @@
+#!/usr/bin/env npx tsx
+/**
+ * Workspace Daemon — standalone process for managing workspace agent orchestrators.
+ *
+ * Runs as an independent HTTP server (like terminal-standalone.ts).
+ * Next.js API routes proxy requests here.
+ *
+ * Usage: npx tsx lib/workspace-standalone.ts [--forge-port=8403]
+ *
+ * Env:
+ *   WORKSPACE_PORT  — HTTP port (default: webPort + 2 = 8405)
+ *   FORGE_DATA_DIR  — data directory
+ */
+
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { readdirSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { WorkspaceOrchestrator, type OrchestratorEvent } from './workspace/orchestrator';
+import { loadWorkspace, saveWorkspace, findWorkspaceByProject } from './workspace/persistence';
+import { installForgeSkills, applyProfileToProject } from './workspace/skill-installer';
+import {
+  loadMemory, formatMemoryForDisplay, getMemoryStats,
+  addObservation, addSessionSummary,
+} from './workspace/smith-memory';
+import type { WorkspaceAgentConfig, WorkspaceState, BusMessage } from './workspace/types';
+import { execSync } from 'node:child_process';
+
+// ─── Config ──────────────────────────────────────────────
+
+const PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const FORGE_PORT = Number(process.env.PORT) || 8403;
+const MAX_ACTIVE = 5;
+
+// ─── State ───────────────────────────────────────────────
+
+const orchestrators = new Map<string, WorkspaceOrchestrator>();
+const sseClients = new Map<string, Set<ServerResponse>>();
+const startTime = Date.now();
+
+// ─── Orchestrator Lifecycle ──────────────────────────────
+
+function getOrchestrator(id: string): WorkspaceOrchestrator | null {
+  return orchestrators.get(id) || null;
+}
+
+function loadOrchestrator(id: string): WorkspaceOrchestrator {
+  const existing = orchestrators.get(id);
+  if (existing) return existing;
+
+  const state = loadWorkspace(id);
+  if (!state) throw new Error('Workspace not found');
+
+  const orch = new WorkspaceOrchestrator(state.id, state.projectPath, state.projectName);
+  if (state.agents.length > 0) {
+    orch.loadSnapshot({
+      agents: state.agents,
+      agentStates: state.agentStates,
+      busLog: state.busLog,
+      busOutbox: state.busOutbox,
+    });
+  }
+
+  // Wire up SSE broadcasting
+  orch.on('event', (event: OrchestratorEvent) => {
+    broadcastSSE(id, event);
+  });
+
+  orchestrators.set(id, orch);
+  // Loaded silently — debug only if needed
+  return orch;
+}
+
+function unloadOrchestrator(id: string): void {
+  const orch = orchestrators.get(id);
+  if (!orch) return;
+  orch.shutdown();
+  orchestrators.delete(id);
+  // Close SSE connections for this workspace
+  const clients = sseClients.get(id);
+  if (clients) {
+    for (const res of clients) {
+      try { res.end(); } catch {}
+    }
+    sseClients.delete(id);
+  }
+  // Unloaded silently
+}
+
+function evictIdleWorkspace(): boolean {
+  for (const [id, orch] of orchestrators) {
+    const states = orch.getAllAgentStates();
+    const hasRunning = Object.values(states).some(s =>
+      s.taskStatus === 'running' || s.smithStatus === 'active'
+    );
+    if (!hasRunning) {
+      unloadOrchestrator(id);
+      return true;
+    }
+  }
+  return false;
+}
+
+// ─── SSE Management ──────────────────────────────────────
+
+function addSSEClient(workspaceId: string, res: ServerResponse): void {
+  if (!sseClients.has(workspaceId)) sseClients.set(workspaceId, new Set());
+  sseClients.get(workspaceId)!.add(res);
+}
+
+function removeSSEClient(workspaceId: string, res: ServerResponse): void {
+  sseClients.get(workspaceId)?.delete(res);
+  if (sseClients.get(workspaceId)?.size === 0) sseClients.delete(workspaceId);
+}
+
+function broadcastSSE(workspaceId: string, event: OrchestratorEvent): void {
+  const clients = sseClients.get(workspaceId);
+  if (!clients) return;
+  const data = `data: ${JSON.stringify(event)}\n\n`;
+  for (const res of clients) {
+    try { res.write(data); } catch { removeSSEClient(workspaceId, res); }
+  }
+}
+
+// ─── HTTP Helpers ────────────────────────────────────────
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on('data', (c: Buffer) => chunks.push(c));
+    req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+    req.on('error', reject);
+  });
+}
+
+function json(res: ServerResponse, data: unknown, status = 200): void {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(data));
+}
+
+function jsonError(res: ServerResponse, msg: string, status = 400): void {
+  json(res, { error: msg }, status);
+}
+
+function parseUrl(url: string): { path: string; query: URLSearchParams } {
+  const u = new URL(url, 'http://localhost');
+  return { path: u.pathname, query: u.searchParams };
+}
+
+// ─── Route: Agent Operations ─────────────────────────────
+
+async function handleAgentsPost(id: string, body: any, res: ServerResponse): Promise<void> {
+  let orch: WorkspaceOrchestrator;
+  try {
+    orch = loadOrchestrator(id);
+  } catch (err: any) {
+    return jsonError(res, err.message, err.message.includes('not found') ? 404 : 429);
+  }
+
+  const { action, agentId, config, content, input } = body;
+
+  try {
+    switch (action) {
+      case 'add': {
+        if (!config) return jsonError(res, 'config required');
+        try {
+          orch.addAgent(config as WorkspaceAgentConfig);
+          return json(res, { ok: true });
+        } catch (err: any) {
+          return jsonError(res, err.message);
+        }
+      }
+      case 'create_pipeline': {
+        const { createDevPipeline } = require('./workspace/presets');
+        const pipeline = createDevPipeline();
+        for (const cfg of pipeline) orch.addAgent(cfg);
+        return json(res, { ok: true, agents: pipeline.length });
+      }
+      case 'remove': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.removeAgent(agentId);
+        return json(res, { ok: true });
+      }
+      case 'update': {
+        if (!agentId || !config) return jsonError(res, 'agentId and config required');
+        try {
+          orch.updateAgentConfig(agentId, config as WorkspaceAgentConfig);
+          return json(res, { ok: true });
+        } catch (err: any) {
+          return jsonError(res, err.message);
+        }
+      }
+      case 'agent_done': {
+        // Called by Claude Code Stop hook — agent finished a turn
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.handleHookDone(agentId);
+        return json(res, { ok: true });
+      }
+      case 'run': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        if (!orch.isDaemonActive()) return jsonError(res, 'Start daemon first before running agents');
+        try {
+          await orch.runAgent(agentId, input, true); // force=true: manual trigger skips dep check
+          return json(res, { ok: true, status: 'started' });
+        } catch (err: any) {
+          return jsonError(res, err.message);
+        }
+      }
+      case 'run_all': {
+        orch.runAll().catch(err => {
+          console.error('[workspace] runAll error:', err.message);
+        });
+        return json(res, { ok: true, status: 'started' });
+      }
+      case 'complete_input': {
+        if (!agentId || !content) return jsonError(res, 'agentId and content required');
+        orch.completeInput(agentId, content);
+        return json(res, { ok: true });
+      }
+      case 'pause': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.pauseAgent(agentId);
+        return json(res, { ok: true });
+      }
+      case 'resume': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.resumeAgent(agentId);
+        return json(res, { ok: true });
+      }
+      case 'stop': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.stopAgent(agentId);
+        return json(res, { ok: true });
+      }
+      case 'mark_done': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.markAgentDone(agentId, body.notify !== false);
+        return json(res, { ok: true });
+      }
+      case 'mark_failed': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.markAgentFailed(agentId, body.notify !== false);
+        return json(res, { ok: true });
+      }
+      case 'retry': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        if (!orch.isDaemonActive()) return jsonError(res, 'Start daemon first before retrying agents');
+        const retryState = orch.getAgentState(agentId);
+        if (!retryState) return jsonError(res, 'Agent not found');
+        if (retryState.taskStatus === 'running') return jsonError(res, 'Agent is already running');
+        if (retryState.taskStatus !== 'failed') return jsonError(res, `Agent is ${retryState.taskStatus}, not failed`);
+        try {
+          console.log(`[workspace] Retry ${agentId}: smith=${retryState.smithStatus}, task=${retryState.taskStatus}`);
+          await orch.runAgent(agentId, undefined, true);
+          return json(res, { ok: true, status: 'retrying' });
+        } catch (err: any) {
+          console.error(`[workspace] Retry failed for ${agentId}:`, err.message);
+          return jsonError(res, err.message);
+        }
+      }
+      case 'set_tmux_session': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        const { sessionName } = body;
+        orch.setTmuxSession(agentId, sessionName);
+        return json(res, { ok: true });
+      }
+      case 'reset': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.resetAgent(agentId);
+        // If daemon is active, re-enter daemon mode for this agent
+        if (orch.isDaemonActive()) {
+          orch.restartAgentDaemon(agentId);
+        }
+        return json(res, { ok: true });
+      }
+      case 'open_terminal': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        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);
+
+        // Resolve launch info using shared logic (same as VibeCoding terminal)
+        let launchInfo: any = { cliCmd: 'claude', cliType: 'claude-code', supportsSession: true };
+        try {
+          const { resolveTerminalLaunch, clearAgentCache } = await import('./agents/index.js');
+          clearAgentCache(); // ensure fresh settings are read
+          launchInfo = resolveTerminalLaunch(agentConfig.agentId);
+        } catch {}
+
+        // resolveOnly: return launch info + current session ID (no side effects)
+        if (body.resolveOnly) {
+          let currentSessionId: string | null = null;
+          if (agentConfig.primary) {
+            try {
+              const { getFixedSession } = await import('./project-sessions.js');
+              currentSessionId = getFixedSession(orch.projectPath) || null;
+            } catch {}
+          } else {
+            currentSessionId = agentConfig.boundSessionId || null;
+          }
+          return json(res, { ok: true, ...launchInfo, currentSessionId });
+        }
+
+        // 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 });
+        }
+
+        // No tmux has-session liveness check — it adds latency with no benefit.
+        // If the session is dead, openTerminalSession will recreate it anyway.
+
+        // Ensure tmux session exists (creates if needed, no 3s startup delay)
+        // forceRestart: kill existing tmux so launch script is rewritten with current boundSessionId
+        const tmuxSession = await orch.openTerminalSession(agentId, body.forceRestart === true);
+
+        orch.setManualMode(agentId);
+        // Skills call Next.js API (/api/workspace/.../smith), so use FORGE_PORT not daemon PORT
+        const result = installForgeSkills(orch.projectPath, id, agentId, FORGE_PORT);
+
+        return json(res, {
+          ok: true,
+          primary: agentConfig.primary || undefined,
+          fixedSession: agentConfig.primary || undefined,
+          skillsInstalled: result.installed,
+          agentId,
+          label: agentConfig.label,
+          tmuxSession: tmuxSession || undefined,
+          ...launchInfo,
+        });
+      }
+      case 'close_terminal': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        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': {
+        if (!agentId || !content) return jsonError(res, 'agentId (from) and content required');
+        const targetId = body.targetId;
+        if (!targetId) return jsonError(res, 'targetId required');
+        const causedByMsg = body.causedByMessageId ? orch.getBus().getLog().find(m => m.id === body.causedByMessageId) : undefined;
+        const causedBy = causedByMsg ? { messageId: causedByMsg.id, from: causedByMsg.from, to: causedByMsg.to } : undefined;
+        const ticket = orch.getBus().createTicket(agentId, targetId, body.ticketAction || 'bug_report', content, body.files, causedBy);
+        return json(res, { ok: true, ticketId: ticket.id });
+      }
+      case 'update_ticket': {
+        const { messageId, ticketStatus } = body;
+        if (!messageId || !ticketStatus) return jsonError(res, 'messageId and ticketStatus required');
+        orch.getBus().updateTicketStatus(messageId, ticketStatus);
+        return json(res, { ok: true });
+      }
+      case 'message': {
+        if (!agentId || !content) return jsonError(res, 'agentId and content required');
+        orch.sendMessageToAgent(agentId, content);
+        return json(res, { ok: true });
+      }
+      case 'approve': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.approveAgent(agentId);
+        return json(res, { ok: true });
+      }
+      case 'reject': {
+        if (!agentId) return jsonError(res, 'agentId required');
+        orch.rejectApproval(agentId);
+        return json(res, { ok: true });
+      }
+      case 'retry_message': {
+        const { messageId } = body;
+        if (!messageId) return jsonError(res, 'messageId required');
+        if (!orch.isDaemonActive()) return jsonError(res, 'Start daemon first before retrying messages');
+        const msg = orch.getBus().retryMessage(messageId);
+        if (!msg) return jsonError(res, 'Message not found or already pending');
+        orch.emit('event', { type: 'bus_message_status', messageId: msg.id, status: 'pending' });
+        return json(res, { ok: true, messageId: msg.id, action: msg.payload.action });
+      }
+      case 'abort_message': {
+        const { messageId } = body;
+        if (!messageId) return jsonError(res, 'messageId required');
+        const abortMsg = orch.getBus().abortMessage(messageId);
+        if (abortMsg) {
+          orch.emit('event', { type: 'bus_message_status', messageId, status: 'failed' });
+        }
+        return json(res, { ok: true, messageId, aborted: !!abortMsg });
+      }
+      case 'approve_message': {
+        const { messageId } = body;
+        if (!messageId) return jsonError(res, 'messageId required');
+        const approveMsg = orch.getBus().getLog().find(m => m.id === messageId);
+        if (!approveMsg) return jsonError(res, 'Message not found');
+        if (approveMsg.status !== 'pending_approval') return jsonError(res, 'Message is not pending approval');
+        if (body.content) approveMsg.payload.content = body.content;
+        approveMsg.status = 'pending';
+        orch.emit('event', { type: 'bus_message_status', messageId, status: 'pending' });
+        return json(res, { ok: true });
+      }
+      case 'reject_message': {
+        const { messageId } = body;
+        if (!messageId) return jsonError(res, 'messageId required');
+        const rejectMsg = orch.getBus().getLog().find(m => m.id === messageId);
+        if (!rejectMsg) return jsonError(res, 'Message not found');
+        rejectMsg.status = 'failed';
+        orch.emit('event', { type: 'bus_message_status', messageId, status: 'failed' });
+        return json(res, { ok: true });
+      }
+      case 'delete_message': {
+        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 '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 (include 'starting' to prevent exceeding MAX_ACTIVE)
+        const activeCount = Array.from(orchestrators.values()).filter(o =>
+          o.isDaemonActive() || Object.values(o.getAllAgentStates()).some(s => s.smithStatus === 'starting')
+        ).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);
+        });
+        return json(res, { ok: true, status: 'daemon_started' });
+      }
+      case 'stop_daemon': {
+        orch.stopDaemon();
+        return json(res, { ok: true, status: 'daemon_stopped' });
+      }
+      default:
+        return jsonError(res, `Unknown action: ${action}`);
+    }
+  } catch (err: any) {
+    return jsonError(res, err.message, 500);
+  }
+}
+
+function handleAgentsGet(id: string, res: ServerResponse): void {
+  let orch: WorkspaceOrchestrator;
+  try {
+    orch = loadOrchestrator(id);
+  } catch (err: any) {
+    return jsonError(res, err.message, err.message.includes('not found') ? 404 : 429);
+  }
+
+  json(res, {
+    agents: orch.getSnapshot().agents,
+    states: orch.getAllAgentStates(),
+    busLog: orch.getBusLog(),
+    daemonActive: orch.isDaemonActive(),
+  });
+}
+
+// ─── Route: SSE Stream ───────────────────────────────────
+
+function handleStream(id: string, req: IncomingMessage, res: ServerResponse): void {
+  let orch: WorkspaceOrchestrator;
+  try {
+    orch = loadOrchestrator(id);
+  } catch (err: any) {
+    res.writeHead(err.message.includes('not found') ? 404 : 429);
+    res.end(err.message);
+    return;
+  }
+
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    'Connection': 'keep-alive',
+  });
+
+  // Send initial snapshot
+  const snapshot = orch.getSnapshot();
+  res.write(`data: ${JSON.stringify({ type: 'init', ...snapshot })}\n\n`);
+
+  addSSEClient(id, res);
+
+  // Keep-alive ping every 15s
+  const ping = setInterval(() => {
+    try { res.write(`: ping\n\n`); } catch {
+      clearInterval(ping);
+      removeSSEClient(id, res);
+    }
+  }, 15000);
+
+  // Cleanup on disconnect
+  req.on('close', () => {
+    clearInterval(ping);
+    removeSSEClient(id, res);
+  });
+}
+
+// ─── Route: Smith API ────────────────────────────────────
+
+async function handleSmith(id: string, body: any, res: ServerResponse): Promise<void> {
+  const orch = getOrchestrator(id);
+  if (!orch) return jsonError(res, 'Workspace not found', 404);
+
+  const { action, agentId } = body;
+
+  switch (action) {
+    case 'done': {
+      if (!agentId) return jsonError(res, 'agentId required');
+
+      try {
+        let gitDiff = '';
+        try {
+          gitDiff = execSync('git diff --stat HEAD', {
+            cwd: orch.projectPath, encoding: 'utf-8', timeout: 5000,
+          }).trim();
+        } catch {}
+
+        // Parse file names from --stat output (lines with ' | ') instead of a second execSync
+        const changedFiles = gitDiff
+          .split('\n')
+          .filter(l => l.includes(' | '))
+          .map(l => l.split(' | ')[0].trim())
+          .filter(Boolean);
+        const entry = (orch as any).agents?.get(agentId);
+        const config = entry?.config;
+
+        if (config && changedFiles.length > 0) {
+          await addObservation(id, agentId, config.label, config.role, {
+            type: 'change',
+            title: `Manual work completed: ${changedFiles.length} files changed`,
+            filesModified: changedFiles.slice(0, 10),
+            detail: gitDiff.slice(0, 500),
+            stepLabel: 'manual',
+          });
+
+          await addSessionSummary(id, agentId, {
+            request: 'Manual development session',
+            investigated: `Worked on ${changedFiles.length} files`,
+            learned: '', completed: gitDiff.slice(0, 300), nextSteps: '',
+            filesRead: [], filesModified: changedFiles,
+          });
+        }
+
+        // Parse bus markers
+        const { output } = body;
+        let markersSent = 0;
+        if (output && typeof output === 'string') {
+          const markerRegex = /\[SEND:([^:]+):([^\]]+)\]\s*(.+)/g;
+          const snapshot = orch.getSnapshot();
+          const labelToId = new Map(snapshot.agents.map(a => [a.label.toLowerCase(), a.id]));
+          const seen = new Set<string>();
+          let match;
+          while ((match = markerRegex.exec(output)) !== null) {
+            const targetLabel = match[1].trim();
+            const msgAction = match[2].trim();
+            const content = match[3].trim();
+            const targetId = labelToId.get(targetLabel.toLowerCase());
+            if (targetId && targetId !== agentId) {
+              const key = `${targetId}:${msgAction}:${content}`;
+              if (!seen.has(key)) {
+                seen.add(key);
+                orch.getBus().send(agentId, targetId, 'notify', { action: msgAction, content });
+                markersSent++;
+              }
+            }
+          }
+        }
+
+        orch.completeManualAgent(agentId, changedFiles);
+
+        return json(res, {
+          ok: true, filesChanged: changedFiles.length,
+          files: changedFiles.slice(0, 20),
+          gitDiff: gitDiff.slice(0, 500), markersSent,
+        });
+      } catch (err: any) {
+        return jsonError(res, err.message, 500);
+      }
+    }
+
+    case 'send': {
+      const { to, msgAction, content } = body;
+      if (!to || !content) {
+        return jsonError(res, 'to and content required');
+      }
+
+      const snapshot = orch.getSnapshot();
+      const target = snapshot.agents.find(a => a.label.toLowerCase() === to.toLowerCase() || a.id === to);
+      if (!target) return jsonError(res, `Agent "${to}" not found. Available: ${snapshot.agents.map(a => a.label).join(', ')}`, 404);
+
+      // Resolve sender: validate agentId exists in workspace, otherwise 'user'
+      const senderExists = agentId && agentId !== 'unknown' && snapshot.agents.some(a => a.id === agentId);
+      if (agentId && agentId !== 'unknown' && !senderExists) {
+        return jsonError(res, `Sender agent "${agentId}" not found in workspace`);
+      }
+      const senderId = senderExists ? agentId : 'user';
+
+      // Block: if sender is currently processing a message FROM the target,
+      // don't send — the result is already delivered via markMessageDone
+      if (senderId !== 'user') {
+        const senderEntry = orch.getSnapshot().agentStates[senderId];
+        if (senderEntry?.currentMessageId) {
+          const currentMsg = orch.getBus().getLog().find(m => m.id === senderEntry.currentMessageId);
+          if (currentMsg && currentMsg.from === target.id && currentMsg.status === 'running') {
+            return json(res, {
+              ok: true, skipped: true,
+              reason: `You are processing a message from ${target.label}. Your result will be delivered automatically — no need to send a reply.`,
+            });
+          }
+        }
+      }
+
+      const sentMsg = orch.getBus().send(senderId, target.id, 'notify', {
+        action: msgAction || 'agent_message',
+        content,
+      });
+
+      return json(res, { ok: true, sentTo: target.label, messageId: sentMsg.id });
+    }
+
+    case 'logs': {
+      if (!agentId) return jsonError(res, 'agentId required');
+      const { readAgentLog } = await import('./workspace/persistence.js');
+      const logs = readAgentLog(id, agentId);
+      return json(res, { logs });
+    }
+
+    case 'clear_logs': {
+      if (!agentId) return jsonError(res, 'agentId required');
+      const { clearAgentLog } = await import('./workspace/persistence.js');
+      clearAgentLog(id, agentId);
+      // Also clear in-memory history
+      const agentState = orch.getAgentState(agentId);
+      if (agentState) (agentState as any).history = [];
+      return json(res, { ok: true });
+    }
+
+    case 'inbox': {
+      if (!agentId) return jsonError(res, 'agentId required');
+
+      const messages = orch.getBus().getMessagesFor(agentId)
+        .filter(m => m.type !== 'ack')
+        .slice(-20)
+        .map(m => ({
+          id: m.id,
+          from: (orch.getSnapshot().agents.find(a => a.id === m.from)?.label || m.from),
+          action: m.payload.action,
+          content: m.payload.content,
+          status: m.status || 'pending',
+          time: new Date(m.timestamp).toLocaleTimeString(),
+        }));
+
+      return json(res, { messages });
+    }
+
+    case 'message_done': {
+      // Manual mode: user marks a specific inbox message as done
+      const { messageId } = body;
+      if (!agentId || !messageId) return jsonError(res, 'agentId and messageId required');
+      const busMsg = orch.getBus().getLog().find(m => m.id === messageId && m.to === agentId);
+      if (!busMsg) return jsonError(res, 'Message not found');
+      busMsg.status = 'done';
+      return json(res, { ok: true });
+    }
+
+    case 'message_failed': {
+      const { messageId } = body;
+      if (!agentId || !messageId) return jsonError(res, 'agentId and messageId required');
+      const busMsg = orch.getBus().getLog().find(m => m.id === messageId && m.to === agentId);
+      if (!busMsg) return jsonError(res, 'Message not found');
+      busMsg.status = 'failed';
+      return json(res, { ok: true });
+    }
+
+    case 'sessions': {
+      // List recent claude sessions for resume picker
+      // Uses the agent's workDir (or project root) to find sessions
+      try {
+        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(/[^a-zA-Z0-9]/g, '-');
+        const sessDir = join(homedir(), '.claude', 'projects', encoded);
+        const entries = readdirSync(sessDir);
+        const files = entries
+          .filter((f: string) => f.endsWith('.jsonl'))
+          .map((f: string) => {
+            const fp = join(sessDir, f);
+            const st = statSync(fp);
+            return { id: f.replace('.jsonl', ''), modified: st.mtime.toISOString(), size: st.size };
+          })
+          .sort((a: any, b: any) => new Date(b.modified).getTime() - new Date(a.modified).getTime())
+          .slice(0, 5);
+        return json(res, { sessions: files });
+      } catch {
+        return json(res, { sessions: [] });
+      }
+    }
+
+    case 'status': {
+      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, primary: a.primary || undefined,
+        smithStatus: states[a.id]?.smithStatus || 'down',
+        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}`);
+  }
+}
+
+// ─── Route: Memory ───────────────────────────────────────
+
+function handleMemory(workspaceId: string, query: URLSearchParams, res: ServerResponse): void {
+  const agentId = query.get('agentId');
+  if (!agentId) return jsonError(res, 'agentId required');
+
+  const memory = loadMemory(workspaceId, agentId);
+  const stats = getMemoryStats(memory);
+  const display = formatMemoryForDisplay(memory);
+
+  json(res, { memory, stats, display });
+}
+
+// ─── HTTP Router ─────────────────────────────────────────
+
+const server = createServer(async (req, res) => {
+  const { path, query } = parseUrl(req.url || '/');
+  const method = req.method || 'GET';
+
+  // CORS for local dev
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+  if (method === 'OPTIONS') {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+
+  try {
+    // Health check
+    if (path === '/health' && method === 'GET') {
+      return json(res, {
+        ok: true,
+        active: orchestrators.size,
+        maxActive: MAX_ACTIVE,
+        uptime: Math.floor((Date.now() - startTime) / 1000),
+      });
+    }
+
+    // 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, {
+        workspaces: Array.from(orchestrators.keys()),
+      });
+    }
+
+    // Create workspace (daemon is the exclusive writer of state.json)
+    if (path === '/workspace/create' && method === 'POST') {
+      const bodyStr = await readBody(req);
+      const { id, projectPath, projectName, agents, agentStates, nodePositions, template, createdAt } = JSON.parse(bodyStr);
+
+      if (!projectPath || !projectName) return jsonError(res, 'projectPath and projectName required');
+
+      // Guard against concurrent creates for the same project
+      const existing = findWorkspaceByProject(projectPath);
+      if (existing && !template) return json(res, existing);
+
+      const state: import('./workspace/types').WorkspaceState = {
+        id: id || require('node:crypto').randomUUID(),
+        projectPath,
+        projectName,
+        agents: [],
+        agentStates: {},
+        nodePositions: {},
+        busLog: [],
+        createdAt: createdAt || Date.now(),
+        updatedAt: Date.now(),
+      };
+
+      // Import template: create agents from template with new IDs
+      if (template?.agents) {
+        const idMap = new Map<string, string>();
+        const ts = Date.now();
+        for (const agent of template.agents) {
+          const newId = `${agent.label.toLowerCase().replace(/\s+/g, '-')}-${ts}-${Math.random().toString(36).slice(2, 5)}`;
+          idMap.set(agent.id, newId);
+        }
+        for (const agent of template.agents) {
+          state.agents.push({
+            ...agent,
+            id: idMap.get(agent.id) || agent.id,
+            dependsOn: agent.dependsOn.map((d: string) => idMap.get(d) || d),
+            entries: agent.type === 'input' ? [] : undefined,
+          });
+          state.agentStates[idMap.get(agent.id) || agent.id] = { smithStatus: 'down', taskStatus: 'idle', history: [], artifacts: [] };
+        }
+        if (template.nodePositions) {
+          for (const [oldId, pos] of Object.entries(template.nodePositions)) {
+            const newId = idMap.get(oldId);
+            if (newId) state.nodePositions[newId] = pos as { x: number; y: number };
+          }
+        }
+      }
+
+      // Persist to disk — daemon is the single writer
+      await saveWorkspace(state);
+
+      // Load into memory immediately so SSE/API work without a second round-trip
+      const orch = new WorkspaceOrchestrator(state.id, state.projectPath, state.projectName);
+      if (state.agents.length > 0) {
+        orch.loadSnapshot({
+          agents: state.agents,
+          agentStates: state.agentStates,
+          busLog: state.busLog,
+          busOutbox: state.busOutbox,
+        });
+      }
+      orch.on('event', (event: OrchestratorEvent) => { broadcastSSE(state.id, event); });
+      orchestrators.set(state.id, orch);
+
+      return json(res, state, 201);
+    }
+
+    // Route: /workspace/:id/...
+    const wsMatch = path.match(/^\/workspace\/([^/]+)(\/.*)?$/);
+    if (!wsMatch) {
+      return jsonError(res, 'Not found', 404);
+    }
+
+    const id = wsMatch[1];
+    const subPath = wsMatch[2] || '';
+
+    // Load/Unload
+    if (subPath === '/load' && method === 'POST') {
+      try {
+        loadOrchestrator(id);
+        return json(res, { ok: true });
+      } catch (err: any) {
+        return jsonError(res, err.message, err.message.includes('not found') ? 404 : 429);
+      }
+    }
+
+    if (subPath === '/unload' && method === 'POST') {
+      unloadOrchestrator(id);
+      return json(res, { ok: true });
+    }
+
+    // Agent operations
+    if (subPath === '/agents' && method === 'POST') {
+      const bodyStr = await readBody(req);
+      let body: any;
+      try { body = JSON.parse(bodyStr); } catch { return jsonError(res, 'Invalid JSON', 400); }
+      return handleAgentsPost(id, body, res);
+    }
+
+    if (subPath === '/agents' && method === 'GET') {
+      return handleAgentsGet(id, res);
+    }
+
+    // SSE stream
+    if (subPath === '/stream' && method === 'GET') {
+      return handleStream(id, req, res);
+    }
+
+    // Smith API
+    if (subPath === '/smith' && method === 'POST') {
+      const bodyStr = await readBody(req);
+      let body: any;
+      try { body = JSON.parse(bodyStr); } catch { return jsonError(res, 'Invalid JSON', 400); }
+      return handleSmith(id, body, res);
+    }
+
+    // Memory
+    if (subPath === '/memory' && method === 'GET') {
+      return handleMemory(id, query, res);
+    }
+
+    return jsonError(res, 'Not found', 404);
+
+  } catch (err: any) {
+    console.error('[workspace] Request error:', err);
+    return jsonError(res, err.message || 'Internal error', 500);
+  }
+});
+
+// ─── Graceful Shutdown ───────────────────────────────────
+
+function shutdown() {
+  console.log('[workspace] Shutting down...');
+  for (const [id] of orchestrators) {
+    unloadOrchestrator(id);
+  }
+  server.close(() => {
+    console.log('[workspace] Server closed.');
+    process.exit(0);
+  });
+  // Force exit after 5s
+  setTimeout(() => process.exit(0), 5000);
+}
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+process.on('uncaughtException', (err) => {
+  console.error('[workspace] Uncaught exception:', err);
+});
+process.on('unhandledRejection', (err) => {
+  console.error('[workspace] Unhandled rejection:', 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, MCP on ${MCP_PORT})`);
+});