martty 0.2.32 → 0.2.34

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,10 +103,11 @@ 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,
     })
+    if (message.method === 'session/load') reset(readString(message.params, 'sessionId', 'session_id'))
   }
 
   function observeAgent(message) {
@@ -98,13 +116,22 @@ 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
+      // Replay notifications precede the setup response. Preserve their state.
+      if (!plansBySession.has(bound)) reset(bound)
+      else if (bound === sessionId) publish()
       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 +139,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 +151,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 +165,7 @@ export function installAcpSessionPlan(ctx) {
         },
         observeClient,
         observeAgent,
+        selectSession,
       }
   if (typeof ctx.provide !== 'function') ctx.acpSessionPlan = service
   return service