martty 0.2.38 → 0.2.39-beta.1

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,18 @@
  *
  * 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 { harnessEnvironment } from './harness-environment.js'
 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 +87,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 +96,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)
 }
@@ -109,7 +116,7 @@ export function apply(ctx, config = {}) {
 function spawnAgent(agent) {
   const child = spawn(agent.command, agent.args ?? [], {
     stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, ...(agent.env ?? {}) },
+    env: harnessEnvironment(agent.env),
   })
   child.stdin.on('error', () => {})
   child.stdout.on('error', () => {})
@@ -185,233 +192,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,18 @@ 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,
+                runtime: { command: owner.command, args: owner.args ?? [] },
+                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 +274,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/boot.js

@@ -1,3 +1,4 @@
+import { apply as applyHarnessBadge, inject as harnessBadgeInject } from './harness-badge.js'
 /**
  * Boot-time restore of a statically-registered gallery palette (ayu,
  * iceberg, …). `/theme` persistence writes `settings.theme`; dynamic
@@ -142,6 +143,7 @@ export async function bootClient(options = {}) {
     await ctx.plugin({ name: 'stats-view', inject: statsViewInject, apply: applyStatsView })
     await ctx.plugin({ name: 'acp-session-status', inject: sessionStatusInject, apply: applySessionStatus })
     await ctx.plugin({ name: 'status-view', inject: statusViewInject, apply: applyStatusView })
+    await ctx.plugin({ name: 'harness-badge', inject: harnessBadgeInject, apply: applyHarnessBadge }, harnessConfig)
     await ctx.plugin({ name: 'harness-view', inject: harnessViewInject, apply: applyHarnessView }, harnessConfig)
     await ctx.plugin({ name: 'deepseek-logo', inject: deepseekLogoInject, apply: applyDeepseekLogo })
     const localPlugins = installTuiLocalPlugins(ctx, {
@@ -203,6 +205,7 @@ export async function bootClient(options = {}) {
     applyStatsView(ctx)
     applySessionStatus(ctx)
     applyStatusView(ctx)
+    applyHarnessBadge(ctx, harnessConfig)
     applyHarnessView(ctx, harnessConfig)
     applyDeepseekLogo(ctx)
     const localPlugins = installTuiLocalPlugins(ctx, {

package/lib/harness-badge.js

@@ -0,0 +1,137 @@
+/** Registry-owned Harness marks. Only the Rust painter touches the terminal. */
+import { createHash, randomUUID } from 'node:crypto'
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { createRequire } from 'node:module'
+import { readAcpRegistrySnapshot } from './harness-registry.js'
+import { discoverHarnesses } from './harnesses.js'
+
+export const name = 'harness-badge'
+export const inject = ['acpSessionStatus', 'tuiSlots']
+// ACP Registry does not list DeepSeek yet. Use Lobe's MIT-licensed mark,
+// supplied by the installed SVG library. Registry always takes priority.
+const deepseekBadge = {
+  label: 'DeepSeek',
+  icon: 'lobe:deepseek',
+}
+const require = createRequire(import.meta.url)
+const MAX_BYTES = 512 * 1024
+const png = bytes => bytes.length <= MAX_BYTES && bytes.subarray(0, 8).equals(Buffer.from([137,80,78,71,13,10,26,10]))
+
+export function createIconCache(options = {}) {
+  const pending = new Map()
+  return function load(url) {
+    if (typeof url !== 'string' || (url !== 'lobe:deepseek' && !url.startsWith('https://'))) return Promise.resolve(undefined)
+    if (pending.has(url)) return pending.get(url)
+    const promise = (async () => {
+      const local = url === 'lobe:deepseek'
+      const version = local ? require('@lobehub/icons-static-svg/package.json').version : ''
+      const key = createHash('sha256').update(local ? `${url}@${version}` : url).digest('hex')
+      const file = options.settingsPath && path.join(path.dirname(options.settingsPath), 'cache', 'harness-icons', `${key}.png`)
+      if (file) {
+        try {
+          if ((await fs.stat(file)).size <= MAX_BYTES) {
+            const cached = await fs.readFile(file)
+            if (png(cached)) return cached.toString('base64')
+          }
+        } catch { /* Missing cache: fetch below. */ }
+      }
+      let source
+      if (local) {
+        source = await fs.readFile(require.resolve('@lobehub/icons-static-svg/icons/deepseek.svg'))
+        if (source.length > MAX_BYTES) throw new Error('Icon too large')
+      } else {
+        const response = await (options.fetchImpl ?? fetch)(url, { signal: AbortSignal.timeout(5000) })
+        if (!response.ok) throw new Error('Icon unavailable')
+        if (Number(response.headers.get('content-length')) > MAX_BYTES) throw new Error('Icon too large')
+        const chunks = []
+        let size = 0
+        for await (const chunk of response.body) {
+          size += chunk.length
+          if (size > MAX_BYTES) throw new Error('Icon too large')
+          chunks.push(chunk)
+        }
+        source = Buffer.concat(chunks)
+      }
+      // Lazy import: an unavailable optional native renderer still leaves the name usable.
+      const { Resvg } = await import('@resvg/resvg-js')
+      let bytes
+      if (png(source)) {
+        bytes = source
+      } else {
+        const renderer = new Resvg(source.toString('utf8').replaceAll('currentColor', '#a0a0a0'), {
+          fitTo: { mode: 'width', value: 64 }, font: { loadSystemFonts: false },
+        })
+        if (renderer.width <= 0 || renderer.height <= 0 || renderer.height / renderer.width > 4) throw new Error('Invalid icon dimensions')
+        bytes = renderer.render().asPng()
+      }
+      if (!png(bytes)) throw new Error('Invalid icon')
+      if (file) {
+        const temporary = `${file}.${randomUUID()}.tmp`
+        try {
+          await fs.mkdir(path.dirname(file), { recursive: true })
+          await fs.writeFile(temporary, bytes)
+          await fs.rename(temporary, file)
+        } catch { /* A read-only cache must not hide a downloaded icon. */ }
+        finally { await fs.rm(temporary, { force: true }).catch(() => {}) }
+      }
+      return bytes.toString('base64')
+    })().catch(() => undefined)
+    pending.set(url, promise)
+    return promise
+  }
+}
+
+function packageName(spec) {
+  if (typeof spec !== 'string') return undefined
+  return /^(?:(@[^/\s]+\/[^@/\s]+)|([^@/\s:]+))(?:@[^\s]+)?$/.exec(spec)?.slice(1).find(Boolean)
+}
+
+function runtimePackage(runtime) {
+  if (!runtime || !/(?:^|[/\\])npx(?:\.cmd|\.exe)?$/i.test(runtime.command ?? '')) return undefined
+  const args = runtime.args ?? []
+  const explicit = args.findIndex(arg => arg === '--package' || arg === '-p')
+  return packageName(explicit >= 0 ? args[explicit + 1] : args.find(arg => !arg.startsWith('-')))
+}
+
+export function apply(ctx, options = {}) {
+  const loadIcon = options.loadIcon ?? createIconCache(options)
+  let panel, disposed = false, generation = 0, lastKey
+  let nodes = []
+  const stopSlot = ctx.tuiSlots.inject('conversation.harness', () => {
+    panel = ctx.tuiSlots.register({ name: 'conversation.harness', id: 'harness' }, nodes)
+    return () => panel.dispose()
+  })
+  function update(status) {
+    const session = status.session?.bound ? status.session.sessionId : undefined
+    const key = JSON.stringify([session, status.server, status.runtime])
+    if (key === lastKey) return
+    lastKey = key
+    const token = ++generation
+    if (!session) { nodes = []; panel?.update(nodes); return }
+    const registry = options.registry ?? readAcpRegistrySnapshot(options)
+    const runtime = status.runtime
+    const entries = options.entries ?? discoverHarnesses(options.settingsPath, { ...options, registry, pathValue: '' })
+    const entry = runtime && entries.find(candidate => candidate.command === runtime.command
+      && JSON.stringify(candidate.args ?? []) === JSON.stringify(runtime.args ?? []))
+    const npmPackage = runtimePackage(runtime) ?? packageName(status.server)
+    const record = registry.find(candidate => candidate.id === entry?.id)
+      ?? registry.find(candidate => candidate.id === status.server || candidate.label === status.server)
+      ?? (npmPackage && registry.find(candidate => candidate.distributions?.some(distribution =>
+        distribution.type === 'npx' && packageName(distribution.args?.[0]) === npmPackage)))
+      ?? (['dsh-acp', '@deepseek-ai/dsh-acp', '@openma/deepseek-harness-acp'].includes(status.server)
+        || ['@deepseek-ai/dsh-acp', '@openma/deepseek-harness-acp'].includes(npmPackage)
+        ? deepseekBadge : undefined)
+    const label = (record?.label ?? entry?.label ?? status.server ?? runtime?.command)?.replace(/\s+harness$/i, '')
+    nodes = label ? [{ id: session, kind: 'image', name: label, mime: 'image/png' }] : []
+    panel?.update(nodes)
+    if (record?.icon && nodes.length) void loadIcon(record.icon).then(dataBase64 => {
+      if (disposed || token !== generation || !dataBase64) return
+      nodes = [{ ...nodes[0], dataBase64 }]
+      panel?.update(nodes)
+    })
+  }
+  update(ctx.acpSessionStatus.current())
+  const stopStatus = ctx.acpSessionStatus.subscribe(update)
+  return () => { disposed = true; ++generation; stopStatus?.(); stopSlot?.() }
+}

package/lib/harness-environment.js

@@ -0,0 +1,9 @@
+/** npm exec exports its invocation selectors to children. They belong to Martty's
+ * launcher, not a nested Harness runner (npx otherwise treats a package as a bin).
+ * Keep registry/proxy/cache/auth settings and explicit Harness overrides intact.
+ */
+export function harnessEnvironment(overrides = {}, inherited = process.env) {
+  const env = Object.fromEntries(Object.entries(inherited).filter(([key]) =>
+    !/^npm_config_(package|call|workspace|workspaces|include_workspace_root)$/i.test(key)))
+  return { ...env, ...overrides }
+}

package/lib/harness-package.js

@@ -1,3 +1,4 @@
+import { harnessEnvironment } from './harness-environment.js'
 import { StringDecoder } from 'node:string_decoder'
 import spawn from 'cross-spawn'
 
@@ -155,7 +156,7 @@ export async function prepareHarnessPackage(entry, options = {}) {
     try {
       child = (options.spawnImpl ?? spawn)(runner, args, {
         cwd: options.cwd,
-        env: { ...process.env, ...distribution.env, ...entry.env, ...options.env },
+        env: harnessEnvironment({ ...distribution.env, ...entry.env, ...options.env }),
         stdio: ['ignore', 'pipe', 'pipe'],
         windowsHide: true,
         detached: process.platform !== 'win32',

package/lib/harness-registry.js

@@ -128,6 +128,7 @@ export function normalizeAcpRegistry(value, options = {}) {
     return [{
       id: agent.id,
       label: agent.name,
+      ...(typeof agent.icon === 'string' ? { icon: agent.icon } : {}),
       version: agent.version,
       description: typeof agent.description === 'string' ? agent.description : '',
       distributions,

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,32 @@ 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' })
+    const emptySession = ctx.acpSessionStatus?.current()?.session?.started === false
+    if (!options.hostOwned && (openNow || emptySession)) 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 +318,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 +537,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 +566,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 +586,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/lobe-icons.LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 LobeHub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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/lib/tui-slots.js

@@ -16,9 +16,11 @@ export const SLOT_NAMES = Object.freeze([
   'conversation.input.dock',
   'conversation.navigation.dock',
   'conversation.composer.dock',
+  'conversation.harness',
 ])
 
 const SLOT_DEFINITIONS = Object.freeze({
+  'conversation.harness': Object.freeze({ kind: 'single', scope: 'session' }),
   'welcome.hero': Object.freeze({ kind: 'single', scope: 'root' }),
   'welcome.info': Object.freeze({ kind: 'single', scope: 'root' }),
   'chrome.right': Object.freeze({ kind: 'list', scope: 'root' }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "martty",
-  "version": "0.2.38",
+  "version": "0.2.39-beta.1",
   "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-badge.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": {
@@ -76,7 +76,9 @@
   },
   "dependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
+    "@lobehub/icons-static-svg": "1.95.0",
     "@openma/deepseek-harness-acp": "0.4.31",
+    "@resvg/resvg-js": "2.6.2",
     "cross-spawn": "^7.0.6",
     "node-downloader-helper": "2.1.11"
   },