martty 0.2.38 → 0.2.39-beta.0

package/lib/acp-agent-pool.js

@@ -0,0 +1,282 @@
+/** ACP connections live as long as their sessions, independently of the default recipe. */
+import { PassThrough } from 'node:stream'
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { createHash } from 'node:crypto'
+import { onJsonLines } from './mux.js'
+import { readCordisCapability } from './cordis-protocol.js'
+
+const identity = spec => JSON.stringify([spec.command, spec.args ?? [],
+  Object.entries(spec.env ?? {}).sort(([a], [b]) => a.localeCompare(b))])
+const namespace = spec => createHash('sha256').update(identity(spec)).digest('hex').slice(0, 24)
+const setupMethods = new Set(['session/new', 'session/load', 'session/resume'])
+
+export function createAgentPool(initial, { spawnAgent, resolveAgent, diagnosticError, timeoutMs = 20 * 60_000 }) {
+  const input = new PassThrough()
+  const output = new PassThrough()
+  const connections = new Map()
+  const sessions = new Map()
+  const callbacks = new Map()
+  const authMethods = new Map()
+  const context = new AsyncLocalStorage()
+  let nextConnection = 0
+  let nextRequest = 0
+  let defaultAgent = initial
+  let initializeParams
+  let active
+  let lastSetup
+  let closed = false
+
+  const write = value => { if (!closed) output.write(JSON.stringify(value) + '\n') }
+  const writeAgent = (owner, value) => owner.handle.stdin.write(JSON.stringify(value) + '\n')
+
+  function metadata(owner) {
+    return {
+      id: owner.id,
+      agentInfo: owner.init?.agentInfo,
+      agentCapabilities: owner.init?.agentCapabilities ?? {},
+      authMethods: (owner.init?.authMethods ?? []).map(method => {
+        const id = owner.id === 'h1' ? method.id : `${owner.id}:${method.id}`
+        authMethods.set(id, { owner, id: method.id })
+        return { ...method, id }
+      }),
+      command: owner.spec.command,
+      args: owner.spec.args ?? [],
+    }
+  }
+
+  function sessionId(owner, raw) {
+    if (typeof raw !== 'string' || !raw) return raw
+    if (owner.sessions.has(raw)) return owner.sessions.get(raw)
+    let id = owner.id === 'h1' ? raw : `martty:${owner.namespace}:${raw}`
+    while (sessions.has(id)) id = `martty:${owner.namespace}:${id}`
+    owner.sessions.set(raw, id)
+    sessions.set(id, { owner, raw })
+    return id
+  }
+
+  function incomingParams(owner, params) {
+    if (params === null || typeof params !== 'object') return params
+    const value = { ...params }
+    for (const key of ['sessionId', 'session_id', 'parentSessionId']) {
+      if (typeof value[key] === 'string') value[key] = sessionId(owner, value[key])
+    }
+    return value
+  }
+
+  function response(owner, message, pending) {
+    message = { ...message, _meta: { ...message._meta, marttyConnectionId: owner.id } }
+    if (message.error !== undefined) {
+      const error = message.error
+      const detail = owner.failed?.message === error.message ? owner.failed
+        : diagnosticError(new Error(error.message ?? 'ACP request failed'), owner.handle)
+      return { ...message, jsonrpc: '2.0', id: pending.id, error: { ...error, message: detail.message,
+        data: { ...(error.data && typeof error.data === 'object' ? error.data : { detail: error.data }),
+          marttyConnection: { ...metadata(owner), cwd: pending.params?.cwd } } } }
+    }
+    let result = message.result
+    if (pending.method === 'initialize') {
+      owner.init = result
+      metadata(owner)
+    }
+    if (setupMethods.has(pending.method) && result && typeof result === 'object') {
+      const raw = result.sessionId ?? pending.params?.sessionId
+      result = { ...result, sessionId: sessionId(owner, raw),
+        _meta: { ...result._meta, marttyConnection: { ...metadata(owner), cwd: pending.params?.cwd } } }
+    }
+    if (pending.method === 'session/list' && Array.isArray(result?.sessions)) {
+      result = { ...result, sessions: result.sessions.map(session => ({ ...session,
+        sessionId: sessionId(owner, session.sessionId) })) }
+    }
+    return { ...message, jsonrpc: '2.0', id: pending.id, result }
+  }
+
+  function fail(owner, error) {
+    if (owner.failed || closed) return
+    owner.failed = diagnosticError(error, owner.handle)
+    for (const pending of owner.pending.values()) {
+      if (pending.reject) pending.reject(owner.failed)
+      else write(response(owner, { error: { code: -32603, message: owner.failed.message } }, pending))
+    }
+    owner.pending.clear()
+  }
+
+  function connection(spec) {
+    const key = identity(spec)
+    const existing = connections.get(key)
+    if (existing && !existing.failed) return existing
+    const owner = { id: `h${++nextConnection}`, namespace: namespace(spec), spec, handle: spawnAgent(spec),
+      sessions: new Map(), pending: new Map(), init: undefined, initializing: undefined, failed: undefined }
+    connections.set(key, owner)
+    owner.handle.child.on('error', error => fail(owner, error))
+    owner.handle.child.once('close', (code, signal) => fail(owner,
+      new Error(`ACP process exited (${signal ?? code ?? 'unknown'}) before completing the request`)))
+    onJsonLines(owner.handle.stdout, line => {
+      let message
+      try { message = JSON.parse(line) } catch { return }
+      if (message.id !== undefined && typeof message.method !== 'string') {
+        const pending = owner.pending.get(message.id)
+        if (!pending) return
+        owner.pending.delete(message.id)
+        if (pending.resolve) {
+          if (message.error) pending.reject(Object.assign(new Error(message.error.message), { acpError: message.error }))
+          else pending.resolve(message.result)
+        } else write(response(owner, message, pending))
+        return
+      }
+      const forwarded = { ...message, params: incomingParams(owner, message.params) }
+      if (message.id !== undefined) {
+        const id = `martty-agent-${++nextRequest}`
+        callbacks.set(id, { owner, id: message.id })
+        forwarded.id = id
+      }
+      // Origin metadata is consumed locally by the mux, never sent to an Agent.
+      forwarded._meta = { ...forwarded._meta, marttyConnectionId: owner.id }
+      write(forwarded)
+    })
+    return owner
+  }
+
+  async function initialize(owner) {
+    if (owner.failed) throw owner.failed
+    if (owner.init) return
+    if (!initializeParams) throw new Error('ACP initialize must precede session/new')
+    if (!owner.initializing) {
+      owner.initializing = new Promise((resolve, reject) => {
+        const id = `martty-initialize-${++nextRequest}`
+        const timer = setTimeout(() => {
+          owner.pending.delete(id)
+          reject(new Error(`ACP setup timed out after ${timeoutMs / 1000}s`))
+        }, timeoutMs)
+        timer.unref?.()
+        const settle = callback => value => { clearTimeout(timer); callback(value) }
+        owner.pending.set(id, { resolve: settle(resolve), reject: settle(reject) })
+        writeAgent(owner, { jsonrpc: '2.0', id, method: 'initialize', params: initializeParams })
+      }).then(value => { owner.init = value; metadata(owner) })
+        .catch(error => { owner.initializing = undefined; throw error })
+    }
+    await owner.initializing
+  }
+
+  function ownerFor(message) {
+    const sid = message.params?.sessionId ?? message.params?.session_id
+    if (typeof sid === 'string') {
+      const bound = sessions.get(sid)
+      if (bound) return bound.owner
+      if (!setupMethods.has(message.method)) throw new Error(`Unknown ACP session: ${sid}`)
+      const saved = /^martty:([a-f0-9]{24}):([\s\S]+)$/.exec(sid)
+      if (saved) {
+        const owner = [...connections.values()].find(owner => owner.namespace === saved[1] && !owner.failed)
+          ?? (namespace(defaultAgent) === saved[1] ? connection(defaultAgent) : undefined)
+        if (!owner) throw new Error('Select the session’s original Harness before resuming it')
+        sessions.set(sid, { owner, raw: saved[2] })
+        owner.sessions.set(saved[2], sid)
+        return owner
+      }
+    }
+    return context.getStore() ?? active
+  }
+
+  async function outgoing(message) {
+    if (closed) return
+    if (typeof message.method !== 'string') {
+      const callback = callbacks.get(message.id)
+      if (callback) {
+        callbacks.delete(message.id)
+        writeAgent(callback.owner, { ...message, id: callback.id })
+      }
+      return
+    }
+    let owner
+    let params = message.params
+    try {
+      // Capture the recipe before awaiting initialization. Later default edits
+      // cannot retarget a session/new request already in flight.
+      if (message.method === 'session/new') {
+        owner = authMethods.get(params?._meta?.marttyAuthMethod)?.owner ?? connection(defaultAgent)
+        lastSetup = owner
+        if (params?._meta?.marttyAuthMethod) {
+          params = { ...params, _meta: { ...params._meta } }
+          delete params._meta.marttyAuthMethod
+        }
+        await initialize(owner)
+      } else if (message.method === 'initialize') {
+        initializeParams = structuredClone(params ?? {})
+        owner = active
+      } else if (message.method === 'authenticate') {
+        const method = authMethods.get(params?.methodId)
+        owner = method?.owner ?? lastSetup ?? active
+        if (method) params = { ...params, methodId: method.id }
+      } else {
+        owner = ownerFor(message)
+        if (setupMethods.has(message.method)) await initialize(owner)
+      }
+      if (owner.failed) throw owner.failed
+      if (message.method.startsWith('_dsh/cordis/') && readCordisCapability(owner.init) === null) {
+        throw new Error('agent has not advertised _dsh/cordis')
+      }
+      if (params && typeof params === 'object') {
+        params = { ...params }
+        for (const key of ['sessionId', 'session_id']) {
+          const bound = sessions.get(params[key])
+          if (bound) params[key] = bound.raw
+        }
+      }
+      const forwarded = { ...message, params }
+      if (message.id !== undefined) {
+        const id = `martty-client-${++nextRequest}`
+        owner.pending.set(id, { id: message.id, method: message.method, params })
+        forwarded.id = id
+      }
+      writeAgent(owner, forwarded)
+    } catch (error) {
+      if (message.id !== undefined) {
+        const failed = { error: { ...error.acpError, code: error.acpError?.code ?? -32603, message: error.message } }
+        write(owner ? response(owner, failed, message) : { jsonrpc:'2.0', id:message.id, ...failed })
+      }
+    }
+  }
+
+  active = connection(initial)
+  onJsonLines(input, line => {
+    let message
+    try { message = JSON.parse(line) } catch { return }
+    void outgoing(message)
+  })
+
+  return {
+    kind: 'spawn', stdin: input, stdout: output,
+    get child() { return active.handle.child },
+    get command() { return active.spec.command },
+    get args() { return active.spec.args ?? [] },
+    get env() { return active.spec.env },
+    diagnostics() { return active.handle.diagnostics() },
+    setDefaultAgent(spec) { defaultAgent = resolveAgent({ agent: spec }) },
+    hasAgent(spec) { const owner = connections.get(identity(spec)); return !!owner && !owner.failed },
+    selectSession(id) {
+      const bound = sessions.get(id)
+      if (bound) active = bound.owner
+      else if (!id && lastSetup) active = lastSetup
+    },
+    capabilityFor(message) {
+      const id = message?._meta?.marttyConnectionId
+      const owner = id ? [...connections.values()].find(owner => owner.id === id) : ownerFor(message)
+      return readCordisCapability(owner?.init)
+    },
+    withOrigin(message, callback) {
+      const id = message?._meta?.marttyConnectionId
+      const owner = [...connections.values()].find(owner => owner.id === id)
+      return context.run(owner ?? active, callback)
+    },
+    close() {
+      if (closed) return
+      for (const owner of connections.values()) {
+        fail(owner, new Error('acpClient is closed'))
+        try { owner.handle.child.kill('SIGTERM') } catch { /* already exited */ }
+      }
+      closed = true
+      callbacks.clear()
+      input.destroy()
+      output.destroy()
+    },
+  }
+}

package/lib/acp-client.js

@@ -3,16 +3,17 @@
  *
  * Provides `ctx.acpClient` plus the standard-ACP-backed
  * `ctx.acpSessionConfig`. Does not import a harness, dsh, or dsh-acp.
- * Switching agents is `{ command, args }` (or `config.stream`).
+ * Spawned sessions retain their connection; setDefaultAgent changes the recipe
+ * used by the next session/new. An externally owned config.stream stays fixed.
  */
 
 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'
+import { createAgentPool } from './acp-agent-pool.js'
 
 export { installAcpSessionConfig } from './acp-session-config.js'
 export { installAcpSessionPlan } from './acp-session-plan.js'
@@ -85,6 +86,8 @@ export function apply(ctx, config = {}) {
   if (
     liveAgent !== null
     && liveAgent.child.exitCode === null
+    && !liveAgent.child.killed
+    && !liveAgent.stdin.destroyed
     && liveAgent.command === agent.command
     && JSON.stringify(liveAgent.args) === JSON.stringify(agent.args ?? [])
     && JSON.stringify(liveAgent.env ?? {}) === JSON.stringify(agent.env ?? {})
@@ -92,16 +95,19 @@ export function apply(ctx, config = {}) {
     provide(ctx, liveAgent)
     return
   }
-  // Replacing the agent: the previous child must not outlive its spec.
-  if (liveAgent !== null && liveAgent.child.exitCode === null) {
+  // A new Client tree owns a new pool; dispose every child of the old tree.
+  if (liveAgent !== null) {
     try {
-      liveAgent.child.kill('SIGTERM')
+      liveAgent.close()
     } catch {
       // already gone
     }
   }
   liveAgent = null
-  const service = createSpawnService(agent)
+  const service = createAgentPool(agent, { spawnAgent, resolveAgent, diagnosticError })
+  if (liveAgentExitHook !== null) process.removeListener('exit', liveAgentExitHook)
+  liveAgentExitHook = () => service.close()
+  process.once('exit', liveAgentExitHook)
   liveAgent = service
   provide(ctx, service)
 }
@@ -185,233 +191,6 @@ function diagnosticError(error, handle) {
   })
 }
 
-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 {
-      service.close()
-    } catch {
-      // already gone
-    }
-  }
-  process.once('exit', liveAgentExitHook)
-  return service
-}
-
 function provide(ctx, service) {
   if (typeof ctx.provide === 'function') {
     ctx.provide('acpClient', service)

package/lib/acp-session-status.js

@@ -61,6 +61,8 @@ export function installAcpSessionStatus(ctx, options = {}) {
 
   const listeners = new Set()
   const sessions = new Map()
+  const connections = new Map()
+  const connectionAuthMethods = new Map()
   const fallback = zeroSession(undefined, false)
   let sessionId
   let selectionKnown = false
@@ -70,7 +72,7 @@ export function installAcpSessionStatus(ctx, options = {}) {
   let initializeId
   let authMethods = []
   const pendingRequests = new Set()
-  const pendingAuthenticate = new Set()
+  const pendingAuthenticate = new Map()
   const pendingSetup = new Map()
   const pendingPrompts = new Map()
 
@@ -90,8 +92,9 @@ export function installAcpSessionStatus(ctx, options = {}) {
 
   function current() {
     const value = stateFor(sessionId)
-    const { permissionPreset: _permissionPreset, sandboxMode: _sandboxMode, ...visible } = value
-    return structuredClone({ connection, server, auth, ...visible })
+    const { permissionPreset: _permissionPreset, sandboxMode: _sandboxMode,
+      connectionFacts, ...visible } = value
+    return structuredClone({ connection, server, auth, ...connectionFacts, ...visible })
   }
 
   function publish() {
@@ -135,6 +138,8 @@ export function installAcpSessionStatus(ctx, options = {}) {
     if (message.method === 'initialize' && message.id !== undefined) {
       pendingRequests.clear()
       sessions.clear()
+      connections.clear()
+      connectionAuthMethods.clear()
       Object.assign(fallback, zeroSession(undefined, false))
       delete fallback.error
       sessionId = undefined
@@ -154,12 +159,14 @@ export function installAcpSessionStatus(ctx, options = {}) {
     }
     if (message.id !== undefined) pendingRequests.add(message.id)
     if (message.method === 'authenticate' && message.id !== undefined) {
-      pendingAuthenticate.add(message.id)
       const methodId = readString(message.params, 'methodId')
-      const method = authMethods.find((candidate) => candidate?.id === methodId)
-      if (methodId !== undefined) auth.method = readString(method, 'name', 'label') ?? methodId
-      delete auth.message
-      auth.status = 'signing in'
+      const owned = connectionAuthMethods.get(methodId)
+      const target = owned?.facts.auth ?? auth
+      pendingAuthenticate.set(message.id, target)
+      const method = owned?.method ?? authMethods.find((candidate) => candidate?.id === methodId)
+      if (methodId !== undefined) target.method = readString(method, 'name', 'label') ?? methodId
+      delete target.message
+      target.status = 'signing in'
       publish()
       return
     }
@@ -204,13 +211,14 @@ export function installAcpSessionStatus(ctx, options = {}) {
     // its authentication or run state in the new connection.
     if (response(message) && !pendingRequests.delete(message.id)) return
     if (message.id !== undefined && pendingAuthenticate.has(message.id)) {
+      const target = pendingAuthenticate.get(message.id)
       pendingAuthenticate.delete(message.id)
       if (message.error === undefined) {
-        auth.status = 'configured'
-        delete auth.message
+        target.status = 'configured'
+        delete target.message
       } else {
-        auth.status = 'sign-in failed'
-        auth.message = readString(message.error?.data, 'details', 'message')
+        target.status = 'sign-in failed'
+        target.message = readString(message.error?.data, 'details', 'message')
           ?? readString(message.error, 'message') ?? 'Authentication failed'
       }
       publish()
@@ -239,6 +247,17 @@ export function installAcpSessionStatus(ctx, options = {}) {
         const bound = readString(message.result, 'sessionId', 'session_id') ?? setup.sessionId
         if (bound !== undefined) {
           stateFor(bound).session = { sessionId: bound, bound: true, started: setup.started }
+          const owner = message.result?._meta?.marttyConnection
+          if (owner) {
+            let facts = connections.get(owner.id)
+            if (!facts) {
+              facts = { connection: 'attached', server: owner.agentInfo?.name,
+                auth: { status: owner.authMethods?.length ? 'configured' : undefined, method: undefined } }
+              connections.set(owner.id, facts)
+            }
+            stateFor(bound).connectionFacts = facts
+            for (const method of owner.authMethods ?? []) connectionAuthMethods.set(method.id, { facts, method })
+          }
           delete stateFor(bound).error
           if (authMethods.length > 0) {
             auth.status = 'configured'
@@ -254,12 +273,13 @@ export function installAcpSessionStatus(ctx, options = {}) {
       const promptSessionId = pendingPrompts.get(message.id)
       pendingPrompts.delete(message.id)
       let changed = false
+      const value = stateFor(promptSessionId)
+      const target = value.connectionFacts?.auth ?? auth
       if (message.error !== undefined && isAuthRequired(message.error)
-        && auth.status !== 'needs sign-in') {
-        auth.status = 'needs sign-in'
+        && target.status !== 'needs sign-in') {
+        target.status = 'needs sign-in'
         changed = true
       }
-      const value = stateFor(promptSessionId)
       if (!hasPendingPrompt(promptSessionId) && value.state !== 'idle') {
         value.state = 'idle'
         changed = true

package/lib/harness-removal.js

@@ -46,7 +46,7 @@ export function planHarnessRemoval(settingsPath, id, options = {}) {
   const entries = savedHarnesses(settingsPath)
   const entry = entries.find(entry => entry.id === id)
   if (!entry) throw new Error('Only a saved Harness configuration can be removed')
-  if (options.isCurrent?.(entry)) throw new Error('Switch to another Harness before removing the current Harness')
+  if (options.isCurrent?.(entry)) throw new Error('This Harness is still running. Restart Martty with another default before removing it')
   const forced = [options.forcedHarness, ...(options.defaults ?? []).filter(entry => entry.source === 'forced')].filter(Boolean)
   if (forced.some(value => value.id === id || value.command === entry.command)) throw new Error('This Harness is product-forced and cannot be removed here')
   const installation = privateInstallation(settingsPath, entry)

package/lib/harness-view.js

@@ -1,7 +1,7 @@
-/** Built-in Client Plugin: discover, prepare, and switch standalone ACP Harnesses. */
+/** Built-in Client Plugin: configure default ACP Harnesses and open new sessions. */
 import {
   addHarnessAsync, discoverHarnessCandidates, discoverHarnesses, fetchAcpRegistry,
-  setDefaultHarness, tokenizeHarnessArgs, upsertHarness, savedHarnesses,
+  setDefaultHarness, selectedHarness, tokenizeHarnessArgs, upsertHarness, savedHarnesses,
 } from './harnesses.js'
 import { planHarnessRemoval, removeHarness } from './harness-removal.js'
 import { scanHarnessCandidates } from './harness-discovery.js'
@@ -47,7 +47,6 @@ export function apply(ctx, options = {}) {
   let registrySnapshot = options.registry ?? readAcpRegistrySnapshot({ ...options, settingsPath })
   let candidateSnapshot = []
   let flow = 0
-  let switchVersion = 0
   let disposed = false
   let operation
   let ownedOverlay
@@ -64,9 +63,9 @@ export function apply(ctx, options = {}) {
     downloadNotice = ctx.tuiSlots.register({ name: 'conversation.input.dock', id: 'harness-downloads', order: -20 }, [])
     return () => downloadNotice.dispose()
   })
-  let runningRecipe = options.forcedHarness
-  let failedRecipe
+  const runningRecipe = options.forcedHarness
   const isRunning = (entry) => {
+    if (typeof ctx.acpClient?.hasAgent === 'function') return ctx.acpClient.hasAgent(entry)
     const child = ctx.acpClient?.child
     if (child?.exitCode != null || child?.signalCode != null) return false
     const live = ctx.acpClient?.command ? ctx.acpClient : runningRecipe
@@ -74,16 +73,15 @@ export function apply(ctx, options = {}) {
       id: '', command: live.command, args: live.args, env: live.env,
     })
   }
-  const isCurrent = (entry) => isRunning(entry) && recipeIdentity(entry) !== failedRecipe
-  const currentOption = (entry) => isCurrent(entry) ? { label: `${entry.label} (current)`, disabled: true } : {}
-  const currentFirst = (left, right) => Number(isCurrent(right)) - Number(isCurrent(left))
+  const currentOption = (entry) => entry.id === selectedHarness(settingsPath)?.id ? { label: `${entry.label} (default)` } : {}
+  const currentFirst = (left, right) => Number(right.id === selectedHarness(settingsPath)?.id) - Number(left.id === selectedHarness(settingsPath)?.id)
   const choices = () => discoverHarnesses(settingsPath, options).sort(currentFirst).map((entry) => ({
     value: entry.id, label: entry.label, description: `${entry.source} · ${commandText(entry)}`,
     ...currentOption(entry),
   }))
   const commandChoices = () => [...choices(), { ...addOption, value: 'add' }]
   const refreshCommandChoices = () => commandRegistration?.update({ input: {
-    hint: '[id] | add | remove [id] | find [query]', options: commandChoices(),
+    hint: '[id] [--new] | add | remove [id] | find [query]', options: commandChoices(),
   } })
 
   function openView(spec, handlers) {
@@ -226,84 +224,31 @@ export function apply(ctx, options = {}) {
     } finally { removing.delete(id) }
   }
 
-  async function switchNow(entry, download) {
-    if (disposed) return
-    if (removing.has(entry.id)) throw new Error('This Harness is being removed; wait until removal finishes')
-    const version = ++switchVersion
-    failedRecipe = undefined
-    pendingFailure = undefined
-    try {
-      if (typeof ctx.acpClient?.switchAgent !== 'function') throw new Error('Harness switching is unavailable on this ACP transport')
-      // Connect registers the prepared recipe, independently of sign-in/session setup.
-      // A failed or cancelled login must not make an explicitly added Harness disappear.
-      upsertHarness(settingsPath, entry)
-      refreshCommandChoices()
-      const handoff = await ctx.acpClient.switchAgent({ command: entry.command, args: entry.args,
-        ...(entry.env !== undefined ? { env: entry.env } : {}) })
-      if (disposed || version !== switchVersion) {
-        void handoff?.ready?.catch(() => {})
-        return
-      }
-      // The process is current already; readiness controls persistence, not
-      // which running recipe the picker/composer identifies.
-      refreshCommandChoices()
-      const commit = () => {
-        if (disposed || version !== switchVersion) return
-        setDefaultHarness(settingsPath, entry.id)
-        runningRecipe = entry
-        refreshCommandChoices()
-        if (download !== undefined && downloads.get(download.key) === download) {
-          downloads.delete(download.key)
-          notifyDownloads()
-        }
-      }
-      // The action lets the painter initialize/session/new; awaiting ready here deadlocks it.
-      if (handoff?.ready !== undefined) {
-        void handoff.ready.then(commit).catch((error) => {
-          if (!disposed && version === switchVersion) {
-            failedRecipe = recipeIdentity(entry)
-            refreshCommandChoices()
-            retryView(`Could not connect ${entry.label}`, error, () => switchNow(entry, download))
-          }
-        })
-      } else commit() // Older stream integrations keep their existing contract.
-      return { action: 'harness-switched', harness: {
-        id: entry.id, label: entry.label, command: entry.command, args: entry.args,
-        ...(entry.env !== undefined ? { env: entry.env } : {}),
-      } }
-    } catch (error) { retryView(`Could not connect ${entry.label}`, error, () => switchNow(entry, download)) }
-  }
-
-  async function save(id, preparedEntry, download) {
-    if (disposed) return
-    const entry = preparedEntry ?? discoverHarnesses(settingsPath, options).find((candidate) => candidate.id === id)
+  async function save(id, preparedEntry, download, openNow = false) {
+    const entry = preparedEntry ?? discoverHarnesses(settingsPath, options).find(entry => entry.id === id)
     if (entry === undefined) throw new Error(`unknown harness ${JSON.stringify(id)}`)
-    if (!options.hostOwned && isCurrent(entry)) return
-    if (options.hostOwned) {
-      upsertHarness(settingsPath, entry)
-      setDefaultHarness(settingsPath, id)
-      refreshCommandChoices()
-      if (download !== undefined && downloads.get(download.key) === download) {
-        downloads.delete(download.key)
-        notifyDownloads()
-      }
-      openView({ id: 'harness-saved', title: 'Harness saved', nodes: [{
-        id: 'notice', kind: 'notice', level: 'info',
-        text: `${entry.label} is saved for a new standalone session. The current dsh profile and session remain Host-owned.`,
-      }] })
-      return
-    }
-    // Selecting a registered recipe is a switch, not Add/Install. The saved
-    // launcher owns its cache; a per-process preparation flag is not evidence
-    // that the package needs downloading again.
-    if (ctx.acpSessionStatus?.current?.().session?.started === true) {
-      openSelect({ id: 'harness-confirm', title: 'Switch Harness? · starts a new session', value: 'switch', options: [
-        { value: 'switch', label: `Switch to ${entry.label}`, description: 'Current session stays available in /session' },
-        { value: 'cancel', label: 'Stay in current session', description: 'Keep using the current Harness' },
-      ] }, { onSubmit: (action) => action === 'switch' ? switchNow(entry, download) : undefined })
-      return
+    if (removing.has(id)) throw new Error('This Harness is being removed; wait until removal finishes')
+    upsertHarness(settingsPath, entry)
+    setDefaultHarness(settingsPath, id)
+    ctx.acpClient?.setDefaultAgent?.({ command: entry.command, args: entry.args ?? [],
+      ...(entry.env !== undefined ? { env: entry.env } : {}) })
+    refreshCommandChoices()
+    if (download !== undefined && downloads.get(download.key) === download) {
+      downloads.delete(download.key)
+      notifyDownloads()
     }
-    return switchNow(entry, download)
+    const newSession = () => ({ action: 'new-session' })
+    if (openNow && !options.hostOwned) return newSession()
+    openView({ id: 'harness-saved', title: 'Default Harness saved', nodes: [{
+      id: 'notice', kind: 'notice', level: 'info',
+      text: options.hostOwned
+        ? `${entry.label} is saved for the next standalone session. The current profile owns its Harness.`
+        : `${entry.label} will be used for new sessions. Enter opens a new tab now. Esc keeps the current session.`,
+    }] }, options.hostOwned ? undefined : { onSubmit: newSession })
+    if (!options.hostOwned) return { action: 'harness-selected', harness: {
+      id: entry.id, label: entry.label, command: entry.command, args: entry.args ?? [],
+      ...(entry.env !== undefined ? { env: entry.env } : {}),
+    } }
   }
 
   function configured(entry) {
@@ -372,14 +317,14 @@ export function apply(ctx, options = {}) {
         downloads.delete(job.key)
         hide()
       }
-      openView({ id: 'harness-installing', title: `Download complete · ${job.entry.label} · enter switch · esc close`, nodes: [
+      openView({ id: 'harness-installing', title: `Download complete · ${job.entry.label} · enter new session · esc close`, nodes: [
         { id: 'complete', kind: 'notice', level: 'info', text: job.registered
           ? `${job.entry.label} is installed and configured.`
           : `${job.entry.label} is installed. Your newer configuration is unchanged.` },
-        { id: 'next', kind: 'text', text: 'Setup is complete. Enter switches to this Harness using its saved configuration. Esc closes without switching.' },
+        { id: 'next', kind: 'text', text: 'Setup is complete. Enter opens a new session with this Harness. Esc closes without switching.' },
       ] }, { onSubmit: () => {
         acknowledge()
-        return save(job.entry.id)
+        return save(job.entry.id, undefined, undefined, true)
       }, onCancel: acknowledge })
       return
     }
@@ -591,8 +536,8 @@ export function apply(ctx, options = {}) {
     } })()
   }
 
-  commandRegistration = ctx.tuiCommands.register({ name: 'harness', description: 'Switch or add a Harness; switching starts a new session',
-    input: { hint: '[id] | add | remove [id] | find [query]', options: commandChoices() },
+  commandRegistration = ctx.tuiCommands.register({ name: 'harness', description: 'Choose the default Harness for new sessions',
+    input: { hint: '[id] [--new] | add | remove [id] | find [query]', options: commandChoices() },
   }, async (args) => {
     if (disposed) return
     refreshCommandChoices()
@@ -620,7 +565,7 @@ export function apply(ctx, options = {}) {
     }
     if (tokens[0] !== undefined) {
       const saved = discoverHarnesses(settingsPath, options).find((entry) => entry.id === tokens[0])
-      if (saved !== undefined) return save(saved.id, saved)
+      if (saved !== undefined) return save(saved.id, saved, undefined, tokens.includes('--new'))
       const job = [...downloads.values()].filter((job) => job.entry.id === tokens[0]).at(-1)
       return job === undefined ? save(tokens[0]) : showDownload(job)
     }
@@ -640,14 +585,14 @@ export function apply(ctx, options = {}) {
     }
     const downloaded = downloadOptions()
     if (entries.length === 0 && downloaded.length === 0) return browse()
-    openSelect({ id: 'harness', title: 'Switch Harness · starts a new session',
-      value: (entries.find(entry => entry.value === selected) ?? entries.find((entry) => entry.disabled) ?? entries[0] ?? downloaded[0]).value,
+    openSelect({ id: 'harness', title: 'Default Harness · for new sessions',
+      value: (entries.find(entry => entry.value === selected) ?? entries.find((entry) => entry.value === selectedHarness(settingsPath)?.id) ?? entries[0] ?? downloaded[0]).value,
       options: [...entries, ...downloaded, addOption],
     }, { onDelete: id => removal(id),
       onSubmit: (id) => id === ADD ? browse() : id.startsWith(DOWNLOAD) ? showDownload(downloads.get(id.slice(DOWNLOAD.length))) : save(id) })
   }
   return () => {
-    disposed = true; ++flow; ++switchVersion; operation?.abort()
+    disposed = true; ++flow; operation?.abort()
     for (const job of downloads.values()) job.controller.abort()
     ownedOverlay?.close(); stopDownloadSlot?.(); commandRegistration?.()
   }

package/lib/index.js

@@ -248,6 +248,7 @@ export async function applyShell(ctx, options = {}) {
         }
         if (message.method === CORDIS_METHODS.sessionActive) {
           const active = message.params?.sessionId
+          agent.selectSession?.(active)
           clientEvents.selectSession(
             typeof active === 'string' && active.length > 0 ? active : undefined,
           )

package/lib/mux.js

@@ -165,6 +165,13 @@ export function muxAcpAndCompositor(opts) {
   let initializeId
   /** @type {{ protocol: number } | null} */
   let agentCordis = null
+  const initializedConnections = new Set()
+  const capabilityFor = message => {
+    if (typeof agent.capabilityFor !== 'function') return agentCordis
+    try { return agent.capabilityFor(message) } catch { return null }
+  }
+  const withOrigin = (message, callback) => typeof agent.withOrigin === 'function'
+    ? agent.withOrigin(message, callback) : callback()
 
   onJsonLines(agent.stdout, (line) => {
     let message
@@ -186,14 +193,21 @@ export function muxAcpAndCompositor(opts) {
       return
     }
     if (isHostMessage(message)) {
-      if (agentCordis !== null) onHost?.(message)
+      if (capabilityFor(message) !== null) withOrigin(message, () => onHost?.(message))
       return
     }
     if (message?.id !== undefined && typeof message.method !== 'string') pendingClient.delete(message.id)
     onAcp?.('agent', message)
     tui.output.write(`${line}\n`)
+    const connection = message.result?._meta?.marttyConnection
+    if (connection && !initializedConnections.has(connection.id)) {
+      initializedConnections.add(connection.id)
+      const capability = readCordisCapability(connection)
+      if (capability !== null) withOrigin(message, () => onCordisReady?.(capability))
+    }
     if (initializeId !== undefined && message && typeof message === 'object' && message.id === initializeId) {
       initializeId = undefined
+      if (message._meta?.marttyConnectionId) initializedConnections.add(message._meta.marttyConnectionId)
       agentCordis = readCordisCapability(message.result)
       if (agentCordis !== null) onCordisReady?.(agentCordis)
     }
@@ -251,7 +265,7 @@ export function muxAcpAndCompositor(opts) {
     if (
       typeof message.method === 'string'
       && message.method.startsWith('_dsh/cordis/')
-      && agentCordis === null
+      && capabilityFor(message) === null
     ) {
       if (message.id !== undefined) {
         writeJsonLine(tui.output, {
@@ -287,6 +301,7 @@ export function muxAcpAndCompositor(opts) {
     failAgent,
     resetAgent() {
       initializeId = undefined
+      initializedConnections.clear()
       agentCordis = null
       failAgent(new Error('ACP Agent was replaced'))
     },
@@ -297,7 +312,7 @@ export function muxAcpAndCompositor(opts) {
       )
     },
     requestAgent(method, params) {
-      if (method.startsWith('_dsh/cordis/') && agentCordis === null) {
+      if (method.startsWith('_dsh/cordis/') && capabilityFor({ method, params }) === null) {
         return Promise.reject(new Error('agent has not advertised _dsh/cordis'))
       }
       const id = `tui-host-${++nextHostId}`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "martty",
-  "version": "0.2.38",
+  "version": "0.2.39-beta.0",
   "description": "Terminal-native ACP client UI; Cordis client tree, any ACP agent",
   "license": "MIT",
   "repository": {
@@ -14,9 +14,9 @@
   "type": "module",
   "main": "lib/index.js",
   "scripts": {
-    "test:harness-ui": "node --test ../scripts/harness-management-tui.test.mjs",
+    "test:harness-ui": "node --test ../scripts/harness-management-tui.test.mjs ../scripts/harness-session-tui.test.mjs",
     "pretest": "node --test ../scripts/workflow-release.test.mjs ../scripts/package-alias.test.mjs ../scripts/harness-removal.test.mjs",
-    "test": "node --test ../scripts/download.test.mjs ../scripts/package-native.test.mjs ../scripts/check-release-tag.test.mjs ../scripts/check-static-elf.test.mjs ../scripts/smoke-old-linux.test.mjs ../scripts/cargo-guard.test.mjs ../scripts/build-npm.test.mjs ../scripts/client-profile.test.mjs ../scripts/plugin-runner.test.mjs ../scripts/profile-link-resolution.test.mjs ../scripts/packaged-acp-permission.test.mjs ../scripts/profile-smoke-tui.test.mjs ../scripts/release.test.mjs ../scripts/jsonrpc-line-transport.test.mjs ../scripts/tui-theme.test.mjs ../scripts/tui-presets.test.mjs ../scripts/tui-plugin-store.test.mjs ../scripts/tui-local-plugins.test.mjs ../scripts/tui-client-plugin-registry.test.mjs ../scripts/tui-slots.test.mjs ../scripts/tui-commands.test.mjs ../scripts/tui-overlay.test.mjs ../scripts/tui-agents.test.mjs ../scripts/tui-queue.test.mjs ../scripts/mux.test.mjs ../scripts/acp-client.test.mjs ../scripts/harnesses.test.mjs ../scripts/harness-discovery.test.mjs ../scripts/harness-discovery-scenario.test.mjs ../scripts/harness-view.test.mjs ../scripts/harness-onboarding.test.mjs ../scripts/harness-registry.test.mjs ../scripts/harness-package.test.mjs ../scripts/acp-client-events.test.mjs ../scripts/acp-session-config.test.mjs ../scripts/acp-session-plan.test.mjs ../scripts/acp-session-stats.test.mjs ../scripts/acp-session-status.test.mjs ../scripts/agents-view.test.mjs ../scripts/plan-view.test.mjs ../scripts/queue-view.test.mjs ../scripts/stats-view.test.mjs ../scripts/status-view.test.mjs ../scripts/deepseek-logo.test.mjs ../scripts/runner.test.mjs ../scripts/inspect.test.mjs ../scripts/creator-overlay.test.mjs ../scripts/real-agent-e2e.test.mjs",
+    "test": "node --test ../scripts/download.test.mjs ../scripts/package-native.test.mjs ../scripts/check-release-tag.test.mjs ../scripts/check-static-elf.test.mjs ../scripts/smoke-old-linux.test.mjs ../scripts/cargo-guard.test.mjs ../scripts/build-npm.test.mjs ../scripts/client-profile.test.mjs ../scripts/plugin-runner.test.mjs ../scripts/profile-link-resolution.test.mjs ../scripts/packaged-acp-permission.test.mjs ../scripts/profile-smoke-tui.test.mjs ../scripts/release.test.mjs ../scripts/jsonrpc-line-transport.test.mjs ../scripts/tui-theme.test.mjs ../scripts/tui-presets.test.mjs ../scripts/tui-plugin-store.test.mjs ../scripts/tui-local-plugins.test.mjs ../scripts/tui-client-plugin-registry.test.mjs ../scripts/tui-slots.test.mjs ../scripts/tui-commands.test.mjs ../scripts/tui-overlay.test.mjs ../scripts/tui-agents.test.mjs ../scripts/tui-queue.test.mjs ../scripts/mux.test.mjs ../scripts/acp-client.test.mjs ../scripts/acp-agent-pool.test.mjs ../scripts/harnesses.test.mjs ../scripts/harness-discovery.test.mjs ../scripts/harness-discovery-scenario.test.mjs ../scripts/harness-view.test.mjs ../scripts/harness-onboarding.test.mjs ../scripts/harness-registry.test.mjs ../scripts/harness-package.test.mjs ../scripts/acp-client-events.test.mjs ../scripts/acp-session-config.test.mjs ../scripts/acp-session-plan.test.mjs ../scripts/acp-session-stats.test.mjs ../scripts/acp-session-status.test.mjs ../scripts/agents-view.test.mjs ../scripts/plan-view.test.mjs ../scripts/queue-view.test.mjs ../scripts/stats-view.test.mjs ../scripts/status-view.test.mjs ../scripts/deepseek-logo.test.mjs ../scripts/runner.test.mjs ../scripts/inspect.test.mjs ../scripts/creator-overlay.test.mjs ../scripts/real-agent-e2e.test.mjs",
     "test:profile-install-matrix": "node --test ../scripts/profile-install-matrix.test.mjs"
   },
   "publishConfig": {