martty 0.3.2 → 0.3.3

package/README.md

@@ -24,7 +24,7 @@ x64. Requires Node.js 22.19+.
 
 ```sh
 npm install --global martty
-martty
+martty-cli   # the first launch creates `martty`; use `martty` afterwards
 ```
 
 Martty directly depends on our `@openma/deepseek-harness-acp` implementation.
@@ -46,6 +46,38 @@ The profile command is the recommended install and upgrade path. It creates a
 missing profile and installs the TUI plus its ACP dependency; no global
 `martty` installation is required.
 
+dsh installs plugins with pnpm. Martty declares no install lifecycle scripts
+(`preinstall`/`install`/`postinstall`), so it installs under pnpm's strict
+build-script policy (`ERR_PNPM_IGNORED_BUILDS`) without `--ignore-scripts`. A
+profile where an install of 0.3.2 or earlier failed (`martty` is a dependency
+but not in `dsh.profile.bundles`) needs `dsh plugin --profile martty remove
+martty` and then `add` again.
+
+With such a profile in place, the npm entry point attaches to it too:
+
+```sh
+npx martty --dsh martty     # same as dsh --profile martty, after a version check
+```
+
+## Harness resolution and supported dsh
+
+1. Default (`martty` / `npx martty`): the bundled `@openma/deepseek-harness-acp`
+   and its bundled dsh runtime; ambient installs never override it.
+2. `--dsh <profile>`: the global `dsh` on `PATH` with that profile — a profile
+   carrying `martty` gets the terminal, one carrying only dsh-acp becomes the
+   ACP agent. Below the dsh floor Martty falls back to (1) and shows a short
+   notice (`/dismiss` hides it).
+3. As a dsh plugin (`dsh --profile martty`): the hosting dsh.
+4. An explicit dsh path in a harness recipe (`--dsh-path` / `DSH_PATH`).
+
+Supported dsh is a floor, `>=0.1.7-rc.2` (`engines.dsh`, which dsh's own plugin
+compatibility check reads), never an exact list. Newer dsh releases are
+attempted — API differences are feature-detected, and a dsh newer than the
+newest tested one (`0.2.1-rc.2`) only warns. Below the floor, or when the Host
+lacks a required capability, `dsh --profile martty` still opens the TUI and the
+conversation explains the installed version, the floor or missing capability,
+and the options (`npx martty`, or install a supported dsh).
+
 ## Migrating from DeepSeek Harness TUI / the scoped package
 
 `martty` is the recommended package name. Starting with `0.2.13`, it and the
@@ -63,17 +95,17 @@ published versions of `martty` register `dsh-tui`
 legacy checkouts own the same names (a checkout of this repository links as
 `martty`, so it replaces — or is replaced by — an installed `martty` with no
 collision). The `martty` package declares only `martty-cli` so npm never
-refuses the install over a bin another package owns (`EEXIST`); a
-postinstall step then retires the stale `martty`/`dsh-tui`/`dsb` links that
-verifiably belonged to the legacy package (a third-party `dsh-tui` stays
-untouched), creates the `martty` command itself, and detaches the legacy
-package's bin declarations so a later `npm rm -g` can't take `martty` down
-with it. Removing `martty` afterwards is optional
+refuses the install over a bin another package owns (`EEXIST`). It ships no
+install scripts: the first launch of `martty-cli` (or `npx martty`) retires
+the stale `martty`/`dsh-tui`/`dsb` links that verifiably belonged to the
+legacy package (a third-party `dsh-tui` stays untouched), creates the `martty`
+command itself, and detaches the legacy package's bin declarations so a later
+`npm rm -g` can't take `martty` down with it. Until that first launch a fresh
+install has only `martty-cli`; upgrades from 0.3.2 keep their `martty`.
+Removing `martty` afterwards is optional
 cleanup; `martty` warns at launch while it remains — on an interactive
 terminal the notice prints when the session exits, so the TUI cannot hide
-it. With `--ignore-scripts`
-the postinstall never runs — invoke `martty-cli` once (or `npx martty`) and
-the first launch finishes the migration itself. And after `npm rm -g
+it. And after `npm rm -g
 martty`, the `martty` command left behind is a self-cleaning shim: invoking
 it once prints the reinstall hint and removes it — nothing dead is left
 in `<prefix>/bin`.

package/bin/martty.js

@@ -10,6 +10,7 @@ import { bootClient, parseClientArgv, painterArgs, uiSettingsPath } from '../lib
 import { runHarnessCommandAsync } from '../lib/harnesses.js'
 import { nativeBinary } from '../lib/spawn-tui.js'
 import { reportLaunchNotices, warnAboutLegacyPackage } from '../lib/install-migration.js'
+import { planDshLaunch, runDshProfile, takeDshFlag } from '../lib/dsh-launch.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const configuredBin = process.env.MARTTY_BIN || process.env.DSH_TUI_BIN
@@ -90,12 +91,29 @@ if (argv[0] === 'harness') {
 // Validate startup arguments before resolving the native painter. A source
 // checkout must report the same usage errors as an installed package.
 let parsed
+let dshNotice
 if (!wantHelp && !wantVersion && !wantDemo && !wantDemoSkin) {
-  try { parsed = parseClientArgv(argv) }
-  catch (error) {
-    console.error(`martty: ${error instanceof Error ? error.message : String(error)}`)
+  let dshPlan
+  try {
+    // `--dsh <profile>` attaches to the global dsh. Its version is checked
+    // before anything spawns: below a floor, Martty keeps its bundled
+    // harness and says why in the TUI; newer than tested only warns.
+    const { profile, rest } = takeDshFlag(argv)
+    if (profile !== null) dshPlan = planDshLaunch(profile, rest)
+    parsed = parseClientArgv(rest)
+    if (dshPlan?.mode === 'agent') parsed = { ...parsed, agent: dshPlan.agent }
+    if (dshPlan?.mode === 'bundled') console.error(`martty: ${dshPlan.notice.text}`)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    console.error(message.startsWith('martty:') ? message : `martty: ${message}`)
     process.exit(Number.isInteger(error?.exitCode) ? error.exitCode : 1)
   }
+  dshNotice = dshPlan?.notice
+  if (dshPlan?.mode === 'profile') {
+    // The profile carries Martty itself: dsh boots its Host tree and the
+    // profile's runner starts the TUI on this terminal.
+    process.exit(runDshProfile(dshPlan))
+  }
 }
 
 if (configuredBin && !fs.existsSync(configuredBin)) {
@@ -141,4 +159,4 @@ if (wantDemoSkin) {
 }
 
 process.env.MARTTY_BIN ??= binaryPath
-await bootClient({ agent: parsed.agent, extraArgs: painterArgs(parsed) })
+await bootClient({ agent: parsed.agent, extraArgs: painterArgs(parsed), notice: dshNotice })

package/lib/acp-host.js

@@ -1,7 +1,12 @@
 /** Resolve the embeddable ACP plugin from TUI's own dependency graph. */
 
+import { readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { pathToFileURL } from 'node:url'
+import { DSH_FLOOR, isUntested, requirementOf, satisfiesRange, untestedWarning } from './dsh-compat.js'
+import { createHostNoticeServer } from './host-notice-agent.js'
+
+const OWN_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version
 
 export const name = 'dsh-tui-acp-host'
 export const inject = ['loader', 'userQuestions', 'permissionPresets']
@@ -203,6 +208,69 @@ export function installSessionPersistenceCompatibility(ctx) {
   return true
 }
 
+function readManifest(anchor, specifier) {
+  if (typeof anchor !== 'string') return undefined
+  try {
+    const file = createRequire(anchor).resolve(`${specifier}/package.json`)
+    return { file, manifest: JSON.parse(readFileSync(file, 'utf8')) }
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * The hosting dsh and the ACP plugin this entry is about to mount, resolved
+ * the way dsh-acp resolves them: the Host anchor is `dshAcpHostBaseUrl` or
+ * the profile base; the plugin comes from the profile, then from Martty's
+ * own dependency graph.
+ */
+export function hostCompatibility(ctx) {
+  const hostBase = ctx.get?.('dshAcpHostBaseUrl')
+  const host = readManifest(typeof hostBase === 'string' ? hostBase : ctx.baseUrl, '@deepseek-ai/dsh')
+  let acp
+  for (const anchor of [ctx.baseUrl, import.meta.url]) {
+    acp = readManifest(anchor, '@openma/deepseek-harness-acp')
+    if (acp !== undefined) break
+  }
+  const dsh = host?.manifest?.version
+  const checks = [{ name: 'martty', version: OWN_VERSION, range: DSH_FLOOR }]
+  const acpRange = requirementOf(acp?.manifest)
+  if (acpRange !== undefined) {
+    checks.push({ name: '@openma/deepseek-harness-acp', version: acp.manifest.version, range: acpRange })
+  }
+  const unmet = typeof dsh === 'string' ? checks.filter(({ range }) => !satisfiesRange(dsh, range)) : []
+  return { dsh, dshPath: host?.file, unmet, untested: isUntested(dsh) }
+}
+
+/** The in-TUI explanation when the ACP plugin cannot run on this Host. */
+export function hostNoticeMessage({ dsh, dshPath, reason, unmet = [] }) {
+  const lines = ['**Martty cannot attach to this dsh profile.**', '']
+  if (reason !== undefined) lines.push(reason, '')
+  if (dsh !== undefined) lines.push(`Installed dsh: \`${dsh}\`${dshPath ? ` (${dshPath})` : ''}`)
+  for (const { name, version, range } of unmet) {
+    lines.push(`\`${name}\` ${version} supports dsh \`${range}\``)
+  }
+  lines.push(
+    '',
+    'To continue:',
+    '- run Martty with its bundled harness instead: `npx martty`',
+    '- or install a supported dsh: `npm install -g @deepseek-ai/dsh@latest`',
+    '- or update this profile\'s plugins: `dsh plugin --profile <name> update`',
+  )
+  return lines.join('\n')
+}
+
+function provideHostNotice(ctx, details) {
+  if (ctx.get?.('acpServer') !== undefined) return
+  const message = hostNoticeMessage(details)
+  process.stderr.write(`${message.replace(/\*\*|`/g, '')}\n`)
+  ctx.provide?.('acpServer', createHostNoticeServer(message, { version: OWN_VERSION }))
+}
+
+// How long the ACP plugin may wait for a Host service before Martty names
+// the missing capability in the TUI instead of leaving the runner pending.
+export const REQUIRED_SERVICE_WAIT_MS = 10_000
+
 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.
@@ -231,6 +299,16 @@ async function mountHostCompatibility(ctx) {
 }
 
 export async function apply(ctx, config) {
+  const compatibility = hostCompatibility(ctx)
+  if (compatibility.unmet.length > 0) {
+    // Below a declared floor (or an older dsh-acp's exact list): show why in
+    // the TUI rather than mounting a plugin that will refuse the Host.
+    provideHostNotice(ctx, compatibility)
+    return
+  }
+  if (compatibility.untested) {
+    process.stderr.write(`${untestedWarning(compatibility.dsh, compatibility.dshPath)}\n`)
+  }
   await mountHostCompatibility(ctx)
   installUserQuestionsCompatibility(ctx)
   const specifier = '@openma/deepseek-harness-acp/plugin'
@@ -242,9 +320,48 @@ export async function apply(ctx, config) {
     throw new Error(`dsh-tui: failed to import ${specifier} from ${resolved}`, { cause })
   }
   const plugin = ctx.loader.unwrapExports(exports)
+  let fiber
   try {
-    await ctx.plugin(plugin, config)
+    fiber = ctx.plugin(plugin, config)
+    await fiber
   } catch (cause) {
-    throw new Error(`dsh-tui: failed to mount ${specifier}`, { cause })
+    provideHostNotice(ctx, { ...compatibility, reason: `The ACP plugin failed to mount: ${errorText(cause)}` })
+    return
   }
+  watchAcpPlugin(ctx, fiber, plugin, compatibility)
+}
+
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/**
+ * The ACP plugin activates asynchronously (it waits for its injected Host
+ * services) and reports a refusal from its own fiber, which dsh's
+ * activation report never sees. Surface either outcome in the TUI: a
+ * failure names its error; a service still missing after
+ * {@link REQUIRED_SERVICE_WAIT_MS} is named as the absent capability.
+ */
+function watchAcpPlugin(ctx, fiber, plugin, compatibility) {
+  if (ctx.get?.('acpServer') !== undefined) return
+  let settled = false
+  fiber?.await?.().then(
+    () => { settled = true },
+    (error) => {
+      settled = true
+      provideHostNotice(ctx, { ...compatibility, reason: `The ACP plugin did not start: ${errorText(error)}` })
+    },
+  )
+  const timer = setTimeout(() => {
+    if (settled || ctx.get?.('acpServer') !== undefined) return
+    const missing = (Array.isArray(plugin?.inject) ? plugin.inject : [])
+      .filter((service) => ctx.get?.(service) === undefined)
+    if (missing.length === 0) return
+    provideHostNotice(ctx, {
+      ...compatibility,
+      reason: `This dsh does not provide ${missing.length === 1 ? 'a service' : 'services'} the ACP plugin requires: ${missing.map((name) => `\`${name}\``).join(', ')}.`,
+    })
+  }, REQUIRED_SERVICE_WAIT_MS)
+  timer.unref?.()
+  ctx.effect?.(() => () => clearTimeout(timer), 'martty.acp-plugin-watch')
 }

package/lib/boot.js

@@ -1,3 +1,4 @@
+import { apply as applyLaunchNotice, inject as launchNoticeInject } from './launch-notice.js'
 import { apply as applyHarnessBadge, inject as harnessBadgeInject } from './harness-badge.js'
 /**
  * Boot-time restore of a statically-registered gallery palette (ayu,
@@ -71,6 +72,7 @@ import { installTuiLocalPlugins } from './tui-local-plugins.js'
  * Internal product-only forced Harness; null means no pinned Harness.
  * @param {{ id: string, label: string, command: string, args?: string[] } | null} [options.forcedHarness]
  * @param {string} [options.artifactRoot]
+ * @param {{ text: string, level?: 'info' | 'warn' | 'error', dismissAfterMs?: number }} [options.notice]
  * @param {Array<{ id: string, label: string, command: string, args?: string[], source?: string }>} [options.harnessDefaults]
  * @param {string} [options.harnessPathValue]
  * @param {Array<{ id: string, kind: 'theme' | 'ui', entry: string }>} [options.packagePlugins]
@@ -131,6 +133,9 @@ export async function bootClient(options = {}) {
     restorePreferredTheme(ctx.get('tuiTheme'))
     await ctx.plugin({ name: 'tui-slots', inject: [], apply: applySlots })
     await ctx.plugin({ name: 'tui-commands', inject: [], apply: applyCommands })
+    if (options.notice !== undefined) {
+      await ctx.plugin({ name: 'launch-notice', inject: launchNoticeInject, apply: applyLaunchNotice }, options.notice)
+    }
     await ctx.plugin({ name: 'tui-overlay', inject: [], apply: applyOverlay })
     await ctx.plugin({ name: 'tui-agents', inject: [], apply: applyAgents })
     await ctx.plugin({ name: 'tui-queue', inject: [], apply: applyQueue })
@@ -193,6 +198,7 @@ export async function bootClient(options = {}) {
     restorePreferredTheme(ctx.tuiTheme)
     applySlots(ctx)
     applyCommands(ctx)
+    if (options.notice !== undefined) applyLaunchNotice(ctx, options.notice)
     applyOverlay(ctx)
     applyAgents(ctx)
     applyQueue(ctx)

package/lib/creator-overlay.js

@@ -8,9 +8,16 @@ import { installSessionPersistenceCompatibility } from './acp-host.js'
 import { createTuiPluginStore } from './tui-plugin-store.js'
 
 export const name = 'tui-creator-overlay'
-export const inject = [
-  'agentPresets', 'skills', 'systemPrompt', 'loader', 'tools', 'dynamicCordisRunner',
-]
+export const inject = ['skills', 'systemPrompt', 'loader', 'tools']
+
+/**
+ * Services the ACP plugin provides. They are awaited by a nested
+ * `ctx.inject` rather than by this entry: when the ACP plugin cannot run on
+ * the Host (Martty then shows the reason in the TUI), the overlay simply
+ * stays idle instead of becoming a pending top-level entry in dsh's
+ * activation report.
+ */
+export const acpServices = ['agentPresets', 'dynamicCordisRunner']
 
 const SKILL_NAME = 'tui-plugin-development'
 const ROUTING_PROMPT = `# Dynamic TUI Plugin routing
@@ -224,7 +231,11 @@ const skillContent = skillDocument.slice(skillFrontmatter[0].length)
  * @param {object} ctx
  * @param {{ preset?: string, scopeWaitMs?: number, scopePollMs?: number }} [config]
  */
-export async function apply(ctx, config = {}) {
+export function apply(ctx, config = {}) {
+  ctx.inject(acpServices, (scoped) => applyOverlay(scoped, config))
+}
+
+export async function applyOverlay(ctx, config = {}) {
   // Standalone launches mount this overlay directly into the ACP Host tree,
   // which never loads martty/acp-host; both trees need the ACP compatibility
   // surface, and the installer is idempotent when the profile path already

package/lib/dsh-compat.js

@@ -0,0 +1,52 @@
+/**
+ * Martty's dsh compatibility policy: a minimum-version floor, never an
+ * exact-version allow-list.
+ *
+ * - Below the floor (`engines.dsh` in package.json — the field dsh's own
+ *   plugin loader evaluates for bundles): not attempted; the user gets a
+ *   message naming the installed version, the floor, and what to do.
+ * - At or above the floor: attempted. API differences are handled by feature
+ *   detection where they are used.
+ * - Newer than {@link TESTED_DSH_THROUGH}: attempted with a warning only.
+ *
+ * A dependency that still declares an exact-version list (dsh-acp <= 0.4.38)
+ * is evaluated the same way through {@link requirementOf}: its declared range
+ * is what it will enforce at mount time.
+ */
+
+import { readFileSync } from 'node:fs'
+import semver from 'semver'
+
+/** Highest dsh CI exercises Martty with (the `next` leg of the dsh-plugin matrix). */
+export const TESTED_DSH_THROUGH = '0.2.1-rc.2'
+
+const ownManifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'))
+
+/** The floor this Martty declares for its hosting dsh. */
+export const DSH_FLOOR = ownManifest.engines?.dsh ?? '*'
+
+export function satisfiesRange(version, range) {
+  if (typeof version !== 'string' || semver.valid(version) === null) return false
+  if (typeof range !== 'string' || range.trim() === '') return false
+  return semver.satisfies(version, range, { includePrerelease: true })
+}
+
+export function isUntested(version, testedThrough = TESTED_DSH_THROUGH) {
+  return typeof version === 'string' && semver.valid(version) !== null && semver.gt(version, testedThrough)
+}
+
+/**
+ * The dsh range a plugin manifest declares, mirroring dsh's own rule: an
+ * `engines.dsh` range decides alone, otherwise the `@deepseek-ai/dsh` peer.
+ * @returns {string | undefined}
+ */
+export function requirementOf(manifest) {
+  const engines = manifest?.engines?.dsh
+  if (typeof engines === 'string') return engines
+  const peer = manifest?.peerDependencies?.['@deepseek-ai/dsh']
+  return typeof peer === 'string' ? peer : undefined
+}
+
+export function untestedWarning(version, where) {
+  return `martty: dsh ${version}${where ? ` (${where})` : ''} is newer than the newest dsh Martty was tested with (${TESTED_DSH_THROUGH}); continuing.`
+}

package/lib/dsh-launch.js

@@ -0,0 +1,217 @@
+/**
+ * `martty --dsh <profile>`: run against the user's global dsh instead of
+ * the bundled dsh-acp runtime.
+ *
+ * The profile decides how Martty attaches:
+ * - a profile carrying the `martty` bundle (`dsh plugin --profile <name> add
+ *   martty`) is a complete TUI surface: dsh boots its Host tree and its own
+ *   runner starts the TUI Client, so the launcher hands the terminal to
+ *   `dsh --profile <name>`;
+ * - a profile carrying only `@openma/deepseek-harness-acp` is an ACP server
+ *   on stdio, so `dsh --profile <name>` becomes the ACP agent this Client
+ *   spawns.
+ *
+ * Either way the global dsh version is checked up front against the floor
+ * every installed plugin declares. A dsh below a floor is not attempted:
+ * the launcher falls back to the bundled dsh-acp runtime and the TUI shows a
+ * short notice saying why. A dsh newer than the newest tested one is
+ * attempted with a warning — versions are never rejected for being new.
+ */
+
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { homedir } from 'node:os'
+import path from 'node:path'
+import crossSpawn from 'cross-spawn'
+import semver from 'semver'
+import { DSH_FLOOR, isUntested, requirementOf, satisfiesRange, TESTED_DSH_THROUGH } from './dsh-compat.js'
+
+export const MARTTY_BUNDLE = 'martty'
+export const ACP_BUNDLE = '@openma/deepseek-harness-acp'
+const OWN_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version
+const INSTALL_HINT = 'npm install -g @deepseek-ai/dsh@latest'
+
+const usage = (message) => Object.assign(new Error(message), { exitCode: 2 })
+const failure = (message) => Object.assign(new Error(message), { exitCode: 1 })
+
+/**
+ * Split `--dsh <profile>` / `--dsh=<profile>` off argv.
+ * @param {string[]} argv
+ * @returns {{ profile: string | null, rest: string[] }}
+ */
+export function takeDshFlag(argv) {
+  let profile = null
+  const rest = []
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i]
+    let value
+    if (token === '--dsh') {
+      value = argv[i + 1]
+      i += 1
+    } else if (token.startsWith('--dsh=')) {
+      value = token.slice('--dsh='.length)
+    } else {
+      rest.push(token)
+      continue
+    }
+    if (typeof value !== 'string' || value.trim() === '' || value.startsWith('-')) {
+      throw usage('--dsh needs a dsh profile name (for example --dsh martty)')
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value)) {
+      throw usage(`--dsh: ${JSON.stringify(value)} is not a dsh profile name`)
+    }
+    if (profile !== null && profile !== value) throw usage('--dsh may name only one profile')
+    profile = value
+  }
+  if (profile !== null && rest.some((arg) => arg === '--agent' || arg === '--agent-arg')) {
+    throw usage('--dsh selects the agent itself; it cannot be combined with --agent/--agent-arg')
+  }
+  return { profile, rest }
+}
+
+/**
+ * The global dsh: whatever `dsh` resolves to on PATH, asked for its version.
+ * @returns {{ command: string, version: string }}
+ */
+export function resolveGlobalDsh({ env = process.env, spawnSync = crossSpawn.sync } = {}) {
+  const command = 'dsh'
+  const result = spawnSync(command, ['--version'], { encoding: 'utf8', env, timeout: 30_000 })
+  if (result.error?.code === 'ENOENT') {
+    throw failure(`martty: --dsh needs a global dsh on PATH, but \`${command}\` was not found. Install it with: ${INSTALL_HINT}`)
+  }
+  const version = semver.valid(String(result.stdout ?? '').trim().split(/\s+/).at(-1))
+  if (result.status !== 0 || version === null) {
+    const detail = String(result.stderr ?? result.error?.message ?? '').trim()
+    throw failure(`martty: could not read the version of the global \`${command}\`${detail ? `: ${detail}` : ''}`)
+  }
+  return { command, version }
+}
+
+export function dshHome(env = process.env) {
+  return env.DSH_HOME?.trim() ? path.resolve(env.DSH_HOME) : path.join(homedir(), '.dsh')
+}
+
+function installedManifest(profileDir, name) {
+  try {
+    const file = createRequire(path.join(profileDir, 'package.json')).resolve(`${name}/package.json`)
+    return JSON.parse(readFileSync(file, 'utf8'))
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Read a profile and decide whether the given dsh version may run it.
+ * @returns {{ mode: 'profile' | 'agent', dir: string, requirements: { name: string, version: string, range: string, supported: boolean }[] }}
+ */
+export function inspectDshProfile(profile, dshVersion, { env = process.env } = {}) {
+  const dir = path.join(dshHome(env), 'profiles', profile)
+  const manifestPath = path.join(dir, 'package.json')
+  if (!existsSync(manifestPath)) {
+    throw failure([
+      `martty: dsh profile "${profile}" does not exist (${dir}).`,
+      `Install Martty into it first: dsh plugin --profile ${profile} add martty@latest`,
+    ].join('\n'))
+  }
+  let manifest
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, 'utf8'))
+  } catch (cause) {
+    throw failure(`martty: cannot read dsh profile "${profile}" (${manifestPath}): ${cause.message}`)
+  }
+  const bundles = Array.isArray(manifest?.dsh?.profile?.bundles) ? manifest.dsh.profile.bundles : []
+  const mode = bundles.includes(MARTTY_BUNDLE)
+    ? 'profile'
+    : bundles.includes(ACP_BUNDLE) ? 'agent' : null
+  if (mode === null) {
+    throw failure([
+      `martty: dsh profile "${profile}" carries neither the ${MARTTY_BUNDLE} nor the ${ACP_BUNDLE} bundle.`,
+      `Add Martty to it: dsh plugin --profile ${profile} add martty@latest`,
+    ].join('\n'))
+  }
+  // Every floor that gates the Host: this Martty's, the profile's installed
+  // Martty's (`engines.dsh`; releases <= 0.3.2 declared `dsh.supported`), and
+  // the ACP plugin's, which it enforces at mount time.
+  const requirements = [{ name: `${MARTTY_BUNDLE} (launcher)`, version: OWN_VERSION, range: DSH_FLOOR }]
+  const martty = mode === 'profile' ? installedManifest(dir, MARTTY_BUNDLE) : undefined
+  const marttyRange = requirementOf(martty) ?? martty?.dsh?.supported
+  if (typeof marttyRange === 'string') {
+    requirements.push({ name: MARTTY_BUNDLE, version: martty.version, range: marttyRange })
+  }
+  const acp = installedManifest(dir, ACP_BUNDLE)
+  const acpRange = requirementOf(acp)
+  if (typeof acpRange === 'string') {
+    requirements.push({ name: ACP_BUNDLE, version: acp.version, range: acpRange })
+  }
+  for (const requirement of requirements) {
+    requirement.supported = satisfiesRange(dshVersion, requirement.range)
+  }
+  return { mode, dir, requirements }
+}
+
+/** The notice shown in the TUI when `--dsh` falls back to the bundled runtime. */
+export function fallbackNotice(profile, dsh, requirements) {
+  const unmet = requirements.filter(({ supported }) => !supported)
+  const needs = unmet.map(({ name, version, range }) => `${name} ${version} needs dsh ${range}`).join('; ')
+  return [
+    `--dsh ${profile}: the global dsh ${dsh.version} is not supported (${needs}), so Martty is using its bundled harness.`,
+    `Install a supported dsh (${INSTALL_HINT}) or update the profile: dsh plugin --profile ${profile} update`,
+  ].join('\n')
+}
+
+export function untestedNotice(dsh) {
+  return `The global dsh ${dsh.version} is newer than the newest dsh Martty was tested with (${TESTED_DSH_THROUGH}); continuing.`
+}
+
+/**
+ * Resolve `--dsh <profile>`:
+ * - `profile`: hand the terminal to `dsh --profile <name>` (the profile carries Martty);
+ * - `agent`: spawn `dsh --profile <name>` as this Client's ACP agent;
+ * - `bundled`: the global dsh is below a floor — keep the bundled harness and
+ *   show `notice` in the TUI.
+ * Missing dsh / missing profile still fail with a message: there is nothing
+ * to attach to and the user named it explicitly.
+ * @returns {{ mode: 'profile', command: string, args: string[], warning?: string }
+ *   | { mode: 'agent', agent: { command: string, args: string[] }, notice?: { text: string, level: 'info' } }
+ *   | { mode: 'bundled', notice: { text: string, level: 'warn' } }}
+ */
+export function planDshLaunch(profile, appArgs, options = {}) {
+  const dsh = resolveGlobalDsh(options)
+  const { mode, requirements } = inspectDshProfile(profile, dsh.version, options)
+  if (requirements.some((requirement) => !requirement.supported)) {
+    return { mode: 'bundled', notice: { text: fallbackNotice(profile, dsh, requirements), level: 'warn' } }
+  }
+  const untested = isUntested(dsh.version) ? untestedNotice(dsh) : undefined
+  if (mode === 'profile') {
+    return {
+      mode, command: dsh.command, args: ['--profile', profile, ...appArgs],
+      ...(untested ? { warning: `martty: ${untested}` } : {}),
+    }
+  }
+  return {
+    mode, agent: { command: dsh.command, args: ['--profile', profile] },
+    ...(untested ? { notice: { text: untested, level: 'info' } } : {}),
+  }
+}
+
+/**
+ * Hand the terminal to `dsh --profile <name>` and return the exit code to
+ * use. The child owns the terminal, so this process ignores Ctrl-C while it
+ * runs and lets dsh decide what it means.
+ */
+export function runDshProfile(plan, { spawnSync = crossSpawn.sync } = {}) {
+  if (plan.warning) console.error(plan.warning)
+  const ignore = () => {}
+  for (const signal of ['SIGINT', 'SIGQUIT']) process.on(signal, ignore)
+  try {
+    const result = spawnSync(plan.command, plan.args, { stdio: 'inherit' })
+    if (result.error) {
+      console.error(`martty: failed to launch dsh: ${result.error.message}`)
+      return 1
+    }
+    if (result.status !== null) return result.status
+    return result.signal === 'SIGINT' ? 130 : result.signal === 'SIGTERM' ? 143 : 1
+  } finally {
+    for (const signal of ['SIGINT', 'SIGQUIT']) process.off(signal, ignore)
+  }
+}

package/lib/host-notice-agent.js

@@ -0,0 +1,88 @@
+/**
+ * A minimal ACP agent that only explains why the real one is unavailable.
+ *
+ * In the dsh plugin profile the TUI Client attaches to the Host's
+ * `acpServer`, which the ACP plugin provides. When that plugin cannot run on
+ * this Host (a dsh below the floor, a required Host capability missing, or a
+ * mount failure), nothing provides `acpServer`: the runner would wait
+ * forever and dsh would only report pending entries. Providing this agent
+ * instead lets the TUI start and show the reason in the conversation, with
+ * the actions that fix it, while the profile stays otherwise intact.
+ */
+
+export const NOTICE_SESSION_ID = 'martty-host-notice'
+
+function textUpdate(sessionId, text) {
+  return {
+    jsonrpc: '2.0',
+    method: 'session/update',
+    params: {
+      sessionId,
+      update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text } },
+    },
+  }
+}
+
+/**
+ * @param {string} message - Markdown shown as the agent's message.
+ * @param {{ version?: string }} [options]
+ * @returns {{ connect(stream: { readable: ReadableStream, writable: WritableStream }): { closed: Promise<void>, dispose(): Promise<void> } }}
+ */
+export function createHostNoticeServer(message, { version = '0.0.0' } = {}) {
+  return {
+    connect(stream) {
+      const writer = stream.writable.getWriter()
+      const reader = stream.readable.getReader()
+      let disposed = false
+      const send = (payload) => (disposed ? Promise.resolve() : writer.write(payload).catch(() => {}))
+      const respond = (id, result) => send({ jsonrpc: '2.0', id, result })
+      const fail = (id, code, text) => send({ jsonrpc: '2.0', id, error: { code, message: text } })
+
+      async function handle(request) {
+        const { id, method, params } = request ?? {}
+        if (id === undefined || id === null) return // notifications need no answer
+        switch (method) {
+          case 'initialize':
+            return respond(id, {
+              protocolVersion: typeof params?.protocolVersion === 'number' ? params.protocolVersion : 1,
+              agentCapabilities: { loadSession: false },
+              authMethods: [],
+              agentInfo: { name: 'martty-host-notice', title: 'Martty (dsh host unavailable)', version },
+            })
+          case 'session/new': {
+            await respond(id, { sessionId: NOTICE_SESSION_ID })
+            return send(textUpdate(NOTICE_SESSION_ID, message))
+          }
+          case 'session/prompt':
+            await send(textUpdate(params?.sessionId ?? NOTICE_SESSION_ID, message))
+            return respond(id, { stopReason: 'end_turn' })
+          case 'session/cancel':
+            return respond(id, null)
+          default:
+            return fail(id, -32601, message.split('\n')[0])
+        }
+      }
+
+      const closed = (async () => {
+        try {
+          for (;;) {
+            const { value, done } = await reader.read()
+            if (done) break
+            await handle(value)
+          }
+        } catch {
+          // The Client went away; nothing to clean up beyond the streams.
+        }
+      })()
+      return {
+        closed,
+        async dispose() {
+          if (disposed) return
+          disposed = true
+          await reader.cancel().catch(() => {})
+          await writer.close().catch(() => {})
+        },
+      }
+    },
+  }
+}

package/lib/install-migration.js

@@ -2,26 +2,35 @@
 // `martty`.
 //
 // npm refuses to link a global bin owned by another package, and it links
-// bins before running any lifecycle script — so no script inside this
-// package can stop an EEXIST on a name the legacy package may already own
-// (`martty`, `dsh-tui`, `dsb`). The published `martty` package therefore
-// declares only `martty-cli` — a name nothing else owns — and this
-// postinstall step creates the user-facing `martty` command itself after
-// retiring any legacy-owned links. It also strips `bin` from the legacy
-// package's installed manifest, because `npm rm -g` deletes bin links by
-// name without checking what they point at — left in place, removing the
-// old package would take the fresh `martty` command down with it.
+// bins before running any lifecycle script — so nothing inside this package
+// can stop an EEXIST on a name the legacy package may already own
+// (`martty`, `dsh-tui`, `dsb`) or on the `martty` shim earlier martty
+// releases wrote. The published `martty` package therefore declares only
+// `martty-cli` — a name nothing else owns — and the user-facing `martty`
+// command is a shim this module writes itself, after retiring any
+// legacy-owned links. It also strips `bin` from the legacy package's
+// installed manifest, because `npm rm -g` deletes bin links by name without
+// checking what they point at — left in place, removing the old package
+// would take the fresh `martty` command down with it.
 //
 // `martty` is a small shim file, not a symlink: `npm rm -g martty` removes
 // the package but not this command, and a shim can degrade gracefully —
 // when its package is gone it prints a one-line hint and deletes itself,
 // instead of leaving a dead symlink behind.
 //
-// npm hides postinstall output on success, so the binary re-checks its
-// install root at launch: invoked as a real `martty`/`martty-cli` command
-// it converges the prefix the same way the postinstall does (retire legacy
-// links, recreate `martty`, sanitize) and warns while the legacy package is
-// still present — which is also what recovers a `--ignore-scripts` install.
+// None of this runs as an install lifecycle script. A `postinstall` makes
+// every pnpm-managed consumer — `dsh plugin --profile <name> add martty`
+// above all — treat the package as one with build scripts, and pnpm's
+// build-script policy then refuses the install (ERR_PNPM_IGNORED_BUILDS
+// under `strictDepBuilds`, which newer pnpm releases enable by default);
+// npm's allow-scripts policy flags it as well. The binary converges at
+// launch instead: invoked as a real `martty`/`martty-cli` command it creates
+// `martty` next to `martty-cli`, and for a global prefix still holding the
+// legacy package it retires the legacy links and sanitizes the legacy
+// install. That single
+// path covers fresh installs, upgrades, and `--ignore-scripts` installs
+// alike; a fresh `npm i -g martty` exposes `martty-cli` until its first
+// launch writes `martty`.
 //
 // The legacy name is intentionally assembled: `scripts/package-alias.mjs`
 // rewrites the literal `martty` to `martty` in every
@@ -30,7 +39,7 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
+import { fileURLToPath } from 'node:url'
 
 export const LEGACY_PACKAGE = ['@openma', 'deepseek-harness-tui'].join('/')
 const scopedParts = LEGACY_PACKAGE.split('/')
@@ -279,32 +288,17 @@ function retireLegacyBins(prefix, write) {
   }
 }
 
-// postinstall entry point (`npm_package_name`/`npm_config_*` env): retire
-// the legacy package's bin links, create the `martty` command, and nudge
-// the user to remove the old package. Never fails the install.
-export function migrate(env, write = stderrLine, platform = process.platform) {
-  if (env.npm_config_global !== 'true') return
-  const prefix = env.npm_config_prefix
-  if (!prefix) return
-  const packageName = env.npm_package_name ?? ''
-
-  if (packageName === LEGACY_PACKAGE) {
-    legacyNotice(write)
-    return
-  }
-
-  const legacyInstalled = legacyInstallDirs(prefix).some((dir) => fs.existsSync(dir))
-
+// Converge one global prefix that still holds the legacy package: retire
+// the legacy package's bin links, (re)create the `martty` command in the
+// prefix's bin directory, and detach the legacy `bin` declarations. Every
+// step is best effort and only touches entries this package or the legacy
+// package verifiably owns.
+export function convergePrefix(prefix, { packageDir, platform = process.platform, write = stderrLine } = {}) {
+  const selfPackageDir = packageDir ?? path.dirname(path.dirname(fileURLToPath(import.meta.url)))
   retireLegacyBins(prefix, write)
-
-  const packageDir = path.dirname(path.dirname(fileURLToPath(import.meta.url)))
   const binDir = platform === 'win32' ? prefix : path.join(prefix, 'bin')
-  ensureMarttyLink({ binDir, packageDir, platform, write })
-
-  if (legacyInstalled) {
-    sanitizeLegacyInstall(prefix, write)
-    marttyNotice(write, `npm rm -g ${LEGACY_PACKAGE}`)
-  }
+  ensureMarttyLink({ binDir, packageDir: selfPackageDir, platform, write })
+  sanitizeLegacyInstall(prefix, write)
 }
 
 // Neutralize the legacy package's `bin` declarations so a later
@@ -364,12 +358,11 @@ export function sanitizeLegacyInstall(prefix, write = stderrLine) {
   }
 }
 
-// Launch-time entry point: npm hides postinstall output unless it fails, so
-// the binary re-checks its install root on every run. Invoked through a
-// real command name (`martty`, `martty-cli`, `npx`) it converges the global
-// prefix the same way the postinstall does — retire the legacy links,
-// (re)create `martty`, sanitize the legacy install — which is also what
-// recovers an install whose scripts were skipped. A bare `node
+// Launch-time entry point — the only migration path; the package ships no
+// install lifecycle script. Invoked through a real command name (`martty`,
+// `martty-cli`, `npx`) it writes the `martty` command next to `martty-cli`
+// and converges a global prefix that still holds the legacy package
+// (retire the legacy links, sanitize the legacy install). A bare `node
 // bin/martty.js` or a dsh profile layout only gets the warning, never the
 // filesystem changes.
 export function warnAboutLegacyPackage({ argv1, libDir, write = stderrLine, platform = process.platform } = {}) {
@@ -419,10 +412,7 @@ export function warnAboutLegacyPackage({ argv1, libDir, write = stderrLine, plat
     }
     hint ??= `npm rm -g ${LEGACY_PACKAGE}`
     try {
-      retireLegacyBins(prefix, write)
-      const binDir = platform === 'win32' ? prefix : path.join(prefix, 'bin')
-      ensureMarttyLink({ binDir, packageDir, platform, write })
-      sanitizeLegacyInstall(prefix, write)
+      convergePrefix(prefix, { packageDir, platform, write })
     } catch {
       // Best effort: nothing here may break the launch.
     }
@@ -451,6 +441,3 @@ export function reportLaunchNotices(
   for (const line of lines) write(line)
 }
 
-if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
-  migrate(process.env)
-}

package/lib/launch-notice.js

@@ -0,0 +1,46 @@
+/**
+ * Built-in Client Plugin: one launch-time notice in the composer dock.
+ *
+ * Used when the launcher had to change course before the TUI started — for
+ * example `martty --dsh <profile>` falling back to the bundled harness
+ * because the global dsh is below the supported floor. The notice is short,
+ * names the reason, and goes away on `/dismiss` or after `dismissAfterMs`.
+ */
+
+export const name = 'launch-notice'
+export const inject = ['tuiSlots', 'tuiCommands']
+
+export const DEFAULT_DISMISS_AFTER_MS = 60_000
+
+/**
+ * @param {{ text?: string, level?: 'info' | 'warn' | 'error', dismissAfterMs?: number }} [config]
+ */
+export function apply(ctx, config = {}) {
+  if (typeof config.text !== 'string' || config.text.trim() === '') return undefined
+  const level = ['info', 'warn', 'error'].includes(config.level) ? config.level : 'warn'
+  const controller = ctx.tuiSlots.register(
+    { name: 'conversation.input.dock', id: 'launch-notice', order: -30 },
+    [{ id: 'notice', kind: 'notice', level, text: `${config.text.trim()}\n(/dismiss to hide)` }],
+  )
+  let stopCommand
+  let timer
+  let dismissed = false
+  const dismiss = () => {
+    if (dismissed) return
+    dismissed = true
+    clearTimeout(timer)
+    controller.dispose()
+    stopCommand?.()
+    stopCommand = undefined
+  }
+  stopCommand = ctx.tuiCommands.register(
+    { name: 'dismiss', description: 'Hide the launch notice' },
+    async () => dismiss(),
+  )
+  const after = Number.isFinite(config.dismissAfterMs) ? config.dismissAfterMs : DEFAULT_DISMISS_AFTER_MS
+  if (after > 0) {
+    timer = setTimeout(dismiss, after)
+    timer.unref?.()
+  }
+  return dismiss
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "martty",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Terminal-native ACP client UI; Cordis client tree, any ACP agent",
   "license": "MIT",
   "repository": {
@@ -14,10 +14,9 @@
   "type": "module",
   "main": "lib/index.js",
   "scripts": {
-    "postinstall": "node lib/install-migration.js",
     "test:harness-ui": "node --test ../scripts/harness-management-tui.test.mjs ../scripts/harness-session-tui.test.mjs",
     "pretest": "node --test ../scripts/workflow-release.test.mjs ../scripts/package-alias.test.mjs ../scripts/harness-removal.test.mjs",
-    "test": "node --test ../scripts/download.test.mjs ../scripts/package-native.test.mjs ../scripts/check-release-tag.test.mjs ../scripts/release-check.test.mjs ../scripts/check-static-elf.test.mjs ../scripts/smoke-old-linux.test.mjs ../scripts/cargo-guard.test.mjs ../scripts/build-npm.test.mjs ../scripts/client-profile.test.mjs ../scripts/plugin-runner.test.mjs ../scripts/profile-link-resolution.test.mjs ../scripts/packaged-acp-permission.test.mjs ../scripts/profile-smoke-tui.test.mjs ../scripts/release.test.mjs ../scripts/jsonrpc-line-transport.test.mjs ../scripts/tui-theme.test.mjs ../scripts/tui-presets.test.mjs ../scripts/tui-plugin-store.test.mjs ../scripts/tui-local-plugins.test.mjs ../scripts/tui-client-plugin-registry.test.mjs ../scripts/tui-slots.test.mjs ../scripts/tui-commands.test.mjs ../scripts/tui-overlay.test.mjs ../scripts/tui-agents.test.mjs ../scripts/tui-queue.test.mjs ../scripts/mux.test.mjs ../scripts/acp-client.test.mjs ../scripts/acp-agent-pool.test.mjs ../scripts/harnesses.test.mjs ../scripts/harness-discovery.test.mjs ../scripts/harness-discovery-scenario.test.mjs ../scripts/harness-view.test.mjs ../scripts/harness-onboarding.test.mjs ../scripts/harness-registry.test.mjs ../scripts/harness-badge.test.mjs ../scripts/harness-package.test.mjs ../scripts/acp-client-events.test.mjs ../scripts/acp-session-config.test.mjs ../scripts/acp-session-plan.test.mjs ../scripts/acp-session-stats.test.mjs ../scripts/acp-session-status.test.mjs ../scripts/agents-view.test.mjs ../scripts/plan-view.test.mjs ../scripts/queue-view.test.mjs ../scripts/stats-view.test.mjs ../scripts/status-view.test.mjs ../scripts/deepseek-logo.test.mjs ../scripts/runner.test.mjs ../scripts/inspect.test.mjs ../scripts/creator-overlay.test.mjs ../scripts/install-migration.test.mjs ../scripts/global-install-collision.test.mjs ../scripts/real-agent-e2e.test.mjs",
+    "test": "node --test ../scripts/download.test.mjs ../scripts/package-native.test.mjs ../scripts/check-release-tag.test.mjs ../scripts/release-check.test.mjs ../scripts/check-static-elf.test.mjs ../scripts/smoke-old-linux.test.mjs ../scripts/cargo-guard.test.mjs ../scripts/build-npm.test.mjs ../scripts/client-profile.test.mjs ../scripts/plugin-runner.test.mjs ../scripts/profile-link-resolution.test.mjs ../scripts/packaged-acp-permission.test.mjs ../scripts/profile-smoke-tui.test.mjs ../scripts/release.test.mjs ../scripts/jsonrpc-line-transport.test.mjs ../scripts/tui-theme.test.mjs ../scripts/tui-presets.test.mjs ../scripts/tui-plugin-store.test.mjs ../scripts/tui-local-plugins.test.mjs ../scripts/tui-client-plugin-registry.test.mjs ../scripts/tui-slots.test.mjs ../scripts/tui-commands.test.mjs ../scripts/tui-overlay.test.mjs ../scripts/tui-agents.test.mjs ../scripts/tui-queue.test.mjs ../scripts/mux.test.mjs ../scripts/acp-client.test.mjs ../scripts/acp-agent-pool.test.mjs ../scripts/harnesses.test.mjs ../scripts/harness-discovery.test.mjs ../scripts/harness-discovery-scenario.test.mjs ../scripts/harness-view.test.mjs ../scripts/harness-onboarding.test.mjs ../scripts/harness-registry.test.mjs ../scripts/harness-badge.test.mjs ../scripts/harness-package.test.mjs ../scripts/acp-client-events.test.mjs ../scripts/acp-session-config.test.mjs ../scripts/acp-session-plan.test.mjs ../scripts/acp-session-stats.test.mjs ../scripts/acp-session-status.test.mjs ../scripts/agents-view.test.mjs ../scripts/plan-view.test.mjs ../scripts/queue-view.test.mjs ../scripts/stats-view.test.mjs ../scripts/status-view.test.mjs ../scripts/deepseek-logo.test.mjs ../scripts/runner.test.mjs ../scripts/inspect.test.mjs ../scripts/creator-overlay.test.mjs ../scripts/dsh-launch.test.mjs ../scripts/host-notice.test.mjs ../scripts/install-migration.test.mjs ../scripts/global-install-collision.test.mjs ../scripts/real-agent-e2e.test.mjs",
     "test:profile-install-matrix": "node --test ../scripts/profile-install-matrix.test.mjs"
   },
   "publishConfig": {
@@ -71,23 +70,24 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
-    },
-    "supported": "0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2"
+    }
   },
   "dependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@lobehub/icons-static-svg": "1.95.0",
     "@openma/common": "^0.9.2",
-    "@openma/deepseek-harness-acp": "0.4.38",
+    "@openma/deepseek-harness-acp": "0.4.39",
     "@resvg/resvg-js": "2.6.2",
     "cross-spawn": "^7.0.6",
-    "node-downloader-helper": "2.1.11"
+    "node-downloader-helper": "2.1.11",
+    "semver": "^7.8.5"
   },
   "devDependencies": {
     "@deepseek-ai/dsh": "0.2.0-rc.2"
   },
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=22.19.0",
+    "dsh": ">=0.1.7-rc.2"
   },
   "keywords": [
     "deepseek",
@@ -98,10 +98,10 @@
     "agent-client-protocol"
   ],
   "optionalDependencies": {
-    "@openma/martty-darwin-arm64": "0.3.2",
-    "@openma/martty-darwin-x64": "0.3.2",
-    "@openma/martty-linux-x64": "0.3.2",
-    "@openma/martty-linux-arm64": "0.3.2",
-    "@openma/martty-win32-x64": "0.3.2"
+    "@openma/martty-darwin-arm64": "0.3.3",
+    "@openma/martty-darwin-x64": "0.3.3",
+    "@openma/martty-linux-x64": "0.3.3",
+    "@openma/martty-linux-arm64": "0.3.3",
+    "@openma/martty-win32-x64": "0.3.3"
   }
 }