martty 0.2.17 → 0.2.18

package/lib/acp-host.js

@@ -1,24 +1,36 @@
 /** Resolve the embeddable ACP plugin from TUI's own dependency graph. */
 
 import { createRequire } from 'node:module'
+import { pathToFileURL } from 'node:url'
 
 export const name = 'dsh-tui-acp-host'
 export const inject = ['loader']
 
-const requireFromTui = createRequire(import.meta.url)
-
-function ownAcpPlugin() {
-  const specifier = '@openma/deepseek-harness-acp/plugin'
-  try {
-    return requireFromTui.resolve(specifier)
-  } catch {
-    // A source-linked package may rely on the active profile's installation.
-    return specifier
+function resolvedModule(ctx, specifier) {
+  for (const anchor of [ctx.baseUrl, import.meta.url]) {
+    if (typeof anchor !== 'string') continue
+    try {
+      return pathToFileURL(createRequire(anchor).resolve(specifier)).href
+    } catch {
+      // Try TUI's dependency graph after the active profile.
+    }
   }
+  return specifier
 }
 
 export async function apply(ctx, config) {
-  const exports = await ctx.loader.import(ownAcpPlugin())
+  const specifier = '@openma/deepseek-harness-acp/plugin'
+  const resolved = resolvedModule(ctx, specifier)
+  let exports
+  try {
+    exports = await import(resolved)
+  } catch (cause) {
+    throw new Error(`dsh-tui: failed to import ${specifier} from ${resolved}`, { cause })
+  }
   const plugin = ctx.loader.unwrapExports(exports)
-  await ctx.plugin(plugin, config)
+  try {
+    await ctx.plugin(plugin, config)
+  } catch (cause) {
+    throw new Error(`dsh-tui: failed to mount ${specifier}`, { cause })
+  }
 }

package/lib/ayu.js

@@ -0,0 +1,22 @@
+/**
+ * Gallery palette pack `ayu`. Registers complete token maps: dark from the
+ * Ayu dark variant, light from Ayu Light
+ * (terminalcolors.com/themes/ayu). Does not activate:
+ * `/theme` covers it. `inject = ['tuiTheme']`: sibling profile row, not
+ * `ctx.plugin` inside the runner.
+ */
+
+import { readFileSync } from 'node:fs'
+
+const ayuPalette = JSON.parse(
+  readFileSync(new URL('./palettes/ayu.json', import.meta.url), 'utf8'),
+)
+
+export const name = 'tui-theme-ayu'
+export const inject = ['tuiTheme']
+
+export function apply(ctx) {
+  ctx.effect(() => ctx.tuiTheme.register(ayuPalette, { activate: false }))
+}
+
+export { ayuPalette }

package/lib/boot.js

@@ -15,6 +15,12 @@ import { apply as applyShell } from './index.js'
 import { resolveStackedAgent } from './agent.js'
 import { apply as applySlots } from './tui-slots.js'
 import { apply as applyTheme } from './tui-theme.js'
+import { apply as applyAyu, inject as ayuInject } from './ayu.js'
+import { apply as applyCatppuccin, inject as catppuccinInject } from './catppuccin.js'
+import { apply as applyKanagawa, inject as kanagawaInject } from './kanagawa.js'
+import { apply as applyEverforest, inject as everforestInject } from './everforest.js'
+import { apply as applyIceberg, inject as icebergInject } from './iceberg.js'
+import { apply as applySolarized, inject as solarizedInject } from './solarized.js'
 import { apply as applyCommands } from './tui-commands.js'
 import { apply as applyOverlay } from './tui-overlay.js'
 import { apply as applyPresets, inject as presetsInject } from './tui-presets.js'
@@ -34,7 +40,7 @@ import { installTuiLocalPlugins } from './tui-local-plugins.js'
  * @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]
+ * @param {Array<{ id: string, kind: 'theme' | 'ui', entry: string }>} [options.packagePlugins]
  */
 export async function bootClient(options = {}) {
   const { Context } = await import('@deepseek-ai/cordis')
@@ -49,6 +55,12 @@ export async function bootClient(options = {}) {
   const presetConfig = { settingsPath }
   if (typeof ctx.plugin === 'function') {
     await ctx.plugin({ name: 'tui-theme', inject: [], apply: applyTheme }, presetConfig)
+    await ctx.plugin({ name: 'tui-theme-ayu', inject: ayuInject, apply: applyAyu })
+    await ctx.plugin({ name: 'tui-theme-catppuccin', inject: catppuccinInject, apply: applyCatppuccin })
+    await ctx.plugin({ name: 'tui-theme-kanagawa', inject: kanagawaInject, apply: applyKanagawa })
+    await ctx.plugin({ name: 'tui-theme-everforest', inject: everforestInject, apply: applyEverforest })
+    await ctx.plugin({ name: 'tui-theme-iceberg', inject: icebergInject, apply: applyIceberg })
+    await ctx.plugin({ name: 'tui-theme-solarized', inject: solarizedInject, apply: applySolarized })
     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 })
@@ -87,7 +99,7 @@ export async function bootClient(options = {}) {
         name: 'dsh-tui-shell',
         inject: [
           'acpClient', 'tuiTheme', 'tuiSlots', 'tuiCommands', 'tuiOverlay',
-          'acpClientEvents', 'acpSessionConfig', 'tuiCordisClientRunner',
+          'tuiPresets', 'acpClientEvents', 'acpSessionConfig', 'tuiCordisClientRunner',
         ],
         apply: applyShell,
       },
@@ -95,6 +107,12 @@ export async function bootClient(options = {}) {
     )
   } else {
     applyTheme(ctx, presetConfig)
+    applyAyu(ctx)
+    applyCatppuccin(ctx)
+    applyKanagawa(ctx)
+    applyEverforest(ctx)
+    applyIceberg(ctx)
+    applySolarized(ctx)
     applySlots(ctx)
     applyCommands(ctx)
     applyOverlay(ctx)
@@ -145,7 +163,7 @@ export function parseClientPluginsEnv(value) {
     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)) {
+    if (!['theme', 'ui', 'ui-preset'].includes(entry.kind)) {
       throw new Error(`dsh-tui: installed Client plugin entry ${index} has an invalid kind`)
     }
     if (typeof entry.entry !== 'string') {
@@ -160,7 +178,11 @@ export function parseClientPluginsEnv(value) {
     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 }
+    return {
+      id: entry.id,
+      kind: entry.kind === 'ui-preset' ? 'ui' : entry.kind,
+      entry: url.href,
+    }
   })
 }
 

package/lib/catppuccin.js

@@ -0,0 +1,23 @@
+/**
+ * Gallery palette pack `catppuccin`. Registers complete token maps: dark
+ * from the Catppuccin Mocha variant, light from Catppuccin Latte
+ * (terminalcolors.com/themes/catppuccin)
+ * (terminalcolors.com/themes/catppuccin). Does not activate: `/theme`
+ * covers it. `inject = ['tuiTheme']`: sibling profile row, not `ctx.plugin`
+ * inside the runner.
+ */
+
+import { readFileSync } from 'node:fs'
+
+const catppuccinPalette = JSON.parse(
+  readFileSync(new URL('./palettes/catppuccin.json', import.meta.url), 'utf8'),
+)
+
+export const name = 'tui-theme-catppuccin'
+export const inject = ['tuiTheme']
+
+export function apply(ctx) {
+  ctx.effect(() => ctx.tuiTheme.register(catppuccinPalette, { activate: false }))
+}
+
+export { catppuccinPalette }

package/lib/client-run.js

@@ -161,7 +161,10 @@ function restrictedCtx(env, own, inject) {
             && typeof sourceTheme.registerOwned === 'function'
             ? sourceTheme.registerOwned.bind(sourceTheme, env.pluginId)
             : sourceTheme.register.bind(sourceTheme)
-          const registration = register(palette, options)
+          const registration = register(palette, {
+            ...options,
+            ...(typeof env.pluginSource === 'string' ? { source: env.pluginSource } : {}),
+          })
           const dispose = own(
             typeof registration?.dispose === 'function'
               ? registration.dispose.bind(registration)
@@ -199,7 +202,13 @@ function restrictedCtx(env, own, inject) {
     ? undefined
     : {
         register(options, mount) {
-          return own(sourcePresets.register(options, mount))
+          const register = typeof env.pluginId === 'string'
+            && typeof sourcePresets.registerOwned === 'function'
+            ? sourcePresets.registerOwned.bind(sourcePresets, env.pluginId)
+            : sourcePresets.register.bind(sourcePresets)
+          return own(register(options, mount, {
+            ...(typeof env.pluginSource === 'string' ? { source: env.pluginSource } : {}),
+          }))
         },
         list() {
           return sourcePresets.list()

package/lib/cordis-protocol.js

@@ -21,6 +21,10 @@ export const CORDIS_METHODS = Object.freeze({
   pluginStart: '_dsh/cordis/plugins/start',
   pluginStop: '_dsh/cordis/plugins/stop',
   pluginRetract: '_dsh/cordis/plugins/retract',
+  approvalsUpdate: '_dsh/cordis/tui/approvals/update',
+  approvalRespond: '_dsh/cordis/tui/approvals/respond',
+  uiUpdate: '_dsh/cordis/tui/ui/update',
+  uiSelected: '_dsh/cordis/tui/ui/selected',
   themeUpdate: '_dsh/cordis/tui/theme/update',
   themeRemove: '_dsh/cordis/tui/theme/remove',
   themeSelected: '_dsh/cordis/tui/theme/selected',

package/lib/creator-overlay.js

@@ -41,7 +41,7 @@ function registerArtifactTools(ctx, scopedCtx, defineTool, store) {
     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 '
+      + 'Use this only after cordis_run succeeds. UI and Theme Plugins survive restart only '
       + 'after this Tool returns saved. Replacing an existing artifact must be explicit.',
     parameters: {
       artifactId: {
@@ -52,7 +52,7 @@ function registerArtifactTools(ctx, scopedCtx, defineTool, store) {
       kind: {
         type: 'string',
         required: true,
-        enum: ['ui-preset', 'theme'],
+        enum: ['ui', 'theme'],
         description: 'Durable TUI contribution kind.',
       },
       pluginId: {
@@ -86,7 +86,7 @@ function registerArtifactTools(ctx, scopedCtx, defineTool, store) {
       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',
+          + 'belongs to the connected Harness and needs its separate shipping path',
         )
       }
       if (typeof source.code?.client !== 'string') {

package/lib/everforest.js

@@ -0,0 +1,21 @@
+/**
+ * Gallery palette pack `everforest`. Registers complete dark/light token maps:
+ * dark from Everforest Dark, light from Everforest Light (terminalcolors.com/themes/everforest). Does not activate:
+ * `/theme` covers it. `inject = ['tuiTheme']`: sibling profile row, not
+ * `ctx.plugin` inside the runner.
+ */
+
+import { readFileSync } from 'node:fs'
+
+const everforestPalette = JSON.parse(
+  readFileSync(new URL('./palettes/everforest.json', import.meta.url), 'utf8'),
+)
+
+export const name = 'tui-theme-everforest'
+export const inject = ['tuiTheme']
+
+export function apply(ctx) {
+  ctx.effect(() => ctx.tuiTheme.register(everforestPalette, { activate: false }))
+}
+
+export { everforestPalette }

package/lib/iceberg.js

@@ -0,0 +1,21 @@
+/**
+ * Gallery palette pack `iceberg`. Registers complete dark/light token maps:
+ * dark from Iceberg Dark, light from Iceberg Light (terminalcolors.com/themes/iceberg). Does not activate:
+ * `/theme` covers it. `inject = ['tuiTheme']`: sibling profile row, not
+ * `ctx.plugin` inside the runner.
+ */
+
+import { readFileSync } from 'node:fs'
+
+const icebergPalette = JSON.parse(
+  readFileSync(new URL('./palettes/iceberg.json', import.meta.url), 'utf8'),
+)
+
+export const name = 'tui-theme-iceberg'
+export const inject = ['tuiTheme']
+
+export function apply(ctx) {
+  ctx.effect(() => ctx.tuiTheme.register(icebergPalette, { activate: false }))
+}
+
+export { icebergPalette }

package/lib/index.js

@@ -16,7 +16,7 @@ import { muxAcpAndCompositor } from './mux.js'
 
 export const name = 'dsh-tui-shell'
 export const inject = [
-  'acpClient', 'tuiTheme', 'tuiSlots', 'tuiCommands', 'tuiOverlay',
+  'acpClient', 'tuiTheme', 'tuiPresets', 'tuiSlots', 'tuiCommands', 'tuiOverlay',
   'acpClientEvents', 'acpSessionConfig', 'tuiCordisClientRunner',
 ]
 
@@ -115,6 +115,7 @@ export async function applyShell(ctx, options = {}) {
     throw new Error('dsh-tui-shell: ctx.acpClient must expose stdin and stdout')
   }
   const clientRunner = ctx.tuiCordisClientRunner ?? ctx.get?.('tuiCordisClientRunner')
+  const presets = ctx.tuiPresets ?? ctx.get?.('tuiPresets')
   if (clientRunner === undefined || typeof clientRunner.bindTransport !== 'function'
     || typeof clientRunner.selectTheme !== 'function') {
     throw new Error(
@@ -225,18 +226,25 @@ export async function applyShell(ctx, options = {}) {
         if (message.method === CORDIS_METHODS.overlayEvent) {
           return overlay.dispatch(message.params)
         }
+        if (message.method === CORDIS_METHODS.approvalRespond) {
+          return clientRunner.respondApproval(message.params)
+        }
+        if (message.method === CORDIS_METHODS.uiSelected) {
+          return clientRunner.selectUi(message.params)
+        }
         throw new Error(`unsupported Cordis TUI method: ${String(message.method)}`)
       },
     })
     const notifyTui = (method, params) => mux.notifyTui(method, params)
     republishCompositorState = () => {
       handle.bindNotify(notifyTui)
+      presets?.bindNotify?.(notifyTui)
       slots.bindNotify(notifyTui)
       commands.bindNotify(notifyTui)
       overlay.bindNotify(notifyTui)
     }
     republishCompositorState()
-    clientRunner.bindTransport(mux.requestAgent)
+    clientRunner.bindTransport(mux.requestAgent, notifyTui)
     sessionConfig.bindTransport(mux.requestTui)
     connection.resume?.()
     connection.muxed = true

package/lib/inspect.js

@@ -756,14 +756,15 @@ async function mountClientHalf(
  *   acpSessionStatus?: object,
  *   localPlugins?: object,
  *   requestAgent: (method: string, params?: object) => Promise<unknown>,
+ *   notifyTui?: (method: string, params?: object) => void,
  * }} opts
- * @returns {{ onHost: (message: object) => void }}
+ * @returns {{ onHost: (message: object) => void, respondApproval: (params: object) => Promise<void> }}
  */
 export function attachTuiClient(opts) {
   const {
     ctx, tuiTheme, tuiPresets, tuiSlots, tuiCommands, tuiOverlay, acpSessionConfig, acpSessionPlan,
     acpSessionStats, acpSessionStatus, localPlugins,
-    requestAgent,
+    requestAgent, notifyTui = () => {},
   } = opts
   const providers = [
     themeInspectProvider(tuiTheme),
@@ -780,6 +781,23 @@ export function attachTuiClient(opts) {
   /** @type {Map<string, () => void>} */
   const loaded = new Map()
   const pendingThemeSelections = new Map()
+  const pendingUiSelections = new Map()
+  const pendingApprovals = new Map()
+
+  function publishApprovals() {
+    notifyTui(CORDIS_METHODS.approvalsUpdate, {
+      protocol: 0,
+      approvals: [...pendingApprovals.values()].map((request) => ({
+        requestId: request.requestId,
+        agentId: request.agentId,
+        pluginId: request.pluginId,
+        packageId: request.packageId,
+        mode: request.mode,
+        name: request.name,
+        purpose: request.purpose,
+      })),
+    })
+  }
 
   async function stopOwner(agentId, pluginId) {
     if (localPlugins?.has?.(pluginId) === true) {
@@ -828,7 +846,7 @@ export function attachTuiClient(opts) {
     await requestAgent(CORDIS_METHODS.inspectResolve, { agentId, requestId, resolution }).catch(() => {})
   }
 
-  async function runClient(params, direct = false) {
+  async function runClient(params, direct = false, approveFutureVersions = false) {
     const request = params !== null && typeof params === 'object' ? params : {}
     const requestId = request.requestId
     if (!direct && typeof requestId !== 'string') return
@@ -842,6 +860,7 @@ export function attachTuiClient(opts) {
       ? { ok: true, pluginRunId: request.pluginRunId }
       : undefined
     const previousThemeOwner = tuiTheme.owner?.(tuiTheme.active())
+    const previousUiOwner = tuiPresets?.owner?.(tuiPresets.active?.())
     try {
       if (!direct) {
         host = await requestAgent(CORDIS_METHODS.runHost, {
@@ -850,7 +869,7 @@ export function attachTuiClient(opts) {
           packageId: request.packageId,
           mode: request.mode,
           requestId,
-          approveFutureVersions: false,
+          approveFutureVersions,
         })
       }
       if (host === null || typeof host !== 'object' || host.ok !== true) {
@@ -909,6 +928,15 @@ export function attachTuiClient(opts) {
         },
       )
       loaded.set(request.pluginId, applied.dispose)
+      const selectedUi = pendingUiSelections.get(request.pluginId)
+      if (selectedUi !== undefined && tuiPresets?.isLoaded?.(selectedUi) === true) {
+        pendingUiSelections.delete(request.pluginId)
+        tuiPresets.activate(selectedUi)
+        if (previousUiOwner !== undefined && previousUiOwner !== request.pluginId
+          && tuiTheme.owner?.(tuiTheme.active()) !== previousUiOwner) {
+          await stopOwner(request.agentId, previousUiOwner)
+        }
+      }
       const selectedTheme = pendingThemeSelections.get(request.pluginId)
       if (selectedTheme !== undefined && tuiTheme.isLoaded?.(selectedTheme) === true) {
         pendingThemeSelections.delete(request.pluginId)
@@ -953,7 +981,21 @@ export function attachTuiClient(opts) {
       case CORDIS_METHODS.inspectQuery:
         return answerQuery(message.params)
       case CORDIS_METHODS.requestRun:
+        if (message.params !== null && typeof message.params === 'object'
+          && message.params.requiresApproval === true
+          && typeof message.params.requestId === 'string') {
+          pendingApprovals.set(message.params.requestId, { ...message.params })
+          publishApprovals()
+          return
+        }
         return runClient(message.params)
+      case CORDIS_METHODS.requestRunResolved: {
+        const requestId = message.params !== null && typeof message.params === 'object'
+          ? message.params.requestId
+          : undefined
+        if (typeof requestId === 'string' && pendingApprovals.delete(requestId)) publishApprovals()
+        return
+      }
       case CORDIS_METHODS.userRun:
         return runClient(message.params, true)
       case CORDIS_METHODS.pluginRetract: {
@@ -970,6 +1012,29 @@ export function attachTuiClient(opts) {
     }
   }
 
+  async function respondApproval(params) {
+    const request = params !== null && typeof params === 'object' ? params : {}
+    if (request.protocol !== 0) throw new Error('unsupported approval response payload')
+    if (typeof request.requestId !== 'string' || request.requestId.length === 0) {
+      throw new Error('approval response needs requestId')
+    }
+    if (!['allow-version', 'allow-future', 'reject'].includes(request.decision)) {
+      throw new Error('approval response has an invalid decision')
+    }
+    const pending = pendingApprovals.get(request.requestId)
+    if (pending === undefined) return
+    pendingApprovals.delete(request.requestId)
+    publishApprovals()
+    if (request.decision === 'reject') {
+      await requestAgent(CORDIS_METHODS.resolveRequestRun, {
+        requestId: request.requestId,
+        resolution: { ok: false, reason: 'rejected' },
+      })
+      return
+    }
+    await runClient(pending, false, request.decision === 'allow-future')
+  }
+
   async function selectTheme(params) {
     const request = params !== null && typeof params === 'object' ? params : {}
     if (request.protocol !== 0) throw new Error('unsupported theme selection payload')
@@ -1042,12 +1107,71 @@ export function attachTuiClient(opts) {
     }
   }
 
+  async function selectUi(params) {
+    const request = params !== null && typeof params === 'object' ? params : {}
+    if (request.protocol !== 0) throw new Error('unsupported UI selection payload')
+    if (typeof request.agentId !== 'string' || request.agentId.length === 0) {
+      throw new Error('UI selection needs agentId')
+    }
+    if (typeof request.id !== 'string' || request.id.length === 0) {
+      throw new Error('UI selection needs id')
+    }
+    if (!tuiPresets?.list?.().some((entry) => entry.id === request.id)) {
+      throw new Error(`UI Plugin "${request.id}" is not registered`)
+    }
+    const previousId = tuiPresets.active()
+    const previousOwner = tuiPresets.owner?.(previousId)
+    const targetOwner = tuiPresets.owner?.(request.id)
+
+    if (targetOwner === undefined || tuiPresets.isLoaded?.(request.id) === true) {
+      tuiPresets.activate(request.id)
+      if (previousOwner !== undefined && previousOwner !== targetOwner
+        && tuiTheme.owner?.(tuiTheme.active()) !== previousOwner) {
+        await stopOwner(request.agentId, previousOwner)
+      }
+      return { ok: true, status: 'selected', id: request.id }
+    }
+    if (localPlugins?.has?.(targetOwner) === true) {
+      await localPlugins.start(targetOwner)
+      if (tuiPresets.isLoaded?.(request.id) !== true) {
+        throw new Error(`local UI Plugin "${targetOwner}" did not load UI "${request.id}"`)
+      }
+      tuiPresets.activate(request.id)
+      if (previousOwner !== undefined && previousOwner !== targetOwner
+        && tuiTheme.owner?.(tuiTheme.active()) !== previousOwner) {
+        await stopOwner(request.agentId, previousOwner)
+      }
+      return { ok: true, status: 'selected', id: request.id }
+    }
+
+    pendingUiSelections.set(targetOwner, request.id)
+    try {
+      const started = await requestAgent(CORDIS_METHODS.pluginStart, {
+        agentId: request.agentId,
+        pluginId: targetOwner,
+      })
+      if (started?.ok === false) {
+        throw new Error(typeof started.message === 'string'
+          ? started.message
+          : `failed to start UI Plugin "${targetOwner}"`)
+      }
+      return { ok: true, status: 'starting', id: request.id }
+    } catch (error) {
+      pendingUiSelections.delete(targetOwner)
+      throw error
+    }
+  }
+
   function dispose() {
     for (const release of loaded.values()) release()
     loaded.clear()
+    if (pendingApprovals.size > 0) {
+      pendingApprovals.clear()
+      publishApprovals()
+    }
   }
 
-  return { onHost, selectTheme, sync, dispose }
+  return { onHost, respondApproval, selectTheme, selectUi, sync, dispose }
 }
 
 /** Mount the TUI counterpart of the Web Cordis Client runner. */
@@ -1064,12 +1188,12 @@ export function apply(ctx) {
   const localPlugins = ctx.get?.('tuiLocalPlugins')
   let client
   const service = {
-    bindTransport(requestAgent) {
+    bindTransport(requestAgent, notifyTui) {
       client?.dispose()
       client = attachTuiClient({
         ctx, tuiTheme, tuiPresets, tuiSlots, tuiCommands, tuiOverlay, acpSessionConfig, acpSessionPlan,
         acpSessionStats, acpSessionStatus, localPlugins,
-        requestAgent,
+        requestAgent, notifyTui,
       })
       const attached = client
       return () => {
@@ -1085,6 +1209,14 @@ export function apply(ctx) {
       if (client === undefined) throw new Error('TUI Cordis Client runner is not attached')
       return client.selectTheme(params)
     },
+    selectUi(params) {
+      if (client === undefined) throw new Error('TUI Cordis Client runner is not attached')
+      return client.selectUi(params)
+    },
+    respondApproval(params) {
+      if (client === undefined) throw new Error('TUI Cordis Client runner is not attached')
+      return client.respondApproval(params)
+    },
     sync() {
       client?.sync()
     },

package/lib/kanagawa.js

@@ -0,0 +1,22 @@
+/**
+ * Gallery palette pack `kanagawa`. Registers complete dark/light token maps:
+ * dark from the Kanagawa Wave variant, light from Kanagawa Lotus
+ * (terminalcolors.com/themes/kanagawa). Does not activate: `/theme` covers
+ * it. `inject = ['tuiTheme']`: sibling profile row, not `ctx.plugin` inside
+ * the runner.
+ */
+
+import { readFileSync } from 'node:fs'
+
+const kanagawaPalette = JSON.parse(
+  readFileSync(new URL('./palettes/kanagawa.json', import.meta.url), 'utf8'),
+)
+
+export const name = 'tui-theme-kanagawa'
+export const inject = ['tuiTheme']
+
+export function apply(ctx) {
+  ctx.effect(() => ctx.tuiTheme.register(kanagawaPalette, { activate: false }))
+}
+
+export { kanagawaPalette }

package/lib/mux.js

@@ -21,6 +21,8 @@ const COMPOSITOR_METHODS = Object.freeze(new Set([
   CORDIS_METHODS.commandInvoke,
   CORDIS_METHODS.overlayEvent,
   CORDIS_METHODS.sessionConfigSet,
+  CORDIS_METHODS.approvalRespond,
+  CORDIS_METHODS.uiSelected,
 ]))
 
 /** Agent → TUI Node extras. Not compositor paint; Rust never sees these. */

package/lib/palettes/ayu.json

@@ -0,0 +1,44 @@
+{
+  "id": "ayu",
+  "label": "Ayu",
+  "dark": {
+    "bg": "#0b0e14",
+    "surface": "#0b0e14",
+    "panel": "#1e232b",
+    "fg": "#bfbdb6",
+    "fg_secondary": "#686868",
+    "fg_tertiary": "#686868",
+    "caption": "#686868",
+    "brand": "#53bdfa",
+    "brand_soft": "#cda1fa",
+    "bubble_bg": "#1b3a5b",
+    "bubble_fg": "#bfbdb6",
+    "border": "#686868",
+    "code_bg": "#0b0e14",
+    "ok": "#7fd962",
+    "warn": "#f9af4f",
+    "err": "#ea6c73",
+    "hint": "#90e1c6",
+    "chip_bg": "#1e232b"
+  },
+  "light": {
+    "bg": "#f8f9fa",
+    "surface": "#f8f9fa",
+    "panel": "#d1d1d1",
+    "fg": "#5c6166",
+    "fg_secondary": "#686868",
+    "fg_tertiary": "#686868",
+    "caption": "#686868",
+    "brand": "#3199e1",
+    "brand_soft": "#9e75c7",
+    "bubble_bg": "#d3e1f5",
+    "bubble_fg": "#5c6166",
+    "border": "#686868",
+    "code_bg": "#f8f9fa",
+    "ok": "#6cbf43",
+    "warn": "#eca944",
+    "err": "#ea6c6d",
+    "hint": "#46ba94",
+    "chip_bg": "#d1d1d1"
+  }
+}