martty 0.2.32 → 0.2.34

package/lib/acp-session-stats.js

@@ -5,7 +5,7 @@ import { Service } from '@deepseek-ai/cordis'
 export const name = 'acp-session-stats'
 export const inject = []
 
-const SETUP_METHODS = new Set(['session/new', 'session/load'])
+const SETUP_METHODS = new Set(['session/new', 'session/load', 'session/resume'])
 
 class AcpSessionStatsService extends Service {
   constructor(ctx, core) {
@@ -17,6 +17,7 @@ class AcpSessionStatsService extends Service {
   subscribe(listener) { return this.core.subscribe(this.ctx, listener) }
   observeClient(message) { return this.core.observeClient(message) }
   observeAgent(message) { return this.core.observeAgent(message) }
+  selectSession(sessionId) { return this.core.selectSession(sessionId) }
 }
 
 function zero(sessionId) {
@@ -44,20 +45,51 @@ export function installAcpSessionStats(ctx, options = {}) {
   const pendingPrompts = new Map()
   const activePrompts = new Map()
   const toolStarts = new Map()
-  let value = zero(undefined)
+  const values = new Map()
+  let sessionId
+  let selectionKnown = false
 
-  function current() { return structuredClone(value) }
+  function stateFor(targetSessionId) {
+    if (typeof targetSessionId !== 'string' || targetSessionId.length === 0) {
+      return zero(undefined)
+    }
+    let value = values.get(targetSessionId)
+    if (value === undefined) {
+      value = zero(targetSessionId)
+      values.set(targetSessionId, value)
+    }
+    return value
+  }
+
+  function current() { return structuredClone(stateFor(sessionId)) }
 
   function publish() {
     const snapshot = current()
     for (const listener of [...listeners]) listener(snapshot)
   }
 
-  function reset(sessionId) {
-    value = zero(sessionId)
-    activePrompts.clear()
-    pendingPrompts.clear()
-    toolStarts.clear()
+  function publishIf(targetSessionId) {
+    if (targetSessionId === sessionId) publish()
+  }
+
+  function reset(targetSessionId) {
+    if (typeof targetSessionId !== 'string' || targetSessionId.length === 0) return
+    values.set(targetSessionId, zero(targetSessionId))
+    activePrompts.delete(targetSessionId)
+    for (const [id, prompt] of pendingPrompts) {
+      if (prompt.sessionId === targetSessionId) pendingPrompts.delete(id)
+    }
+    for (const key of toolStarts.keys()) {
+      if (key.startsWith(`${targetSessionId}\u0000`)) toolStarts.delete(key)
+    }
+    publishIf(targetSessionId)
+  }
+
+  function selectSession(nextSessionId) {
+    selectionKnown = true
+    sessionId = typeof nextSessionId === 'string' && nextSessionId.length > 0
+      ? nextSessionId
+      : undefined
     publish()
   }
 
@@ -84,22 +116,30 @@ export function installAcpSessionStats(ctx, options = {}) {
     if (!object(message) || message.id === undefined || typeof message.method !== 'string') return
     if (SETUP_METHODS.has(message.method)) {
       pendingSetup.set(message.id, {
-        sessionId: message.method === 'session/load'
+        sessionId: message.method !== 'session/new'
           ? readString(message.params, 'sessionId', 'session_id')
           : undefined,
       })
+      if (message.method === 'session/load') reset(readString(message.params, 'sessionId', 'session_id'))
       return
     }
     if (message.method !== 'session/prompt') return
-    const sessionId = readString(message.params, 'sessionId', 'session_id')
-    if (sessionId === undefined) return
-    if (value.sessionId === undefined) value.sessionId = sessionId
-    if (value.sessionId !== sessionId) return
-    const prompt = { sessionId, started: now(), firstToken: undefined, toolMillis: 0 }
+    const promptSessionId = readString(message.params, 'sessionId', 'session_id')
+    if (promptSessionId === undefined) return
+    if (!selectionKnown && sessionId === undefined) sessionId = promptSessionId
+    const prompt = {
+      sessionId: promptSessionId,
+      primary: !activePrompts.has(promptSessionId),
+      started: now(),
+      firstToken: undefined,
+      toolMillis: 0,
+    }
     pendingPrompts.set(message.id, prompt)
-    activePrompts.set(sessionId, prompt)
-    value.stats.turns += 1
-    publish()
+    if (prompt.primary) {
+      activePrompts.set(promptSessionId, prompt)
+      stateFor(promptSessionId).stats.turns += 1
+    }
+    publishIf(promptSessionId)
   }
 
   function observeAgent(message) {
@@ -108,32 +148,38 @@ export function installAcpSessionStats(ctx, options = {}) {
       const tracked = pendingSetup.get(message.id)
       pendingSetup.delete(message.id)
       if (message.error !== undefined || !object(message.result)) return
-      reset(readString(message.result, 'sessionId', 'session_id') ?? tracked.sessionId)
+      const bound = readString(message.result, 'sessionId', 'session_id') ?? tracked.sessionId
+      if (!selectionKnown) sessionId = bound
+      // Replay notifications precede the setup response. Preserve their state.
+      if (!values.has(bound)) reset(bound)
+      else if (bound === sessionId) publish()
       return
     }
     if (message.id !== undefined && pendingPrompts.has(message.id)) {
       const prompt = pendingPrompts.get(message.id)
       pendingPrompts.delete(message.id)
-      activePrompts.delete(prompt.sessionId)
+      if (activePrompts.get(prompt.sessionId) === prompt) activePrompts.delete(prompt.sessionId)
+      const value = stateFor(prompt.sessionId)
       if (message.error === undefined && object(message.result)) {
-        addUsage(message.result.usage)
+        addUsage(value, message.result.usage)
       }
       const elapsed = Math.max(0, now() - prompt.started)
-      value.stats.llmMillis += Math.max(0, elapsed - prompt.toolMillis)
-      publish()
+      if (prompt.primary) value.stats.llmMillis += Math.max(0, elapsed - prompt.toolMillis)
+      publishIf(prompt.sessionId)
       return
     }
     if (message.method !== 'session/update' || !object(message.params)) return
-    const sessionId = readString(message.params, 'sessionId', 'session_id')
-    if (value.sessionId !== undefined && sessionId !== value.sessionId) return
-    if (value.sessionId === undefined) value.sessionId = sessionId
+    const updateSessionId = readString(message.params, 'sessionId', 'session_id')
+    if (updateSessionId === undefined) return
+    if (!selectionKnown && sessionId === undefined) sessionId = updateSessionId
+    const value = stateFor(updateSessionId)
     const update = message.params.update
     if (!object(update)) return
 
     const replay = update?._meta?.dsh
     if (object(replay) && replay.event === 'prompt/usage') {
       value.usage = usageOf(replay.usage)
-      publish()
+      publishIf(updateSessionId)
       return
     }
 
@@ -147,11 +193,11 @@ export function installAcpSessionStats(ctx, options = {}) {
       const size = number(update.size)
       if (size > 0) {
         value.context = { used: number(update.used), size }
-        publish()
+        publishIf(updateSessionId)
       }
       return
     }
-    const prompt = sessionId === undefined ? undefined : activePrompts.get(sessionId)
+    const prompt = activePrompts.get(updateSessionId)
     if (prompt !== undefined && prompt.firstToken === undefined
       && (type === 'agent_message_chunk' || type === 'agent_thought_chunk')
       && textOf(update.content).length > 0) {
@@ -162,28 +208,28 @@ export function installAcpSessionStats(ctx, options = {}) {
     if (type === 'agent_message_chunk'
       && update?._meta?.dsh?.event === 'assistant_message') {
       value.stats.steps += 1
-      publish()
+      publishIf(updateSessionId)
       return
     }
     const callId = readString(update, 'toolCallId', 'tool_call_id')
     if (type === 'tool_call' && callId !== undefined) {
-      toolStarts.set(`${sessionId ?? ''}\u0000${callId}`, now())
+      toolStarts.set(`${updateSessionId}\u0000${callId}`, now())
       return
     }
     if (type === 'tool_call_update' && callId !== undefined
       && ['completed', 'failed'].includes(update.status)) {
-      const key = `${sessionId ?? ''}\u0000${callId}`
+      const key = `${updateSessionId}\u0000${callId}`
       const started = toolStarts.get(key)
       toolStarts.delete(key)
       if (started === undefined) return
       const duration = Math.max(0, now() - started)
       value.stats.toolMillis += duration
       if (prompt !== undefined) prompt.toolMillis += duration
-      publish()
+      publishIf(updateSessionId)
     }
   }
 
-  function addUsage(usage) {
+  function addUsage(value, usage) {
     const next = usageOf(usage)
     value.usage.input += next.input
     value.usage.output += next.output
@@ -193,7 +239,7 @@ export function installAcpSessionStats(ctx, options = {}) {
     value.usage.reasoning += next.reasoning
   }
 
-  const core = { current, subscribe, observeClient, observeAgent }
+  const core = { current, subscribe, observeClient, observeAgent, selectSession }
   const service = typeof ctx.provide === 'function'
     ? new AcpSessionStatsService(ctx, core)
     : {
@@ -201,6 +247,7 @@ export function installAcpSessionStats(ctx, options = {}) {
         subscribe(listener) { return subscribe(ctx, listener) },
         observeClient,
         observeAgent,
+        selectSession,
       }
   if (typeof ctx.provide !== 'function') ctx.acpSessionStats = service
   return service

package/lib/acp-session-status.js

@@ -14,7 +14,7 @@ export const name = 'acp-session-status'
 export const inject = ['acpClientEvents', 'acpSessionConfig']
 
 const AUTH_REQUIRED_CODE = -32000
-const SETUP_METHODS = new Set(['session/new', 'session/load'])
+const SETUP_METHODS = new Set(['session/new', 'session/load', 'session/resume'])
 const RUNNING_UPDATE_TYPES = new Set([
   'user_message_chunk',
   'agent_message_chunk',
@@ -37,20 +37,20 @@ class AcpSessionStatusService extends Service {
   subscribe(listener) { return this.core.subscribe(this.ctx, listener) }
   observeClient(message) { return this.core.observeClient(message) }
   observeAgent(message) { return this.core.observeAgent(message) }
+  selectSession(sessionId) { return this.core.selectSession(sessionId) }
 }
 
-function zero() {
+function zeroSession(sessionId, bound = sessionId !== undefined) {
   return {
     state: 'idle',
-    connection: 'connecting',
-    server: undefined,
-    auth: { status: undefined, method: undefined },
-    session: { sessionId: undefined, bound: false },
+    session: { sessionId, bound },
     model: undefined,
     effort: undefined,
     permission: undefined,
     plan: undefined,
     agent: undefined,
+    permissionPreset: undefined,
+    sandboxMode: undefined,
   }
 }
 
@@ -60,21 +60,55 @@ export function installAcpSessionStatus(ctx, options = {}) {
     ?? ctx.acpSessionConfig ?? ctx.get?.('acpSessionConfig')
 
   const listeners = new Set()
-  let value = zero()
+  const sessions = new Map()
+  const fallback = zeroSession(undefined, false)
+  let sessionId
+  let selectionKnown = false
+  let connection = 'connecting'
+  let server
+  const auth = { status: undefined, method: undefined }
   let initializeId
-  let pendingAuthenticate = new Set()
+  const pendingAuthenticate = new Set()
   const pendingSetup = new Map()
   const pendingPrompts = new Map()
-  let permissionPreset
-  let sandboxMode
 
-  function current() { return structuredClone(value) }
+  function stateFor(targetSessionId, bound = targetSessionId !== undefined) {
+    if (typeof targetSessionId !== 'string' || targetSessionId.length === 0) {
+      return fallback
+    }
+    let value = sessions.get(targetSessionId)
+    if (value === undefined) {
+      value = zeroSession(targetSessionId, bound)
+      sessions.set(targetSessionId, value)
+    } else if (bound) {
+      value.session.bound = true
+    }
+    return value
+  }
+
+  function current() {
+    const value = stateFor(sessionId)
+    const { permissionPreset: _permissionPreset, sandboxMode: _sandboxMode, ...visible } = value
+    return structuredClone({ connection, server, auth, ...visible })
+  }
 
   function publish() {
     const snapshot = current()
     for (const listener of [...listeners]) listener(snapshot)
   }
 
+  function publishIf(targetSessionId) {
+    if (targetSessionId === sessionId) publish()
+  }
+
+  function selectSession(nextSessionId) {
+    selectionKnown = true
+    sessionId = typeof nextSessionId === 'string' && nextSessionId.length > 0
+      ? nextSessionId
+      : undefined
+    publish()
+  }
+
   function subscribe(effectCtx, listener) {
     if (typeof listener !== 'function') {
       throw new Error('acpSessionStatus.subscribe: listener must be a function')
@@ -102,27 +136,28 @@ export function installAcpSessionStatus(ctx, options = {}) {
     }
     if (message.method === 'authenticate' && message.id !== undefined) {
       pendingAuthenticate.add(message.id)
-      value.auth.status = 'signing in'
+      auth.status = 'signing in'
       publish()
       return
     }
     if (SETUP_METHODS.has(message.method) && message.id !== undefined) {
       pendingSetup.set(
         message.id,
-        message.method === 'session/load'
+        message.method !== 'session/new'
           ? readString(message.params, 'sessionId', 'session_id')
           : undefined,
       )
       return
     }
     if (message.method === 'session/prompt' && message.id !== undefined) {
-      pendingPrompts.set(
-        message.id,
-        readString(message.params, 'sessionId', 'session_id'),
-      )
+      const promptSessionId = readString(message.params, 'sessionId', 'session_id')
+      if (promptSessionId === undefined) return
+      if (!selectionKnown && sessionId === undefined) sessionId = promptSessionId
+      pendingPrompts.set(message.id, promptSessionId)
+      const value = stateFor(promptSessionId)
       if (value.state === 'idle') {
         value.state = 'starting'
-        publish()
+        publishIf(promptSessionId)
       }
     }
   }
@@ -131,14 +166,14 @@ export function installAcpSessionStatus(ctx, options = {}) {
     if (!object(message)) return
     if (message.id !== undefined && message.id === initializeId) {
       initializeId = undefined
-      value.connection = 'attached'
+      connection = 'attached'
       const result = object(message.result) ? message.result : undefined
-      value.server = readString(result?.agentInfo, 'name')
+      server = readString(result?.agentInfo, 'name')
       const methods = Array.isArray(result?.authMethods) ? result.authMethods : []
       const method = methods.find((candidate) => object(candidate)
         && typeof candidate.id === 'string' && candidate.id.length > 0)
-      if (method !== undefined && value.auth.status === undefined) {
-        value.auth.method = readString(method, 'name', 'label') ?? method.id
+      if (method !== undefined && auth.status === undefined) {
+        auth.method = readString(method, 'name', 'label') ?? method.id
       }
       publish()
       return
@@ -146,11 +181,11 @@ export function installAcpSessionStatus(ctx, options = {}) {
     if (message.id !== undefined && pendingAuthenticate.has(message.id)) {
       pendingAuthenticate.delete(message.id)
       if (message.error === undefined) {
-        value.auth.status = 'configured'
+        auth.status = 'configured'
       } else if (isAuthRequired(message.error)) {
-        value.auth.status = 'needs sign-in'
+        auth.status = 'needs sign-in'
       } else {
-        value.auth.status = undefined
+        auth.status = undefined
       }
       publish()
       return
@@ -159,82 +194,99 @@ export function installAcpSessionStatus(ctx, options = {}) {
       const requested = pendingSetup.get(message.id)
       pendingSetup.delete(message.id)
       if (message.error !== undefined) {
-        if (isAuthRequired(message.error)) value.auth.status = 'needs sign-in'
-        value.session = { sessionId: requested, bound: false }
+        if (isAuthRequired(message.error)) auth.status = 'needs sign-in'
+        if (requested !== undefined) {
+          stateFor(requested, false).session.bound = false
+        }
+        if (!selectionKnown) sessionId = requested
       } else {
-        const sessionId = readString(message.result, 'sessionId', 'session_id') ?? requested
-        value.session = { sessionId, bound: sessionId !== undefined }
+        const bound = readString(message.result, 'sessionId', 'session_id') ?? requested
+        if (bound !== undefined) stateFor(bound).session = { sessionId: bound, bound: true }
+        if (!selectionKnown) sessionId = bound
       }
       publish()
       return
     }
     if (response(message) && pendingPrompts.has(message.id)) {
+      const promptSessionId = pendingPrompts.get(message.id)
       pendingPrompts.delete(message.id)
       let changed = false
       if (message.error !== undefined && isAuthRequired(message.error)
-        && value.auth.status !== 'needs sign-in') {
-        value.auth.status = 'needs sign-in'
+        && auth.status !== 'needs sign-in') {
+        auth.status = 'needs sign-in'
         changed = true
       }
-      if (pendingPrompts.size === 0 && value.state !== 'idle') {
+      const value = stateFor(promptSessionId)
+      if (!hasPendingPrompt(promptSessionId) && value.state !== 'idle') {
         value.state = 'idle'
         changed = true
       }
-      if (changed) publish()
+      if (changed && (promptSessionId === sessionId || auth.status === 'needs sign-in')) publish()
       return
     }
     if (message.error !== undefined && isAuthRequired(message.error)) {
-      value.auth.status = 'needs sign-in'
+      auth.status = 'needs sign-in'
       publish()
       return
     }
 
     if (message.method === 'session.status' && object(message.params)) {
+      const statusSessionId = readString(message.params, 'sessionId', 'session_id') ?? sessionId
+      if (statusSessionId === undefined) return
+      if (!selectionKnown && sessionId === undefined) sessionId = statusSessionId
       const status = readString(message.params, 'status')
-      if (status === 'running' || (status === 'idle' && pendingPrompts.size === 0)) {
+      const value = stateFor(statusSessionId)
+      if (status === 'running' || (status === 'idle' && !hasPendingPrompt(statusSessionId))) {
         value.state = status
-        publish()
+        publishIf(statusSessionId)
       }
       return
     }
     if (message.method === 'session.event' && object(message.params)) {
+      const eventSessionId = readString(message.params, 'sessionId', 'session_id') ?? sessionId
+      if (eventSessionId === undefined) return
+      if (!selectionKnown && sessionId === undefined) sessionId = eventSessionId
+      const value = stateFor(eventSessionId)
       const event = object(message.params.event) ? message.params.event : undefined
       const type = readString(event, 'type')
       const data = object(event?.data) ? event.data : undefined
       if (type === 'permission/preset') {
         const preset = readString(data, 'preset')
         if (preset !== undefined) {
-          permissionPreset = preset
-          value.permission = permissionPreset ?? sandboxMode
-          publish()
+          value.permissionPreset = preset
+          value.permission = value.permissionPreset ?? value.sandboxMode
+          publishIf(eventSessionId)
         }
       } else if (type === 'sandbox/mode') {
         const mode = readString(data, 'mode')
         if (mode !== undefined) {
-          sandboxMode = mode
-          value.permission = permissionPreset ?? sandboxMode
-          publish()
+          value.sandboxMode = mode
+          value.permission = value.permissionPreset ?? value.sandboxMode
+          publishIf(eventSessionId)
         }
       } else if (type === 'plan/mode' && typeof data?.active === 'boolean') {
         value.plan = data.active
-        publish()
+        publishIf(eventSessionId)
       } else if (type === 'agent-preset/selected') {
         const preset = readString(data, 'agentPreset')
         if (preset !== undefined) {
           value.agent = preset
-          publish()
+          publishIf(eventSessionId)
         }
       }
       return
     }
     if (message.method !== 'session/update' || !object(message.params)) return
-    const sessionId = readString(message.params, 'sessionId', 'session_id')
+    const updateSessionId = readString(message.params, 'sessionId', 'session_id')
+    if (updateSessionId === undefined) return
+    if (!selectionKnown && sessionId === undefined) sessionId = updateSessionId
     const update = object(message.params.update) ? message.params.update : undefined
     const type = readString(update, 'sessionUpdate', 'session_update')
-    if (value.state !== 'running' && hasPendingPrompt(sessionId)
+    const value = stateFor(updateSessionId)
+    if (value.state !== 'running' && hasPendingPrompt(updateSessionId)
       && RUNNING_UPDATE_TYPES.has(type)) {
       value.state = 'running'
-      publish()
+      publishIf(updateSessionId)
     }
   }
 
@@ -248,13 +300,13 @@ export function installAcpSessionStatus(ctx, options = {}) {
 
   function onConfigSnapshot(snapshot) {
     if (snapshot === null || typeof snapshot !== 'object') return
-    if (typeof snapshot.sessionId === 'string' && snapshot.sessionId.length > 0
-      && value.session.sessionId === undefined) {
-      value.session = { sessionId: snapshot.sessionId, bound: true }
-    }
+    const configSessionId = typeof snapshot.sessionId === 'string' && snapshot.sessionId.length > 0
+      ? snapshot.sessionId
+      : sessionId
+    const value = stateFor(configSessionId)
     value.model = optionValue(snapshot.options, 'model') ?? value.model
     value.effort = optionValue(snapshot.options, 'effort') ?? value.effort
-    publish()
+    publishIf(configSessionId)
   }
 
   function optionValue(options, id) {
@@ -265,7 +317,7 @@ export function installAcpSessionStatus(ctx, options = {}) {
     return typeof raw === 'string' ? raw : undefined
   }
 
-  const core = { current, subscribe, observeClient, observeAgent }
+  const core = { current, subscribe, observeClient, observeAgent, selectSession }
   const service = typeof ctx.provide === 'function'
     ? new AcpSessionStatusService(ctx, core)
     : {
@@ -273,6 +325,7 @@ export function installAcpSessionStatus(ctx, options = {}) {
         subscribe(listener) { return subscribe(ctx, listener) },
         observeClient,
         observeAgent,
+        selectSession,
       }
   if (typeof ctx.provide !== 'function') ctx.acpSessionStatus = service
 
@@ -286,7 +339,7 @@ export function installAcpSessionStatus(ctx, options = {}) {
   if (typeof events?.register === 'function') {
     // register(observer) only: the service scopes the subscription to its
     // own Context, so pass the folding object alone.
-    events.register({ observeClient, observeAgent })
+    events.register({ observeClient, observeAgent, selectSession })
   }
 
   return service

package/lib/cordis-protocol.js

@@ -37,6 +37,7 @@ export const CORDIS_METHODS = Object.freeze({
   agentsUpdate: '_dsh/cordis/tui/agents/update',
   agentsSelect: '_dsh/cordis/tui/agents/select',
   agentsNavigate: '_dsh/cordis/tui/agents/navigate',
+  sessionActive: '_dsh/cordis/tui/session/active',
   sessionConfigSet: '_dsh/cordis/tui/session-config/set',
 })
 

package/lib/harnesses.js

@@ -28,14 +28,28 @@ function readSettings(settingsPath) {
   try {
     value = JSON.parse(readFileSync(settingsPath, 'utf8'))
   } catch (error) {
-    throw new Error(`invalid Martty settings: ${error.message}`)
+    // A corrupt settings file must never block boot (boot.js: "must not
+    // block boot"). Park the unreadable file for diagnosis and start
+    // over — the same resilience tui-theme/tui-presets apply.
+    quarantineSettings(settingsPath, `invalid Martty settings: ${error.message}`)
+    return {}
   }
   if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-    throw new Error('invalid Martty settings: root must be an object')
+    quarantineSettings(settingsPath, 'invalid Martty settings: root must be an object')
+    return {}
   }
   return value
 }
 
+function quarantineSettings(settingsPath, reason) {
+  process.stderr.write(`martty: ${reason} — moving it aside and starting fresh\n`)
+  try {
+    renameSync(settingsPath, `${settingsPath}.corrupt-${Date.now()}`)
+  } catch {
+    // Best effort only; the fresh settings write below still proceeds.
+  }
+}
+
 function writeSettings(settingsPath, value) {
   mkdirSync(path.dirname(settingsPath), { recursive: true })
   const temporary = `${settingsPath}.${process.pid}.${Date.now()}.tmp`

package/lib/index.js

@@ -132,9 +132,10 @@ export async function applyShell(ctx, options = {}) {
   }
   const clientEvents = ctx.acpClientEvents ?? ctx.get?.('acpClientEvents')
   if (clientEvents === undefined || typeof clientEvents.observeClient !== 'function'
-    || typeof clientEvents.observeAgent !== 'function') {
+    || typeof clientEvents.observeAgent !== 'function'
+    || typeof clientEvents.selectSession !== 'function') {
     throw new Error(
-      'dsh-tui-shell: ctx.acpClientEvents must expose ACP observers',
+      'dsh-tui-shell: ctx.acpClientEvents must expose ACP observers and Session selection',
     )
   }
   const queue = ctx.tuiQueue ?? ctx.get?.('tuiQueue')
@@ -180,7 +181,9 @@ export async function applyShell(ctx, options = {}) {
           if (!shouldQuitOnPainterExit(signal)) return
           shellState.refuseRespawn = true
           if (shellState.livePainter?.child === child) shellState.livePainter = null
-          process.exit(code ?? (signal === 'SIGINT' ? 130 : 0))
+          // Signal exits must not read as success: 130/143 match the
+          // bin/martty.js convention; any other signal is a failure.
+          process.exit(code ?? (signal === 'SIGINT' ? 130 : signal === 'SIGTERM' ? 143 : 1))
         })
         child.on('error', (err) => {
           console.error(`dsh-tui: ${err.message}`)
@@ -241,6 +244,13 @@ export async function applyShell(ctx, options = {}) {
         if (message.method === CORDIS_METHODS.agentsUpdate) {
           return { ok: agents.observe(message.params) }
         }
+        if (message.method === CORDIS_METHODS.sessionActive) {
+          const active = message.params?.sessionId
+          clientEvents.selectSession(
+            typeof active === 'string' && active.length > 0 ? active : undefined,
+          )
+          return { ok: true }
+        }
         if (message.method === CORDIS_METHODS.approvalRespond) {
           return clientRunner.respondApproval(message.params)
         }

package/lib/mux.js

@@ -24,6 +24,7 @@ const COMPOSITOR_METHODS = Object.freeze(new Set([
   CORDIS_METHODS.agentsUpdate,
   CORDIS_METHODS.agentsSelect,
   CORDIS_METHODS.agentsNavigate,
+  CORDIS_METHODS.sessionActive,
   CORDIS_METHODS.sessionConfigSet,
   CORDIS_METHODS.approvalRespond,
   CORDIS_METHODS.uiSelected,

package/lib/runner.js

@@ -79,7 +79,11 @@ export async function apply(ctx) {
     void release()
   })
   child.once('exit', (code, signal) => {
-    requestExit(code ?? (signal === 'SIGINT' ? 130 : 1))
+    // Profile patch watching can recompose the Host tree immediately after
+    // startup. In that path our disposer deliberately terminates this Client
+    // process; its resulting SIGTERM belongs to the old fiber and must not
+    // tear down the replacement tree through appExit(1).
+    if (!released) requestExit(code ?? (signal === 'SIGINT' ? 130 : 1))
     void release()
   })
   process.once('exit', onProcessExit)