martty 0.2.28 → 0.2.30

package/lib/acp-client.js

@@ -80,12 +80,31 @@ export function apply(ctx, config = {}) {
     provide(ctx, liveAgent)
     return
   }
+  // Replacing the agent: the previous child must not outlive its spec.
+  if (liveAgent !== null && liveAgent.child.exitCode === null) {
+    try {
+      liveAgent.child.kill('SIGTERM')
+    } catch {
+      // already gone
+    }
+  }
+  liveAgent = null
   const child = spawn(agent.command, agent.args ?? [], {
     stdio: ['pipe', 'pipe', 'inherit'],
     env: { ...process.env, ...(agent.env ?? {}) },
   })
   child.stdin.on('error', () => {})
   child.stdout.on('error', () => {})
+  child.on('error', (err) => {
+    // A failed spawn (ENOENT, EACCES) emits 'error' on the child; without a
+    // listener it is an uncaught exception. Surface EOF to the transport
+    // instead so pending requests fail instead of hanging, and drop the
+    // cached handle so the next apply() retries the spawn.
+    console.error(`acp-client: failed to spawn agent ${agent.command}: ${err.message}`)
+    if (liveAgent?.child === child) liveAgent = null
+    child.stdin.destroy()
+    child.stdout.destroy()
+  })
   const service = {
     kind: 'spawn',
     command: agent.command,

package/lib/acp-session-stats.js

@@ -25,6 +25,7 @@ function zero(sessionId) {
     usage: {
       input: 0, output: 0, cached: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0,
     },
+    context: { used: 0, size: 0 },
     stats: {
       turns: 0,
       steps: 0,
@@ -137,6 +138,19 @@ export function installAcpSessionStats(ctx, options = {}) {
     }
 
     const type = readString(update, 'sessionUpdate', 'session_update')
+    if (type === 'usage_update') {
+      // Harness-authoritative context gauge: `used` is the final prompt
+      // size (input + cache + output) of the last step and `size` the
+      // real model window from `request/context`. Client-side
+      // accumulation cannot derive either: per-prompt input sums every
+      // step's full context, and standard ACP does not carry the window.
+      const size = number(update.size)
+      if (size > 0) {
+        value.context = { used: number(update.used), size }
+        publish()
+      }
+      return
+    }
     const prompt = sessionId === undefined ? undefined : activePrompts.get(sessionId)
     if (prompt !== undefined && prompt.firstToken === undefined
       && (type === 'agent_message_chunk' || type === 'agent_thought_chunk')

package/lib/agents-view.js

@@ -5,29 +5,49 @@ export const inject = ['tuiAgents', 'tuiSlots', 'tuiCommands']
 
 export function apply(ctx) {
   let current = ctx.tuiAgents.current()
+  // Issue #80: `/agents` is an on/off switch for the panel. `visible` is
+  // the user preference; `forced` remembers `/agents on` so the summary
+  // stays open even after every task ended, until the next batch starts.
+  let visible = true
+  let forced = false
   let panel
 
   const stopSlot = ctx.tuiSlots.inject('conversation.navigation.dock', () => {
     panel = ctx.tuiSlots.register(
       { name: 'conversation.navigation.dock', id: 'agents-view', order: 0 },
-      dockNodes(current),
+      dockNodes(current, visible, forced),
     )
     return () => panel.dispose()
   })
   const stopAgents = ctx.tuiAgents.subscribe((snapshot) => {
     current = snapshot
-    panel?.update(dockNodes(current))
+    // A new running batch clears the forced-open state so the panel
+    // auto-closes again once this batch ends.
+    if (snapshot.items.some((item) => item.kind === 'subagent' && item.status === 'running')) {
+      forced = false
+    }
+    panel?.update(dockNodes(current, visible, forced))
   })
   const stopCommand = ctx.tuiCommands.register({
     name: 'agents',
-    description: 'Switch the visible Agent transcript',
+    description: 'Toggle the Agent panel (on/off)',
+    input: { hint: '[on|off|agent-id]' },
   }, async (args) => {
-    current = ctx.tuiAgents.current()
-    const target = args.trim()
-    if (target.length > 0) {
-      return ctx.tuiAgents.select(target)
+    const arg = args.trim().toLowerCase()
+    if (arg === 'on') {
+      visible = true
+      forced = true
+    } else if (arg === 'off') {
+      visible = false
+      forced = false
+    } else if (arg === '') {
+      visible = !visible
+      forced = visible
+    } else {
+      return ctx.tuiAgents.select(args.trim())
     }
-    return ctx.tuiAgents.navigate('begin')
+    panel?.update(dockNodes(current, visible, forced))
+    return true
   })
 
   return () => {
@@ -37,9 +57,10 @@ export function apply(ctx) {
   }
 }
 
-function dockNodes(snapshot) {
+function dockNodes(snapshot, visible = true, forced = false) {
   if (!Array.isArray(snapshot?.items) || snapshot.items.length < 2) return []
   const selecting = snapshot.selectedId !== null && snapshot.selectedId !== undefined
+  if (!visible && !selecting) return []
   if (!selecting) {
     const agents = snapshot.items.filter((item) => item.kind === 'subagent')
     const marked = agents.filter((item) => item.current !== false)
@@ -47,6 +68,10 @@ function dockNodes(snapshot) {
     const completed = current.filter((item) => item.status === 'finished' || item.status === 'failed').length
     const running = current.some((item) => item.status === 'running')
     const failed = current.some((item) => item.status === 'failed')
+    // Issue #80: auto-close once every Agent task has ended. A failed task
+    // keeps the summary so the failure stays visible; `/agents on` (forced)
+    // holds it open until the next batch starts running.
+    if (!running && !failed && !forced) return []
     return [
       {
         id: 'summary', kind: 'generic', title: '· Agents', body: `${completed}/${current.length}`,

package/lib/boot.js

@@ -1,3 +1,24 @@
+/**
+ * Boot-time restore of a statically-registered gallery palette (ayu,
+ * iceberg, …). `/theme` persistence writes `settings.theme`; dynamic
+ * packs are restored by tui-local-plugins (they have an owner), but the
+ * builtin gallery registers with no owner, so nothing would re-activate
+ * the saved pick on the next launch. Runs after every static theme
+ * Plugin is registered; `activate` notifies the painter (or queues until
+ * `bindNotify` flushes). A broken or unknown id must not block boot.
+ */
+export function restorePreferredTheme(tuiTheme) {
+  const preferred = tuiTheme?.preferred?.()
+  if (typeof preferred !== 'string' || preferred === 'default') return
+  if (tuiTheme?.owner?.(preferred) !== undefined) return
+  if (!tuiTheme?.isLoaded?.(preferred)) return
+  try {
+    tuiTheme.activate(preferred)
+  } catch {
+    // a broken pack must not block TUI startup
+  }
+}
+
 /**
  * Cordis client boot: tuiTheme + tuiSlots + acp-client + TUI shell.
  *
@@ -21,6 +42,8 @@ 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 applyOne, inject as oneInject } from './one.js'
+import { apply as applyTomorrow, inject as tomorrowInject } from './tomorrow.js'
 import { apply as applyCommands } from './tui-commands.js'
 import { apply as applyOverlay } from './tui-overlay.js'
 import { apply as applyAgents } from './tui-agents.js'
@@ -65,6 +88,9 @@ export async function bootClient(options = {}) {
     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-theme-one', inject: oneInject, apply: applyOne })
+    await ctx.plugin({ name: 'tui-theme-tomorrow', inject: tomorrowInject, apply: applyTomorrow })
+    restorePreferredTheme(ctx.get('tuiTheme'))
     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 })
@@ -122,6 +148,9 @@ export async function bootClient(options = {}) {
     applyEverforest(ctx)
     applyIceberg(ctx)
     applySolarized(ctx)
+    applyOne(ctx)
+    applyTomorrow(ctx)
+    restorePreferredTheme(ctx.tuiTheme)
     applySlots(ctx)
     applyCommands(ctx)
     applyOverlay(ctx)

package/lib/one.js

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

package/lib/palettes/one.json

@@ -0,0 +1,44 @@
+{
+  "id": "one",
+  "label": "One",
+  "dark": {
+    "bg": "#282c34",
+    "surface": "#282c34",
+    "panel": "#1e2127",
+    "fg": "#abb2bf",
+    "fg_secondary": "#5c6370",
+    "fg_tertiary": "#5c6370",
+    "caption": "#5c6370",
+    "brand": "#61afef",
+    "brand_soft": "#c678dd",
+    "bubble_bg": "#abb2bf",
+    "bubble_fg": "#282c34",
+    "border": "#5c6370",
+    "code_bg": "#282c34",
+    "ok": "#98c379",
+    "warn": "#d19a66",
+    "err": "#e06c75",
+    "hint": "#56b6c2",
+    "chip_bg": "#1e2127"
+  },
+  "light": {
+    "bg": "#f8f8f8",
+    "surface": "#f8f8f8",
+    "panel": "#bbbbbb",
+    "fg": "#2a2b33",
+    "fg_secondary": "#5c6370",
+    "fg_tertiary": "#5c6370",
+    "caption": "#5c6370",
+    "brand": "#2f5af3",
+    "brand_soft": "#a00095",
+    "bubble_bg": "#2a2b33",
+    "bubble_fg": "#f8f8f8",
+    "border": "#5c6370",
+    "code_bg": "#f8f8f8",
+    "ok": "#3e953a",
+    "warn": "#c18401",
+    "err": "#de3d35",
+    "hint": "#0184bc",
+    "chip_bg": "#bbbbbb"
+  }
+}

package/lib/palettes/tomorrow.json

@@ -0,0 +1,44 @@
+{
+  "id": "tomorrow",
+  "label": "Tomorrow",
+  "dark": {
+    "bg": "#000000",
+    "surface": "#000000",
+    "panel": "#424242",
+    "fg": "#eaeaea",
+    "fg_secondary": "#969896",
+    "fg_tertiary": "#969896",
+    "caption": "#969896",
+    "brand": "#7aa6da",
+    "brand_soft": "#c397d8",
+    "bubble_bg": "#424242",
+    "bubble_fg": "#eaeaea",
+    "border": "#969896",
+    "code_bg": "#000000",
+    "ok": "#b9ca4a",
+    "warn": "#e7c547",
+    "err": "#d54e53",
+    "hint": "#70c0b1",
+    "chip_bg": "#424242"
+  },
+  "light": {
+    "bg": "#ffffff",
+    "surface": "#ffffff",
+    "panel": "#d6d6d6",
+    "fg": "#4d4d4c",
+    "fg_secondary": "#8e908c",
+    "fg_tertiary": "#8e908c",
+    "caption": "#8e908c",
+    "brand": "#4271ae",
+    "brand_soft": "#8959a8",
+    "bubble_bg": "#d6d6d6",
+    "bubble_fg": "#4d4d4c",
+    "border": "#8e908c",
+    "code_bg": "#ffffff",
+    "ok": "#718c00",
+    "warn": "#eab700",
+    "err": "#c82829",
+    "hint": "#3e999f",
+    "chip_bg": "#d6d6d6"
+  }
+}

package/lib/plan-view.js

@@ -25,7 +25,7 @@ export function apply(ctx) {
     current = ctx.acpSessionPlan.current()
     ctx.tuiOverlay.openView({
       id: 'plan-view',
-      title: 'Plan',
+      title: viewTitle(current),
       nodes: viewNodes(current),
     })
   })
@@ -67,6 +67,18 @@ function dockNodes(plan) {
   }]
 }
 
+// The overlay window title: the `n/m` counter lives in the border, not in
+// the body, so the review never repeats its heading (issue #85).
+function viewTitle(plan) {
+  if (plan !== null && plan.kind === 'items') {
+    const total = plan.entries.length
+    if (total === 0) return 'Plan'
+    const completed = plan.entries.filter((entry) => entry.status === 'completed').length
+    return `Plan ${completed}/${total}`
+  }
+  return 'Plan'
+}
+
 function viewNodes(plan) {
   if (plan === null) {
     return [{ id: 'empty', kind: 'notice', level: 'info', text: 'No active plan' }]
@@ -78,10 +90,8 @@ function viewNodes(plan) {
     return [{ id: 'file', kind: 'notice', level: 'info', text: plan.uri }]
   }
   // Items render as one markdown node: a task-list review the transcript
-  // pipeline can fully render (headings, bold, strikethrough).
-  const total = plan.entries.length
-  const completed = plan.entries.filter((entry) => entry.status === 'completed').length
-  const lines = [`## Plan · ${completed}/${total}`, '']
+  // pipeline can fully render (bold, strikethrough).
+  const lines = []
   for (const entry of plan.entries) {
     const content = entry.content.replace(/\s*\n\s*/g, ' ')
     let item

package/lib/stats-view.js

@@ -1,47 +1,38 @@
 /** Built-in Client Plugin: standard ACP usage and timing in the composer dock. */
 
 export const name = 'stats-view'
-export const inject = ['acpSessionStats', 'acpSessionStatus', 'tuiSlots']
+export const inject = ['acpSessionStats', 'tuiSlots']
 
 export function apply(ctx) {
   let current = ctx.acpSessionStats.current()
-  let status = ctx.acpSessionStatus.current()
   let panel
   const stopSlot = ctx.tuiSlots.inject('conversation.composer.dock', () => {
     panel = ctx.tuiSlots.register(
       { name: 'conversation.composer.dock', id: 'stats' },
-      nodesOf(current, status),
+      nodesOf(current),
     )
     return () => panel.dispose()
   })
   const stopStats = ctx.acpSessionStats.subscribe((snapshot) => {
     current = snapshot
-    panel?.update(nodesOf(current, status))
-  })
-  const stopStatus = ctx.acpSessionStatus.subscribe((snapshot) => {
-    status = snapshot
-    panel?.update(nodesOf(current, status))
+    panel?.update(nodesOf(current))
   })
   return () => {
     stopStats?.()
-    stopStatus?.()
     stopSlot?.()
   }
 }
 
-function nodesOf(snapshot, status) {
+function nodesOf(snapshot) {
   const usage = snapshot?.usage ?? {}
   const stats = snapshot?.stats ?? {}
-  const model = status?.model
   const nodes = []
   if ((usage.input ?? 0) > 0 || (usage.output ?? 0) > 0) {
     nodes.push(node('tokens', `↑${formatTokens(usage.input)} · ↓${formatTokens(usage.output)}`))
-    const used = (usage.input ?? 0) + (usage.output ?? 0)
-      + (usage.cached ?? 0) + (usage.reasoning ?? 0)
-    const size = contextWindowOf(model)
-    if (used > 0 && size > 0) {
-      const pct = Math.min(100, used / size * 100).toFixed(1)
-      nodes.push(node('context', `${pct}%/${contextSizeLabel(size)}`))
+    const gauge = contextGauge(snapshot)
+    if (gauge.used > 0 && gauge.size > 0) {
+      const pct = Math.min(100, gauge.used / gauge.size * 100).toFixed(1)
+      nodes.push(node('context', `${pct}%/${contextSizeLabel(gauge.size)}`))
     }
   }
   if ((stats.turns ?? 0) > 0 || (stats.steps ?? 0) > 0) {
@@ -83,18 +74,19 @@ function node(id, title) {
 function plural(value, singular) { return value === 1 ? singular : `${singular}s` }
 
 /**
- * Context window of the current model (tokens). The ACP surface does not
- * carry the window size, so the known DeepSeek family sizes stand in;
- * unknown models fall back to a common 128K.
+ * Context-window gauge. Only the harness `usage_update` readout is shown:
+ * `used` is the final prompt size and `size` the real model window from
+ * `request/context`. Nothing client-side can reproduce either — per-turn
+ * usage sums every step's full context (multi-step turns over-report),
+ * and a model-name guess does not know the window (the old 128K guess is
+ * what pegged the dock at 100% early in issue #77). Without an
+ * authoritative readout the gauge is hidden instead of showing a wrong
+ * percentage.
  */
-function contextWindowOf(model) {
-  switch (model) {
-    case 'deepseek-v4-flash':
-    case 'deepseek-v4-pro':
-      return 1_000_000
-    default:
-      return 128_000
-  }
+function contextGauge(snapshot) {
+  const context = snapshot?.context
+  if (context?.size > 0) return { used: context.used ?? 0, size: context.size }
+  return { used: 0, size: 0 }
 }
 
 /** `1000000` → `1.0M`, `128000` → `128K` — keeps the one-decimal look of

package/lib/status-view.js

@@ -27,7 +27,8 @@ export function apply(ctx) {
 }
 
 /**
- * One `## status` markdown node. Run-state facts come from
+ * One markdown node of run-state facts (the window border already names
+ * the popup, so no in-body heading). Facts come from
  * `acpSessionStatus`; every token/turn/step/timing fact comes from
  * `acpSessionStats.current()` — the same snapshot `stats-view` renders in
  * the composer dock, so the two readouts can never drift apart.
@@ -37,7 +38,7 @@ function statusMarkdown(status, stats) {
   const folded = stats?.stats ?? {}
   const total = (usage.input ?? 0) + (usage.output ?? 0)
     + (usage.cached ?? 0) + (usage.reasoning ?? 0)
-  const lines = ['## status', '']
+  const lines = []
   lines.push(`- state · ${status.state ?? 'idle'}`)
   lines.push(`- acp · ${status.connection ?? 'not attached'}`)
   if (status.auth?.status !== undefined) {

package/lib/tomorrow.js

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

package/package.json

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