v2.1.0-provider-picker: BooCoder systemd migration + provider picker

- BooCoder moves from Docker to host systemd service (boocoder.service)
- Agent dispatch (ACP + PTY) switches from SSH to direct spawn/exec
- SSH helpers marked @deprecated (kept for one release cycle)
- Provider registry (5 providers: boocode, opencode, goose, claude, qwen)
- Agent probe with direct which/exec + model discovery (qwen settings, static claude models)
- GET /api/providers route with installed status, models, transport fallback
- ProviderPicker frontend component in CoderPane header
- External provider messages route through tasks row instead of inference enqueue
- Smart scroll: MessageList only auto-scrolls when near bottom (150px threshold)
- DB: available_agents gets models, label, transport columns
- Bug fix: loadContext SELECT includes allowed_read_paths
- Bug fix: cap hit sentinel inserted before buildMessagesPayload
- docker-compose.yml: boocoder service commented out, BOOCODER_URL env var added
- CLAUDE.md: updated docs for systemd, provider registry, JSONB gotcha, loadContext

apps/coder/.env.host

@@ -0,0 +1,14 @@
+NODE_ENV=production
+PORT=9502
+HOST=100.114.205.53
+DATABASE_URL=postgres://boocode:devpass@127.0.0.1:5500/boochat
+LLAMA_SWAP_URL=http://100.101.41.16:8401
+PROJECT_ROOT_WHITELIST=/opt
+BOOTSTRAP_ROOT=/opt/projects
+DEFAULT_MODEL=qwen3.6-35b-a3b-mxfp4
+LOG_LEVEL=info
+SEARXNG_URL=http://100.114.205.53:8888
+GITEA_BASE_URL=https://git.indifferentketchup.com
+GITEA_USER=indifferentketchup
+GITEA_SSH_HOST=100.114.205.53:2222
+MCP_CONFIG_PATH=/data/mcp.json

apps/coder/src/index.ts

@@ -28,6 +28,7 @@ import { registerTaskRoutes } from './routes/tasks.js';
 import { registerInboxRoutes } from './routes/inbox.js';
 import { registerStatsRoutes } from './routes/stats.js';
 import { registerArenaRoutes } from './routes/arena.js';
+import { registerProviderRoutes } from './routes/providers.js';
 import { registerWebSocket } from './routes/ws.js';
 // Phase 4: dispatcher + agent probe
 import { createDispatcher } from './services/dispatcher.js';
@@ -145,6 +146,7 @@ async function main() {
   registerInboxRoutes(app, sql);
   registerStatsRoutes(app, sql);
   registerArenaRoutes(app, sql);
+  registerProviderRoutes(app, sql, config);
   registerWebSocket(app, sql, broker);
 
   // Serve static frontend (built web app). In production, the dist/ is

apps/coder/src/routes/messages.ts

@@ -6,7 +6,9 @@ import type { WsFrame } from '@boocode/server/ws-frames';
 
 const SendBody = z.object({
   content: z.string().min(1).max(64_000),
-  chat_id: z.string().uuid(),
+  chat_id: z.string().uuid().optional(),
+  provider: z.string().max(100).optional(),
+  model: z.string().max(200).optional(),
 });
 
 interface InferenceApi {
@@ -32,73 +34,104 @@ export function registerMessageRoutes(
       }
 
       const sessionId = req.params.sessionId;
-      const { content, chat_id: chatId } = parsed.data;
+      const { content, chat_id: explicitChatId, provider, model } = parsed.data;
+      const isExternal = provider && provider !== 'boocode';
 
       // Validate session exists
-      const sessionRows = await sql<{ id: string }[]>`
-        SELECT id FROM sessions WHERE id = ${sessionId}
+      const sessionRows = await sql<{ id: string; project_id: string }[]>`
+        SELECT id, project_id FROM sessions WHERE id = ${sessionId}
       `;
       if (sessionRows.length === 0) {
         reply.code(404);
         return { error: 'session not found' };
       }
 
-      // Validate chat belongs to session and is open
-      const chatRows = await sql<{ id: string; session_id: string }[]>`
-        SELECT id, session_id FROM chats WHERE id = ${chatId} AND session_id = ${sessionId} AND status = 'open'
+      // Resolve chat_id: use explicit value or find/create a default chat
+      let chatId: string;
+      if (explicitChatId) {
+        const chatRows = await sql<{ id: string }[]>`
+          SELECT id FROM chats WHERE id = ${explicitChatId} AND session_id = ${sessionId} AND status = 'open'
+        `;
+        if (chatRows.length === 0) {
+          reply.code(404);
+          return { error: 'chat not found or not open in this session' };
+        }
+        chatId = explicitChatId;
+      } else {
+        const existing = await sql<{ id: string }[]>`
+          SELECT id FROM chats WHERE session_id = ${sessionId} AND status = 'open' ORDER BY created_at LIMIT 1
+        `;
+        if (existing.length > 0) {
+          chatId = existing[0]!.id;
+        } else {
+          const [newChat] = await sql<{ id: string }[]>`
+            INSERT INTO chats (session_id, name, status)
+            VALUES (${sessionId}, 'Chat', 'open')
+            RETURNING id
+          `;
+          chatId = newChat!.id;
+        }
+      }
+
+      if (!isExternal) {
+        // Reject if inference is already running on this chat
+        if (inference.hasActive(chatId)) {
+          reply.code(409);
+          return { error: 'inference already running on this chat' };
+        }
+      }
+
+      // Create user message
+      const [userMsg] = await sql<{ id: string }[]>`
+        INSERT INTO messages (session_id, chat_id, role, content, status, created_at)
+        VALUES (${sessionId}, ${chatId}, 'user', ${content}, 'complete', clock_timestamp())
+        RETURNING id
       `;
-      if (chatRows.length === 0) {
-        reply.code(404);
-        return { error: 'chat not found or not open in this session' };
-      }
+      await sql`UPDATE sessions SET updated_at = clock_timestamp() WHERE id = ${sessionId}`;
+      await sql`UPDATE chats SET updated_at = clock_timestamp() WHERE id = ${chatId}`;
 
-      // Reject if inference is already running on this chat
-      if (inference.hasActive(chatId)) {
-        reply.code(409);
-        return { error: 'inference already running on this chat' };
-      }
-
-      // Create user message + streaming assistant row in a transaction
-      const result = await sql.begin(async (tx) => {
-        const [userMsg] = await tx<{ id: string }[]>`
-          INSERT INTO messages (session_id, chat_id, role, content, status, created_at)
-          VALUES (${sessionId}, ${chatId}, 'user', ${content}, 'complete', clock_timestamp())
-          RETURNING id
-        `;
-        const [assistantMsg] = await tx<{ id: string }[]>`
-          INSERT INTO messages (session_id, chat_id, role, content, status, created_at)
-          VALUES (${sessionId}, ${chatId}, 'assistant', '', 'streaming', clock_timestamp())
-          RETURNING id
-        `;
-        await tx`UPDATE sessions SET updated_at = clock_timestamp() WHERE id = ${sessionId}`;
-        await tx`UPDATE chats SET updated_at = clock_timestamp() WHERE id = ${chatId}`;
-        return { user_message_id: userMsg!.id, assistant_message_id: assistantMsg!.id };
-      });
-
-      // Publish user message frames so WS subscribers see it immediately
+      // Publish user message frames
       broker.publishFrame(sessionId, {
         type: 'message_started',
-        message_id: result.user_message_id,
+        message_id: userMsg!.id,
         chat_id: chatId,
         role: 'user',
       } as unknown as WsFrame);
       broker.publishFrame(sessionId, {
         type: 'delta',
-        message_id: result.user_message_id,
+        message_id: userMsg!.id,
         chat_id: chatId,
         content,
       } as unknown as WsFrame);
       broker.publishFrame(sessionId, {
         type: 'message_complete',
-        message_id: result.user_message_id,
+        message_id: userMsg!.id,
         chat_id: chatId,
       } as unknown as WsFrame);
 
-      // Enqueue inference — the runner will stream assistant deltas via broker
-      inference.enqueue(sessionId, chatId, result.assistant_message_id, 'default');
+      if (isExternal) {
+        // External provider: create a task for the dispatcher
+        const projectId = sessionRows[0]!.project_id;
+        const [task] = await sql<{ id: string; state: string }[]>`
+          INSERT INTO tasks (project_id, input, agent, model, session_id)
+          VALUES (${projectId}, ${content}, ${provider}, ${model ?? null}, ${sessionId})
+          RETURNING id, state
+        `;
+        reply.code(202);
+        return { user_message_id: userMsg!.id, task_id: task!.id, dispatched: true };
+      }
+
+      // Native provider: create streaming assistant row + enqueue inference
+      const [assistantMsg] = await sql<{ id: string }[]>`
+        INSERT INTO messages (session_id, chat_id, role, content, status, created_at)
+        VALUES (${sessionId}, ${chatId}, 'assistant', '', 'streaming', clock_timestamp())
+        RETURNING id
+      `;
+
+      inference.enqueue(sessionId, chatId, assistantMsg!.id, 'default');
 
       reply.code(202);
-      return result;
+      return { user_message_id: userMsg!.id, assistant_message_id: assistantMsg!.id };
     },
   );
 

apps/coder/src/routes/providers.ts

@@ -0,0 +1,80 @@
+import type { FastifyInstance } from 'fastify';
+import type { Sql } from '../db.js';
+import type { Config } from '../config.js';
+import { PROVIDERS } from '../services/provider-registry.js';
+
+interface ProviderModel {
+  id: string;
+  label: string;
+}
+
+interface ProviderResponse {
+  name: string;
+  label: string;
+  transport: string;
+  installed: boolean;
+  models: ProviderModel[];
+}
+
+interface LlamaSwapModel {
+  id: string;
+  [key: string]: unknown;
+}
+
+async function fetchLlamaSwapModels(config: Config): Promise<ProviderModel[]> {
+  try {
+    const res = await fetch(`${config.LLAMA_SWAP_URL}/v1/models`);
+    if (!res.ok) return [];
+    const parsed = (await res.json()) as { data?: LlamaSwapModel[] };
+    return (parsed.data ?? []).map((m) => ({ id: m.id, label: m.id }));
+  } catch {
+    return [];
+  }
+}
+
+export function registerProviderRoutes(app: FastifyInstance, sql: Sql, config: Config): void {
+  app.get('/api/providers', async (_req, _reply) => {
+    const llamaModels = await fetchLlamaSwapModels(config);
+
+    const agents = await sql<{ name: string; models: ProviderModel[]; label: string | null; transport: string | null; supports_acp: boolean }[]>`
+      SELECT name, models, label, transport, supports_acp FROM available_agents
+    `;
+    const agentMap = new Map(agents.map((a) => [a.name, a]));
+
+    const result: ProviderResponse[] = [];
+
+    for (const provider of PROVIDERS) {
+      const isNative = provider.name === 'boocode';
+      const agentRow = agentMap.get(provider.name);
+      const installed = isNative || !!agentRow;
+
+      if (!installed) continue;
+
+      let models: ProviderModel[];
+      if (provider.modelSource === 'llama-swap') {
+        models = llamaModels;
+      } else if (agentRow?.models && agentRow.models.length > 0) {
+        models = agentRow.models;
+      } else if (provider.staticModels) {
+        models = provider.staticModels;
+      } else {
+        models = [];
+      }
+
+      let transport: string = provider.transport;
+      if (agentRow) {
+        transport = provider.transport === 'acp' && !agentRow.supports_acp ? 'pty' : provider.transport;
+      }
+
+      result.push({
+        name: provider.name,
+        label: agentRow?.label ?? provider.label,
+        transport,
+        installed,
+        models,
+      });
+    }
+
+    return result;
+  });
+}

apps/coder/src/schema.sql

@@ -61,3 +61,8 @@ ALTER TABLE tasks ADD COLUMN IF NOT EXISTS arena_id UUID;
 -- Human inbox: tasks needing attention
 CREATE OR REPLACE VIEW human_inbox AS
   SELECT * FROM tasks WHERE state IN ('blocked', 'failed');
+
+-- v2.1.0: provider picker — extend available_agents with model discovery.
+ALTER TABLE available_agents ADD COLUMN IF NOT EXISTS models JSONB DEFAULT '[]'::jsonb;
+ALTER TABLE available_agents ADD COLUMN IF NOT EXISTS label TEXT;
+ALTER TABLE available_agents ADD COLUMN IF NOT EXISTS transport TEXT DEFAULT 'pty';

apps/coder/src/services/acp-dispatch.ts

@@ -1,12 +1,12 @@
 /**
- * ACP dispatch — runs ACP-capable agents (opencode, goose) on the host via SSH.
+ * ACP dispatch — runs ACP-capable agents (opencode, goose) directly on the host.
  *
- * Uses the @agentclientprotocol/sdk to establish a structured JSON-RPC session
- * with the agent subprocess. The SSH tunnel provides stdio transport.
+ * v2.1.1: BooCoder runs on the host now — agents are spawned directly,
+ * no SSH needed. Uses @agentclientprotocol/sdk for structured JSON-RPC.
  *
  * Flow:
- * 1. SSH to host, start `opencode acp` (or `goose acp`) in the worktree
- * 2. Wrap SSH child's stdin/stdout into NDJSON streams
+ * 1. Spawn `opencode acp` (or `goose acp`) in the worktree
+ * 2. Wrap child's stdin/stdout into NDJSON streams
  * 3. Create a ClientSideConnection from the SDK
  * 4. Initialize → newSession → prompt(task)
  * 5. Collect session updates (tool calls, text output)
@@ -28,7 +28,7 @@ import {
   type CreateTerminalRequest,
   type CreateTerminalResponse,
 } from '@agentclientprotocol/sdk';
-import { sshSpawn } from './ssh.js';
+import { spawn } from 'node:child_process';
 
 export interface AcpDispatchResult {
   exitCode: number;
@@ -42,17 +42,17 @@ export interface AcpDispatchOpts {
   task: string;
   worktreePath: string;
   model?: string;
+  installPath?: string;
   signal?: AbortSignal;
   log: FastifyBaseLogger;
 }
 
-/** Map agent name to the ACP command it exposes. */
-function acpCommand(agent: string): string | null {
+function acpArgs(agent: string): string[] | null {
   switch (agent) {
     case 'opencode':
-      return 'opencode acp';
+      return ['acp'];
     case 'goose':
-      return 'goose acp';
+      return ['acp'];
     default:
       return null;
   }
@@ -114,10 +114,10 @@ function nodeWritableToWeb(nodeStream: NodeJS.WritableStream): WritableStream<Ui
  * all session updates. Returns the collected output and tool calls.
  */
 export async function dispatchViaAcp(opts: AcpDispatchOpts): Promise<AcpDispatchResult> {
-  const { agent, task, worktreePath, signal, log } = opts;
+  const { agent, task, worktreePath, installPath, signal, log } = opts;
 
-  const cmd = acpCommand(agent);
-  if (!cmd) {
+  const args = acpArgs(agent);
+  if (!args) {
     return {
       exitCode: 1,
       output: `Agent '${agent}' does not support ACP.`,
@@ -126,12 +126,13 @@ export async function dispatchViaAcp(opts: AcpDispatchOpts): Promise<AcpDispatch
     };
   }
 
-  // Spawn SSH with the ACP command running in the worktree
-  const escapedPath = worktreePath.replace(/'/g, "'\\''");
-  const fullCommand = `cd '${escapedPath}' && ${cmd}`;
-
-  log.info({ agent, worktreePath }, 'acp-dispatch: spawning');
-  const child = sshSpawn(fullCommand);
+  const binary = installPath ?? agent;
+  log.info({ agent, binary, worktreePath }, 'acp-dispatch: spawning');
+  const child = spawn(binary, args, {
+    cwd: worktreePath,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env },
+  });
 
   // Wire up abort
   let killed = false;

apps/coder/src/services/agent-probe.ts

@@ -1,69 +1,91 @@
 import type { Sql } from '../db.js';
 import type { FastifyBaseLogger } from 'fastify';
-import { sshExec } from './ssh.js';
+import { exec as execCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { PROVIDERS_BY_NAME } from './provider-registry.js';
 
-const KNOWN_AGENTS: Array<{ name: string; supportsAcp: boolean }> = [
-  { name: 'opencode', supportsAcp: true },
-  { name: 'goose', supportsAcp: true },
-  { name: 'claude', supportsAcp: false },
-  { name: 'pi', supportsAcp: false },
-  { name: 'qwen', supportsAcp: false },
-];
+const exec = promisify(execCb);
+
+const KNOWN_AGENTS = ['opencode', 'goose', 'claude', 'qwen'].map((name) => ({
+  name,
+  supportsAcp: PROVIDERS_BY_NAME.get(name)?.transport === 'acp',
+}));
 
 /**
- * Probe for available agents on the HOST via SSH.
+ * Probe for available agents on the HOST.
  *
- * The boocoder container can't run agents locally — they live on the host.
- * We SSH to the host (same mechanism BooTerm uses) and check which agent
- * binaries are on PATH.
+ * v2.1.1: BooCoder runs on the host now — agents are local binaries,
+ * no SSH needed. Direct `which` / `exec` calls.
  */
 export async function probeAgents(sql: Sql, log: FastifyBaseLogger): Promise<void> {
-  log.info('agent-probe: scanning HOST for known agents via SSH');
+  log.info('agent-probe: scanning for known agents');
 
   for (const agent of KNOWN_AGENTS) {
     try {
-      // Check if the agent binary is on the host's PATH
-      const whichResult = await sshExec(`which ${agent.name}`, { timeoutMs: 10_000 });
-      const installPath = whichResult.stdout.trim();
-      if (whichResult.exitCode !== 0 || !installPath) continue;
+      const { stdout: whichOut } = await exec(`which ${agent.name}`, { timeout: 10_000 });
+      const installPath = whichOut.trim();
+      if (!installPath) continue;
 
-      // Get version
       let version: string | null = null;
       try {
-        const verResult = await sshExec(`${agent.name} --version`, { timeoutMs: 15_000 });
-        if (verResult.exitCode === 0) {
-          version = verResult.stdout.trim().slice(0, 100);
-        }
+        const { stdout: verOut } = await exec(`${agent.name} --version`, { timeout: 15_000 });
+        version = verOut.trim().slice(0, 100);
       } catch {
-        // Some agents may not support --version — that's fine
+        // Some agents may not support --version
       }
 
-      // For ACP-capable agents, verify ACP mode actually works
       let supportsAcp = agent.supportsAcp;
       if (supportsAcp) {
         try {
-          const acpCheck = await sshExec(`${agent.name} acp --help`, { timeoutMs: 10_000 });
-          supportsAcp = acpCheck.exitCode === 0;
+          await exec(`${agent.name} acp --help`, { timeout: 10_000 });
         } catch {
           supportsAcp = false;
         }
       }
 
-      // UPSERT into available_agents
+      let models: Array<{ id: string; label: string }> = [];
+      const providerDef = PROVIDERS_BY_NAME.get(agent.name);
+
+      if (providerDef?.modelSource === 'static' && providerDef.staticModels) {
+        models = providerDef.staticModels;
+      }
+
+      if (agent.name === 'qwen') {
+        try {
+          const { stdout: catOut } = await exec('cat ~/.qwen/settings.json', { timeout: 10_000 });
+          if (catOut.trim()) {
+            const settings = JSON.parse(catOut) as {
+              modelProviders?: { openai?: Array<{ id: string }> };
+            };
+            const openaiModels = settings?.modelProviders?.openai;
+            if (Array.isArray(openaiModels)) {
+              models = openaiModels.map((m) => ({ id: m.id, label: m.id }));
+            }
+          }
+        } catch {
+          // ~/.qwen/settings.json missing or unparseable
+        }
+      }
+
+      const label = providerDef?.label ?? agent.name;
+      const transport = providerDef?.transport ?? 'pty';
+
       await sql`
-        INSERT INTO available_agents (name, install_path, version, supports_acp, last_probed_at)
-        VALUES (${agent.name}, ${installPath}, ${version}, ${supportsAcp}, clock_timestamp())
+        INSERT INTO available_agents (name, install_path, version, supports_acp, last_probed_at, models, label, transport)
+        VALUES (${agent.name}, ${installPath}, ${version}, ${supportsAcp}, clock_timestamp(), ${sql.json(models as never)}, ${label}, ${transport})
         ON CONFLICT (name) DO UPDATE SET
           install_path = EXCLUDED.install_path,
           version = EXCLUDED.version,
           supports_acp = EXCLUDED.supports_acp,
-          last_probed_at = EXCLUDED.last_probed_at
+          last_probed_at = EXCLUDED.last_probed_at,
+          models = EXCLUDED.models,
+          label = EXCLUDED.label,
+          transport = EXCLUDED.transport
       `;
-      log.info({ agent: agent.name, version, installPath, supportsAcp }, 'agent-probe: found on host');
+      log.info({ agent: agent.name, version, installPath, supportsAcp, modelCount: models.length }, 'agent-probe: found');
     } catch (err) {
-      // SSH failed or agent not found — skip silently
       const msg = err instanceof Error ? err.message : String(err);
-      log.debug({ agent: agent.name, err: msg }, 'agent-probe: not found or SSH failed');
+      log.debug({ agent: agent.name, err: msg }, 'agent-probe: not found');
     }
   }
 

apps/coder/src/services/dispatcher.ts

@@ -34,8 +34,8 @@ export function createDispatcher(deps: Deps): { start(): void; stop(): Promise<v
     if (running || stopping) return;
 
     // Grab one pending task
-    const rows = await sql<{ id: string; project_id: string; input: string; agent: string | null; model: string | null }[]>`
-      SELECT id, project_id, input, agent, model
+    const rows = await sql<{ id: string; project_id: string; input: string; agent: string | null; model: string | null; session_id: string | null }[]>`
+      SELECT id, project_id, input, agent, model, session_id
       FROM tasks
       WHERE state = 'pending'
       ORDER BY created_at
@@ -51,16 +51,16 @@ export function createDispatcher(deps: Deps): { start(): void; stop(): Promise<v
     });
   }
 
-  async function runTask(task: { id: string; project_id: string; input: string; agent: string | null; model: string | null }): Promise<void> {
+  async function runTask(task: { id: string; project_id: string; input: string; agent: string | null; model: string | null; session_id: string | null }): Promise<void> {
     const taskId = task.id;
 
     // Determine execution path: if agent is specified AND exists in available_agents → Path B
     if (task.agent) {
-      const [agentRow] = await sql<{ name: string; supports_acp: boolean }[]>`
-        SELECT name, supports_acp FROM available_agents WHERE name = ${task.agent}
+      const [agentRow] = await sql<{ name: string; supports_acp: boolean; install_path: string | null }[]>`
+        SELECT name, supports_acp, install_path FROM available_agents WHERE name = ${task.agent}
       `;
       if (agentRow) {
-        await runExternalAgent(task, agentRow.supports_acp);
+        await runExternalAgent(task, agentRow.supports_acp, agentRow.install_path);
         return;
       }
       // Agent specified but not available — fall through to Path A with a warning
@@ -73,7 +73,7 @@ export function createDispatcher(deps: Deps): { start(): void; stop(): Promise<v
 
   // ─── Path A: Native Inference ───────────────────────────────────────────────
 
-  async function runNativeInference(task: { id: string; project_id: string; input: string; agent: string | null; model: string | null }): Promise<void> {
+  async function runNativeInference(task: { id: string; project_id: string; input: string; agent: string | null; model: string | null; session_id: string | null }): Promise<void> {
     const taskId = task.id;
     log.info({ taskId }, 'dispatcher: starting task (path A — native)');
 
@@ -179,8 +179,9 @@ export function createDispatcher(deps: Deps): { start(): void; stop(): Promise<v
   // ─── Path B: External Agent Dispatch ──────<E29480><E29480><EFBFBD>─────────────────────────────────
 
   async function runExternalAgent(
-    task: { id: string; project_id: string; input: string; agent: string | null; model: string | null },
+    task: { id: string; project_id: string; input: string; agent: string | null; model: string | null; session_id: string | null },
     supportsAcp: boolean,
+    installPath: string | null,
   ): Promise<void> {
     const taskId = task.id;
     const agent = task.agent!;
@@ -189,14 +190,14 @@ export function createDispatcher(deps: Deps): { start(): void; stop(): Promise<v
     log.info({ taskId, agent, executionPath }, 'dispatcher: starting task (path B — external)');
 
     // Resolve the project's root path
-    const [project] = await sql<{ root_path: string | null }[]>`
-      SELECT root_path FROM projects WHERE id = ${task.project_id}
+    const [project] = await sql<{ path: string | null }[]>`
+      SELECT path FROM projects WHERE id = ${task.project_id}
     `;
-    const projectPath = project?.root_path;
+    const projectPath = project?.path;
     if (!projectPath) {
       await sql`
         UPDATE tasks
-        SET state = 'failed', ended_at = clock_timestamp(), output_summary = 'Project has no root_path — cannot create worktree'
+        SET state = 'failed', ended_at = clock_timestamp(), output_summary = 'Project has no path — cannot create worktree'
         WHERE id = ${taskId}
       `;
       return;
@@ -213,30 +214,49 @@ export function createDispatcher(deps: Deps): { start(): void; stop(): Promise<v
         WHERE id = ${taskId}
       `;
 
-      // Create session + chat for this task (same as Path A — for output tracking)
-      const sessionName = `Task [${agent}]: ${task.input.slice(0, 30)}`;
-      const [session] = await sql<{ id: string }[]>`
-        INSERT INTO sessions (project_id, name, model, status)
-        VALUES (${task.project_id}, ${sessionName}, ${task.model ?? config.DEFAULT_MODEL}, 'open')
-        RETURNING id
-      `;
-      const sessionId = session!.id;
+      let sessionId: string;
+      let chatId: string;
 
-      const [chat] = await sql<{ id: string }[]>`
-        INSERT INTO chats (session_id, name, status)
-        VALUES (${sessionId}, 'External agent execution', 'open')
-        RETURNING id
-      `;
-      const chatId = chat!.id;
+      if (task.session_id) {
+        sessionId = task.session_id;
+        const chats = await sql<{ id: string }[]>`
+          SELECT id FROM chats WHERE session_id = ${sessionId} AND status = 'open' ORDER BY created_at DESC LIMIT 1
+        `;
+        if (chats.length === 0) {
+          const [chat] = await sql<{ id: string }[]>`
+            INSERT INTO chats (session_id, name, status)
+            VALUES (${sessionId}, 'External agent execution', 'open')
+            RETURNING id
+          `;
+          chatId = chat!.id;
+        } else {
+          chatId = chats[0]!.id;
+        }
+      } else {
+        const sessionName = `Task [${agent}]: ${task.input.slice(0, 30)}`;
+        const [session] = await sql<{ id: string }[]>`
+          INSERT INTO sessions (project_id, name, model, status)
+          VALUES (${task.project_id}, ${sessionName}, ${task.model ?? config.DEFAULT_MODEL}, 'open')
+          RETURNING id
+        `;
+        sessionId = session!.id;
 
-      // Link task to session
-      await sql`UPDATE tasks SET session_id = ${sessionId} WHERE id = ${taskId}`;
+        const [chat] = await sql<{ id: string }[]>`
+          INSERT INTO chats (session_id, name, status)
+          VALUES (${sessionId}, 'External agent execution', 'open')
+          RETURNING id
+        `;
+        chatId = chat!.id;
 
-      // Create user message for the task input
-      await sql`
-        INSERT INTO messages (session_id, chat_id, role, content, status, created_at)
-        VALUES (${sessionId}, ${chatId}, 'user', ${task.input}, 'complete', clock_timestamp())
-      `;
+        await sql`UPDATE tasks SET session_id = ${sessionId} WHERE id = ${taskId}`;
+      }
+
+      if (!task.session_id) {
+        await sql`
+          INSERT INTO messages (session_id, chat_id, role, content, status, created_at)
+          VALUES (${sessionId}, ${chatId}, 'user', ${task.input}, 'complete', clock_timestamp())
+        `;
+      }
 
       // Step 1: Create worktree
       log.info({ taskId, projectPath }, 'dispatcher: creating worktree');
@@ -251,6 +271,7 @@ export function createDispatcher(deps: Deps): { start(): void; stop(): Promise<v
           agent,
           task: task.input,
           worktreePath,
+          installPath: installPath ?? undefined,
           model: task.model ?? undefined,
           signal: ac.signal,
           log,
@@ -267,6 +288,7 @@ export function createDispatcher(deps: Deps): { start(): void; stop(): Promise<v
           agent,
           task: task.input,
           worktreePath,
+          installPath: installPath ?? undefined,
           model: task.model ?? undefined,
           signal: ac.signal,
           log,

apps/coder/src/services/provider-registry.ts

@@ -0,0 +1,46 @@
+export interface ProviderDef {
+  name: string;
+  label: string;
+  transport: 'native' | 'acp' | 'pty';
+  modelSource: 'llama-swap' | 'static';
+  staticModels?: Array<{ id: string; label: string }>;
+}
+
+export const PROVIDERS: ProviderDef[] = [
+  {
+    name: 'boocode',
+    label: 'BooCoder',
+    transport: 'native',
+    modelSource: 'llama-swap',
+  },
+  {
+    name: 'opencode',
+    label: 'OpenCode',
+    transport: 'acp',
+    modelSource: 'llama-swap',
+  },
+  {
+    name: 'goose',
+    label: 'Goose',
+    transport: 'acp',
+    modelSource: 'llama-swap',
+  },
+  {
+    name: 'claude',
+    label: 'Claude Code',
+    transport: 'pty',
+    modelSource: 'static',
+    staticModels: [
+      { id: 'claude-opus-4-20250514', label: 'Opus 4' },
+      { id: 'claude-sonnet-4-20250514', label: 'Sonnet 4' },
+    ],
+  },
+  {
+    name: 'qwen',
+    label: 'Qwen Code',
+    transport: 'pty',
+    modelSource: 'static',
+  },
+];
+
+export const PROVIDERS_BY_NAME = new Map(PROVIDERS.map((p) => [p.name, p]));

apps/coder/src/services/pty-dispatch.ts

@@ -1,19 +1,18 @@
 /**
- * PTY dispatch — runs external agents on the host via SSH.
+ * PTY dispatch — runs external agents directly on the host.
  *
- * For agents without ACP support (claude, pi), we pipe the task into their
- * non-interactive mode and capture stdout/stderr. The agent runs in a git
- * worktree so it can modify files freely.
+ * v2.1.3: Spawns agent binaries directly (no sh -c wrapper) using the
+ * install_path from agent-probe. Follows Paseo's pattern: direct binary
+ * path + args array + cwd.
  *
  * Supported agents:
  * - claude: `claude -p --model <model>` (print mode, reads task from stdin)
- * - opencode: `echo <task> | opencode` (stdin pipe — exact flags TBD)
- * - qwen: `qwen -p <task> --output-format stream-json` (NDJSON structured output)
- * - goose: stub (not yet supported)
- * - pi: stub (not yet supported)
+ * - opencode: `opencode --model <model>` (stdin pipe)
+ * - qwen: `qwen -p <task> --output-format stream-json`
+ * - goose: `goose run --text <task>`
  */
 import type { FastifyBaseLogger } from 'fastify';
-import { sshSpawnWithStdin } from './ssh.js';
+import { spawn } from 'node:child_process';
 
 export interface DispatchResult {
   exitCode: number;
@@ -26,62 +25,61 @@ export interface PtyDispatchOpts {
   task: string;
   worktreePath: string;
   model?: string;
+  installPath?: string;
   signal?: AbortSignal;
   log: FastifyBaseLogger;
 }
 
-/**
- * Build the shell command that runs the agent non-interactively.
- * The command will be executed inside `cd <worktreePath> && ...`.
- */
-function buildAgentCommand(agent: string, task: string, model?: string): string | null {
-  // Escape the task for embedding in a shell command
-  const escapedTask = task.replace(/'/g, "'\\''");
+interface AgentCommand {
+  binary: string;
+  args: string[];
+  stdin?: string;
+}
+
+function buildAgentCommand(agent: string, task: string, model?: string, installPath?: string): AgentCommand | null {
+  const binary = installPath ?? agent;
 
   switch (agent) {
     case 'claude':
-      // Claude Code's print mode: reads prompt from stdin, runs autonomously, prints result
-      return model
-        ? `echo '${escapedTask}' | claude -p --model '${model}'`
-        : `echo '${escapedTask}' | claude -p`;
+      return {
+        binary,
+        args: model ? ['-p', '--model', model] : ['-p'],
+        stdin: task,
+      };
 
     case 'opencode':
-      // opencode non-interactive: pipe task via stdin
-      // NOTE: exact flags may vary — opencode may need --non-interactive or --pipe
-      return model
-        ? `echo '${escapedTask}' | opencode --model '${model}'`
-        : `echo '${escapedTask}' | opencode`;
+      return {
+        binary,
+        args: model ? ['--model', model] : [],
+        stdin: task,
+      };
 
     case 'qwen':
-      // Qwen Code: structured JSON output mode for parseable events
-      return model
-        ? `qwen -p '${escapedTask}' --model '${model}' --output-format stream-json`
-        : `qwen -p '${escapedTask}' --output-format stream-json`;
+      return {
+        binary,
+        args: model
+          ? ['-p', task, '--model', model, '--output-format', 'stream-json']
+          : ['-p', task, '--output-format', 'stream-json'],
+      };
 
     case 'goose':
-      // Not yet verified for non-interactive use
-      return null;
-
-    case 'pi':
-      // Not yet verified for non-interactive use
-      return null;
+      return {
+        binary,
+        args: model
+          ? ['run', '--text', task, '--model', model]
+          : ['run', '--text', task],
+      };
 
     default:
       return null;
   }
 }
 
-/**
- * Dispatch a task to an external agent via SSH.
- *
- * The agent runs in the worktree directory on the host. stdout/stderr are
- * captured in full and returned. The SSH process is killed on abort signal.
- */
 export async function dispatchViaPty(opts: PtyDispatchOpts): Promise<DispatchResult> {
-  const { agent, task, worktreePath, model, signal, log } = opts;
+  const { agent, task, worktreePath, model, installPath, signal, log } = opts;
 
-  const agentCmd = buildAgentCommand(agent, task, model);
-  if (!agentCmd) {
+  const cmd = buildAgentCommand(agent, task, model, installPath);
+  if (!cmd) {
     return {
       exitCode: 1,
       stdout: '',
@@ -89,22 +87,19 @@ export async function dispatchViaPty(opts: PtyDispatchOpts): Promise<DispatchRes
     };
   }
 
-  // Wrap in cd to the worktree
-  const fullCommand = `cd '${worktreePath.replace(/'/g, "'\\''")}' && ${agentCmd}`;
-
-  log.info({ agent, worktreePath }, 'pty-dispatch: starting');
+  log.info({ agent, binary: cmd.binary, worktreePath }, 'pty-dispatch: starting');
 
   return new Promise<DispatchResult>((resolve, reject) => {
-    const child = sshSpawnWithStdin(fullCommand, '');
-    // Note: sshSpawnWithStdin already closes stdin. For agents that read from
-    // stdin via echo piping, the command itself handles the piping on the remote
-    // side. We just need the SSH tunnel.
+    const child = spawn(cmd.binary, cmd.args, {
+      cwd: worktreePath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
 
-    // Actually, re-think: sshSpawnWithStdin writes input and closes stdin on the
-    // LOCAL ssh process. But the remote command is `echo '...' | agent`, which
-    // provides its own stdin. So we should use sshSpawn (no local stdin needed)
-    // or just let the empty stdin close — the remote shell handles piping internally.
-    // This is fine as-is because the echo piping happens WITHIN the remote shell command.
+    if (cmd.stdin) {
+      child.stdin!.write(cmd.stdin);
+    }
+    child.stdin!.end();
 
     let stdout = '';
     let stderr = '';
@@ -117,7 +112,6 @@ export async function dispatchViaPty(opts: PtyDispatchOpts): Promise<DispatchRes
       if (!killed) {
         killed = true;
         child.kill('SIGTERM');
-        // Give it a moment then force-kill
         setTimeout(() => child.kill('SIGKILL'), 5_000);
       }
     };

apps/coder/src/services/ssh.ts

@@ -1,4 +1,7 @@
 /**
+ * @deprecated v2.1.1 — BooCoder runs on the host now. Use direct spawn/exec instead.
+ * Kept for one release cycle in case of rollback.
+ *
  * SSH helper — spawns commands on the host via SSH.
  *
  * BooCode's container cannot directly spawn host processes (opencode, goose, claude, pi).