@swarmclawai/swarmclaw 1.6.1 → 1.7.0

package/src/components/home/home-launchpad.tsx

@@ -1,7 +1,12 @@
 'use client'
 
 import { AgentAvatar } from '@/components/agents/agent-avatar'
-import { LaunchActionCard } from '@/components/shared/launch-action-card'
+import {
+  getLaunchPathCards,
+  type LaunchPathAction,
+  type LaunchPathCardCopy,
+  type LaunchPathId,
+} from '@/lib/home-launchpad'
 import type { Agent } from '@/types'
 
 function SnapshotItem({ label, value, hint }: { label: string; value: string; hint: string }) {
@@ -15,47 +20,58 @@ function SnapshotItem({ label, value, hint }: { label: string; value: string; hi
 }
 
 function PathCard({
-  kicker,
-  title,
-  description,
-  primaryLabel,
-  secondaryLabel,
-  onPrimary,
-  onSecondary,
+  card,
+  onAction,
 }: {
-  kicker: string
-  title: string
-  description: string
-  primaryLabel: string
-  secondaryLabel: string
-  onPrimary: () => void
-  onSecondary: () => void
+  card: LaunchPathCardCopy
+  onAction: (id: LaunchPathId, action: LaunchPathAction) => void
 }) {
   return (
     <div className="flex min-h-[220px] flex-col rounded-[18px] border border-white/[0.07] bg-white/[0.03] p-5">
-      <div className="text-[11px] font-700 uppercase tracking-[0.12em] text-text-3/55">{kicker}</div>
-      <div className="mt-3 text-[18px] font-display font-700 tracking-normal text-text">{title}</div>
-      <p className="mt-2 flex-1 text-[13px] leading-relaxed text-text-3/72">{description}</p>
+      <div className="text-[11px] font-700 uppercase tracking-[0.12em] text-text-3/55">{card.kicker}</div>
+      <div className="mt-3 text-[18px] font-display font-700 tracking-normal text-text">{card.title}</div>
+      <p className="mt-2 flex-1 text-[13px] leading-relaxed text-text-3/72">{card.description}</p>
       <div className="mt-5 flex flex-wrap gap-2">
         <button
           type="button"
-          onClick={onPrimary}
+          onClick={() => onAction(card.id, 'primary')}
           className="rounded-[10px] bg-accent-bright px-3.5 py-2 text-[12px] font-display font-700 text-black transition-opacity hover:opacity-90"
         >
-          {primaryLabel}
+          {card.primaryLabel}
         </button>
         <button
           type="button"
-          onClick={onSecondary}
+          onClick={() => onAction(card.id, 'secondary')}
           className="rounded-[10px] border border-white/[0.08] bg-white/[0.04] px-3.5 py-2 text-[12px] font-display font-700 text-text-2 transition-colors hover:bg-white/[0.08]"
         >
-          {secondaryLabel}
+          {card.secondaryLabel}
         </button>
       </div>
     </div>
   )
 }
 
+function SecondaryAction({
+  label,
+  description,
+  onClick,
+}: {
+  label: string
+  description: string
+  onClick: () => void
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className="rounded-[12px] border border-white/[0.07] bg-white/[0.025] px-3 py-2 text-left transition-colors hover:bg-white/[0.05]"
+    >
+      <div className="text-[12px] font-display font-700 text-text-2">{label}</div>
+      <div className="mt-0.5 text-[11px] leading-relaxed text-text-3/65">{description}</div>
+    </button>
+  )
+}
+
 type Props = {
   firstAgent: Agent | null
   agentCount: number
@@ -64,15 +80,8 @@ type Props = {
   scheduleCount: number
   connectorCount: number
   todayCost: number
-  onOpenFirstAgent: () => void
-  onOpenProtocols: () => void
-  onOpenBuilder: () => void
-  onOpenConnectors: () => void
+  onLaunchPathAction: (id: LaunchPathId, action: LaunchPathAction) => void
   onOpenUsage: () => void
-  onRunEvalSuite: () => void
-  onReviewApprovals: () => void
-  onInspectFailedRuns: () => void
-  onStartReleaseQaMission: () => void
 }
 
 export function HomeLaunchpad({
@@ -83,16 +92,11 @@ export function HomeLaunchpad({
   scheduleCount,
   connectorCount,
   todayCost,
-  onOpenFirstAgent,
-  onOpenProtocols,
-  onOpenBuilder,
-  onOpenConnectors,
+  onLaunchPathAction,
   onOpenUsage,
-  onRunEvalSuite,
-  onReviewApprovals,
-  onInspectFailedRuns,
-  onStartReleaseQaMission,
 }: Props) {
+  const launchPathCards = getLaunchPathCards({ firstAgentName: firstAgent?.name })
+
   return (
     <div className="max-w-[980px] mx-auto px-6 py-10">
       <div className="rounded-[20px] border border-white/[0.06] bg-white/[0.025] p-6">
@@ -137,93 +141,37 @@ export function HomeLaunchpad({
       </div>
 
       <div className="mt-6 grid gap-3 lg:grid-cols-3">
-        <PathCard
-          kicker="Self-hosted assistant"
-          title={firstAgent ? `Work with ${firstAgent.name}` : 'Create the first agent'}
-          description="Open a live agent chat, then add memory, local tools, provider routing, or connector access as the work demands."
-          primaryLabel={firstAgent ? 'Open Chat' : 'Open Agents'}
-          secondaryLabel="Connect Platform"
-          onPrimary={onOpenFirstAgent}
-          onSecondary={onOpenConnectors}
-        />
-        <PathCard
-          kicker="Visual workflow"
-          title="Shape a reusable run"
-          description="Use protocol templates and the builder to turn review, research, planning, or release checks into durable workflows."
-          primaryLabel="Open Builder"
-          secondaryLabel="Use Templates"
-          onPrimary={onOpenBuilder}
-          onSecondary={onOpenProtocols}
-        />
-        <PathCard
-          kicker="Autonomous mission"
-          title="Run with budgets"
-          description="Start a mission template for release QA, research, support triage, cost audit, or failed-run review with reports and caps."
-          primaryLabel="Open Missions"
-          secondaryLabel="Quality Center"
-          onPrimary={onStartReleaseQaMission}
-          onSecondary={onRunEvalSuite}
-        />
+        {launchPathCards.map((card) => (
+          <PathCard key={card.id} card={card} onAction={onLaunchPathAction} />
+        ))}
       </div>
 
-      <div className="mt-6 grid gap-3 md:grid-cols-2 xl:grid-cols-3">
-        <LaunchActionCard
-          title={firstAgent ? 'Open First Agent Chat' : 'Open Agents'}
-          description={firstAgent
-            ? `Jump into ${firstAgent.name} and start using the workspace immediately.`
-            : 'Open the agents workspace to create or tune the first specialist agent.'}
-          actionLabel={firstAgent ? 'Open Chat' : 'Open Agents'}
-          onClick={onOpenFirstAgent}
-          tone="primary"
-        />
-        <LaunchActionCard
-          title="Start Structured Session"
-          description="Open bounded collaboration runs for planning, review, decision-making, or focused multi-agent work."
-          actionLabel="Open Protocols"
-          onClick={onOpenProtocols}
-        />
-        <LaunchActionCard
-          title="Open Workflow Builder"
-          description="Move straight into reusable orchestration graphs if you want a durable workflow instead of a one-off run."
-          actionLabel="Open Builder"
-          onClick={onOpenBuilder}
-        />
-        <LaunchActionCard
-          title="Connect a Platform"
-          description="Bridge agents into chat surfaces like Discord, Slack, Telegram, and WhatsApp."
-          actionLabel="Open Connectors"
-          onClick={onOpenConnectors}
-        />
-        <LaunchActionCard
-          title="Review Usage"
-          description="Check cost, provider health, and activity so the workspace stays observable from the start."
-          actionLabel="Open Usage"
-          onClick={onOpenUsage}
-        />
-        <LaunchActionCard
-          title="Run Eval Suite"
-          description="Open the Quality Center and run scenario or suite checks against an agent before shipping."
-          actionLabel="Open Eval Lab"
-          onClick={onRunEvalSuite}
-        />
-        <LaunchActionCard
-          title="Review Approvals"
-          description="Clear pending human-loop, tool, connector, skill, agent, and budget requests from one desk."
-          actionLabel="Open Approvals"
-          onClick={onReviewApprovals}
-        />
-        <LaunchActionCard
-          title="Inspect Failed Runs"
-          description="Filter recent run failures and open replay evidence without leaving the operator workflow."
-          actionLabel="Open Run Review"
-          onClick={onInspectFailedRuns}
-        />
-        <LaunchActionCard
-          title="Start Release QA Mission"
-          description="Use a budgeted mission template to collect release readiness evidence and quality notes."
-          actionLabel="Open Missions"
-          onClick={onStartReleaseQaMission}
-        />
+      <div className="mt-6 rounded-[16px] border border-white/[0.06] bg-white/[0.02] p-4">
+        <div className="flex flex-col gap-3 md:flex-row md:items-center md:justify-between">
+          <div>
+            <div className="text-[12px] font-display font-700 text-text">Keep the workspace observable</div>
+            <p className="mt-1 text-[12px] leading-relaxed text-text-3/65">
+              Provider spend, connector status, and quality evidence stay nearby after you pick a path.
+            </p>
+          </div>
+          <div className="grid gap-2 sm:grid-cols-3 md:min-w-[520px]">
+            <SecondaryAction
+              label="Usage"
+              description="Cost and provider health"
+              onClick={onOpenUsage}
+            />
+            <SecondaryAction
+              label="Connectors"
+              description="Platform bridges"
+              onClick={() => onLaunchPathAction('assistant', 'secondary')}
+            />
+            <SecondaryAction
+              label="Quality"
+              description="Evals and run review"
+              onClick={() => onLaunchPathAction('mission', 'secondary')}
+            />
+          </div>
+        </div>
       </div>
 
       <div className="mt-8 grid gap-3 md:grid-cols-2 xl:grid-cols-3">

package/src/lib/home-launchpad.test.ts

@@ -1,6 +1,12 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
-import { deriveHomeMode, isSparseWorkspace } from './home-launchpad'
+import {
+  DEFAULT_BUILDER_ROUTE,
+  deriveHomeMode,
+  getLaunchPathCards,
+  isSparseWorkspace,
+  resolveLaunchPathHref,
+} from './home-launchpad'
 
 test('isSparseWorkspace detects a fresh workspace', () => {
   assert.equal(isSparseWorkspace({
@@ -47,3 +53,27 @@ test('deriveHomeMode falls back to ops for active workspaces', () => {
     todayCost: 0,
   }), 'ops')
 })
+
+test('getLaunchPathCards returns the three first-run paths in order', () => {
+  const cards = getLaunchPathCards({ firstAgentName: 'Ada' })
+  assert.deepEqual(cards.map((card) => card.id), ['assistant', 'workflow', 'mission'])
+  assert.equal(cards[0]?.title, 'Work with Ada')
+  assert.equal(cards[0]?.primaryLabel, 'Open Chat')
+  assert.equal(cards[1]?.primaryLabel, 'Open Builder')
+  assert.equal(cards[2]?.secondaryLabel, 'Quality Center')
+})
+
+test('getLaunchPathCards falls back to agent creation copy when no agent exists', () => {
+  const [assistant] = getLaunchPathCards()
+  assert.equal(assistant?.title, 'Create the first agent')
+  assert.equal(assistant?.primaryLabel, 'Open Agents')
+})
+
+test('resolveLaunchPathHref builds primary and secondary destinations', () => {
+  assert.equal(resolveLaunchPathHref('assistant', 'primary', 'agent one'), '/agents/agent%20one')
+  assert.equal(resolveLaunchPathHref('assistant', 'secondary', 'agent one'), '/connectors')
+  assert.equal(resolveLaunchPathHref('workflow', 'primary'), DEFAULT_BUILDER_ROUTE)
+  assert.equal(resolveLaunchPathHref('workflow', 'secondary'), '/protocols')
+  assert.equal(resolveLaunchPathHref('mission', 'primary'), '/missions')
+  assert.equal(resolveLaunchPathHref('mission', 'secondary'), '/quality')
+})

package/src/lib/home-launchpad.ts

@@ -2,6 +2,17 @@ export const HOME_LAUNCHPAD_AFTER_SETUP_KEY = 'sc_launchpad_after_setup_v1'
 export const DEFAULT_BUILDER_ROUTE = '/protocols/builder/facilitated_discussion'
 
 export type HomeMode = 'launchpad' | 'ops'
+export type LaunchPathId = 'assistant' | 'workflow' | 'mission'
+export type LaunchPathAction = 'primary' | 'secondary'
+
+export interface LaunchPathCardCopy {
+  id: LaunchPathId
+  kicker: string
+  title: string
+  description: string
+  primaryLabel: string
+  secondaryLabel: string
+}
 
 export interface HomeModeInput {
   hasLaunchpadFlag: boolean
@@ -28,3 +39,50 @@ export function deriveHomeMode(input: HomeModeInput): HomeMode {
   if (input.hasLaunchpadFlag) return 'launchpad'
   return isSparseWorkspace(input) ? 'launchpad' : 'ops'
 }
+
+export function getLaunchPathCards(input: { firstAgentName?: string | null } = {}): LaunchPathCardCopy[] {
+  const firstAgentName = input.firstAgentName?.trim() || null
+  return [
+    {
+      id: 'assistant',
+      kicker: 'Assistant',
+      title: firstAgentName ? `Work with ${firstAgentName}` : 'Create the first agent',
+      description: 'Open a live agent chat, then add memory, local tools, provider routing, or connector access as the work demands.',
+      primaryLabel: firstAgentName ? 'Open Chat' : 'Open Agents',
+      secondaryLabel: 'Connect Platform',
+    },
+    {
+      id: 'workflow',
+      kicker: 'Workflow',
+      title: 'Shape a reusable run',
+      description: 'Use protocol templates and the builder to turn review, research, planning, or release checks into durable workflows.',
+      primaryLabel: 'Open Builder',
+      secondaryLabel: 'Use Templates',
+    },
+    {
+      id: 'mission',
+      kicker: 'Mission',
+      title: 'Run with budgets',
+      description: 'Start a mission template for release QA, research, support triage, cost audit, or failed-run review with reports and caps.',
+      primaryLabel: 'Open Missions',
+      secondaryLabel: 'Quality Center',
+    },
+  ]
+}
+
+export function resolveLaunchPathHref(
+  id: LaunchPathId,
+  action: LaunchPathAction,
+  firstAgentId?: string | null,
+): string {
+  if (id === 'assistant') {
+    if (action === 'primary') {
+      return firstAgentId ? `/agents/${encodeURIComponent(firstAgentId)}` : '/agents'
+    }
+    return '/connectors'
+  }
+  if (id === 'workflow') {
+    return action === 'primary' ? DEFAULT_BUILDER_ROUTE : '/protocols'
+  }
+  return action === 'primary' ? '/missions' : '/quality'
+}

package/src/lib/providers/cli-utils.test.ts

@@ -100,6 +100,16 @@ describe('isCliProvider', () => {
     assert.equal(isCliProvider('goose'), true)
   })
 
+  it('returns true for the extended generic-cli roster', () => {
+    const sample = [
+      'aider-cli', 'cline-cli', 'continue-cli', 'windsurf-cli', 'warp-cli',
+      'roo-code-cli', 'kilo-code-cli', 'qoder-cli', 'openhands-cli', 'kimi-cli',
+    ]
+    for (const id of sample) {
+      assert.equal(isCliProvider(id), true, `${id} should be recognized as a CLI provider`)
+    }
+  })
+
   it('returns false for non-CLI providers', () => {
     assert.equal(isCliProvider('openai'), false)
     assert.equal(isCliProvider('anthropic'), false)

package/src/lib/providers/cli-utils.ts

@@ -457,6 +457,37 @@ export const CLI_PROVIDER_CAPABILITIES: Record<string, string> = {
   'cursor-cli': 'full-agent coding workflows, multi-file edits, project-aware code changes',
   'qwen-code-cli': 'terminal-native coding workflows, code generation, review, and automation',
   goose: 'agentic coding workflows with extensions, tools, and runtime-managed execution',
+  'aider-cli': 'paired-programming-style multi-file edits and git-aware code changes',
+  'amp-cli': 'agentic coding via Sourcegraph Amp',
+  'augment-cli': 'codebase-aware agentic edits via Augment',
+  'adal-cli': 'AdaL coding agent for terminal-driven workflows',
+  'bob-cli': 'IBM watsonx Code Assistant (Bob) terminal coding workflows',
+  'cline-cli': 'autonomous file-level edits and terminal automation via Cline',
+  'codebuddy-cli': 'CodeBuddy agentic coding workflows',
+  'command-code-cli': 'Command Code terminal-native coding agent',
+  'continue-cli': 'agentic coding via the Continue CLI',
+  'cortex-cli': 'Snowflake Cortex Code agentic workflows',
+  'crush-cli': 'Crush terminal coding agent',
+  'deepagents-cli': 'long-horizon planning and multi-step coding via Deep Agents',
+  'firebender-cli': 'Firebender JetBrains-aligned coding agent',
+  'iflow-cli': 'iFlow CLI agentic coding workflows',
+  'junie-cli': 'JetBrains Junie coding agent for terminal use',
+  'kilo-code-cli': 'Kilo Code agentic coding workflows',
+  'kimi-cli': 'Kimi Code CLI coding agent',
+  'kode-cli': 'Kode terminal coding agent',
+  'mcpjam-cli': 'MCPJam-tooled agentic coding workflows',
+  'mistral-vibe-cli': 'Mistral Vibe coding agent',
+  'mux-cli': 'Mux multi-tool coding agent',
+  'neovate-cli': 'Neovate coding agent for terminal workflows',
+  'openhands-cli': 'OpenHands agentic coding via terminal',
+  'pochi-cli': 'Pochi coding agent',
+  'qoder-cli': 'Qoder agentic coding workflows',
+  'replit-cli': 'Replit Agent terminal coding workflows',
+  'roo-code-cli': 'Roo Code agentic coding workflows',
+  'trae-cn-cli': 'TRAE CN coding agent',
+  'warp-cli': 'Warp Agent terminal-native coding workflows',
+  'windsurf-cli': 'Windsurf agentic coding workflows',
+  'zencoder-cli': 'Zencoder agentic coding workflows',
 }
 
 /** Check if a provider ID is a CLI-based provider. */

package/src/lib/providers/generic-cli.test.ts

@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { GENERIC_CLI_BINARIES, streamGenericCliChat } from './generic-cli'
+
+describe('GENERIC_CLI_BINARIES', () => {
+  it('maps every generic CLI provider id to a non-empty binary name', () => {
+    for (const [providerId, binaryName] of Object.entries(GENERIC_CLI_BINARIES)) {
+      assert.equal(typeof binaryName, 'string', `${providerId} binary must be a string`)
+      assert.ok(binaryName.length > 0, `${providerId} binary must not be empty`)
+      assert.ok(providerId.endsWith('-cli'), `${providerId} should end with -cli for the registry pattern`)
+    }
+  })
+
+  it('does not collide with bespoke CLI provider ids', () => {
+    const bespoke = new Set([
+      'claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli',
+      'droid-cli', 'cursor-cli', 'qwen-code-cli', 'goose',
+    ])
+    for (const id of Object.keys(GENERIC_CLI_BINARIES)) {
+      assert.equal(bespoke.has(id), false, `${id} must not collide with a bespoke CLI provider`)
+    }
+  })
+})
+
+describe('streamGenericCliChat', () => {
+  it('streams stdout lines as deltas via the SSE write callback when the binary exists', async () => {
+    // Use `echo` as a stand-in binary. Every POSIX system has it on PATH.
+    // Note: `echo "<prompt>"` will print the prompt itself, which exercises
+    // the line-buffered pipe.
+    const writes: string[] = []
+    const active = new Map<string, unknown>()
+
+    const result = await streamGenericCliChat({
+      session: { id: 'test-session', cwd: process.cwd() },
+      message: 'hello world',
+      write: (data) => writes.push(data),
+      active,
+      loadHistory: () => [],
+      binaryName: 'echo',
+      displayName: 'Echo',
+    })
+
+    assert.ok(result.includes('hello world'), `expected response to include the prompt, got: ${JSON.stringify(result)}`)
+    assert.ok(writes.length > 0, 'should have emitted at least one SSE event')
+    const allText = writes.join('')
+    assert.ok(allText.includes('hello world'), 'SSE stream should include the echoed prompt')
+    assert.ok(!allText.includes('"t":"err"'), 'should not emit an error event on a successful run')
+    assert.equal(active.size, 0, 'session should be removed from active map after close')
+  })
+
+  it('emits an error event when the binary cannot be found on PATH', async () => {
+    const writes: string[] = []
+    const active = new Map<string, unknown>()
+
+    const result = await streamGenericCliChat({
+      session: { id: 'missing-bin-session', cwd: process.cwd() },
+      message: 'test',
+      write: (data) => writes.push(data),
+      active,
+      loadHistory: () => [],
+      binaryName: 'definitely-not-a-real-binary-zzz-' + Date.now(),
+      displayName: 'Nonexistent CLI',
+    })
+
+    assert.equal(result, '', 'missing binary should produce empty response')
+    assert.equal(writes.length, 1, 'should emit exactly one error event')
+    assert.ok(writes[0].includes('"t":"err"'), 'event should carry the err type')
+    assert.ok(writes[0].includes('Nonexistent CLI not found'), 'error message should mention the display name')
+  })
+})

package/src/lib/providers/generic-cli.ts

@@ -0,0 +1,138 @@
+import { spawn } from 'child_process'
+import type { StreamChatOptions } from './index'
+import { log } from '../server/logger'
+import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
+import { resolveCliBinary, buildCliEnv, attachAbortHandler, isStderrNoise } from './cli-utils'
+
+/**
+ * Map of swarmclaw provider id to the binary name we look up on PATH.
+ * Used by the generic CLI streamer for tools without a bespoke handler.
+ */
+export const GENERIC_CLI_BINARIES: Record<string, string> = {
+  'aider-cli': 'aider',
+  'amp-cli': 'amp',
+  'augment-cli': 'augment',
+  'adal-cli': 'adal',
+  'bob-cli': 'bob',
+  'cline-cli': 'cline',
+  'codebuddy-cli': 'codebuddy',
+  'command-code-cli': 'commandcode',
+  'continue-cli': 'continue',
+  'cortex-cli': 'cortex',
+  'crush-cli': 'crush',
+  'deepagents-cli': 'deepagents',
+  'firebender-cli': 'firebender',
+  'iflow-cli': 'iflow',
+  'junie-cli': 'junie',
+  'kilo-code-cli': 'kilocode',
+  'kimi-cli': 'kimi',
+  'kode-cli': 'kode',
+  'mcpjam-cli': 'mcpjam',
+  'mistral-vibe-cli': 'vibe',
+  'mux-cli': 'mux',
+  'neovate-cli': 'neovate',
+  'openhands-cli': 'openhands',
+  'pochi-cli': 'pochi',
+  'qoder-cli': 'qoder',
+  'replit-cli': 'replit',
+  'roo-code-cli': 'roo',
+  'trae-cn-cli': 'trae-cn',
+  'warp-cli': 'warp',
+  'windsurf-cli': 'windsurf',
+  'zencoder-cli': 'zencoder',
+}
+
+interface GenericCliOptions extends StreamChatOptions {
+  binaryName: string
+  displayName: string
+}
+
+/**
+ * Generic streamer for CLI providers without a bespoke stream parser.
+ *
+ * Spawns the configured binary with the prompt as the final argv, captures
+ * stdout/stderr line-by-line, and emits each line as a delta. No JSON event
+ * parsing — callers that need structured event streams should use a tool-
+ * specific provider instead.
+ */
+export function streamGenericCliChat(opts: GenericCliOptions): Promise<string> {
+  const { session, message, systemPrompt, write, active, signal, binaryName, displayName } = opts
+  const processTimeoutMs = loadRuntimeSettings().cliProcessTimeoutMs
+  const binary = resolveCliBinary(binaryName)
+  if (!binary) {
+    const msg = `${displayName} not found. Install \`${binaryName}\` and ensure it is on your PATH, or remove this provider.`
+    write(`data: ${JSON.stringify({ t: 'err', text: msg })}\n\n`)
+    return Promise.resolve('')
+  }
+
+  const env = buildCliEnv()
+  const prompt = systemPrompt ? `[System instructions]\n${systemPrompt}\n\n${message}` : message
+
+  log.info('generic-cli', `Spawning: ${binary}`, {
+    binaryName,
+    cwd: session.cwd,
+    hasSystemPrompt: Boolean(systemPrompt),
+    promptLength: prompt.length,
+  })
+
+  const proc = spawn(binary, [prompt], {
+    cwd: session.cwd,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: processTimeoutMs,
+  })
+
+  active.set(session.id, proc)
+  attachAbortHandler(proc, signal)
+
+  let fullResponse = ''
+  let buf = ''
+  let stderrText = ''
+
+  proc.stdout?.on('data', (chunk: Buffer) => {
+    buf += chunk.toString()
+    const lines = buf.split('\n')
+    buf = lines.pop() || ''
+    for (const line of lines) {
+      if (!line) continue
+      fullResponse += `${line}\n`
+      write(`data: ${JSON.stringify({ t: 'd', text: `${line}\n` })}\n\n`)
+    }
+  })
+
+  proc.stderr?.on('data', (chunk: Buffer) => {
+    const text = chunk.toString()
+    stderrText += text
+    if (stderrText.length > 16_000) stderrText = stderrText.slice(-16_000)
+    if (isStderrNoise(text)) {
+      log.debug('generic-cli', `stderr noise [${binaryName}/${session.id}]`, text.slice(0, 400))
+    } else {
+      log.warn('generic-cli', `stderr [${binaryName}/${session.id}]`, text.slice(0, 400))
+    }
+  })
+
+  return new Promise((resolve) => {
+    proc.on('close', (code, sig) => {
+      active.delete(session.id)
+      if (buf) {
+        fullResponse += buf
+        write(`data: ${JSON.stringify({ t: 'd', text: buf })}\n\n`)
+        buf = ''
+      }
+      if ((code ?? 0) !== 0 && !fullResponse.trim()) {
+        const msg = stderrText.trim()
+          ? `${displayName} exited with code ${code ?? 'unknown'}${sig ? ` (${sig})` : ''}: ${stderrText.trim().slice(0, 1200)}`
+          : `${displayName} exited with code ${code ?? 'unknown'}${sig ? ` (${sig})` : ''} and returned no output.`
+        write(`data: ${JSON.stringify({ t: 'err', text: msg })}\n\n`)
+      }
+      log.info('generic-cli', `Process closed [${binaryName}]: code=${code} signal=${sig} response=${fullResponse.length}chars`)
+      resolve(fullResponse.trim())
+    })
+
+    proc.on('error', (err) => {
+      active.delete(session.id)
+      write(`data: ${JSON.stringify({ t: 'err', text: err.message })}\n\n`)
+      resolve(fullResponse.trim())
+    })
+  })
+}