martty 0.2.16 → 0.2.17

package/README.md

@@ -57,6 +57,20 @@ The package carries ACP as a runtime dependency and exports its Creator Host
 overlay internally. The profile bundle mounts both on the Host Base tree;
 neither enters the Client tree. Creator adds TUI plugin guidance to the
 existing `cordis` preset and does not use ACP for skill registration.
+Creator-authored UI Presets and Theme Plugins preview as process-local dynamic
+Packages, then persist explicitly under `$MARTTY_HOME/plugins` through
+`tui_plugin_save`; `tui_plugin_read` resumes authoring after restart.
+
+`MARTTY_HOME` resolves explicitly first, then to `$DSH_HOME/.martty`, then to
+`~/.martty`. UI choices live in `$MARTTY_HOME/settings.json`. On first use,
+legacy Creator artifacts and settings are copied forward without deleting or
+overwriting the old files.
+
+Third-party TUI plugins remain ordinary installed packages. Their Host-side
+registrar contributes an absolute Client module entry to `tuiClientPlugins`;
+the Host runner serializes only that directory into the separate Client
+process. Package entries and Creator artifacts share one Client lifecycle
+manager, with installed packages winning same-id conflicts.
 
 Node and Rust use inherited pipes on Unix and an authenticated loopback TCP
 socket on Windows. This compositor channel carries theme/render data only;

package/cordis.patch.yml

@@ -20,6 +20,9 @@
   disabled: true
 
 - insert:
+    - id: tui-client-plugins
+      name: 'martty/client-plugin-registry'
+
     - id: tui-acp-host
       name: 'martty/acp-host'
 

package/lib/boot.js

@@ -7,6 +7,7 @@
  */
 
 import { apply as applyAcpClient } from './acp-client.js'
+import { constants, copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import path from 'node:path'
 import { apply as applyCordisClientRunner } from './inspect.js'
@@ -23,12 +24,17 @@ import { apply as applyStatsView, inject as statsViewInject } from './stats-view
 import { apply as applySessionStatus, inject as sessionStatusInject } from './acp-session-status.js'
 import { apply as applyStatusView, inject as statusViewInject } from './status-view.js'
 import { apply as applyDeepseekLogo, inject as deepseekLogoInject } from './deepseek-logo.js'
+import { createTuiPluginStore, marttyHome } from './tui-plugin-store.js'
+import { installTuiLocalPlugins } from './tui-local-plugins.js'
 
 /**
  * @param {object} [options]
  * @param {{ command: string, args?: string[] }} [options.agent]
  * @param {{ stdin: import('node:stream').Writable, stdout: import('node:stream').Readable, child?: import('node:child_process').ChildProcess }} [options.stream]
  * @param {{ stdin: number | 'inherit', stdout: number | 'inherit' }} [options.tty]
+ * @param {string} [options.settingsPath]
+ * @param {string} [options.artifactRoot]
+ * @param {Array<{ id: string, kind: 'theme' | 'ui-preset', entry: string }>} [options.packagePlugins]
  */
 export async function bootClient(options = {}) {
   const { Context } = await import('@deepseek-ai/cordis')
@@ -36,11 +42,13 @@ export async function bootClient(options = {}) {
   const acpConfig = options.stream !== undefined
     ? { stream: options.stream }
     : { agent: options.agent ?? resolveStackedAgent() }
-  const presetConfig = {
-    settingsPath: options.settingsPath ?? uiSettingsPath(options.extraArgs ?? []),
+  const settingsPath = options.settingsPath ?? uiSettingsPath(options.extraArgs ?? [])
+  if (options.settingsPath === undefined) {
+    migrateLegacyUiSettings(settingsPath, legacyUiSettingsPaths(options.extraArgs ?? []))
   }
+  const presetConfig = { settingsPath }
   if (typeof ctx.plugin === 'function') {
-    await ctx.plugin({ name: 'tui-theme', inject: [], apply: applyTheme })
+    await ctx.plugin({ name: 'tui-theme', inject: [], apply: applyTheme }, presetConfig)
     await ctx.plugin({ name: 'tui-slots', inject: [], apply: applySlots })
     await ctx.plugin({ name: 'tui-commands', inject: [], apply: applyCommands })
     await ctx.plugin({ name: 'tui-overlay', inject: [], apply: applyOverlay })
@@ -52,6 +60,20 @@ export async function bootClient(options = {}) {
     await ctx.plugin({ name: 'acp-session-status', inject: sessionStatusInject, apply: applySessionStatus })
     await ctx.plugin({ name: 'status-view', inject: statusViewInject, apply: applyStatusView })
     await ctx.plugin({ name: 'deepseek-logo', inject: deepseekLogoInject, apply: applyDeepseekLogo })
+    const localPlugins = installTuiLocalPlugins(ctx, {
+      store: createTuiPluginStore({ root: options.artifactRoot }),
+      packages: options.packagePlugins ?? [],
+      tuiTheme: ctx.get('tuiTheme'),
+      tuiPresets: ctx.get('tuiPresets'),
+      tuiSlots: ctx.get('tuiSlots'),
+      tuiCommands: ctx.get('tuiCommands'),
+      tuiOverlay: ctx.get('tuiOverlay'),
+      acpSessionConfig: ctx.get('acpSessionConfig'),
+      acpSessionPlan: ctx.get('acpSessionPlan'),
+      acpSessionStats: ctx.get('acpSessionStats'),
+      acpSessionStatus: ctx.get('acpSessionStatus'),
+    })
+    await localPlugins.discover()
     await ctx.plugin({
       name: 'tui-cordis-client-runner',
       inject: [
@@ -72,7 +94,7 @@ export async function bootClient(options = {}) {
       { extraArgs: options.extraArgs ?? [], tty: options.tty },
     )
   } else {
-    applyTheme(ctx)
+    applyTheme(ctx, presetConfig)
     applySlots(ctx)
     applyCommands(ctx)
     applyOverlay(ctx)
@@ -84,19 +106,100 @@ export async function bootClient(options = {}) {
     applySessionStatus(ctx)
     applyStatusView(ctx)
     applyDeepseekLogo(ctx)
+    const localPlugins = installTuiLocalPlugins(ctx, {
+      store: createTuiPluginStore({ root: options.artifactRoot }),
+      packages: options.packagePlugins ?? [],
+      tuiTheme: ctx.tuiTheme,
+      tuiPresets: ctx.tuiPresets,
+      tuiSlots: ctx.tuiSlots,
+      tuiCommands: ctx.tuiCommands,
+      tuiOverlay: ctx.tuiOverlay,
+      acpSessionConfig: ctx.acpSessionConfig,
+      acpSessionPlan: ctx.acpSessionPlan,
+      acpSessionStats: ctx.acpSessionStats,
+      acpSessionStatus: ctx.acpSessionStatus,
+    })
+    await localPlugins.discover()
     applyCordisClientRunner(ctx)
     await applyShell(ctx, { extraArgs: options.extraArgs ?? [], tty: options.tty })
   }
   return ctx
 }
 
-export function uiSettingsPath(extraArgs = []) {
+/** Parse the Host registry snapshot passed across the process boundary. */
+export function parseClientPluginsEnv(value) {
+  if (value === undefined || value === '') return []
+  let parsed
+  try {
+    parsed = JSON.parse(value)
+  } catch (error) {
+    throw new Error(`dsh-tui: invalid installed Client plugin registry JSON: ${error.message}`)
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error('dsh-tui: installed Client plugin registry must be an array')
+  }
+  return parsed.map((entry, index) => {
+    if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) {
+      throw new Error(`dsh-tui: installed Client plugin entry ${index} must be an object`)
+    }
+    if (typeof entry.id !== 'string' || !/^[a-z0-9][a-z0-9-]*$/.test(entry.id)) {
+      throw new Error(`dsh-tui: installed Client plugin entry ${index} has an invalid id`)
+    }
+    if (!['theme', 'ui-preset'].includes(entry.kind)) {
+      throw new Error(`dsh-tui: installed Client plugin entry ${index} has an invalid kind`)
+    }
+    if (typeof entry.entry !== 'string') {
+      throw new Error(`dsh-tui: installed Client plugin entry ${index} has no file entry`)
+    }
+    let url
+    try {
+      url = new URL(entry.entry)
+    } catch {
+      throw new Error(`dsh-tui: installed Client plugin entry ${index} has an invalid file entry`)
+    }
+    if (url.protocol !== 'file:') {
+      throw new Error(`dsh-tui: installed Client plugin entry ${index} must use a file URL`)
+    }
+    return { id: entry.id, kind: entry.kind, entry: url.href }
+  })
+}
+
+export function uiSettingsPath(extraArgs = [], env = process.env, userHome = homedir()) {
   for (let index = 0; index < extraArgs.length; index += 1) {
     if (extraArgs[index] === '--session-root' && typeof extraArgs[index + 1] === 'string') {
-      return path.join(extraArgs[index + 1], 'dsh-tui-settings.json')
+      return path.join(extraArgs[index + 1], 'settings.json')
+    }
+  }
+  return path.join(marttyHome(env, userHome), 'settings.json')
+}
+
+export function legacyUiSettingsPaths(extraArgs = [], userHome = homedir()) {
+  const paths = []
+  for (let index = 0; index < extraArgs.length; index += 1) {
+    if (extraArgs[index] === '--session-root' && typeof extraArgs[index + 1] === 'string') {
+      paths.push(path.join(extraArgs[index + 1], 'dsh-tui-settings.json'))
+      break
+    }
+  }
+  paths.push(path.join(userHome, '.dsh-tui', 'sessions', 'dsh-tui-settings.json'))
+  return [...new Set(paths)]
+}
+
+export function migrateLegacyUiSettings(settingsPath, legacyPaths) {
+  if (existsSync(settingsPath)) return false
+  for (const legacyPath of legacyPaths) {
+    if (!existsSync(legacyPath)) continue
+    try {
+      const value = JSON.parse(readFileSync(legacyPath, 'utf8'))
+      if (value === null || typeof value !== 'object' || Array.isArray(value)) continue
+      mkdirSync(path.dirname(settingsPath), { recursive: true })
+      copyFileSync(legacyPath, settingsPath, constants.COPYFILE_EXCL)
+      return true
+    } catch {
+      // A malformed or racing legacy file must not block TUI startup.
     }
   }
-  return path.join(homedir(), '.dsh-tui', 'sessions', 'dsh-tui-settings.json')
+  return false
 }
 
 /**

package/lib/client-process.js

@@ -2,10 +2,11 @@
 
 /** Independent TUI Client Cordis process launched by the Host runner. */
 
-import { bootClient } from './boot.js'
+import { bootClient, parseClientPluginsEnv } from './boot.js'
 
 await bootClient({
   stream: { stdin: process.stdout, stdout: process.stdin },
   extraArgs: process.argv.slice(2),
   tty: { stdin: 3, stdout: 4 },
+  packagePlugins: parseClientPluginsEnv(process.env.DSH_TUI_CLIENT_PLUGINS_V0),
 })

package/lib/client-run.js

@@ -76,6 +76,16 @@ export async function applyClientHalf(clientCode, env) {
     }
     throw error
   }
+  return applyClientPlugin(plugin, env)
+}
+
+/**
+ * Apply an already imported Client plugin through the same restricted TUI facade as code.client.
+ * @param {unknown} plugin
+ * @param {{ pluginId?: string, tuiTheme?: object, tuiSlots?: object, tuiCommands?: object, tuiOverlay?: object, acpSessionConfig?: object, acpSessionPlan?: object, acpSessionStats?: object, acpSessionStatus?: object, timer?: object, invoke?: Function }} env
+ * @returns {Promise<{ waitingFor: string[], dispose: () => void }>}
+ */
+export async function applyClientPlugin(plugin, env) {
   const evaluated = normalizePlugin(plugin)
   const inject = evaluated.inject ?? []
   for (const name of inject) {

package/lib/creator-overlay.js

@@ -4,9 +4,12 @@
  */
 
 import { readFileSync } from 'node:fs'
+import { createTuiPluginStore } from './tui-plugin-store.js'
 
 export const name = 'tui-creator-overlay'
-export const inject = ['agentPresets', 'skills', 'systemPrompt', 'loader']
+export const inject = [
+  'agentPresets', 'skills', 'systemPrompt', 'loader', 'tools', 'dynamicCordisRunner',
+]
 
 const SKILL_NAME = 'tui-plugin-development'
 const ROUTING_PROMPT = `# Dynamic TUI Plugin routing
@@ -16,6 +19,158 @@ Load cordis-plugin-development for every dynamic Plugin; it owns the common Plug
 - When any requested behavior belongs to the TUI — terminal themes or backgrounds, native TUI slots, local TUI commands, native overlays, or current ACP Session options — also load tui-plugin-development. Its TUI Provider guidance overrides generic browser UI assumptions only for that half.
 - Browser/Web-only work needs no TUI companion. A mixed Plugin uses the generic skill for common, Host, and Web behavior and the TUI skill for its terminal behavior. Do not translate a TUI request into Web Slots or add Host code unless the requested behavior owns Host data.`
 
+const jsonOutput = {
+  schema: { type: 'json' },
+  render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+}
+
+function requireAgent(exec) {
+  if (exec?.agent === undefined) {
+    throw new Error('TUI artifact tools require an Agent-backed Creator session')
+  }
+  return exec.agent
+}
+
+function registerArtifactTools(ctx, scopedCtx, defineTool, store) {
+  const tools = scopedCtx.get('tools')
+  if (tools === undefined || typeof tools.register !== 'function') {
+    throw new Error('tui-creator-overlay: tools service is unavailable in the preset scope')
+  }
+
+  tools.register(defineTool({
+    name: 'tui_plugin_save',
+    description:
+      'Persist one successfully activated, Client-only Cordis Package as a durable TUI artifact. '
+      + 'Use this only after cordis_run succeeds. UI Presets and Theme Plugins survive restart only '
+      + 'after this Tool returns saved. Replacing an existing artifact must be explicit.',
+    parameters: {
+      artifactId: {
+        type: 'string',
+        required: true,
+        description: 'Stable lowercase artifact id used as its directory name.',
+      },
+      kind: {
+        type: 'string',
+        required: true,
+        enum: ['ui-preset', 'theme'],
+        description: 'Durable TUI contribution kind.',
+      },
+      pluginId: {
+        type: 'string',
+        required: true,
+        description: 'Dynamic Plugin id returned by cordis_define.',
+      },
+      packageId: {
+        type: 'string',
+        required: true,
+        description: 'Exact immutable Package id that cordis_run activated successfully.',
+      },
+      replace: {
+        type: 'boolean',
+        description: 'Replace an existing artifact with this Package. Defaults to false.',
+      },
+    },
+    output: jsonOutput,
+    async execute(args, exec) {
+      const source = ctx.dynamicCordisRunner.inspectPackage(
+        requireAgent(exec),
+        args.pluginId,
+        args.packageId,
+      )
+      if (source.currentPackageId !== args.packageId) {
+        throw new Error(
+          `tui_plugin_save: ${args.pluginId}/${args.packageId} is not the successful current Package; `
+          + 'run it successfully before persisting it',
+        )
+      }
+      if (typeof source.code?.host === 'string') {
+        throw new Error(
+          'tui_plugin_save: durable TUI artifacts are client-only; a Package with a Host half '
+          + 'must be shipped as a standard profile plugin instead',
+        )
+      }
+      if (typeof source.code?.client !== 'string') {
+        throw new Error('tui_plugin_save: Package has no Client half')
+      }
+      const saved = store.save({
+        id: args.artifactId,
+        kind: args.kind,
+        name: source.name,
+        purpose: source.purpose,
+        source: { pluginId: args.pluginId, packageId: args.packageId },
+        clientCode: source.code.client,
+      }, { replace: args.replace === true })
+      return {
+        status: 'saved',
+        artifact: { id: args.artifactId, kind: args.kind },
+        path: saved.path,
+        recovery: 'The TUI Client discovers this artifact from disk on startup.',
+      }
+    },
+  }))
+
+  tools.register(defineTool({
+    name: 'tui_plugin_list',
+    description:
+      'List durable user-authored TUI artifacts from disk, including broken rows that need repair or removal.',
+    parameters: {},
+    output: jsonOutput,
+    execute(_args, exec) {
+      requireAgent(exec)
+      return Promise.resolve({ root: store.root, artifacts: store.list() })
+    },
+    isConcurrencySafe() {
+      return true
+    },
+  }))
+
+  tools.register(defineTool({
+    name: 'tui_plugin_read',
+    description:
+      'Read one durable Creator-authored TUI artifact including its exact code.client source. '
+      + 'Use this before continuing development after a restart; define a new temporary preview '
+      + 'Plugin from the source, then save the successful result with replace:true.',
+    parameters: {
+      artifactId: {
+        type: 'string',
+        required: true,
+        description: 'Exact durable artifact id returned by tui_plugin_list.',
+      },
+    },
+    output: jsonOutput,
+    execute(args, exec) {
+      requireAgent(exec)
+      return Promise.resolve({ artifact: store.resolve(args.artifactId) })
+    },
+    isConcurrencySafe() {
+      return true
+    },
+  }))
+
+  tools.register(defineTool({
+    name: 'tui_plugin_remove',
+    description:
+      'Remove one durable user-authored TUI artifact from disk. This does not undefine the current '
+      + 'Session\'s temporary preview Plugin.',
+    parameters: {
+      artifactId: {
+        type: 'string',
+        required: true,
+        description: 'Exact durable artifact id returned by tui_plugin_list.',
+      },
+    },
+    output: jsonOutput,
+    execute(args, exec) {
+      requireAgent(exec)
+      const removed = store.remove(args.artifactId)
+      return Promise.resolve({
+        status: removed ? 'removed' : 'absent',
+        artifactId: args.artifactId,
+      })
+    },
+  }))
+}
+
 const skillDocument = readFileSync(
   new URL('../skills/tui-plugin-development/SKILL.md', import.meta.url),
   'utf8',
@@ -49,6 +204,10 @@ export async function apply(ctx, config = {}) {
   const { createScope } = scopeModule
   const overlay = createScope(ctx, key)
   try {
+    const toolsModule = await ctx.loader.import('@deepseek-ai/dsh-tools')
+    if (typeof toolsModule?.defineTool !== 'function') {
+      throw new Error('tui-creator-overlay: profile dsh-tools module is unavailable')
+    }
     const skills = overlay.ctx.get('skills')
     if (skills === undefined || typeof skills.register !== 'function') {
       throw new Error('tui-creator-overlay: skills service is unavailable in the preset scope')
@@ -69,6 +228,12 @@ export async function apply(ctx, config = {}) {
       order: 116,
       text: ROUTING_PROMPT,
     })
+    registerArtifactTools(
+      ctx,
+      overlay.ctx,
+      toolsModule.defineTool,
+      createTuiPluginStore({ root: config.artifactRoot }),
+    )
     ctx.effect(() => () => overlay.dispose(), `tui-creator-overlay(${JSON.stringify(preset)})`)
   } catch (error) {
     await overlay.dispose()

package/lib/index.js

@@ -30,16 +30,23 @@ const shellStateKey = Symbol.for('martty/shell-state')
  *   livePainter: null | ({ muxed: boolean } & Awaited<ReturnType<typeof spawnPluginTui>>),
  *   startingPainter: null | Promise<{ muxed: boolean } & Awaited<ReturnType<typeof spawnPluginTui>>>,
  *   refuseRespawn: boolean,
+ *   processExitListener: null | (() => void),
  * }}
  */
 const shellState = globalThis[shellStateKey] ??= {
   livePainter: null,
   startingPainter: null,
   refuseRespawn: false,
+  processExitListener: null,
 }
+if (shellState.processExitListener === undefined) shellState.processExitListener = null
 
 /** Drop the sticky painter so tests can apply() more than once in-process. */
 export function resetShellForTests() {
+  if (shellState.processExitListener !== null) {
+    process.off('exit', shellState.processExitListener)
+    shellState.processExitListener = null
+  }
   shellState.livePainter = null
   shellState.startingPainter = null
   shellState.refuseRespawn = false
@@ -150,6 +157,10 @@ export async function applyShell(ctx, options = {}) {
         shellState.livePainter = live
         const { child } = live
         child.on('exit', (code, signal) => {
+          if (shellState.processExitListener === processExitListener) {
+            process.off('exit', processExitListener)
+            shellState.processExitListener = null
+          }
           try {
             agent.child?.kill('SIGTERM')
           } catch {
@@ -165,13 +176,15 @@ export async function applyShell(ctx, options = {}) {
           console.error(`dsh-tui: ${err.message}`)
           process.exit(1)
         })
-        process.once('exit', () => {
+        const processExitListener = () => {
           try {
             child.kill('SIGTERM')
           } catch {
             // already gone
           }
-        })
+        }
+        shellState.processExitListener = processExitListener
+        process.once('exit', processExitListener)
         return live
       })()
     }

package/lib/inspect.js

@@ -162,7 +162,7 @@ export function uiPresetInspectProvider(tuiPresets) {
               'A synchronous callback that mounts multiple UI contributions and returns one disposer.',
           },
           selection: '/ui <id>',
-          persistence: 'The selected id survives restart in dsh-tui-settings.json.',
+          persistence: 'The selected id survives restart in $MARTTY_HOME/settings.json.',
         },
       }
     },
@@ -754,6 +754,7 @@ async function mountClientHalf(
  *   acpSessionPlan?: object,
  *   acpSessionStats?: object,
  *   acpSessionStatus?: object,
+ *   localPlugins?: object,
  *   requestAgent: (method: string, params?: object) => Promise<unknown>,
  * }} opts
  * @returns {{ onHost: (message: object) => void }}
@@ -761,7 +762,7 @@ async function mountClientHalf(
 export function attachTuiClient(opts) {
   const {
     ctx, tuiTheme, tuiPresets, tuiSlots, tuiCommands, tuiOverlay, acpSessionConfig, acpSessionPlan,
-    acpSessionStats, acpSessionStatus,
+    acpSessionStats, acpSessionStatus, localPlugins,
     requestAgent,
   } = opts
   const providers = [
@@ -780,6 +781,19 @@ export function attachTuiClient(opts) {
   const loaded = new Map()
   const pendingThemeSelections = new Map()
 
+  async function stopOwner(agentId, pluginId) {
+    if (localPlugins?.has?.(pluginId) === true) {
+      await localPlugins.stop(pluginId)
+      return
+    }
+    const stopped = await requestAgent(CORDIS_METHODS.pluginStop, { agentId, pluginId })
+    if (stopped?.ok === false) {
+      throw new Error(typeof stopped.message === 'string'
+        ? stopped.message
+        : `failed to stop theme Plugin "${pluginId}"`)
+    }
+  }
+
   function sync() {
     void requestAgent(CORDIS_METHODS.inspectSync, { providers: providers.map((provider) => provider.manifest) }).catch(() => {
       // Agent has no TUI Client extras (Zed / non-dsh ACP). Stay a standard client.
@@ -905,15 +919,7 @@ export function attachTuiClient(opts) {
         && previousThemeOwner !== undefined
         && previousThemeOwner !== selectedThemeOwner) {
         try {
-          const stopped = await requestAgent(CORDIS_METHODS.pluginStop, {
-            agentId: request.agentId,
-            pluginId: previousThemeOwner,
-          })
-          if (stopped?.ok === false) {
-            throw new Error(typeof stopped.message === 'string'
-              ? stopped.message
-              : `failed to stop theme Plugin "${previousThemeOwner}"`)
-          }
+          await stopOwner(request.agentId, previousThemeOwner)
         } catch (error) {
           if (loaded.get(request.pluginId) === applied.dispose) {
             loaded.delete(request.pluginId)
@@ -981,19 +987,31 @@ export function attachTuiClient(opts) {
     const previousOwner = tuiTheme.owner?.(previousId)
     const targetOwner = tuiTheme.owner?.(request.id)
 
+    if (targetOwner !== undefined && localPlugins?.has?.(targetOwner) === true) {
+      if (localPlugins.isLoaded?.(targetOwner) !== true) {
+        await localPlugins.start(targetOwner)
+      }
+      if (tuiTheme.isLoaded?.(request.id) !== true) {
+        throw new Error(`local theme Plugin "${targetOwner}" did not load palette "${request.id}"`)
+      }
+      tuiTheme.activate(request.id)
+      if (previousOwner !== undefined && previousOwner !== targetOwner) {
+        try {
+          await stopOwner(request.agentId, previousOwner)
+        } catch (error) {
+          await localPlugins.stop(targetOwner)
+          if (tuiTheme.isLoaded?.(previousId) === true) tuiTheme.activate(previousId)
+          throw error
+        }
+      }
+      return { ok: true, status: 'selected', id: request.id }
+    }
+
     if (targetOwner === undefined || loaded.has(targetOwner)) {
       tuiTheme.activate(request.id)
       if (previousOwner !== undefined && previousOwner !== targetOwner) {
         try {
-          const stopped = await requestAgent(CORDIS_METHODS.pluginStop, {
-            agentId: request.agentId,
-            pluginId: previousOwner,
-          })
-          if (stopped?.ok === false) {
-            throw new Error(typeof stopped.message === 'string'
-              ? stopped.message
-              : `failed to stop theme Plugin "${previousOwner}"`)
-          }
+          await stopOwner(request.agentId, previousOwner)
         } catch (error) {
           if (tuiTheme.isLoaded?.(previousId) === true) tuiTheme.activate(previousId)
           throw error
@@ -1043,13 +1061,14 @@ export function apply(ctx) {
   const acpSessionPlan = ctx.acpSessionPlan ?? ctx.get?.('acpSessionPlan')
   const acpSessionStats = ctx.acpSessionStats ?? ctx.get?.('acpSessionStats')
   const acpSessionStatus = ctx.acpSessionStatus ?? ctx.get?.('acpSessionStatus')
+  const localPlugins = ctx.get?.('tuiLocalPlugins')
   let client
   const service = {
     bindTransport(requestAgent) {
       client?.dispose()
       client = attachTuiClient({
         ctx, tuiTheme, tuiPresets, tuiSlots, tuiCommands, tuiOverlay, acpSessionConfig, acpSessionPlan,
-        acpSessionStats, acpSessionStatus,
+        acpSessionStats, acpSessionStatus, localPlugins,
         requestAgent,
       })
       const attached = client

package/lib/runner.js

@@ -12,7 +12,7 @@ import { createRequire } from 'node:module'
 import { fileURLToPath } from 'node:url'
 
 export const name = 'dsh-tui-runner'
-export const inject = ['loader', 'acpServer', 'cmdlineArgs', 'appExit']
+export const inject = ['loader', 'acpServer', 'cmdlineArgs', 'appExit', 'tuiClientPlugins']
 
 const clientEntry = fileURLToPath(new URL('./client-process.js', import.meta.url))
 const requireFromTui = createRequire(import.meta.url)
@@ -44,7 +44,10 @@ export async function apply(ctx) {
       // ACP owns the Client process's stdin/stdout. Its fd 3/4 retain the
       // user's terminal for the Rust painter spawned inside that process.
       stdio: ['pipe', 'pipe', 'inherit', process.stdin, process.stdout],
-      env: process.env,
+      env: {
+        ...process.env,
+        DSH_TUI_CLIENT_PLUGINS_V0: JSON.stringify(ctx.tuiClientPlugins.list()),
+      },
     },
   )
   const agentToClient = child.stdin