@astrale-os/cli 1.0.0-beta.8 → 1.0.0-npm-deprecated.0

package/studio/server/agent/harness/adapter.ts

@@ -1,171 +0,0 @@
-/**
- * harness/adapter.ts — the executable boundary implemented by each local agent
- * harness.
- *
- * A *harness* is whatever local AI agent does the edits (Claude Code, Codex, …).
- * The studio never talks to a model API directly; it shells out to the harness
- * the user already has running locally (no cloud API key of our own). Each
- * harness maps its native streaming output onto `AgentStreamEvent`s and returns
- * a final text blob (which carries the machine-state reply block).
- */
-import type {
-  AgentAccess,
-  AgentEffort,
-  AgentEventKind,
-  HarnessCapabilities,
-  HarnessLoadout,
-} from '../../../shared/types'
-
-/** A single normalized activity event emitted while the harness runs. */
-export interface AgentStreamEvent {
-  kind: AgentEventKind
-  text: string
-  tool?: string
-  target?: string
-}
-
-/** Harness-neutral description of one stdio MCP server. Each harness is
- * responsible for expressing this in its native CLI/config shape. */
-export interface HarnessMcpServer {
-  name: string
-  command: string
-  args?: string[]
-  env?: Record<string, string>
-  required?: boolean
-  /** Studio's run-scoped write-back tools are user-authorized by the submit. */
-  approvalMode?: 'auto' | 'prompt' | 'writes' | 'approve'
-  enabledTools?: string[]
-  /** In-process harnesses may invoke the same grant without spawning stdio. */
-  invoke?: (tool: string, args: Record<string, unknown>) => Promise<unknown>
-}
-
-export interface AgentTurnInput {
-  /** the domain repo root — the agent's working directory */
-  root: string
-  /** the turn message (scaffolded handoff / delta) */
-  prompt: string
-  /** appended to the harness's default system prompt — the reply protocol */
-  appendSystemPrompt?: string
-  /** prior harness session id → resume the same conversation */
-  sessionId?: string
-  /** explicit model override; absent preserves the harness's native config/default */
-  model?: string
-  /** harness reasoning effort for this turn */
-  effort?: AgentEffort
-  /** authority granted to the local harness */
-  access?: AgentAccess
-  /** generated MCP servers exposing Studio write-back */
-  mcpServers?: HarnessMcpServer[]
-  /** extra env merged into the harness CHILD process only. Never touches the
-   *  studio's own env or the user's shell/global harness process. */
-  env?: Record<string, string>
-  /** abort the turn (user pressed Cancel) */
-  signal: AbortSignal
-  /** called for every normalized activity event */
-  onEvent: (e: AgentStreamEvent) => void
-}
-
-export interface AgentTurnResult {
-  /** session id to persist for the next turn's resume */
-  sessionId?: string
-  /** the agent's final message text (parsed for the machine-state reply block) */
-  finalText: string
-  costUsd?: number
-  numTurns?: number
-  /** total token usage reported by the harness */
-  tokens?: number
-  isError: boolean
-  errorMessage?: string
-  /** the resume sessionId we passed was rejected by the harness (the conversation
-   *  no longer exists / expired). The runner uses this to transparently restart the
-   *  turn as a fresh conversation instead of failing — and to know it's safe to drop
-   *  the stored id (vs. keeping it across an unrelated transient failure). */
-  resumeRejected?: boolean
-}
-
-/** A quick, ephemeral "side question" — a FORK of the conversation that inherits
- *  the parent's context but writes nothing back to it (see agent/ask.ts). Streamed. */
-export interface AskInput {
-  root: string
-  /** the composed question (prefix + injected target context + the user's text) */
-  prompt: string
-  /** the ask protocol, appended to the harness default system prompt */
-  appendSystemPrompt?: string
-  /** the domain's live conversation session id to FORK from (undefined ⇒ fresh, no fork) */
-  sessionId?: string
-  /** explicit model override; absent preserves the harness's native config/default */
-  model?: string
-  /** harness reasoning effort for this side question */
-  effort?: AgentEffort
-  /** authority granted to the local harness */
-  access?: AgentAccess
-  /** extra env merged into the harness child only — see AgentTurnInput.env */
-  env?: Record<string, string>
-  signal: AbortSignal
-  /** called with each chunk of the answer as it streams in */
-  onDelta: (text: string) => void
-}
-
-export interface AskResult {
-  text: string
-  isError: boolean
-  errorMessage?: string
-}
-
-/** A richer install/health probe result for the UI (binary found? which version?). */
-export interface HarnessHealth {
-  ok: boolean
-  version?: string
-  /** the binary / command probed (so the user can fix PATH) */
-  bin?: string
-  /** human-readable reason when not ok */
-  detail?: string
-}
-
-export interface HarnessLoadoutOptions {
-  /** Child-only environment overrides used while probing the harness. */
-  env?: Record<string, string>
-  /** Studio's per-domain override for the selected harness. */
-  model?: string
-  /** Bypass the adapter's short-lived probe cache for an explicit user re-probe. */
-  refresh?: boolean
-}
-
-export interface AgentHarness {
-  /** stable id, e.g. 'claude' | 'mock' | 'codex' */
-  id: string
-  /** human label for the UI */
-  label: string
-  capabilities: HarnessCapabilities
-  /** is the underlying CLI/binary actually invokable here? */
-  isAvailable(signal?: AbortSignal): Promise<boolean>
-  /** optional: a richer install probe for the UI (version + reason). Harnesses that
-   *  omit it fall back to isAvailable(). */
-  health?(signal?: AbortSignal): Promise<HarnessHealth>
-  run(input: AgentTurnInput): Promise<AgentTurnResult>
-  /** optional: answer a quick forked side question (Ask). Harnesses without a
-   *  fork concept simply omit this; the studio falls back gracefully. */
-  ask?(input: AskInput): Promise<AskResult>
-  /** optional: report what the harness ACTUALLY loaded for `root` (skills, MCP,
-   *  tools, agents) — a read-only window into the agent for the Settings page.
-   *  Harnesses without an introspectable loadout omit it. `env` (e.g. a custom
-   *  model gateway) is merged into the probe child so the reported model reflects it. */
-  loadout?(root: string, options?: HarnessLoadoutOptions): Promise<HarnessLoadout>
-  /** optional: the raw SKILL.md for a skill command, so the UI can show it. */
-  skillContent?(
-    root: string,
-    command: string,
-  ): Promise<{ command: string; content: string; path: string } | null>
-}
-
-/** Normalize optional rich health probes into one route-facing result. */
-export async function inspectHarnessHealth(
-  harness: AgentHarness,
-  signal?: AbortSignal,
-): Promise<HarnessHealth> {
-  if (harness.health) return harness.health(signal)
-  return {
-    ok: await harness.isAvailable(signal),
-    bin: harness.id,
-  }
-}

package/studio/server/agent/harness/claude/adapter.test.ts

@@ -1,348 +0,0 @@
-import { afterEach, expect, test } from 'bun:test'
-import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { ClaudeCodeHarness } from './adapter'
-
-const roots: string[] = []
-
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function fakeClaude(root: string): string {
-  const file = join(root, 'fake-claude')
-  writeFileSync(
-    file,
-    `#!/usr/bin/env bun
-const fs = require('node:fs')
-const { spawn } = require('node:child_process')
-const args = process.argv.slice(2)
-if (args[0] === '--version') {
-  console.log('2.1.test')
-  process.exit(0)
-}
-if (process.env.FAKE_CLAUDE_LOG) {
-  fs.appendFileSync(process.env.FAKE_CLAUDE_LOG, JSON.stringify({ args }) + '\\n')
-}
-const modelAt = args.indexOf('--model')
-const model = modelAt >= 0 ? args[modelAt + 1] + '-resolved' : 'native-default'
-const resumedAt = args.indexOf('--resume')
-const session = resumedAt >= 0 ? args[resumedAt + 1] : 'fresh-session'
-const send = (event) => process.stdout.write(JSON.stringify(event) + '\\n')
-send({
-  type: 'system',
-  subtype: 'init',
-  session_id: session,
-  model,
-  permissionMode: 'bypassPermissions',
-  apiKeySource: 'none',
-  cwd: process.cwd(),
-  tools: ['Read', 'Edit'],
-  mcp_servers: [],
-  slash_commands: [],
-  agents: [],
-})
-let prompt = ''
-process.stdin.setEncoding('utf8')
-process.stdin.on('data', (chunk) => { prompt += chunk })
-process.stdin.on('end', () => {
-  if (prompt === '.') return setInterval(() => {}, 1000)
-  if (process.env.FAKE_CLAUDE_MODE === 'no-result') process.exit(0)
-  send({ type: 'assistant', message: { content: [{ type: 'text', text: 'answer' }] } })
-  if (process.env.FAKE_CLAUDE_MODE === 'text-then-crash') {
-    console.error('crashed after text')
-    process.exit(7)
-  }
-  if (process.env.FAKE_CLAUDE_MODE === 'result-error') {
-    send({ type: 'result', subtype: 'error_during_execution', is_error: true, result: 'failed' })
-    return
-  }
-  if (process.env.FAKE_CLAUDE_MODE === 'hang-ignore-term') {
-    process.on('SIGTERM', () => {})
-    const child = spawn(process.execPath, ['-e', "process.on('SIGTERM',()=>{});setInterval(()=>{},1000)"], {
-      stdio: 'ignore',
-    })
-    fs.writeFileSync(
-      process.env.FAKE_CLAUDE_PID_LOG,
-      JSON.stringify({ parent: process.pid, child: child.pid }),
-    )
-    return setInterval(() => {}, 1000)
-  }
-  send({
-    type: 'result',
-    subtype: 'success',
-    result: 'done',
-    session_id: session,
-    num_turns: 1,
-    usage: { input_tokens: 2, output_tokens: 3 },
-  })
-})
-`,
-  )
-  chmodSync(file, 0o755)
-  return file
-}
-
-function invocations(log: string): { args: string[] }[] {
-  return readFileSync(log, 'utf8')
-    .trim()
-    .split('\n')
-    .map((line) => JSON.parse(line))
-}
-
-async function waitFor(predicate: () => boolean, timeoutMs = 3_000): Promise<void> {
-  const deadline = Date.now() + timeoutMs
-  while (!predicate()) {
-    if (Date.now() >= deadline) throw new Error('condition did not become true before timeout')
-    await Bun.sleep(20)
-  }
-}
-
-function processExists(pid: number): boolean {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-test('Claude loadout probing reports and passes the Studio model override', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-claude-model-probe-'))
-  roots.push(root)
-  const log = join(root, 'claude.jsonl')
-  const harness = new ClaudeCodeHarness(fakeClaude(root))
-
-  const loadout = await harness.loadout(root, {
-    model: 'sonnet',
-    env: { FAKE_CLAUDE_LOG: log },
-  })
-
-  expect(loadout).toMatchObject({
-    ok: true,
-    model: 'sonnet-resolved',
-    modelSource: 'studio',
-  })
-  const args = invocations(log)[0].args
-  const modelAt = args.indexOf('--model')
-  expect(args.slice(modelAt, modelAt + 2)).toEqual(['--model', 'sonnet'])
-
-  await harness.loadout(root, {
-    model: 'sonnet',
-    env: { FAKE_CLAUDE_LOG: log },
-  })
-  expect(invocations(log)).toHaveLength(1)
-  await harness.loadout(root, {
-    model: 'sonnet',
-    env: { FAKE_CLAUDE_LOG: log },
-    refresh: true,
-  })
-  expect(invocations(log)).toHaveLength(2)
-})
-
-test('Claude turns and Ask calls carry selected models and native effort modes', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-claude-model-turns-'))
-  roots.push(root)
-  const log = join(root, 'claude.jsonl')
-  const harness = new ClaudeCodeHarness(fakeClaude(root))
-  const signal = new AbortController().signal
-
-  const normal = await harness.run({
-    root,
-    prompt: 'normal turn',
-    model: 'sonnet',
-    effort: 'ultracode',
-    access: 'full',
-    env: { FAKE_CLAUDE_LOG: log },
-    signal,
-    onEvent: () => {},
-  })
-  expect(normal).toMatchObject({
-    sessionId: 'fresh-session',
-    finalText: 'done',
-    isError: false,
-  })
-
-  const resumed = await harness.run({
-    root,
-    prompt: 'resumed turn',
-    sessionId: 'parent-session',
-    model: 'opus',
-    effort: 'max',
-    access: 'full',
-    env: { FAKE_CLAUDE_LOG: log },
-    signal,
-    onEvent: () => {},
-  })
-  expect(resumed).toMatchObject({
-    sessionId: 'parent-session',
-    finalText: 'done',
-    isError: false,
-  })
-
-  const fresh = await harness.ask({
-    root,
-    prompt: 'fresh ask',
-    model: 'fable',
-    effort: 'max',
-    access: 'workspace',
-    env: { FAKE_CLAUDE_LOG: log },
-    signal,
-    onDelta: () => {},
-  })
-  const forked = await harness.ask({
-    root,
-    prompt: 'forked ask',
-    sessionId: 'parent-session',
-    model: 'sonnet',
-    effort: 'max',
-    access: 'workspace',
-    env: { FAKE_CLAUDE_LOG: log },
-    signal,
-    onDelta: () => {},
-  })
-  expect(fresh).toEqual({ text: 'done', isError: false })
-  expect(forked).toEqual({ text: 'done', isError: false })
-
-  const [normalArgs, resumedArgs, freshArgs, forkArgs] = invocations(log).map((entry) => entry.args)
-  expect(normalArgs).not.toContain('--resume')
-  expect(
-    normalArgs.slice(normalArgs.indexOf('--model'), normalArgs.indexOf('--model') + 2),
-  ).toEqual(['--model', 'sonnet'])
-  expect(
-    resumedArgs.slice(resumedArgs.indexOf('--resume'), resumedArgs.indexOf('--resume') + 2),
-  ).toEqual(['--resume', 'parent-session'])
-  expect(
-    resumedArgs.slice(resumedArgs.indexOf('--model'), resumedArgs.indexOf('--model') + 2),
-  ).toEqual(['--model', 'opus'])
-  expect(freshArgs.slice(freshArgs.indexOf('--model'), freshArgs.indexOf('--model') + 2)).toEqual([
-    '--model',
-    'fable',
-  ])
-  expect(freshArgs).not.toContain('--resume')
-  expect(forkArgs.slice(forkArgs.indexOf('--model'), forkArgs.indexOf('--model') + 2)).toEqual([
-    '--model',
-    'sonnet',
-  ])
-  expect(forkArgs.slice(forkArgs.indexOf('--resume'), forkArgs.indexOf('--resume') + 3)).toEqual([
-    '--resume',
-    'parent-session',
-    '--fork-session',
-  ])
-  const normalEffortAt = normalArgs.indexOf('--effort')
-  expect(normalArgs.slice(normalEffortAt, normalEffortAt + 2)).toEqual(['--effort', 'xhigh'])
-  const settingsAt = normalArgs.indexOf('--settings')
-  expect(normalArgs.slice(settingsAt, settingsAt + 2)).toEqual(['--settings', '{"ultracode":true}'])
-  expect(normalArgs).not.toContain('ultracode')
-
-  for (const args of [resumedArgs, freshArgs, forkArgs]) {
-    const effortAt = args.indexOf('--effort')
-    expect(args.slice(effortAt, effortAt + 2)).toEqual(['--effort', 'max'])
-  }
-})
-
-test('Claude turns and Ask reject incomplete terminal protocols', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-claude-terminal-'))
-  roots.push(root)
-  const harness = new ClaudeCodeHarness(fakeClaude(root))
-  const input = {
-    root,
-    prompt: 'work',
-    signal: new AbortController().signal,
-    onEvent: () => {},
-  }
-
-  const noResult = await harness.run({
-    ...input,
-    env: { FAKE_CLAUDE_MODE: 'no-result' },
-  })
-  expect(noResult).toMatchObject({
-    isError: true,
-    errorMessage: 'claude exited without a result event',
-  })
-
-  const crashed = await harness.run({
-    ...input,
-    env: { FAKE_CLAUDE_MODE: 'text-then-crash' },
-  })
-  expect(crashed).toMatchObject({
-    isError: true,
-    errorMessage: expect.stringContaining('claude exited 7'),
-  })
-
-  const askInput = {
-    root,
-    prompt: 'question',
-    signal: new AbortController().signal,
-    onDelta: () => {},
-  }
-  const askNoResult = await harness.ask({
-    ...askInput,
-    env: { FAKE_CLAUDE_MODE: 'no-result' },
-  })
-  expect(askNoResult).toMatchObject({
-    isError: true,
-    errorMessage: 'claude exited without a result event',
-  })
-
-  const askCrashed = await harness.ask({
-    ...askInput,
-    env: { FAKE_CLAUDE_MODE: 'text-then-crash' },
-  })
-  expect(askCrashed).toMatchObject({
-    isError: true,
-    errorMessage: expect.stringContaining('claude exited 7'),
-  })
-
-  const askTerminalError = await harness.ask({
-    ...askInput,
-    env: { FAKE_CLAUDE_MODE: 'result-error' },
-  })
-  expect(askTerminalError).toEqual({
-    text: 'failed',
-    isError: true,
-    errorMessage: 'error_during_execution',
-  })
-})
-
-test('Claude Ask cancellation kills the entire stubborn subprocess group', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'studio-claude-ask-cancel-'))
-  roots.push(root)
-  const pidLog = join(root, 'pids.json')
-  const controller = new AbortController()
-  const resultPromise = new ClaudeCodeHarness(fakeClaude(root)).ask({
-    root,
-    prompt: 'question',
-    env: {
-      FAKE_CLAUDE_MODE: 'hang-ignore-term',
-      FAKE_CLAUDE_PID_LOG: pidLog,
-    },
-    signal: controller.signal,
-    onDelta: () => {},
-  })
-
-  let pids: { parent: number; child: number } | undefined
-  await waitFor(() => {
-    if (!existsSync(pidLog)) return false
-    try {
-      pids = JSON.parse(readFileSync(pidLog, 'utf8')) as { parent: number; child: number }
-      return Number.isInteger(pids.parent) && Number.isInteger(pids.child)
-    } catch {
-      return false
-    }
-  })
-  if (!pids) throw new Error('fake Claude did not publish complete process evidence')
-  const processIds = pids
-  expect(processExists(processIds.parent)).toBe(true)
-  expect(processExists(processIds.child)).toBe(true)
-  controller.abort()
-
-  expect(await resultPromise).toEqual({
-    text: '',
-    isError: true,
-    errorMessage: 'canceled',
-  })
-  await waitFor(() => !processExists(processIds.parent) && !processExists(processIds.child))
-})

package/studio/server/agent/harness/claude/adapter.ts

@@ -1,71 +0,0 @@
-import type { HarnessLoadout } from '../../../../shared/types'
-import type {
-  AgentHarness,
-  AgentTurnInput,
-  AgentTurnResult,
-  AskInput,
-  HarnessHealth,
-  HarnessLoadoutOptions,
-} from '../adapter'
-
-import { readSkillContent } from '../skills'
-import { runClaudeAsk } from './ask'
-import { CLAUDE_CAPABILITIES } from './capabilities'
-import { runClaudeTurn } from './events'
-import { loadClaudeConfiguration, probeClaudeHealth } from './loadout'
-import { scanClaudeSkills } from './skills'
-
-const DEFAULT_BIN = process.env.DOMAIN_STUDIO_CLAUDE_BIN || 'claude'
-
-export class ClaudeCodeHarness implements AgentHarness {
-  id = 'claude'
-  label = 'Claude Code (local)'
-  capabilities = CLAUDE_CAPABILITIES
-
-  private availCache?: { at: number; health: HarnessHealth }
-  private loadoutCache?: { at: number; key: string; data: HarnessLoadout }
-
-  constructor(private readonly bin = DEFAULT_BIN) {}
-
-  async health(signal?: AbortSignal): Promise<HarnessHealth> {
-    const now = Date.now()
-    if (this.availCache && now - this.availCache.at < 30_000) return this.availCache.health
-    const health = await probeClaudeHealth(this.bin, signal)
-    if (!signal?.aborted) this.availCache = { at: now, health }
-    return health
-  }
-
-  async isAvailable(signal?: AbortSignal): Promise<boolean> {
-    return (await this.health(signal)).ok
-  }
-
-  async loadout(root: string, options?: HarnessLoadoutOptions): Promise<HarnessLoadout> {
-    const now = Date.now()
-    const key = `${root}\u0000${options?.model ?? ''}\u0000${JSON.stringify(options?.env ?? {})}`
-    if (
-      !options?.refresh &&
-      this.loadoutCache &&
-      this.loadoutCache.key === key &&
-      now - this.loadoutCache.at < 60_000
-    )
-      return this.loadoutCache.data
-    const data = await loadClaudeConfiguration(this.bin, root, options)
-    this.loadoutCache = { at: now, key, data }
-    return data
-  }
-
-  async skillContent(
-    root: string,
-    command: string,
-  ): Promise<{ command: string; content: string; path: string } | null> {
-    return readSkillContent(scanClaudeSkills(root), command)
-  }
-
-  run(input: AgentTurnInput): Promise<AgentTurnResult> {
-    return runClaudeTurn(this.bin, input)
-  }
-
-  ask(input: AskInput) {
-    return runClaudeAsk(this.bin, input)
-  }
-}

package/studio/server/agent/harness/claude/ask.ts

@@ -1,114 +0,0 @@
-import { spawn } from 'node:child_process'
-
-import type { AskInput, AskResult } from '../adapter'
-
-import { childEnvironment, terminateProcessTree } from '../process'
-import { buildClaudeAskArgs } from './command'
-
-/** Execute one ephemeral Claude side-question stream. */
-export function runClaudeAsk(bin: string, input: AskInput): Promise<AskResult> {
-  return new Promise((resolve) => {
-    let finalText = ''
-    let stderr = ''
-    let isError = false
-    let errorMessage: string | undefined
-    let sawResult = false
-    let settled = false
-    let forceKillTimer: ReturnType<typeof setTimeout> | undefined
-    let onAbort = () => {}
-    const finish = (result: AskResult) => {
-      if (settled) return
-      settled = true
-      if (forceKillTimer) clearTimeout(forceKillTimer)
-      input.signal.removeEventListener('abort', onAbort)
-      resolve(result)
-    }
-
-    let child: ReturnType<typeof spawn>
-    try {
-      child = spawn(bin, buildClaudeAskArgs(input), {
-        cwd: input.root,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: childEnvironment(input.env),
-        detached: process.platform !== 'win32',
-      })
-    } catch (error) {
-      finish({
-        text: finalText,
-        isError: true,
-        errorMessage: `failed to spawn ${bin}: ${String(error)}`,
-      })
-      return
-    }
-    onAbort = () => {
-      terminateProcessTree(child)
-      forceKillTimer = setTimeout(() => terminateProcessTree(child, 'SIGKILL'), 2_000)
-      forceKillTimer.unref?.()
-    }
-    if (input.signal.aborted) onAbort()
-    else input.signal.addEventListener('abort', onAbort, { once: true })
-    child.stdin?.write(input.prompt)
-    child.stdin?.end()
-
-    const handleLine = (line: string) => {
-      let event: any
-      try {
-        event = JSON.parse(line)
-      } catch {
-        return
-      }
-      if (event.type === 'assistant' && Array.isArray(event.message?.content)) {
-        for (const block of event.message.content)
-          if (block.type === 'text' && block.text) input.onDelta(block.text)
-      } else if (event.type === 'result') {
-        sawResult = true
-        if (typeof event.result === 'string') finalText = event.result
-        if (
-          event.is_error ||
-          event.subtype === 'error_during_execution' ||
-          event.subtype === 'error_max_turns'
-        ) {
-          isError = true
-          errorMessage = event.subtype || 'ask error'
-        }
-      }
-    }
-    let buffer = ''
-    child.stdout?.setEncoding('utf8')
-    child.stdout?.on('data', (chunk: string) => {
-      buffer += chunk
-      let newline: number
-      while ((newline = buffer.indexOf('\n')) >= 0) {
-        const line = buffer.slice(0, newline).trim()
-        buffer = buffer.slice(newline + 1)
-        if (line) handleLine(line)
-      }
-    })
-    child.stderr?.setEncoding('utf8')
-    child.stderr?.on('data', (chunk: string) => {
-      stderr += chunk
-    })
-    child.on('error', (error) =>
-      finish({
-        text: finalText,
-        isError: true,
-        errorMessage: `failed to spawn ${bin}: ${error.message}`,
-      }),
-    )
-    child.on('close', (code) => {
-      const trailing = buffer.trim()
-      if (trailing) handleLine(trailing)
-      if (input.signal.aborted)
-        return finish({ text: finalText, isError: true, errorMessage: 'canceled' })
-      if (code !== 0) {
-        isError = true
-        errorMessage =
-          errorMessage || `claude exited ${code}${stderr ? `: ${stderr.slice(-300)}` : ''}`
-      } else if (!sawResult) {
-        isError = true
-        errorMessage = 'claude exited without a result event'
-      }
-      finish({ text: finalText, isError, errorMessage })
-    })
-  })
-}