martty 0.2.32 → 0.2.33

package/bin/martty.js

@@ -14,11 +14,19 @@ const vendorDir = path.join(__dirname, '..', 'vendor')
 const binaryName = process.platform === 'win32' ? 'martty.exe' : 'martty'
 const packaged = path.join(vendorDir, platformKey, binaryName)
 const configuredBin = process.env.MARTTY_BIN || process.env.DSH_TUI_BIN
-const binaryPath = typeof configuredBin === 'string'
-  && configuredBin.length > 0
-  && fs.existsSync(configuredBin)
-  ? configuredBin
-  : packaged
+let binaryPath = packaged
+if (typeof configuredBin === 'string' && configuredBin.length > 0) {
+  if (fs.existsSync(configuredBin)) {
+    binaryPath = configuredBin
+  } else {
+    // Never silently fall back: the user believes they are running their
+    // own build (devlocalinstall.sh has caught this confusion before).
+    console.error(
+      `martty: ${configuredBin} (from ${process.env.MARTTY_BIN ? 'MARTTY_BIN' : 'DSH_TUI_BIN'})`
+        + ' does not exist — falling back to the bundled binary',
+    )
+  }
+}
 
 const argv = process.argv.slice(2)
 const wantDemoSkin = argv.includes('--demo-skin')
@@ -74,9 +82,14 @@ if (!fs.existsSync(binaryPath)) {
 }
 
 function exitFromSpawn(result) {
+  if (result.error) {
+    // A failed spawn (ENOENT, EACCES) sets status/signal to null; without
+    // a diagnostic the process would just exit 1 with no explanation.
+    console.error('martty: failed to launch the native binary: ' + result.error.message)
+  }
   process.exit(
-    result.status ??
-      (result.signal === 'SIGINT' ? 130 : result.signal === 'SIGTERM' ? 143 : 1),
+    result.status
+      ?? (result.signal === 'SIGINT' ? 130 : result.signal === 'SIGTERM' ? 143 : 1),
   )
 }
 

package/lib/acp-client-events.js

@@ -14,6 +14,7 @@ class AcpClientEventsService extends Service {
   register(observer) { return this.core.register(this.ctx, observer) }
   observeClient(message) { return this.core.observeClient(message) }
   observeAgent(message) { return this.core.observeAgent(message) }
+  selectSession(sessionId) { return this.core.selectSession(sessionId) }
 }
 
 export function installAcpClientEvents(ctx) {
@@ -48,13 +49,18 @@ export function installAcpClientEvents(ctx) {
     for (const observer of [...observers]) observer.observeAgent?.(message)
   }
 
-  const core = { register, observeClient, observeAgent }
+  function selectSession(sessionId) {
+    for (const observer of [...observers]) observer.selectSession?.(sessionId)
+  }
+
+  const core = { register, observeClient, observeAgent, selectSession }
   const service = typeof ctx.provide === 'function'
     ? new AcpClientEventsService(ctx, core)
     : {
         register(observer) { return register(ctx, observer) },
         observeClient,
         observeAgent,
+        selectSession,
       }
   if (typeof ctx.provide !== 'function') ctx.acpClientEvents = service
   return service

package/lib/acp-client.js

@@ -23,6 +23,14 @@ export const inject = []
 /** @type {null | { command: string, args: string[], child: import('node:child_process').ChildProcess, stdin: import('node:stream').Writable, stdout: import('node:stream').Readable, kind: 'spawn' }} */
 let liveAgent = null
 
+/**
+ * One kill-on-exit hook per process, replaced (not accumulated) whenever a
+ * new agent is spawned. Registering `process.once('exit', …)` per apply()
+ * would stack listeners and kill every past child again on exit.
+ * @type {null | (() => void)}
+ */
+let liveAgentExitHook = null
+
 /**
  * @typedef {{ command: string, args?: string[], env?: Record<string, string> }} AgentSpec
  */
@@ -115,13 +123,17 @@ export function apply(ctx, config = {}) {
   }
   liveAgent = service
   provide(ctx, service)
-  process.once('exit', () => {
+  if (liveAgentExitHook !== null) {
+    process.removeListener('exit', liveAgentExitHook)
+  }
+  liveAgentExitHook = () => {
     try {
       child.kill('SIGTERM')
     } catch {
       // already gone
     }
-  })
+  }
+  process.once('exit', liveAgentExitHook)
 }
 
 function provide(ctx, service) {

package/lib/acp-host.js

@@ -4,7 +4,7 @@ import { createRequire } from 'node:module'
 import { pathToFileURL } from 'node:url'
 
 export const name = 'dsh-tui-acp-host'
-export const inject = ['loader']
+export const inject = ['loader', 'userQuestions', 'permissionPresets']
 
 function resolvedModule(ctx, specifier) {
   for (const anchor of [ctx.baseUrl, import.meta.url]) {
@@ -18,7 +18,130 @@ function resolvedModule(ctx, specifier) {
   return specifier
 }
 
+function resolvedHostModule(ctx, specifier) {
+  if (typeof ctx.baseUrl !== 'string') return undefined
+  try {
+    return pathToFileURL(createRequire(ctx.baseUrl).resolve(specifier)).href
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * dsh 0.1.2 replaced the single user-question provider slot with a scoped
+ * waterfall. Keep the ACP dependency's older provider seam working while it
+ * remains protocol-compatible with both Host generations.
+ */
+export function installUserQuestionsCompatibility(ctx) {
+  const service = ctx.get?.('userQuestions')
+  if (service === undefined || typeof service.registerProvider === 'function') return false
+  const registerProvider = (provider) => {
+    if (provider === null || typeof provider !== 'object' || typeof provider.ask !== 'function') {
+      throw new TypeError('userQuestions.registerProvider: provider must expose ask()')
+    }
+    return ctx.on('user-questions/request', (request) => provider.ask(request))
+  }
+  Object.defineProperty(service, 'registerProvider', {
+    configurable: true,
+    value: registerProvider,
+  })
+  ctx.effect(() => () => {
+    if (service.registerProvider === registerProvider) delete service.registerProvider
+  }, 'dsh-tui.user-questions-compatibility')
+  return true
+}
+
+/**
+ * dsh 0.1.2 replaced Session.events with snapshotEvents(). ACP 0.4.x only
+ * reads the old immutable snapshot, so restore that getter until ACP can
+ * require the new Host API directly.
+ */
+export function installSessionEventsCompatibility(Session) {
+  const prototype = Session?.prototype
+  if (prototype === undefined || 'events' in prototype) return false
+  if (typeof prototype.snapshotEvents !== 'function') return false
+  Object.defineProperty(prototype, 'events', {
+    configurable: true,
+    get() {
+      if (typeof this.snapshotEvents === 'function') return this.snapshotEvents()
+      // Cordis may hand an older plugin a remote Session reference whose
+      // declared surface predates snapshotEvents(). The 0.1.2 reference still
+      // exposes the scalar seq/eventAt pair, which yields the same snapshot.
+      if (typeof this.eventAt === 'function' && Number.isInteger(this.seq)) {
+        const events = []
+        for (let seq = 0; seq < this.seq; seq += 1) {
+          const event = this.eventAt(seq)
+          if (event !== undefined) events.push(event)
+        }
+        return Object.freeze(events)
+      }
+      return Object.freeze([])
+    },
+  })
+  return true
+}
+
+/** Accept ACP 0.4.x's event-array read alongside dsh 0.1.2's Session read. */
+export function installPermissionPresetsCompatibility(permissionPresets) {
+  if (permissionPresets === undefined) return false
+  const current = permissionPresets.current
+  if (typeof current !== 'function' || current.dshTuiAcceptsEventArrays === true) return false
+  const compatibleCurrent = function (target) {
+    if (!Array.isArray(target)) return current.call(this, target)
+    let state = { preset: null, sandbox: null, approval: null, seeded: false }
+    for (const event of target) {
+      switch (event?.type) {
+        case 'permission/preset':
+          state = { ...state, preset: event.data?.preset ?? null }
+          break
+        case 'sandbox/mode':
+          state = { ...state, sandbox: event.data?.mode ?? null }
+          break
+        case 'approval/policy':
+          state = { ...state, approval: event.data?.policy ?? null }
+          break
+        case 'session/end-seed':
+          state = { ...state, seeded: true }
+          break
+      }
+    }
+    return this.derive(state)
+  }
+  Object.defineProperty(compatibleCurrent, 'dshTuiAcceptsEventArrays', { value: true })
+  Object.defineProperty(permissionPresets, 'current', {
+    configurable: true,
+    value: compatibleCurrent,
+  })
+  return true
+}
+
+async function mountHostCompatibility(ctx) {
+  // The service can come from the active Host even when module resolution
+  // below lands on ACP's older peer copy, so adapt the live instance directly.
+  installPermissionPresetsCompatibility(ctx.permissionPresets ?? ctx.get?.('permissionPresets'))
+
+  const sessionModule = resolvedHostModule(ctx, '@deepseek-ai/dsh-session')
+  if (sessionModule !== undefined) {
+    const exports = await ctx.loader.import(sessionModule)
+    installSessionEventsCompatibility(exports.Session)
+  }
+
+  // New dsh presets opt the delegation tool into Host-owned model selection.
+  // Older hosts neither export nor require this service, so resolution is
+  // deliberately anchored only at the active Host profile.
+  if (ctx.get?.('subagentModelSelection') !== undefined) return
+  const resolved = resolvedHostModule(
+    ctx,
+    '@deepseek-ai/dsh-tool-subagent/model-selection-settings',
+  )
+  if (resolved === undefined) return
+  const exports = await ctx.loader.import(resolved)
+  await ctx.plugin(ctx.loader.unwrapExports(exports))
+}
+
 export async function apply(ctx, config) {
+  await mountHostCompatibility(ctx)
+  installUserQuestionsCompatibility(ctx)
   const specifier = '@openma/deepseek-harness-acp/plugin'
   const resolved = resolvedModule(ctx, specifier)
   let exports

package/lib/acp-session-config.js

@@ -12,7 +12,7 @@ import { CORDIS_METHODS, CORDIS_PROTOCOL } from './cordis-protocol.js'
 export const name = 'acp-session-config'
 export const inject = []
 
-const SETUP_METHODS = new Set(['session/new', 'session/load'])
+const SETUP_METHODS = new Set(['session/new', 'session/load', 'session/resume'])
 
 class AcpSessionConfigService extends Service {
   constructor(ctx, core) {
@@ -55,25 +55,35 @@ class AcpSessionConfigService extends Service {
   observeAgent(message) {
     return this.core.observeAgent(message)
   }
+
+  selectSession(sessionId) {
+    return this.core.selectSession(sessionId)
+  }
 }
 
 /** Install the `ctx.acpSessionConfig` standard ACP state service. */
 export function installAcpSessionConfig(ctx) {
   let sessionId
-  let options = []
+  let selectionKnown = false
+  const optionsBySession = new Map()
   let requestTui
   const pending = new Map()
   const listeners = new Set()
 
+  function listFor(targetSessionId) {
+    return cloneJson(optionsBySession.get(targetSessionId) ?? [])
+  }
+
   function list() {
-    return cloneJson(options)
+    return listFor(sessionId)
   }
 
   function current(id) {
     if (typeof id !== 'string' || id.length === 0) {
       throw new Error('acpSessionConfig.current: id must be a non-empty string')
     }
-    const option = options.find((candidate) => candidate?.id === id)
+    const option = (optionsBySession.get(sessionId) ?? [])
+      .find((candidate) => candidate?.id === id)
     return cloneJson(option?.currentValue ?? option?.current_value)
   }
 
@@ -81,23 +91,36 @@ export function installAcpSessionConfig(ctx) {
     if (typeof category !== 'string' || category.length === 0) {
       throw new Error('acpSessionConfig.byCategory: category must be a non-empty string')
     }
-    return cloneJson(options.filter((candidate) => candidate?.category === category))
+    return cloneJson(
+      (optionsBySession.get(sessionId) ?? [])
+        .filter((candidate) => candidate?.category === category),
+    )
   }
 
   function snapshot() {
     return { sessionId, options: list() }
   }
 
-  function publish(nextSessionId, nextOptions) {
-    if (typeof nextSessionId === 'string' && nextSessionId.length > 0) {
-      sessionId = nextSessionId
-    }
-    if (!Array.isArray(nextOptions)) return
-    options = cloneJson(nextOptions)
+  function publish() {
     const next = snapshot()
     for (const listener of [...listeners]) listener(next)
   }
 
+  function updateSession(targetSessionId, nextOptions) {
+    if (typeof targetSessionId !== 'string' || targetSessionId.length === 0
+      || !Array.isArray(nextOptions)) return
+    optionsBySession.set(targetSessionId, cloneJson(nextOptions))
+    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('acpSessionConfig.subscribe: listener must be a function')
@@ -120,7 +143,7 @@ export function installAcpSessionConfig(ctx) {
   function observeClient(message) {
     if (!isObject(message) || message.id === undefined || typeof message.method !== 'string') return
     if (SETUP_METHODS.has(message.method)) {
-      const requested = message.method === 'session/load'
+      const requested = message.method !== 'session/new'
         ? readString(message.params, 'sessionId', 'session_id')
         : undefined
       pending.set(message.id, { kind: 'setup', sessionId: requested })
@@ -143,21 +166,21 @@ export function installAcpSessionConfig(ctx) {
       const bound = readString(message.result, 'sessionId', 'session_id') ?? tracked.sessionId
       const next = readOptions(message.result)
       if (tracked.kind === 'setup') {
-        sessionId = bound
-        publish(bound, next ?? [])
-      } else if (bound === undefined || bound === sessionId) {
-        publish(bound, next)
+        if (!selectionKnown) sessionId = bound
+        updateSession(bound, next ?? [])
+      } else {
+        updateSession(bound, next)
       }
       return
     }
     if (message.method !== 'session/update' || !isObject(message.params)) return
     const updatedSession = readString(message.params, 'sessionId', 'session_id')
-    if (sessionId !== undefined && updatedSession !== sessionId) return
     const update = message.params.update
     if (!isObject(update)) return
     const type = readString(update, 'sessionUpdate', 'session_update')
     if (type !== 'config_option_update') return
-    publish(updatedSession, readOptions(update))
+    if (!selectionKnown && sessionId === undefined) sessionId = updatedSession
+    updateSession(updatedSession, readOptions(update))
   }
 
   function bindTransport(nextRequestTui) {
@@ -170,37 +193,47 @@ export function installAcpSessionConfig(ctx) {
     }
   }
 
-  async function set(id, value) {
+  async function setForSession(targetSessionId, id, value) {
     if (typeof id !== 'string' || id.length === 0) {
       throw new Error('acpSessionConfig.set: id must be a non-empty string')
     }
-    if (sessionId === undefined) {
+    if (targetSessionId === undefined) {
       throw new Error('acpSessionConfig.set: no ACP Session is active')
     }
     if (typeof requestTui !== 'function') {
       throw new Error('acpSessionConfig.set: native ACP transport is unavailable')
     }
-    const option = options.find((candidate) => candidate?.id === id)
+    const option = (optionsBySession.get(targetSessionId) ?? [])
+      .find((candidate) => candidate?.id === id)
     if (option === undefined) {
       throw new Error(`acpSessionConfig.set: option "${id}" is not advertised by the current Session`)
     }
     validateValue(option, value)
     const result = await requestTui(CORDIS_METHODS.sessionConfigSet, {
       protocol: CORDIS_PROTOCOL,
-      sessionId,
+      sessionId: targetSessionId,
       configId: id,
       value,
     })
     if (!isObject(result)) {
       throw new Error('acpSessionConfig.set: native ACP client returned an invalid response')
     }
-    const resultSession = readString(result, 'sessionId', 'session_id') ?? sessionId
-    publish(resultSession, readOptions(result))
-    return list()
+    const resultSession = readString(result, 'sessionId', 'session_id') ?? targetSessionId
+    updateSession(resultSession, readOptions(result))
+    return listFor(targetSessionId)
+  }
+
+  async function set(id, value) {
+    return setForSession(sessionId, id, value)
   }
 
   function transaction(selector) {
-    const option = resolveTransactionOption(selector, options)
+    const transactionSessionId = sessionId
+    if (transactionSessionId === undefined) {
+      throw new Error('acpSessionConfig.transaction: no ACP Session is active')
+    }
+    const transactionOptions = optionsBySession.get(transactionSessionId) ?? []
+    const option = resolveTransactionOption(selector, transactionOptions)
     const original = cloneJson(option.currentValue ?? option.current_value)
     if (original === undefined) {
       throw new Error(
@@ -210,18 +243,18 @@ export function installAcpSessionConfig(ctx) {
 
     let desired = cloneJson(original)
     let applied = cloneJson(original)
-    let chain = Promise.resolve(list())
+    let chain = Promise.resolve(listFor(transactionSessionId))
     let finalizing
     let settled = false
 
     const write = async (value) => {
-      const result = await set(option.id, value)
+      const result = await setForSession(transactionSessionId, option.id, value)
       applied = cloneJson(value)
       return result
     }
 
     const preview = (value) => {
-      if (settled) return Promise.resolve(list())
+      if (settled) return Promise.resolve(listFor(transactionSessionId))
       if (finalizing) return finalizing
       if (Object.is(value, desired)) return chain
       desired = cloneJson(value)
@@ -232,13 +265,13 @@ export function installAcpSessionConfig(ctx) {
     }
 
     const finish = (value) => {
-      if (settled) return finalizing ?? Promise.resolve(list())
+      if (settled) return finalizing ?? Promise.resolve(listFor(transactionSessionId))
       if (finalizing) return finalizing
       desired = cloneJson(value)
       const settle = async () => {
         if (!Object.is(applied, desired)) await write(desired)
         settled = true
-        return list()
+        return listFor(transactionSessionId)
       }
       finalizing = chain.then(settle, settle).catch((error) => {
         finalizing = undefined
@@ -273,6 +306,7 @@ export function installAcpSessionConfig(ctx) {
     bindTransport,
     observeClient,
     observeAgent,
+    selectSession,
   }
   const service = typeof ctx.provide === 'function'
     ? new AcpSessionConfigService(ctx, core)
@@ -288,6 +322,7 @@ export function installAcpSessionConfig(ctx) {
         bindTransport,
         observeClient,
         observeAgent,
+        selectSession,
       }
   if (typeof ctx.provide !== 'function') ctx.acpSessionConfig = service
   return service

package/lib/acp-session-plan.js

@@ -5,7 +5,7 @@ import { Service } from '@deepseek-ai/cordis'
 export const name = 'acp-session-plan'
 export const inject = []
 
-const SETUP_METHODS = new Set(['session/new', 'session/load'])
+const SETUP_METHODS = new Set(['session/new', 'session/load', 'session/resume'])
 
 class AcpSessionPlanService extends Service {
   constructor(ctx, core) {
@@ -32,21 +32,30 @@ class AcpSessionPlanService extends Service {
   observeAgent(message) {
     return this.core.observeAgent(message)
   }
+
+  selectSession(sessionId) {
+    return this.core.selectSession(sessionId)
+  }
 }
 
 /** Install `ctx.acpSessionPlan`, backed only by standard ACP traffic. */
 export function installAcpSessionPlan(ctx) {
   let sessionId
-  const plans = new Map()
+  let selectionKnown = false
+  const plansBySession = new Map()
   const pending = new Map()
   const listeners = new Set()
 
+  function activePlans() {
+    return plansBySession.get(sessionId) ?? new Map()
+  }
+
   function list() {
-    return cloneJson([...plans.values()])
+    return cloneJson([...activePlans().values()])
   }
 
   function current() {
-    return cloneJson([...plans.values()].at(-1) ?? null)
+    return cloneJson([...activePlans().values()].at(-1) ?? null)
   }
 
   function snapshot() {
@@ -58,9 +67,17 @@ export function installAcpSessionPlan(ctx) {
     for (const listener of [...listeners]) listener(next)
   }
 
-  function reset(nextSessionId) {
-    sessionId = nextSessionId
-    plans.clear()
+  function reset(targetSessionId) {
+    if (typeof targetSessionId !== 'string' || targetSessionId.length === 0) return
+    plansBySession.set(targetSessionId, new Map())
+    if (targetSessionId === sessionId) publish()
+  }
+
+  function selectSession(nextSessionId) {
+    selectionKnown = true
+    sessionId = typeof nextSessionId === 'string' && nextSessionId.length > 0
+      ? nextSessionId
+      : undefined
     publish()
   }
 
@@ -86,7 +103,7 @@ export function installAcpSessionPlan(ctx) {
   function observeClient(message) {
     if (!isObject(message) || message.id === undefined || !SETUP_METHODS.has(message.method)) return
     pending.set(message.id, {
-      sessionId: message.method === 'session/load'
+      sessionId: message.method !== 'session/new'
         ? readString(message.params, 'sessionId', 'session_id')
         : undefined,
     })
@@ -98,13 +115,20 @@ export function installAcpSessionPlan(ctx) {
       const tracked = pending.get(message.id)
       pending.delete(message.id)
       if (message.error !== undefined || !isObject(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
+      reset(bound)
       return
     }
     if (message.method !== 'session/update' || !isObject(message.params)) return
     const updatedSession = readString(message.params, 'sessionId', 'session_id')
-    if (sessionId !== undefined && updatedSession !== sessionId) return
-    if (sessionId === undefined && updatedSession !== undefined) sessionId = updatedSession
+    if (updatedSession === undefined) return
+    if (!selectionKnown && sessionId === undefined) sessionId = updatedSession
+    let plans = plansBySession.get(updatedSession)
+    if (plans === undefined) {
+      plans = new Map()
+      plansBySession.set(updatedSession, plans)
+    }
     const update = message.params.update
     if (!isObject(update)) return
     const type = readString(update, 'sessionUpdate', 'session_update')
@@ -112,7 +136,7 @@ export function installAcpSessionPlan(ctx) {
       const id = readString(update, 'planId', 'plan_id')
       if (id === undefined) plans.clear()
       else plans.delete(id)
-      publish()
+      if (updatedSession === sessionId) publish()
       return
     }
     if (type !== 'plan' && type !== 'plan_update') return
@@ -124,10 +148,10 @@ export function installAcpSessionPlan(ctx) {
       plans.delete(plan.id)
       plans.set(plan.id, plan)
     }
-    publish()
+    if (updatedSession === sessionId) publish()
   }
 
-  const core = { list, current, subscribe, observeClient, observeAgent }
+  const core = { list, current, subscribe, observeClient, observeAgent, selectSession }
   const service = typeof ctx.provide === 'function'
     ? new AcpSessionPlanService(ctx, core)
     : {
@@ -138,6 +162,7 @@ export function installAcpSessionPlan(ctx) {
         },
         observeClient,
         observeAgent,
+        selectSession,
       }
   if (typeof ctx.provide !== 'function') ctx.acpSessionPlan = service
   return service

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,26 @@ 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,
       })
       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,
+      started: now(),
+      firstToken: undefined,
+      toolMillis: 0,
+    }
     pendingPrompts.set(message.id, prompt)
-    activePrompts.set(sessionId, prompt)
-    value.stats.turns += 1
-    publish()
+    activePrompts.set(promptSessionId, prompt)
+    stateFor(promptSessionId).stats.turns += 1
+    publishIf(promptSessionId)
   }
 
   function observeAgent(message) {
@@ -108,32 +144,36 @@ 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
+      reset(bound)
       return
     }
     if (message.id !== undefined && pendingPrompts.has(message.id)) {
       const prompt = pendingPrompts.get(message.id)
       pendingPrompts.delete(message.id)
       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()
+      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 +187,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 +202,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 +233,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 +241,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)

package/lib/tui-theme.js

@@ -7,7 +7,7 @@
  * flushed from `bindNotify`.
  */
 
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
 import { dirname, isAbsolute } from 'node:path'
 import { CORDIS_METHODS } from './cordis-protocol.js'
 
@@ -92,7 +92,12 @@ function writePreferred(settingsPath, id) {
   const settings = readSettings(settingsPath)
   settings.theme = id
   mkdirSync(dirname(settingsPath), { recursive: true })
-  writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`)
+  // Atomic write (temp + rename), matching harnesses.writeSettings: a
+  // crash mid-write must never leave a truncated settings.json behind —
+  // every later launch would otherwise start from an unreadable file.
+  const temporary = `${settingsPath}.${process.pid}.${Date.now()}.tmp`
+  writeFileSync(temporary, `${JSON.stringify(settings, null, 2)}\n`)
+  renameSync(temporary, settingsPath)
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "martty",
-  "version": "0.2.32",
+  "version": "0.2.33",
   "description": "Terminal-native ACP client UI; Cordis client tree, any ACP agent",
   "license": "MIT",
   "repository": {