@aion0/forge 0.5.0 → 0.5.1

package/README.md

@@ -49,11 +49,36 @@ Forge turns Claude Code into a remote-accessible coding platform. Run it on your
 
 No API keys required. Uses your existing Claude Code subscription. Code never leaves your machine.
 
+## Multi-Agent Workspace <sup>v0.5.0</sup>
+
+Define agent teams with roles, dependencies, and steps. Agents run as daemons and communicate via a structured message bus.
+
+```mermaid
+graph LR
+    Input["📋 Requirements"] --> PM["🎯 PM"]
+    PM --> Eng["🔨 Engineer"]
+    Eng --> QA["🧪 QA"]
+    Eng --> Rev["👁 Reviewer"]
+    QA --> Rev
+
+    style Input fill:#f0883e,stroke:#f0883e,color:#fff
+    style PM fill:#a371f7,stroke:#a371f7,color:#fff
+    style Eng fill:#58a6ff,stroke:#58a6ff,color:#fff
+    style QA fill:#3fb950,stroke:#3fb950,color:#fff
+    style Rev fill:#f778ba,stroke:#f778ba,color:#fff
+```
+
+- **Agent profiles** — Reusable configs with env vars, model overrides, custom API endpoints (Claude, Codex, Aider)
+- **Message system** — Notifications (follow DAG) + Tickets (any direction, retry limits) with causedBy tracing
+- **Manual mode** — Open a terminal on any agent, work interactively, return to auto
+- **Watch manager** — Monitor files, git, or commands. Auto-analyze or require approval on changes
+
 ## Features
 
 | | |
 |---|---|
-| **Vibe Coding** | Browser tmux terminal, multi-tab, split panes, persistent sessions |
+| **Multi-Agent Workspace** | Agent teams with DAG dependencies, message bus, watch monitoring, manual/auto mode |
+| **Vibe Coding** | Browser tmux terminal, multi-tab, split panes, WebGL, Ctrl+F search |
 | **AI Tasks** | Background Claude Code execution with live streaming output |
 | **Pipelines** | YAML DAG workflows with parallel execution & visual editor |
 | **Remote Access** | Cloudflare Tunnel with 2FA (password + session code) |

package/RELEASE_NOTES.md

@@ -1,182 +1,33 @@
-# Forge v0.5.0
+# Forge v0.5.1
 
 Released: 2026-03-28
 
-## Changes since v0.4.16
+## Changes since v0.5.0
 
 ### Features
-- feat: watch actions (log/analyze/approve) + config UI
-- feat: agent watch — autonomous periodic monitoring
-- feat: Workspace — multi-agent terminal view per project
-- feat: requires-driven scheduling for delivery engine
-- feat: standardized envelope format + request/response audit trail
-- feat: visible data contracts on flow editor — artifact names on edges and nodes
-- feat: ReactFlow-based delivery role editor — drag & connect agent topology
-- feat: customizable delivery roles — users compose agent phases from presets
-- feat: show all 4 agent panels in 2x2 grid with SVG flow arrows
-- feat: Delivery Workspace — multi-agent orchestrated software delivery
-- feat: conversation terminal view with inline input and data flow
-- feat: Conversation Mode — multi-agent dialogue with graph view and live logs
-- feat: Pipeline editor node edit modal has Agent + Mode selectors
-- feat: Pipeline UI shows agent per node
-- feat: per-doc-root agent config (Settings + Docs toolbar)
-- feat: Telegram default agent + Docs agent config
-- feat: TTY support for agents that need terminal (e.g. Codex)
-- feat: per-agent skip permissions flag with presets
-- feat: Telegram agent support — @agent syntax + /agents command
-- feat: agent selection for Pipeline, Mobile, Help
-- feat: per-scene model config for each agent
-- feat: model config moved from global to per-agent
-- feat: task system uses agent adapter + agent selector in NewTaskModal
-- feat: terminal tab agent selection
-- feat: Agents management UI in Settings
-- feat: multi-agent foundation — registry, adapters, API
+- feat: daemon health check + SSE for all message actions
+- feat: pending_approval status for watch approve + requiresApproval
 
 ### Bug Fixes
-- fix: tolerate Next.js 16 _global-error prerender bug in build
-- fix: Log panel reads from persistent logs.jsonl + clear logs button
-- fix: restart watch loop when agent config is updated
-- fix: watch directory picker uses correct tree type and flattens nested dirs
-- fix: send block only when message is still running, not after done
-- fix: block forge-send reply to message sender + skill prompt hint
-- fix: hasRunning check uses worker's current message, not all bus log
-- fix: no extra reply message when processing downstream request
-- fix: smith send API returns messageId for outbox tracking
-- fix: inject FORGE_AGENT_ID/WORKSPACE_ID/PORT into manual terminal env
-- fix: forge skills use $FORGE_AGENT_ID instead of hardcoded 'unknown'
-- fix: deduplicate bus_message SSE events by message ID
-- fix: emit done before markMessageDone so causedBy can read messageId
-- fix: remove notifyDownstreamForRevalidation + prevent multiple running messages
-- fix: abort_message no longer errors on already-aborted messages
-- fix: getAllAgentStates returns worker state with entry mode override
-- fix: manual stays in mode field, displayed as purple 'manual' on node
-- fix: show 'manual' task status when agent is in manual mode
-- fix: close terminal uses close_terminal action instead of reset
-- fix: restartAgentDaemon recreates worker after resetAgent kills it
-- fix: parseBusMarkers re-scanning entire history causes message loops
-- fix: restartAgentDaemon aligned with simplified setManualMode
-- fix: manual mode shows down because worker async cleanup overrides state
-- fix: buffered wake prevents lost messages in daemon loop
-- fix: simplify retry — reset original message to pending, no emit
-- fix: retry creates new message, preserves original for history
-- fix: message retry causing duplicate execution
-- fix: PTY spawn in ESM — use createRequire for node-pty
-- fix: TTY detection for codex profiles + clear agent cache on terminal open
-- fix: project terminal dialog loads sessions from claude-sessions API
-- fix: bypass GitHub CDN cache on skills sync
-- fix: merge tags from info.json during v2 registry sync
-- fix: enable allowProposedApi for search decorations
-- fix: profile env/model propagation across all terminal launch paths
-- fix: saveAgentConfig preserves profile fields (base/env/model/type)
-- fix: sessions API uses orch.projectPath, ESM imports, non-claude compat
-- fix: stricter workDir validation — block .. and sibling dir escape
-- fix: workDir with leading / treated as relative to project, not absolute
-- fix: workDir normalize strips ./ prefix, default to smith label
-- fix: only use claude -c (resume) if existing session exists
-- fix: handle unknown agentId in smith send API
-- fix: whitelist /api/workspace in middleware for forge skill auto-discover
-- fix: install skills as directories with SKILL.md (Claude Code format)
-- fix: use imported resolve instead of require('node:path') in ESM context
-- fix: orchestrator actively manages smith lifecycle in start/stop daemon
-- fix: startDaemon error handling + stopDaemon cleanup
-- fix: close terminal should enter listening, not execute steps
-- fix: workspace terminal uses correct message types from terminal server
-- fix: workspace terminal input + keep alive when switching tabs
-- fix: rewrite WorkspaceView — each agent is a real interactive terminal
-- fix: move ssr:false dynamic import to client wrapper component
-- fix: disable SSR for Dashboard to eliminate hydration mismatch
-- fix: default phases missing _outputArtifactName/_label/_icon metadata
-- fix: data flow arrows based on requires/produces, not sequential order
-- fix: suppress hydration warning from locale/extension mismatch
-- fix: pipeline node shows 'default' instead of 'claude' when no agent set
-- fix: PTY onExit/onData registered once, fixes stuck tasks after cancel
-- fix: auto-kill PTY agents after 15s idle
-- fix: strip ANSI/terminal control codes from PTY agent output
-- fix: retryTask preserves original agent selection
-- fix: use pipe stdin for task spawn, close immediately after
-- fix: non-claude agents no longer fallback to claude or show claude model
-- fix: settings agent config debounced save + unsaved warning on close
-- fix: generic agents use taskFlags from settings, log raw text output
-- fix: only pass model flag to agents that support it, show agent in task
-- fix: settings agent colors match terminal — use API detected status
-- fix: show all configured agents, not just detected ones
-
-### Performance
-- perf: watch heartbeat only logs to console, not to files/history
-- perf: watch uses timestamp comparison instead of full snapshot
-
-### Refactoring
-- refactor: remove Delivery tab, keep only Workspace
+- fix: stop old worker before creating new one in enterDaemonListening
+- fix: prevent multiple running messages + clean stale running
+- fix: requiresApproval set at message arrival, not in message loop
+- fix: approved messages not re-converted to pending_approval
+- fix: message loop never stops + auto-recreate dead workers
+- fix: approve/reject emit SSE events + reject marks as failed
+- fix: emit bus_message_status after watch approve sets pending_approval
+- fix: pending_approval edge cases
+- fix: system messages (_watch, _system, user) bypass causedBy rules
 
 ### Documentation
-- docs: update workspace help with message system design
-- docs: add workspace help, update settings/projects/overview docs
+- docs: add workspace section + agent flow diagram to README
+- docs: README with Mermaid diagrams for v0.5.0
+- docs: update README for v0.5.0 — multi-agent workspace
+- docs: update workspace help with watch, logs, forge skills, send protection
 
 ### Other
-- watch: push heartbeat + alert logs to agent history for Log panel
-- watch: log heartbeat on each check cycle
-- ui: structured watch target builder with directory picker
-- debug: log deleteMessage results for diagnosing message reappearance
-- persist currentMessageId as task trigger identifier
-- inbox: abort all pending button for batch operations
-- inbox/outbox: batch select + delete for completed messages
-- Phase 3: ticket UI, retry limits, ticket API actions
-- Phase 2: causedBy chain + ticket messages + receive rules
-- Phase 1: anti-loop — DAG cycle detection, directional broadcast, disable SEND markers
-- ui: show mode (auto/manual) as separate line on agent node
-- simplify: setManualMode only changes mode, message loop skips manual
-- debug: log when agent message loop skips due to not-listening state
-- skills: auto-loop sync with progress indicator
-- skills: incremental sync — registry fast, info.json in batches
-- terminal: add Ctrl/Cmd+F search in terminal buffer
-- terminal: add WebGL rendering + Unicode 11 support
-- unified terminal launch: resolveTerminalLaunch for both VibeCoding + Workspace
-- settings: agent has profile selector dropdown
-- settings: profiles are global/shared, not per-agent
-- settings: add cliType selector to agent config panel
-- settings: profiles nested inside each agent, not standalone section
-- open_terminal: return cliType + cliCmd from agent registry
-- settings: env var templates per CLI type for profiles
-- agent config: add cliType field (claude-code/codex/aider/generic)
-- vibecoding: profile selector + session picker + env injection for terminal
-- terminal profile: env var injection via export, not settings.json
-- terminal: session picker with recent sessions list
-- terminal: styled launch dialog — New Session / Resume Latest
-- terminal: simple prompt dialog for new/resume before opening
-- terminal: prompt user to choose new session or resume
-- cleanup: simplify resume flag check in FloatingTerminal
-- UI: show resolved workDir path hint below input
-- forge skills: explicit 2-step commands, no env var checks
-- forge skills: inline auto-discover, no separate setup step
-- workDir validation: unique per smith, must be within project, no nesting
-- profile settings: write to smith workDir, not project root
-- profile terminal: apply env/model to .claude/settings.json on open_terminal
-- forge skills: install/update on every forge startup
-- forge skills: auto-discover workspace context with fallback defaults
-- skills: install once in startDaemon, remove per-smith install
-- skills: install to ~/.claude/skills/ globally + fix project deny rules
-- skill installer: auto-fix .claude/settings.json curl permissions
-- forge skills: env var injection + auto-install on smith startup
-- agent profiles: editable profile rows with expand/collapse
-- agent profiles: env vars support for custom CLI configs (e.g., FortiAI)
-- agent profiles UI: settings management + workspace profile selector
-- agent profiles + provider config data layer
-- smith message-driven architecture: independent message loop, inbox management, status simplification
-- multiple agent implementation
-- fix issue
-- fix issue for workspace
-- optmized projects
-- refactoring workspace
-- implement workspace and fix issue
-- implement multiple agents
-- ui: show agent badge on ReactFlow node blocks in pipeline editor
-- simplify: single docs agent instead of per-root
-- ui: remove Docs page agent selector, keep Settings-only config
-- ui: remove leftover model/permissions migration notes from Settings
-- ui: consistent agent colors across terminal and settings
-- ui: agent buttons green=installed, gray=not installed
-- ui: agent buttons ≤3 inline, >3 overflow with dropdown
-- ui: agent buttons inline with project name in new tab modal
+- ui: add requiresApproval toggle in agent config modal
+- debug: log watch analyze skip reasons
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.4.16...v0.5.0
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.0...v0.5.1

package/components/WorkspaceView.tsx

@@ -279,6 +279,7 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
   const [stepsText, setStepsText] = useState(
     (initial.steps || []).map(s => `${s.label}: ${s.prompt}`).join('\n') || ''
   );
+  const [requiresApproval, setRequiresApproval] = useState(initial.requiresApproval || false);
   const [watchEnabled, setWatchEnabled] = useState(initial.watch?.enabled || false);
   const [watchInterval, setWatchInterval] = useState(String(initial.watch?.interval || 60));
   const [watchAction, setWatchAction] = useState<'log' | 'analyze' | 'approve'>(initial.watch?.action || 'log');
@@ -465,6 +466,13 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
             </div>
           </div>
 
+          {/* Requires Approval */}
+          <div className="flex items-center gap-2">
+            <input type="checkbox" id="requiresApproval" checked={requiresApproval} onChange={e => setRequiresApproval(e.target.checked)}
+              className="accent-[#58a6ff]" />
+            <label htmlFor="requiresApproval" className="text-[9px] text-gray-400">Require approval before processing inbox messages</label>
+          </div>
+
           {/* Steps */}
           <div className="flex flex-col gap-1">
             <label className="text-[9px] text-gray-500 uppercase">Steps (one per line — Label: Prompt)</label>
@@ -570,6 +578,7 @@ function AgentConfigModal({ initial, mode, existingAgents, projectPath, onConfir
               workDir: workDirVal.trim() || label.trim().toLowerCase().replace(/\s+/g, '-') + '/',
               outputs: outputs.split(',').map(s => s.trim()).filter(Boolean),
               steps: parseSteps(),
+              requiresApproval: requiresApproval || undefined,
               watch: watchEnabled && watchTargets.length > 0 ? {
                 enabled: true,
                 interval: Math.max(10, parseInt(watchInterval) || 60),
@@ -1001,7 +1010,7 @@ function InboxPanel({ agentId, agentLabel, busLog, agents, workspaceId, onClose
                   }`}>{msg.ticketStatus}</span>
                 )}
                 {/* Message delivery status */}
-                <span className={`text-[7px] ${msg.status === 'done' ? 'text-green-500' : msg.status === 'running' ? 'text-blue-400' : msg.status === 'failed' ? 'text-red-500' : 'text-yellow-500'}`}>
+                <span className={`text-[7px] ${msg.status === 'done' ? 'text-green-500' : msg.status === 'running' ? 'text-blue-400' : msg.status === 'failed' ? 'text-red-500' : msg.status === 'pending_approval' ? 'text-orange-400' : 'text-yellow-500'}`}>
                   {msg.status || 'pending'}
                 </span>
                 {/* Retry count for tickets */}
@@ -1015,6 +1024,18 @@ function InboxPanel({ agentId, agentLabel, busLog, agents, workspaceId, onClose
                   </span>
                 )}
                 {/* Actions */}
+                {msg.status === 'pending_approval' && (
+                  <div className="flex gap-1 ml-auto">
+                    <button onClick={() => wsApi(workspaceId, 'approve_message', { 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">
+                      ✓ Approve
+                    </button>
+                    <button onClick={() => wsApi(workspaceId, 'reject_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">
+                      ✕ Reject
+                    </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">
@@ -1780,7 +1801,7 @@ function WorkspaceViewInner({ projectPath, projectName, onClose }: {
             onShowLog: () => setLogTarget({ id: agent.id, label: agent.label }),
             onShowMemory: () => setMemoryTarget({ id: agent.id, label: agent.label }),
             onShowInbox: () => setInboxTarget({ id: agent.id, label: agent.label }),
-            inboxPending: busLog.filter(m => m.to === agent.id && m.status === 'pending' && m.type !== 'ack').length,
+            inboxPending: busLog.filter(m => m.to === agent.id && (m.status === 'pending' || m.status === 'pending_approval') && m.type !== 'ack').length,
             inboxFailed: busLog.filter(m => m.to === agent.id && m.status === 'failed' && m.type !== 'ack').length,
             onOpenTerminal: async () => {
               if (!workspaceId) return;

package/lib/help-docs/11-workspace.md

@@ -184,9 +184,58 @@ curl -X POST http://localhost:8403/api/workspace/<id>/smith \
 curl http://localhost:8403/api/workspace/<id>/stream
 ```
 
+## Watch (Autonomous Monitoring)
+
+Agents can autonomously monitor file changes, git commits, or custom commands without relying on messages.
+
+### Configuration
+
+In the agent config modal, enable Watch and configure:
+- **Interval**: Check frequency in seconds (min 10, default 60)
+- **Targets**: What to monitor
+  - `Directory` — select from project folders, detect file mtime changes
+  - `Git` — detect new commits via HEAD hash comparison
+  - `Agent Output` — monitor another agent's declared output paths
+  - `Command` — run a shell command, detect output changes
+- **On Change**: Action when changes detected
+  - `Log` — write to agent log only (default, no token cost)
+  - `Analyze` — auto-wake agent to analyze changes (costs tokens)
+  - `Approve` — create pending approval, user decides whether to trigger
+
+### Watch Behavior
+
+- First check builds a baseline (no alert)
+- Subsequent checks compare timestamps — only files modified since last check are reported
+- No-change heartbeats log to console only (not to files)
+- Change alerts write to `logs.jsonl` and appear in Log panel
+- Watch never sends bus messages — report only, no auto-triggering other agents
+
+## Agent Logs
+
+Each agent has a persistent log file (`logs.jsonl`) that survives daemon restarts and agent re-execution.
+
+- **Log panel**: Click the log button on any agent node to view
+- **Persistent**: Logs are append-only, not cleared on reset or re-run
+- **Clear**: Use the "Clear" button in the Log panel header to manually wipe logs
+- **Content**: Execution output, watch alerts, bus message receipts, system events
+
+## Forge Skills (Terminal Communication)
+
+When in manual mode, agents have forge env vars injected (`FORGE_AGENT_ID`, `FORGE_WORKSPACE_ID`, `FORGE_PORT`) and can use:
+
+| Skill | Description |
+|-------|-------------|
+| `/forge-send` | Send a message to another smith |
+| `/forge-inbox` | Check incoming messages |
+| `/forge-status` | Check all smiths' status |
+| `/forge-workspace-sync` | Sync progress back to workspace |
+
+**Send protection**: If an agent is currently processing a message from another agent, `/forge-send` to that agent is blocked (returns `skipped: true`). Results are delivered automatically via the message system. Only use `/forge-send` for new issues to other agents.
+
 ## Persistence
 
 - Workspace state: `~/.forge/workspaces/<id>/state.json`
+- Agent logs: `~/.forge/workspaces/<id>/agents/<agentId>/logs.jsonl`
 - Auto-saved every 10 seconds
 - Atomic writes (temp file → rename) for crash safety
 - Synchronous save on daemon shutdown
@@ -200,5 +249,6 @@ curl http://localhost:8403/api/workspace/<id>/stream
 4. **Notifications flow downstream** — upstream agents won't receive downstream broadcasts
 5. **Use tickets for bugs** — tickets ignore DAG direction, have retry limits
 6. **Open Terminal** for manual intervention — mode switches to manual, inbox pauses
-7. **Check Inbox** when a smith is stuck — it may have unprocessed messages
-8. **Batch delete** completed messages to keep inbox clean
+7. **Use Watch for monitoring** — detect file changes without message overhead (set action to `log` to avoid token costs)
+8. **Check Log panel** for execution history and watch alerts — logs persist across restarts
+9. **Batch operations** — select all completed messages for bulk delete, or abort all pending at once

package/lib/help-docs/CLAUDE.md

@@ -40,5 +40,7 @@ Your job is to answer user questions about Forge features, configuration, and tr
 - Skill/marketplace → `06-skills.md`
 - Project/favorite/terminal → `07-projects.md`
 - Rules/CLAUDE.md/template → `08-rules.md`
-- Workspace/smith/daemon/multi-agent/bus/message → `11-workspace.md`
+- Workspace/smith/daemon/multi-agent/bus/message/ticket → `11-workspace.md`
+- Watch/monitor/detect/file changes/autonomous → `11-workspace.md`
 - Agent profile/env/model/cliType → `01-settings.md` + `11-workspace.md`
+- Agent log/logs/history/clear logs → `11-workspace.md`

package/lib/workspace/agent-bus.ts

@@ -265,7 +265,7 @@ export class AgentBus extends EventEmitter {
   /** Retry/re-run a message — set back to pending and re-deliver */
   retryMessage(messageId: string): BusMessage | null {
     const msg = this.log.find(m => m.id === messageId);
-    if (!msg || msg.status === 'pending' || msg.status === 'running') return null;
+    if (!msg || msg.status === 'pending' || msg.status === 'pending_approval' || msg.status === 'running') return null;
     msg.status = 'pending';
     msg.retries = 0;
     this.unsee(messageId);

package/lib/workspace/orchestrator.ts

@@ -61,6 +61,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
   private approvalQueue = new Set<string>();
   private daemonActive = false;
   private createdAt = Date.now();
+  private healthCheckTimer: NodeJS.Timeout | null = null;
 
   constructor(workspaceId: string, projectPath: string, projectName: string) {
     super();
@@ -816,6 +817,9 @@ export class WorkspaceOrchestrator extends EventEmitter {
     // Start watch loops for agents with watch config
     this.watchManager.start();
 
+    // Start health check — monitor all agents every 10s, auto-heal
+    this.startHealthCheck();
+
     console.log(`[workspace] Daemon started: ${started} smiths active, ${failed} failed`);
     this.emitAgentsChanged();
   }
@@ -852,10 +856,14 @@ export class WorkspaceOrchestrator extends EventEmitter {
     const entry = this.agents.get(agentId);
     if (!entry) return;
 
-    const { config } = entry;
+    // Stop existing worker first to prevent duplicate execution
+    if (entry.worker) {
+      entry.worker.removeAllListeners();
+      entry.worker.stop();
+      entry.worker = null;
+    }
 
-    // TODO: per-smith install hook for future use (commands, custom skills, etc.)
-    // Skills are installed globally in startDaemon, not per-smith
+    const { config } = entry;
 
     const backend = this.createBackend(config, agentId);
     const peerAgentIds = Array.from(this.agents.keys()).filter(id => id !== agentId);
@@ -960,9 +968,81 @@ export class WorkspaceOrchestrator extends EventEmitter {
     this.bus.markAllRunningAsFailed();
     this.emitAgentsChanged();
     this.watchManager.stop();
+    this.stopHealthCheck();
     console.log('[workspace] Daemon stopped');
   }
 
+  // ─── Health Check — auto-heal agents ─────────────────
+
+  private startHealthCheck(): void {
+    if (this.healthCheckTimer) return;
+    this.healthCheckTimer = setInterval(() => this.runHealthCheck(), 10_000);
+    this.healthCheckTimer.unref();
+  }
+
+  private stopHealthCheck(): void {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+  }
+
+  private runHealthCheck(): void {
+    if (!this.daemonActive) return;
+
+    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);
+        continue;
+      }
+
+      // Check 2: SmithStatus should be active
+      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);
+      }
+
+      // Check 3: Message loop should be running
+      if (!this.messageLoopTimers.has(id)) {
+        console.log(`[health] ${entry.config.label}: message loop stopped — restarting`);
+        this.startMessageLoop(id);
+      }
+
+      // Check 4: Stale running messages (agent not actually running) → mark failed
+      if (entry.state.taskStatus !== 'running') {
+        const staleRunning = this.bus.getLog().filter(m => m.to === id && m.status === 'running' && m.type !== 'ack');
+        for (const m of staleRunning) {
+          const age = Date.now() - m.timestamp;
+          if (age > 60_000) { // running for 60s+ but agent is idle = stale
+            console.log(`[health] ${entry.config.label}: stale running message ${m.id.slice(0, 8)} (${Math.round(age/1000)}s) — marking failed`);
+            m.status = 'failed';
+            this.emit('event', { type: 'bus_message_status', messageId: m.id, status: 'failed' } as any);
+          }
+        }
+      }
+
+      // Check 5: Pending messages but agent idle — try wake
+      if (entry.state.taskStatus !== 'running' && entry.state.mode === 'auto') {
+        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
+          const age = Date.now() - pending[0].timestamp;
+          if (age > 30_000) { // stuck for 30+ seconds
+            console.log(`[health] ${entry.config.label}: ${pending.length} pending msg(s) stuck for ${Math.round(age/1000)}s — message loop should pick up`);
+          }
+        }
+      }
+    }
+  }
+
   /** Handle watch alert based on agent's configured action */
   private handleWatchAlert(agentId: string, summary: string): void {
     const entry = this.agents.get(agentId);
@@ -976,8 +1056,15 @@ 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') return;
-      if (!entry.worker?.isListening()) return;
+      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})`);
+        return;
+      }
+      if (!entry.worker?.isListening()) {
+        console.log(`[watch] ${entry.config.label}: skipped analyze (worker=${!!entry.worker} listening=${entry.worker?.isListening()})`);
+        return;
+      }
+      console.log(`[watch] ${entry.config.label}: triggering analyze`);
 
       const prompt = entry.config.watch?.prompt || 'Analyze the following changes and produce a report:';
       const logEntry = {
@@ -992,13 +1079,13 @@ export class WorkspaceOrchestrator extends EventEmitter {
     }
 
     if (action === 'approve') {
-      // Create pending approval — user must click to trigger analysis
-      this.bus.send('_watch', agentId, 'notify', {
+      // Create message with pending_approval status — user must approve to execute
+      const msg = this.bus.send('_watch', agentId, 'notify', {
         action: 'watch_changes',
         content: `Watch detected changes (awaiting approval):\n${summary}`,
       });
-      this.approvalQueue.add(agentId);
-      this.emit('event', { type: 'approval_required', agentId, upstreamId: '_watch' } satisfies OrchestratorEvent);
+      msg.status = 'pending_approval';
+      this.emit('event', { type: 'bus_message_status', messageId: msg.id, status: 'pending_approval' } as any);
       console.log(`[watch] ${entry.config.label}: changes detected, awaiting approval`);
     }
   }
@@ -1501,6 +1588,14 @@ export class WorkspaceOrchestrator extends EventEmitter {
       return;
     }
 
+    // ── requiresApproval → set pending_approval on arrival ──
+    if (target.config.requiresApproval) {
+      msg.status = 'pending_approval';
+      this.emit('event', { type: 'bus_message_status', messageId: msg.id, status: 'pending_approval' } as any);
+      console.log(`[bus] ${target.config.label}: received ${action} — pending approval`);
+      return;
+    }
+
     // ── Message stays pending — message loop will consume it when smith is ready ──
     console.log(`[bus] ${target.config.label}: received ${action} — queued in inbox (${msg.status})`);
   }
@@ -1515,28 +1610,40 @@ export class WorkspaceOrchestrator extends EventEmitter {
     let debugTick = 0;
     const tick = () => {
       const entry = this.agents.get(agentId);
-      if (!entry || entry.state.smithStatus !== 'active') {
+      if (!entry) {
         this.stopMessageLoop(agentId);
         return;
       }
 
+      // Don't stop loop if smith is down — just skip this tick
+      // (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;
       if (entry.state.taskStatus === 'running') return;
 
-      // Skip if no worker ready
-      if (!entry.worker?.isListening()) {
+      // 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 (worker=${!!entry.worker} smith=${entry.state.smithStatus} task=${entry.state.taskStatus})`);
+          console.log(`[inbox] ${entry.config.label}: not listening (smith=${entry.state.smithStatus} task=${entry.state.taskStatus})`);
         }
         return;
       }
 
-      // Skip if worker is currently processing a message
-      if (entry.worker?.getCurrentMessageId()) {
-        const currentMsg = this.bus.getLog().find(m => m.id === entry.worker!.getCurrentMessageId());
-        if (currentMsg && currentMsg.status === 'running') 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;
+
+      // requiresApproval is handled at message arrival time (routeMessageToAgent),
+      // not in the message loop. Approved messages come through as normal 'pending'.
 
       // Find next pending message, applying causedBy rules
       const allPending = this.bus.getPendingMessagesFor(agentId).filter(m => m.from !== agentId && m.type !== 'ack');
@@ -1554,6 +1661,9 @@ export class WorkspaceOrchestrator extends EventEmitter {
           return true;
         }
 
+        // System messages (from _watch, _system, user) bypass causedBy rules
+        if (m.from.startsWith('_') || m.from === 'user') return true;
+
         // Notifications: check causedBy for loop prevention
         if (m.causedBy) {
           // Rule 1: Is this a response to something I sent? → accept (for verification)

package/lib/workspace/types.ts

@@ -141,7 +141,7 @@ export interface BusMessage {
   };
   timestamp: number;
   // Delivery tracking
-  status?: 'pending' | 'running' | 'done' | 'failed';
+  status?: 'pending' | 'pending_approval' | 'running' | 'done' | 'failed';
   retries?: number;
   // Message classification
   category?: MessageCategory;        // 'notification' (default, follows DAG) | 'ticket' (1-to-1, ignores DAG)

package/lib/workspace-standalone.ts

@@ -347,14 +347,38 @@ async function handleAgentsPost(id: string, body: any, res: ServerResponse): Pro
         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 } = body;
         if (!messageId) return jsonError(res, 'messageId required');

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.0",
+  "version": "0.5.1",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {