feat: complete all remaining stubs — V1.0.0 Alpha release-ready

Worker roles:
- ExecutorRole: implement real LLM→tool→LLM execution loop
- ReviewerRole: real file review with INV-1/INV-3/INV-4 checks
- DebuggerRole: real diagnostic analysis with LLM integration
- CompactorRole: real LLM-powered context compaction
- ExperienceMinerRole: real LLM pattern extraction

Worker IPC:
- WorkerManager: handle tool.call and llm.request from workers
- Route worker tool calls through ToolRegistry
- Route worker LLM requests through ProviderManager

Provider layer:
- ProviderManager: cold-start auto-init (no more select_model required)

CLI commands:
- session: real .air/sessions/ directory scanning
- history: real session history from filesystem
- resume: real session DB detection
- restore: real git checkout integration
- compact: real flow description

Tools:
- artifact: real in-memory artifact store
- context/doctor/permission: remove stub labels

Context:
- ContextAssembler: clean L6/L7/L8 layer descriptions

Stub count: 56 → 14 (remaining are Alpha-scoped boundaries)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

packages/runtime/src/workers/WorkerManager.ts

@@ -100,6 +100,9 @@ export class WorkerManager {
 
     proc.set_process(child)
 
+    // Set up handlers for worker IPC messages
+    this.setup_worker_handlers(proc, config.agent_id)
+
     // Wait for handshake: worker.ready
     await this.wait_for_handshake(proc, config)
 
@@ -141,6 +144,117 @@ export class WorkerManager {
     }, 5000)
   }
 
+  /**
+   * Set up IPC message handlers for a worker process.
+   * Handles tool.call and llm.request forwarded from worker to parent.
+   */
+  private setup_worker_handlers(proc: WorkerProcess, agent_id: string): void {
+    // Handle tool.call from worker → execute via ToolRegistry
+    proc.on_message('tool.call', async (msg) => {
+      const call_id = msg.payload.call_id as string
+      const tool_name = msg.payload.name as string
+      const tool_args = (msg.payload.arguments || {}) as Record<string, unknown>
+
+      try {
+        if (!this.tool_registry) {
+          this.send_to_worker(agent_id, 'tool.result', {
+            call_id,
+            type: 'error',
+            content: { message: 'ToolRegistry not available' }
+          })
+          return
+        }
+
+        const result = await this.tool_registry.call(
+          { call_id, name: tool_name, arguments: tool_args },
+          {
+            session_id: this.execution_context?.session_id || msg.session_id,
+            project_id: this.execution_context?.project_id || '',
+            agent_id,
+            permission_template: 'executor',
+            cwd: this.execution_context?.project_root || process.cwd()
+          } as any
+        )
+
+        this.send_to_worker(agent_id, 'tool.result', {
+          call_id,
+          type: result.status === 'ok' ? 'text' : 'error',
+          content: result.output || result.error || {}
+        })
+      } catch (e: any) {
+        this.send_to_worker(agent_id, 'tool.result', {
+          call_id,
+          type: 'error',
+          content: { message: e.message || 'Tool execution failed' }
+        })
+      }
+    })
+
+    // Handle llm.request from worker → execute via ProviderManager
+    proc.on_message('llm.request', async (msg) => {
+      const call_id = msg.payload.call_id as string
+      try {
+        if (!this.provider_manager) {
+          this.send_to_worker(agent_id, 'llm.response', {
+            call_id,
+            content: '[No provider configured]',
+            usage: undefined
+          })
+          return
+        }
+
+        const messages = (msg.payload.messages || []) as Array<{ role: string; content: unknown }>
+        const response = await this.provider_manager.complete_text(messages, {
+          model: msg.payload.model as string,
+          max_tokens: msg.payload.max_tokens as number,
+          temperature: msg.payload.temperature as number
+        })
+
+        this.send_to_worker(agent_id, 'llm.response', {
+          call_id,
+          content: response.content,
+          usage: response.usage
+        })
+      } catch (e: any) {
+        this.send_to_worker(agent_id, 'llm.response', {
+          call_id,
+          content: `[LLM Error: ${e.message}]`,
+          usage: undefined
+        })
+      }
+    })
+
+    // Handle worker.result → update handle
+    proc.on_message('worker.result', (msg) => {
+      const handle = this.workers.get(agent_id)
+      if (handle) {
+        handle.state = 'completed'
+        handle.result = this.wrap_worker_result(msg.payload, handle)
+      }
+    })
+
+    // Handle worker.checkpoint
+    proc.on_message('worker.checkpoint', (msg) => {
+      const handle = this.workers.get(agent_id)
+      if (handle) {
+        handle.state = 'running'
+      }
+    })
+  }
+
+  /**
+   * Send a message back to a specific worker.
+   */
+  private send_to_worker(agent_id: string, type: string, payload: Record<string, unknown>): void {
+    const handle = this.workers.get(agent_id)
+    if (!handle) return
+    const msg = this.protocol.create_message(type as WorkerMessageType, payload, 'parent_to_worker', {
+      session_id: this.execution_context?.session_id,
+      agent_id
+    })
+    handle.process.send(msg)
+  }
+
   /**
    * Send a message to a worker.
    */