martty 0.2.33 → 0.2.35

package/README.md

@@ -64,24 +64,121 @@ profiles remain compatible.
 The profile Host mounts the ACP plugin on Base, then starts a separate TUI
 Client process over standard ACP stdin/stdout. For standalone use, run
 `martty` and use `--agent <cmd>` plus repeated `--agent-arg <arg>` for another
-ACP server. Named standalone harnesses can also be discovered, saved, and selected:
+ACP server.
+
+### Harness CLI quick start
+
+Run these commands in a system terminal. Browse first and replace `<id>` with the ID printed
+by `find`, not the display name. The angle brackets are placeholders, not literal shell input.
+
+```sh
+martty harness find         # Browse Registry and local candidates
+martty harness add <id>     # Install/save configuration
+martty harness use <id>     # Set the next-launch default
+martty                     # Start the TUI in the current directory
+```
+
+`add` and `use` do not switch a running TUI; use `/harness` inside it to switch now.
+To inspect, refresh, or remove configuration:
 
 ```sh
 martty harness list
-martty harness add local --command local-acp --arg --stdio
-martty harness use local
+martty harness find --refresh
+martty harness remove <id> --cleanup --dry-run  # Preview only
+martty harness remove <id>                     # Confirm configuration-only removal
+martty harness remove <id> --cleanup           # Also delete exclusive private binaries
 ```
 
+In a source checkout where `martty` is not on PATH, run `node npm/bin/martty.js harness --help`
+from the repository root and use that entrypoint in place of `martty` in the other commands.
+For an unlisted ACP server, use `martty harness add local --command /absolute/path/to/local-acp
+--arg --stdio`, replacing the path and arguments with your server's actual ACP invocation.
+
+### Registry and TUI setup
+
+`harness find` reads a cached/bundled snapshot of the official ACP Registry from
+`https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json` and supplements it
+with local `*-acp` / `*_acp` PATH discovery; it is not an npm package search or an immediate
+switch. `npx` / `uvx` entries become launch recipes without implicit `--yes` or
+`--prefer-offline` flags. Selecting a binary distribution downloads it into
+`$MARTTY_HOME/bin/<id>/<version>/<platform>`, verifies its declared SHA-256, and configures
+the resulting executable without modifying the system PATH. The same flow is available in
+the TUI with `/harness find`; manual `--command` remains available for unregistered agents.
+Use `harness find --refresh` for a network refresh; offline refresh keeps the local catalog.
+CLI `add` only installs/saves configuration and reuses saved recipes; `use` sets the next-launch
+default without starting/authenticating an agent. `harness remove <id>` previews and confirms
+configuration removal; `--cleanup` also removes exclusive private binary resources, `--dry-run`
+only previews, and `--yes` confirms in scripts. Global programs, shared caches, history and
+credentials are kept. Stop other instances using the target before cleanup. Downloads report
+progress to stderr, and Ctrl-C cancels and clears staging without saving incomplete configuration.
+Windows uses `%MARTTY_HOME%\bin\<id>\<version>\<platform>` (`windows-x86_64` or `windows-aarch64`) and
+resolves package runners through `PATHEXT` (`npx.cmd`, `uvx.exe`, and similar launchers).
+When a record also has a binary for the current platform, missing npx/uvx falls back to the
+managed binary installer. Package-only records explain how to install Node.js/npm or uv and
+are not persisted until their runner is available.
+Run `harness find` without a query to browse the full catalog; users do not need to know an
+agent name in advance. Query text is only an optional filter, and every unconfigured CLI result
+prints the corresponding `martty harness add <id>` command.
+
+### Harness TUI workflow
+
+Run `/harness` inside Martty. The current item is pinned first and disabled; selecting another
+configured item uses the normal switch flow. Choose **+ Add Harness…** to browse/search the Registry.
+Press Delete on a saved, non-current item in the switch menu to remove configuration and optionally
+exclusive private binaries. Escape returns from removal confirmation to removal mode, then to the
+list, preserving selection. Use `/auth` for sign-in and `/status` to inspect runtime state.
+Error panels show the reason and diagnostics directly; Enter retries.
+
+In the TUI, choose **+ Add Harness** from `/harness` or run `/harness add` to open the
+searchable catalog. Verified local npm/uv programs are reused where possible. Missing
+dependencies offer installation guidance and recheck; Registry failures keep local choices.
+Local discovery runs off the UI event loop alongside the Registry request. The picker
+fills progressively, keeping search and selection, with non-selectable dividers for
+`Installed / configured` and `Not downloaded`. A saved recipe is not proof that its
+package has already been downloaded. Binary transfers time out only on connection
+failure or lack of progress, not on total download duration.
+Binary transfer uses `node-downloader-helper` in the existing Node.js client;
+no separate downloader executable is required. Failed transfers can be retried
+from the panel; partial downloads are cleaned up, not resumed across restarts.
+npx/uvx preparation and binary downloads run in a progress panel. Enter keeps unfinished
+downloads open; Escape hides the panel and continues in the background while Martty stays
+open. Completion/failure is announced in the composer. Installation automatically saves
+configuration; Enter on completion uses the normal `/harness` switch flow, while Escape only
+closes the panel and Enter retries failures. Add/Install/Connect do not automatically switch or
+authenticate. Press Enter on completion or select the configured Harness from `/harness`
+to switch. Quitting stops unfinished jobs.
+Installer output is captured, never written over the terminal. A switch updates
+the default only after ACP `initialize` and `session/new` succeed, with retry on failure.
+
+From a source checkout, `node scripts/harness-discovery-scenario.mjs --check` creates
+and probes six isolated discovery states. Use `--tui` to open them in the local Martty
+binary, then `/harness add`. The fixture uses a private temporary directory and fake
+ACP replies; no real model, package download, or user Harness settings are used.
+
 The same registry is available through three entry points: edit
 `$MARTTY_HOME/settings.json`, use `martty harness`, or run `/harness` (or
-`/harness <id>`) inside the TUI. A saved choice takes effect on the next
-standalone launch, which starts a fresh ACP session. It does not replace a
-running or profile-owned Host, and it never carries a session across Harnesses.
-
-The selected entry is stored in `$MARTTY_HOME/settings.json` and takes effect
-on the next standalone launch through a new `session/new`. `--agent` and
-`DSH_TUI_AGENT` remain higher priority. This does not replace the Host-owned
-runtime or session of `dsh --profile martty`.
+`/harness <id>`) inside the TUI. In a standalone TUI, `/harness` immediately
+switches before the current session has started. After the first prompt has
+started a session, or an existing session was loaded, it first confirms that
+the selected Harness will start another session; the current session remains
+available in `/session`. Confirming stops the current ACP child and initializes
+the selected Harness without closing Martty, then immediately sends `session/new`
+to bind an empty session. This does not start a model turn. It never carries one session
+across Harnesses. The settings and CLI entry points select the Harness for the
+next standalone launch; a profile-owned Host cannot be replaced by its Client.
+
+Every selection is stored in `$MARTTY_HOME/settings.json` as `defaultHarness`. CLI/settings
+selection takes effect on the next standalone launch; TUI selection also
+updates the running standalone process immediately. Standalone startup only
+initializes the selected Harness and binds an empty ACP session before showing Ready.
+The product's internal `forcedHarness` initialization value is empty by
+default and is not a CLI/user startup argument. When the product supplies it,
+startup selects it before consulting the persisted `defaultHarness`; when
+empty, startup uses that saved default and otherwise the bundled fallback.
+`/harness` updates the saved `defaultHarness`, never the product forced value.
+`--agent` and `DSH_TUI_AGENT` remain higher startup priorities.
+None of these replace the Host-owned runtime or session of
+`dsh --profile martty`.
 
 The Node Client process owns a Cordis tree and starts the Rust painter. A sibling
 `tui-cordis-client-runner` publishes TUI Client capabilities and evaluates

package/bin/martty.js

@@ -4,9 +4,10 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
+import { createInterface } from 'node:readline/promises'
 import { resolveDependencyStack } from '../lib/agent.js'
 import { bootClient, parseClientArgv, painterArgs, uiSettingsPath } from '../lib/boot.js'
-import { runHarnessCommand } from '../lib/harnesses.js'
+import { runHarnessCommandAsync } from '../lib/harnesses.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const platformKey = process.platform + '-' + process.arch
@@ -35,6 +36,18 @@ const wantHelp = argv.includes('-h') || argv.includes('--help')
 const wantVersion = argv.includes('-V') || argv.includes('--version')
 
 if (argv[0] === 'harness') {
+  const controller = new AbortController()
+  let interrupted = 0
+  const interrupt = (code) => {
+    interrupted = code
+    controller.abort(new Error('Harness operation cancelled'))
+  }
+  const onInterrupt = () => interrupt(130)
+  const onTerminate = () => interrupt(143)
+  process.on('SIGINT', onInterrupt)
+  process.on('SIGTERM', onTerminate)
+  let lastPhase, lastProgress = 0
+  let exitCode = 0
   let defaults = []
   try {
     const agent = resolveDependencyStack()
@@ -48,16 +61,51 @@ if (argv[0] === 'harness') {
     // Source checkouts without installed dependencies still list PATH entries.
   }
   try {
-    const result = runHarnessCommand(argv.slice(1), {
+    const result = await runHarnessCommandAsync(argv.slice(1), {
       settingsPath: uiSettingsPath(),
       defaults,
+      columns: process.stdout.columns,
+      color: process.stdout.isTTY && process.env.NO_COLOR === undefined,
+      cwd: process.cwd(),
+      signal: controller.signal,
+      onProgress({ phase, receivedBytes }) {
+        const now = Date.now()
+        if (phase === lastPhase && now - lastProgress < 1000) return
+        lastPhase = phase; lastProgress = now
+        process.stderr.write(`Harness install: ${phase}${Number.isFinite(receivedBytes) ? ` · ${receivedBytes} bytes` : ''}\n`)
+      },
+      ...(process.stdin.isTTY && process.stderr.isTTY ? { async confirmRemoval(preview) {
+        process.stderr.write(preview)
+        const prompt = createInterface({ input: process.stdin, output: process.stderr })
+        prompt.once('SIGINT', onInterrupt)
+        try {
+          const closed = new Promise(resolve => prompt.once('close', () => resolve('')))
+          const answer = await Promise.race([prompt.question('Remove this Harness? [y/N] ', { signal: controller.signal }), closed])
+          return /^y(es)?$/i.test(answer.trim())
+        } finally { prompt.close() }
+      } } : {}),
     })
     if (result.stdout) process.stdout.write(result.stdout)
     if (result.stderr) process.stderr.write(result.stderr)
-    process.exit(result.code)
+    exitCode = interrupted || result.code
   } catch (error) {
     console.error(`martty harness: ${error instanceof Error ? error.message : String(error)}`)
-    process.exit(1)
+    exitCode = interrupted || (Number.isInteger(error?.exitCode) ? error.exitCode : 1)
+  } finally {
+    process.removeListener('SIGINT', onInterrupt)
+    process.removeListener('SIGTERM', onTerminate)
+  }
+  process.exit(exitCode)
+}
+
+// Validate startup arguments before resolving the native painter. A source
+// checkout must report the same usage errors as an installed package.
+let parsed
+if (!wantHelp && !wantVersion && !wantDemo && !wantDemoSkin) {
+  try { parsed = parseClientArgv(argv) }
+  catch (error) {
+    console.error(`martty: ${error instanceof Error ? error.message : String(error)}`)
+    process.exit(Number.isInteger(error?.exitCode) ? error.exitCode : 1)
   }
 }
 
@@ -108,5 +156,4 @@ if (wantDemoSkin) {
 }
 
 process.env.MARTTY_BIN ??= binaryPath
-const parsed = parseClientArgv(argv)
 await bootClient({ agent: parsed.agent, extraArgs: painterArgs(parsed) })

package/lib/acp-client.js

@@ -6,11 +6,13 @@
  * Switching agents is `{ command, args }` (or `config.stream`).
  */
 
-import { spawn } from 'node:child_process'
+import spawn from 'cross-spawn'
+import { PassThrough } from 'node:stream'
 import { installAcpClientEvents } from './acp-client-events.js'
 import { installAcpSessionConfig } from './acp-session-config.js'
 import { installAcpSessionPlan } from './acp-session-plan.js'
 import { installAcpSessionStats } from './acp-session-stats.js'
+import { tokenizeCommandArgs } from './command-args.js'
 
 export { installAcpSessionConfig } from './acp-session-config.js'
 export { installAcpSessionPlan } from './acp-session-plan.js'
@@ -20,7 +22,7 @@ export { installAcpClientEvents } from './acp-client-events.js'
 export const name = 'acp-client'
 export const inject = []
 
-/** @type {null | { command: string, args: string[], child: import('node:child_process').ChildProcess, stdin: import('node:stream').Writable, stdout: import('node:stream').Readable, kind: 'spawn' }} */
+/** @type {null | { command: string, args: string[], env?: Record<string, string>, child: import('node:child_process').ChildProcess, stdin: import('node:stream').Writable, stdout: import('node:stream').Readable, kind: 'spawn' }} */
 let liveAgent = null
 
 /**
@@ -50,7 +52,8 @@ export function resolveAgent(config = {}) {
   }
   const envCmd = process.env.DSH_TUI_AGENT
   if (typeof envCmd === 'string' && envCmd.trim().length > 0) {
-    const tokens = envCmd.trim().split(/\s+/)
+    const tokens = tokenizeCommandArgs(envCmd)
+    if (!tokens[0]) throw new Error('DSH_TUI_AGENT needs a non-empty command')
     return { command: tokens[0], args: tokens.slice(1) }
   }
   return { command: 'dsh-acp', args: [] }
@@ -84,6 +87,7 @@ export function apply(ctx, config = {}) {
     && liveAgent.child.exitCode === null
     && liveAgent.command === agent.command
     && JSON.stringify(liveAgent.args) === JSON.stringify(agent.args ?? [])
+    && JSON.stringify(liveAgent.env ?? {}) === JSON.stringify(agent.env ?? {})
   ) {
     provide(ctx, liveAgent)
     return
@@ -97,43 +101,315 @@ export function apply(ctx, config = {}) {
     }
   }
   liveAgent = null
+  const service = createSpawnService(agent)
+  liveAgent = service
+  provide(ctx, service)
+}
+
+function spawnAgent(agent) {
   const child = spawn(agent.command, agent.args ?? [], {
-    stdio: ['pipe', 'pipe', 'inherit'],
+    stdio: ['pipe', 'pipe', 'pipe'],
     env: { ...process.env, ...(agent.env ?? {}) },
   })
   child.stdin.on('error', () => {})
   child.stdout.on('error', () => {})
-  child.on('error', (err) => {
-    // A failed spawn (ENOENT, EACCES) emits 'error' on the child; without a
-    // listener it is an uncaught exception. Surface EOF to the transport
-    // instead so pending requests fail instead of hanging, and drop the
-    // cached handle so the next apply() retries the spawn.
-    console.error(`acp-client: failed to spawn agent ${agent.command}: ${err.message}`)
-    if (liveAgent?.child === child) liveAgent = null
-    child.stdin.destroy()
-    child.stdout.destroy()
-  })
-  const service = {
+  const diagnostics = drainDiagnostics(child.stderr)
+  return {
     kind: 'spawn',
     command: agent.command,
     args: agent.args ?? [],
+    ...(agent.env !== undefined ? { env: { ...agent.env } } : {}),
     stdin: child.stdin,
     stdout: child.stdout,
+    diagnostics,
     child,
   }
-  liveAgent = service
-  provide(ctx, service)
-  if (liveAgentExitHook !== null) {
-    process.removeListener('exit', liveAgentExitHook)
+}
+
+function drainDiagnostics(stream) {
+  const limit = 8192
+  let tail = Buffer.alloc(0)
+  let state = 'text'
+  // stderr is not a UI surface. Drain it even without a diagnostics consumer,
+  // strip control strings incrementally, and never retain their payloads.
+  stream.setEncoding('utf8')
+  stream.on('error', () => {})
+  stream.on('data', (chunk) => {
+    let text = ''
+    for (const char of chunk) {
+      const code = char.codePointAt(0)
+      if (state === 'osc' || state === 'string') {
+        if (code === 0x9c || (state === 'osc' && code === 7)) state = 'text'
+        else if (code === 27) state += '-escape'
+        continue
+      }
+      if (state === 'osc-escape' || state === 'string-escape') {
+        if (char === '\\' || code === 0x9c || (state === 'osc-escape' && code === 7)) state = 'text'
+        else if (code !== 27) state = state.replace('-escape', '')
+        continue
+      }
+      if (code === 27) { state = 'escape'; continue }
+      if (state === 'escape') {
+        if (char === '[') state = 'csi'
+        else if (char === ']') state = 'osc'
+        else if (['P', 'X', '^', '_'].includes(char)) state = 'string'
+        else state = code >= 0x20 && code <= 0x2f ? 'intermediate' : 'text'
+        continue
+      }
+      if (state === 'csi' || state === 'intermediate') {
+        if (code >= (state === 'csi' ? 0x40 : 0x30) && code <= 0x7e) state = 'text'
+        continue
+      }
+      if (code === 0x9b) { state = 'csi'; continue }
+      if (code === 0x9d) { state = 'osc'; continue }
+      if ([0x90, 0x98, 0x9e, 0x9f].includes(code)) { state = 'string'; continue }
+      if ((code < 0x20 && code !== 10) || (code >= 0x7f && code <= 0x9f)) continue
+      text += char
+    }
+    if (text.length === 0) return
+    const combined = Buffer.concat([tail, Buffer.from(text)])
+    let start = Math.max(0, combined.length - limit)
+    // Never split a UTF-8 code point or retain the large incoming allocation.
+    while (start < combined.length && (combined[start] & 0xc0) === 0x80) start++
+    tail = Buffer.from(combined.subarray(start))
+  })
+  return () => tail.toString('utf8').trim()
+}
+
+function diagnosticError(error, handle) {
+  if (typeof error?.diagnostics === 'string') return error
+  const diagnostics = handle.diagnostics()
+  if (!diagnostics) return error
+  return Object.assign(new Error(`${error.message}\nAgent stderr:\n${diagnostics}`, { cause: error }), {
+    ...error, diagnostics,
+  })
+}
+
+function waitForSpawn(handle) {
+  if (handle.child.pid !== undefined) return Promise.resolve()
+  return new Promise((resolve, reject) => {
+    const spawned = () => {
+      handle.child.off('error', failed)
+      resolve()
+    }
+    const failed = (error) => {
+      handle.child.off('spawn', spawned)
+      reject(error)
+    }
+    handle.child.once('spawn', spawned)
+    handle.child.once('error', failed)
+  })
+}
+
+function createSpawnService(agent) {
+  const input = new PassThrough()
+  const output = new PassThrough()
+  const switchListeners = new Set()
+  const failureListeners = new Set()
+  let current = spawnAgent(agent)
+  let closed = false
+  let pendingSwitch
+  let hasSwitched = false
+
+  const attach = (handle) => {
+    input.pipe(handle.stdin, { end: false })
+    handle.stdout.pipe(output, { end: false })
+  }
+  const detach = (handle) => {
+    input.unpipe(handle.stdin)
+    handle.stdout.unpipe(output)
+  }
+  attach(current)
+
+  const service = {
+    kind: 'spawn',
+    command: current.command,
+    args: current.args,
+    ...(current.env !== undefined ? { env: current.env } : {}),
+    stdin: input,
+    stdout: output,
+    child: current.child,
+    diagnostics() { return current.diagnostics() },
+    onSwitch(listener) {
+      if (typeof listener !== 'function') throw new Error('acpClient.onSwitch needs a function')
+      switchListeners.add(listener)
+      return () => switchListeners.delete(listener)
+    },
+    onFailure(listener) {
+      if (typeof listener !== 'function') throw new Error('acpClient.onFailure needs a function')
+      failureListeners.add(listener)
+      return () => failureListeners.delete(listener)
+    },
+    observeClient(message) {
+      if (pendingSwitch === undefined || message?.id === undefined) return
+      if (!['initialize', 'authenticate', 'session/new'].includes(message.method)) return
+      pendingSwitch.requests.set(message.id, message.method)
+      // Browser/device sign-in is user-driven, not a machine setup operation.
+      if (message.method === 'authenticate') pendingSwitch.pause()
+      else pendingSwitch.arm()
+    },
+    observeAgent(message) {
+      const pending = pendingSwitch
+      if (pending === undefined || message?.id === undefined) return
+      const method = pending.requests.get(message.id)
+      if (method === undefined) return
+      pending.requests.delete(message.id)
+      if (message.error !== undefined) {
+        // Authentication is user-driven; do not time out while an auth form is open.
+        if (method !== 'initialize' && message.error?.code === -32000) {
+          pending.pause()
+          return
+        }
+        pending.reject(Object.assign(new Error(`${method}: ${message.error?.message ?? 'ACP setup failed'}`), {
+          method, acpError: structuredClone(message.error),
+        }))
+        return
+      }
+      if (method === 'initialize') {
+        if (!Number.isInteger(message.result?.protocolVersion)) {
+          pending.reject(new Error('initialize: invalid ACP response'))
+          return
+        }
+        pending.initialized = true
+        pending.server = message.result?.agentInfo?.name
+      } else if (method === 'authenticate') {
+        // Once sign-in returns, the ensuing session/new must finish promptly.
+        pending.arm()
+      } else if (method === 'session/new') {
+        const sessionId = message.result?.sessionId
+        if (!pending.initialized || typeof sessionId !== 'string' || sessionId.length === 0) {
+          pending.reject(new Error('session/new: invalid ACP session response'))
+          return
+        }
+        pending.resolve({
+          sessionId,
+          ...(typeof pending.server === 'string' ? { server: pending.server } : {}),
+        })
+      }
+    },
+    async switchAgent(nextAgent, { timeoutMs = 20 * 60_000 } = {}) {
+      if (closed) throw new Error('acpClient is closed')
+      if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error('ACP setup timeout must be positive')
+      const spec = resolveAgent({ agent: nextAgent })
+      const next = spawnAgent(spec)
+      try {
+        await waitForSpawn(next)
+        for (const listener of switchListeners) await listener(next, current)
+        if (next.child.exitCode !== null || next.child.signalCode !== null) {
+          throw new Error(`ACP process exited (${next.child.signalCode ?? next.child.exitCode}) during handoff`)
+        }
+      } catch (error) {
+        try {
+          next.child.kill('SIGTERM')
+        } catch {
+          // failed spawns may not own a process
+        }
+        throw diagnosticError(error, next)
+      }
+      pendingSwitch?.reject(new Error('Harness switch was superseded'))
+      const previous = current
+      detach(previous)
+      attach(next)
+      current = next
+      service.command = next.command
+      service.args = next.args
+      service.env = next.env
+      service.child = next.child
+      hasSwitched = true
+      const ready = waitForReady(timeoutMs)
+      watchCurrent(next)
+      try {
+        previous.child.kill('SIGTERM')
+      } catch {
+        // already gone
+      }
+      // Rust starts initialize only after the local command returns. Awaiting
+      // ready here would deadlock; callers persist selection when this settles.
+      return { ready }
+    },
+    close(error = new Error('acpClient is closed')) {
+      if (closed) return
+      failTransport(error)
+      closed = true
+      detach(current)
+      try {
+        current.child.kill('SIGTERM')
+      } catch {
+        // already gone
+      }
+      input.destroy()
+      output.destroy()
+      if (liveAgent === service) liveAgent = null
+    },
+  }
+
+  function waitForReady(timeoutMs) {
+    let resolve
+    let reject
+    let timer
+    const ready = new Promise((yes, no) => { resolve = yes; reject = no })
+    // A child may fail before the caller has received the handoff result.
+    ready.catch(() => {})
+    const pending = {
+      requests: new Map(),
+      initialized: false,
+      server: undefined,
+      arm() {
+        clearTimeout(timer)
+        timer = setTimeout(() => {
+          failTransport(new Error(`ACP setup timed out after ${timeoutMs / 1000}s`))
+          detach(current)
+          try { current.child.kill('SIGTERM') } catch { /* already gone */ }
+        }, timeoutMs)
+        timer.unref?.()
+      },
+      pause() { clearTimeout(timer) },
+      resolve(value) { settle(resolve, value) },
+      reject(error) { settle(reject, diagnosticError(error, current)) },
+    }
+    const settle = (complete, value) => {
+      if (pendingSwitch !== pending) return
+      pendingSwitch = undefined
+      clearTimeout(timer)
+      complete(value)
+    }
+    pendingSwitch = pending
+    pending.arm()
+    return ready
+  }
+
+  function failTransport(error) {
+    const failure = diagnosticError(error, current)
+    pendingSwitch?.reject(failure)
+    for (const listener of failureListeners) listener(failure)
+  }
+
+  function watchCurrent(handle) {
+    handle.child.on('error', (err) => {
+      if (current !== handle || closed) return
+      if (hasSwitched) {
+        failTransport(err)
+        return
+      }
+      service.close(err)
+    })
+    // 'close' follows the stdio drain, so final startup errors are not lost.
+    handle.child.once('close', (code, signal) => {
+      if (current !== handle || closed) return
+      failTransport(new Error(`ACP process exited (${signal ?? code ?? 'unknown'}) before completing the request`))
+    })
   }
+  watchCurrent(current)
+  if (liveAgentExitHook !== null) process.removeListener('exit', liveAgentExitHook)
   liveAgentExitHook = () => {
     try {
-      child.kill('SIGTERM')
+      service.close()
     } catch {
       // already gone
     }
   }
   process.once('exit', liveAgentExitHook)
+  return service
 }
 
 function provide(ctx, service) {