@aion0/forge 0.5.9 → 0.5.12

package/CLAUDE.md

@@ -77,3 +77,10 @@ Example: find /Users/zliu/MyDocuments/obsidian-project -name "*.md" | head -20
 When I ask about my notes, use bash to search and read files from the vault directory.
 Example: find <vault_path> -name "*.md" | head -20
 <!-- /forge:template:obsidian-vault -->
+
+
+<!-- FORGE:BEGIN -->
+## Forge Workspace Integration
+When you finish processing a task or message from Forge, end your final response with the marker: [FORGE_DONE]
+This helps Forge detect task completion. Do not include this marker if you are still working.
+<!-- FORGE:END -->

package/RELEASE_NOTES.md

@@ -1,15 +1,13 @@
-# Forge v0.5.9
+# Forge v0.5.12
 
-Released: 2026-03-30
+Released: 2026-03-31
 
-## Changes since v0.5.8
-
-### Features
-- feat: terminal floats below agent node, follows on drag/zoom
+## Changes since v0.5.11
 
 ### Bug Fixes
-- fix: revise dedup to not block legitimate messages
-- fix: reduce duplicate messages in workspace agent communication
+- fix: correct bin paths in package.json
+- fix: merge pending upstream_complete — auto-complete older ones before sending new
+- fix: upstream_complete notification tells agent to ignore if busy or duplicate
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.8...v0.5.9
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.11...v0.5.12

package/components/WorkspaceView.tsx

@@ -446,13 +446,15 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
   const [role, setRole] = useState(initial.role || '');
   const [backend, setBackend] = useState<'api' | 'cli'>(initial.backend === 'api' ? 'api' : 'cli');
   const [agentId, setAgentId] = useState(initial.agentId || 'claude');
-  const [availableAgents, setAvailableAgents] = useState<{ id: string; name: string; isProfile?: boolean; backendType?: string }[]>([]);
+  const [availableAgents, setAvailableAgents] = useState<{ id: string; name: string; isProfile?: boolean; backendType?: string; base?: string; cliType?: string }[]>([]);
 
   useEffect(() => {
     fetch('/api/agents').then(r => r.json()).then(data => {
       const list = (data.agents || data || []).map((a: any) => ({
         id: a.id, name: a.name || a.id,
         isProfile: a.isProfile || a.base,
+        base: a.base,
+        cliType: a.cliType,
         backendType: a.backendType || 'cli',
       }));
       setAvailableAgents(list);
@@ -681,24 +683,38 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
             <label htmlFor="requiresApproval" className="text-[9px] text-gray-400">Require approval before processing inbox messages</label>
           </div>
 
-          {/* Persistent Session */}
-          <div className="flex items-center gap-2">
-            <input type="checkbox" id="persistentSession" checked={persistentSession} onChange={e => !isPrimary && setPersistentSession(e.target.checked)}
-              disabled={isPrimary}
-              className={`accent-[#3fb950] ${isPrimary ? 'opacity-50 cursor-not-allowed' : ''}`} />
-            <label htmlFor="persistentSession" className={`text-[9px] text-gray-400 ${isPrimary ? 'opacity-50' : ''}`}>
-              Terminal mode {isPrimary ? '(required for primary)' : '— run in terminal instead of headless (claude -p)'}
-            </label>
-          </div>
-          {persistentSession && (
-            <div className="flex flex-col gap-1.5 ml-4">
-              <div className="flex items-center gap-2">
-                <input type="checkbox" id="skipPermissions" checked={skipPermissions} onChange={e => setSkipPermissions(e.target.checked)}
-                  className="accent-[#f0883e]" />
-                <label htmlFor="skipPermissions" className="text-[9px] text-gray-400">Skip permissions (auto-approve all tool calls)</label>
+          {/* Persistent Session — only for claude-code based agents */}
+          {(() => {
+            // Check if selected agent supports terminal mode (claude-code or its profiles)
+            const selectedAgent = availableAgents.find(a => a.id === agentId);
+            const isClaude = agentId === 'claude' || selectedAgent?.base === 'claude' || selectedAgent?.cliType === 'claude-code' || !selectedAgent;
+            const canTerminal = isClaude || isPrimary;
+            return canTerminal ? (
+              <>
+                <div className="flex items-center gap-2">
+                  <input type="checkbox" id="persistentSession" checked={persistentSession} onChange={e => !isPrimary && setPersistentSession(e.target.checked)}
+                    disabled={isPrimary}
+                    className={`accent-[#3fb950] ${isPrimary ? 'opacity-50 cursor-not-allowed' : ''}`} />
+                  <label htmlFor="persistentSession" className={`text-[9px] text-gray-400 ${isPrimary ? 'opacity-50' : ''}`}>
+                    Terminal mode {isPrimary ? '(required for primary)' : '— run in terminal instead of headless'}
+                  </label>
+                </div>
+                {persistentSession && (
+                  <div className="flex flex-col gap-1.5 ml-4">
+                    <div className="flex items-center gap-2">
+                      <input type="checkbox" id="skipPermissions" checked={skipPermissions} onChange={e => setSkipPermissions(e.target.checked)}
+                        className="accent-[#f0883e]" />
+                      <label htmlFor="skipPermissions" className="text-[9px] text-gray-400">Skip permissions (auto-approve all tool calls)</label>
+                    </div>
+                  </div>
+                )}
+              </>
+            ) : (
+              <div className="text-[8px] text-gray-500 bg-gray-500/10 px-2 py-1 rounded">
+                Headless mode only — {agentId} does not support terminal mode
               </div>
-            </div>
-          )}
+            );
+          })()}
 
           {/* Steps */}
           <div className="flex flex-col gap-1">
@@ -766,6 +782,7 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
                       <option value="agent_log">Agent Log</option>
                       <option value="session">Session Output</option>
                       <option value="command">Command</option>
+                      <option value="agent_status">Agent Status</option>
                     </select>
                     {t.type === 'directory' && (
                       <select value={t.path || ''} onChange={e => {
@@ -777,6 +794,29 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
                         {projectDirs.map(d => <option key={d} value={d + '/'}>{d}/</option>)}
                       </select>
                     )}
+                    {t.type === 'agent_status' && (<>
+                      <select value={t.path || ''} onChange={e => {
+                        const next = [...watchTargets];
+                        next[i] = { ...t, path: e.target.value };
+                        setWatchTargets(next);
+                      }} className="text-[10px] bg-[#161b22] border border-[#30363d] rounded px-1 py-0.5 text-white flex-1">
+                        <option value="">Select agent...</option>
+                        {existingAgents.filter(a => a.id !== initial.id).map(a =>
+                          <option key={a.id} value={a.id}>{a.icon} {a.label}</option>
+                        )}
+                      </select>
+                      <select value={t.pattern || ''} onChange={e => {
+                        const next = [...watchTargets];
+                        next[i] = { ...t, pattern: e.target.value };
+                        setWatchTargets(next);
+                      }} className="text-[10px] bg-[#161b22] border border-[#30363d] rounded px-1 py-0.5 text-white w-20">
+                        <option value="">Any change</option>
+                        <option value="done">done</option>
+                        <option value="failed">failed</option>
+                        <option value="running">running</option>
+                        <option value="idle">idle</option>
+                      </select>
+                    </>)}
                     {t.type === 'agent_output' && (
                       <select value={t.path || ''} onChange={e => {
                         const next = [...watchTargets];
@@ -810,7 +850,7 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
                     {t.type === 'session' && (
                       <SessionTargetSelector
                         target={t}
-                        agents={existingAgents.filter(a => a.id !== initial.id && (!a.agentId || a.agentId === 'claude'))}
+                        agents={existingAgents.filter(a => a.id !== initial.id)}
                         projectPath={projectPath}
                         onChange={(updated) => {
                           const next = [...watchTargets];
@@ -1357,11 +1397,17 @@ function InboxPanel({ agentId, agentLabel, busLog, agents, workspaceId, onClose
                     </button>
                   </div>
                 )}
-                {msg.status === 'pending' && msg.type !== 'ack' && (
-                  <button onClick={() => wsApi(workspaceId, 'abort_message', { messageId: msg.id })}
-                    className="text-[7px] px-1.5 py-0.5 rounded bg-red-600/20 text-red-400 hover:bg-red-600/30 ml-auto">
-                    ✕ Abort
-                  </button>
+                {(msg.status === 'pending' || msg.status === 'running') && msg.type !== 'ack' && (
+                  <div className="flex gap-1 ml-auto">
+                    <button onClick={() => wsApi(workspaceId, 'message_done', { messageId: msg.id })}
+                      className="text-[7px] px-1.5 py-0.5 rounded bg-green-600/20 text-green-400 hover:bg-green-600/30">
+                      ✓ Done
+                    </button>
+                    <button onClick={() => wsApi(workspaceId, 'abort_message', { messageId: msg.id })}
+                      className="text-[7px] px-1.5 py-0.5 rounded bg-red-600/20 text-red-400 hover:bg-red-600/30">
+                      ✕ Abort
+                    </button>
+                  </div>
                 )}
                 {(msg.status === 'done' || msg.status === 'failed') && msg.type !== 'ack' && (
                   <div className="flex gap-1 ml-auto">
@@ -1735,13 +1781,18 @@ function FloatingTerminalInline({ agentLabel, agentIcon, projectPath, agentCliId
               const envWithoutModel = profileEnv ? Object.fromEntries(
                 Object.entries(profileEnv).filter(([k]) => k !== 'CLAUDE_MODEL')
               ) : {};
-              // Unset old profile vars + set new ones
+              // Build commands as separate short lines
+              const commands: string[] = [];
               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 unsetPrefix = profileVarsToReset.map(v => `unset ${v}`).join(' && ') + ' && ';
-              const envExportsClean = unsetPrefix + (Object.keys(envWithoutModel).length > 0
-                ? Object.entries(envWithoutModel).map(([k, v]) => `export ${k}="${v}"`).join(' && ') + ' && '
-                : '');
-              // Resolve session: explicit > boundSessionId > fixedSession (primary) > fresh
+              commands.push(profileVarsToReset.map(v => `unset ${v}`).join('; '));
+              const envWithoutForge = Object.entries(envWithoutModel).filter(([k]) => !k.startsWith('FORGE_'));
+              if (envWithoutForge.length > 0) {
+                commands.push(envWithoutForge.map(([k, v]) => `export ${k}="${v}"`).join('; '));
+              }
+              const forgeVars = Object.entries(envWithoutModel).filter(([k]) => k.startsWith('FORGE_'));
+              if (forgeVars.length > 0) {
+                commands.push(forgeVars.map(([k, v]) => `export ${k}="${v}"`).join('; '));
+              }
               let resumeId = resumeSessionId || boundSessionId;
               if (isClaude && !resumeId && isPrimary) {
                 try {
@@ -1753,10 +1804,12 @@ function FloatingTerminalInline({ agentLabel, agentIcon, projectPath, agentCliId
               let mcpFlag = '';
               if (isClaude) { try { const { getMcpFlag } = await import('@/lib/session-utils'); mcpFlag = await getMcpFlag(projectPath); } catch {} }
               const sf = skipPermissions ? (cliType === 'codex' ? ' --full-auto' : cliType === 'aider' ? ' --yes' : ' --dangerously-skip-permissions') : '';
-              const cmd = `${envExportsClean}${cdCmd} && ${cli}${resumeFlag}${modelFlag}${sf}${mcpFlag}\n`;
-              setTimeout(() => {
-                if (!disposed && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'input', data: cmd }));
-              }, 300);
+              commands.push(`${cdCmd} && ${cli}${resumeFlag}${modelFlag}${sf}${mcpFlag}`);
+              commands.forEach((cmd, i) => {
+                setTimeout(() => {
+                  if (!disposed && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'input', data: cmd + '\n' }));
+                }, 300 + i * 300);
+              });
             }
           }
         } catch {}
@@ -1914,14 +1967,26 @@ function FloatingTerminal({ agentLabel, agentIcon, projectPath, agentCliId, cliC
             const envWithoutModel = profileEnv ? Object.fromEntries(
               Object.entries(profileEnv).filter(([k]) => k !== 'CLAUDE_MODEL')
             ) : {};
-            // Unset old profile vars + set new ones (prevents leaking between agent switches)
+            // Build commands as separate short lines to avoid terminal truncation
+            const commands: string[] = [];
+
+            // 1. Unset old profile vars
             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 unsetPrefix = profileVarsToReset.map(v => `unset ${v}`).join(' && ') + ' && ';
-            const envExportsClean = unsetPrefix + (Object.keys(envWithoutModel).length > 0
-              ? Object.entries(envWithoutModel).map(([k, v]) => `export ${k}="${v}"`).join(' && ') + ' && '
-              : '');
-            // Primary: use fixed session. Non-primary: use explicit sessionId or -c
-            // Resolve session: explicit > boundSessionId > fixedSession (primary) > fresh
+            commands.push(profileVarsToReset.map(v => `unset ${v}`).join('; '));
+
+            // 2. Export new profile vars (if any)
+            const envWithoutForge = Object.entries(envWithoutModel).filter(([k]) => !k.startsWith('FORGE_'));
+            if (envWithoutForge.length > 0) {
+              commands.push(envWithoutForge.map(([k, v]) => `export ${k}="${v}"`).join('; '));
+            }
+
+            // 3. Export FORGE vars
+            const forgeVars = Object.entries(envWithoutModel).filter(([k]) => k.startsWith('FORGE_'));
+            if (forgeVars.length > 0) {
+              commands.push(forgeVars.map(([k, v]) => `export ${k}="${v}"`).join('; '));
+            }
+
+            // 4. CLI command
             let resumeId = resumeSessionId || boundSessionId;
             if (isClaude && !resumeId && isPrimary) {
               try {
@@ -1932,11 +1997,15 @@ function FloatingTerminal({ agentLabel, agentIcon, projectPath, agentCliId, cliC
             const resumeFlag = isClaude && resumeId ? ` --resume ${resumeId}` : '';
             let mcpFlag = '';
             if (isClaude) { try { const { getMcpFlag } = await import('@/lib/session-utils'); mcpFlag = await getMcpFlag(projectPath); } catch {} }
-            const sf = skipPermissions ? ' --dangerously-skip-permissions' : '';
-            const cmd = `${envExportsClean}${cdCmd} && ${cli}${resumeFlag}${modelFlag}${sf}${mcpFlag}\n`;
-            setTimeout(() => {
-              if (!disposed && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'input', data: cmd }));
-            }, 300);
+            const sf = skipPermissions ? (cliType === 'codex' ? ' --full-auto' : cliType === 'aider' ? ' --yes' : ' --dangerously-skip-permissions') : '';
+            commands.push(`${cdCmd} && ${cli}${resumeFlag}${modelFlag}${sf}${mcpFlag}`);
+
+            // Send each command with delay between them
+            commands.forEach((cmd, i) => {
+              setTimeout(() => {
+                if (!disposed && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'input', data: cmd + '\n' }));
+              }, 300 + i * 300);
+            });
           }
         } catch {}
       };
@@ -2190,8 +2259,13 @@ function AgentFlowNode({ data }: NodeProps<Node<AgentNodeData>>) {
             {(() => {
               // Execution mode is determined by config, not tmux state
               const isTerminalMode = config.persistentSession;
-              const color = isTerminalMode ? (hasTmux ? '#3fb950' : '#f0883e') : '#484f58';
-              const label = isTerminalMode ? (hasTmux ? 'terminal' : 'terminal (down)') : 'headless';
+              const isActive = smithStatus === 'active';
+              const color = isTerminalMode
+                ? (hasTmux ? '#3fb950' : '#f0883e')         // terminal: green (up) / orange (down)
+                : (isActive ? '#58a6ff' : '#484f58');        // headless: blue (active) / gray (down)
+              const label = isTerminalMode
+                ? (hasTmux ? 'terminal' : 'terminal (down)')
+                : (isActive ? 'headless' : 'headless (down)');
               return (<>
                 <div className="w-1.5 h-1.5 rounded-full" style={{ background: color }} />
                 <span className="text-[7px] font-medium" style={{ color }}>{label}</span>
@@ -2410,10 +2484,9 @@ function WorkspaceViewInner({ projectPath, projectName, onClose }: {
             inboxFailed: busLog.filter(m => m.to === agent.id && m.status === 'failed' && m.type !== 'ack').length,
             onOpenTerminal: async () => {
               if (!workspaceId) return;
-              if (!daemonActiveFromStream) {
-                alert('Start daemon first before opening terminal.');
-                return;
-              }
+              // Sync stale daemonActiveFromStream from agent states
+              const anyActive = Object.values(states).some(s => s?.smithStatus === 'active');
+              if (anyActive && !daemonActiveFromStream) setDaemonActiveFromStream(true);
               // Close existing terminal (config may have changed)
               setFloatingTerminals(prev => prev.filter(t => t.agentId !== agent.id));
 

package/lib/agents/index.ts

@@ -27,9 +27,9 @@ export function listAgents(): AgentConfig[] {
 
   // Codex
   const codexConfig = settings.agents?.codex;
-  const codex = detectAgent('codex', 'OpenAI Codex', codexConfig?.path || 'codex');
+  const codex = detectAgent('codex', 'OpenAI Codex', codexConfig?.path || 'codex', ['exec']);
   if (codex) {
-    codex.capabilities.requiresTTY = true;
+    codex.capabilities.requiresTTY = false; // exec subcommand is non-interactive
     agents.push({ ...codex, enabled: codexConfig?.enabled !== false, detected: true, skipPermissionsFlag: codexConfig?.skipPermissionsFlag || '--full-auto', cliType: 'codex' } as any);
   }
 

package/lib/workspace/agent-worker.ts

@@ -444,20 +444,11 @@ export class AgentWorker extends EventEmitter {
       this.state.history.push(msg);
     }
 
-    // Execute using the last step definition as template (or first if no steps)
+    // Execute using step template, or create one from the prompt if no steps defined
     const stepTemplate = this.config.steps[this.config.steps.length - 1] || this.config.steps[0];
-    if (!stepTemplate) {
-      // No steps defined — just log
-      this.state.history.push({
-        type: 'system', subtype: 'daemon',
-        content: `[Daemon] Wake: ${reason.type} — no steps defined to execute`,
-        timestamp: new Date().toISOString(),
-      });
-      return;
-    }
 
     const step = {
-      ...stepTemplate,
+      ...(stepTemplate || { id: '', label: '', prompt: '' }),
       id: `daemon-${this.state.daemonIteration}`,
       label: `Daemon iteration ${this.state.daemonIteration}`,
       prompt,

package/lib/workspace/backends/cli-backend.ts

@@ -91,6 +91,7 @@ function detectArtifacts(parsed: any): Artifact[] {
 export class CliBackend implements AgentBackend {
   private child: ChildProcess | null = null;
   private sessionId: string | undefined;
+  headlessSessionId: string | undefined; // exposed for session file monitoring
   /** Callback to persist sessionId back to agent state */
   onSessionId?: (id: string) => void;
 
@@ -118,6 +119,12 @@ export class CliBackend implements AgentBackend {
     // Note: if no sessionId, each execution starts a new session (no resume).
     // To maintain context, user can enable persistent terminal session per agent.
 
+    // Generate a session ID for headless execution so we can monitor the .jsonl file
+    const isClaude = adapter.config.type === 'claude-code';
+    if (isClaude && !this.sessionId) {
+      this.headlessSessionId = crypto.randomUUID();
+    }
+
     const spawnOpts = adapter.buildTaskSpawn({
       projectPath,
       prompt,
@@ -125,6 +132,7 @@ export class CliBackend implements AgentBackend {
       conversationId: this.sessionId,
       skipPermissions: true,
       outputFormat: adapter.config.capabilities?.supportsStreamJson ? 'stream-json' : undefined,
+      extraFlags: this.headlessSessionId && !this.sessionId ? ['--session-id', this.headlessSessionId] : undefined,
     });
 
     onLog?.({
@@ -148,9 +156,10 @@ export class CliBackend implements AgentBackend {
       };
       delete env.CLAUDECODE;
 
-      // Check if agent needs TTY (same logic as task-manager)
+      // Check if agent needs TTY — use cliType not agentId
+      const cliType = (adapter.config as any).cliType || adapter.config.type;
       const needsTTY = adapter.config.capabilities?.requiresTTY
-        || agentId === 'codex' || (adapter.config as any).base === 'codex';
+        || cliType === 'codex';
 
       if (needsTTY) {
         this.executePTY(spawnOpts, projectPath, env, onLog, abortSignal, resolve, reject);

package/lib/workspace/orchestrator.ts

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

package/lib/workspace/session-monitor.ts

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

package/lib/workspace/types.ts

@@ -47,7 +47,7 @@ export interface WorkspaceAgentConfig {
 // ─── Watch Config ─────────────────────────────────────────
 
 export interface WatchTarget {
-  type: 'directory' | 'git' | 'agent_output' | 'agent_log' | 'session' | 'command';
+  type: 'directory' | 'git' | 'agent_output' | 'agent_log' | 'session' | 'command' | 'agent_status';
   path?: string;           // directory: relative path; agent_output/agent_log: agent ID
   pattern?: string;        // glob for directory, regex/keyword for agent_log, stdout pattern for command
   cmd?: string;            // shell command (type='command' only)

package/lib/workspace/watch-manager.ts

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

package/lib/workspace-standalone.ts

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

package/next-env.d.ts

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

package/package.json

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