@brimveyn/aimux 1.18.4 → 1.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.18.4",
+  "version": "1.19.1",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",

package/src/cli/commands/tab/list.ts

@@ -1,20 +1,51 @@
 import type { CliCommand } from '../../registry'
 
-import { IPC_CAPABILITY_LIST_TABS, IPC_CAPABILITY_THIN_ATTACH } from '../../../ipc/protocol'
+import {
+  IPC_CAPABILITY_LIST_TABS,
+  IPC_CAPABILITY_LIST_TABS_LAST_LINE,
+  IPC_CAPABILITY_THIN_ATTACH,
+  type TabSessionSummary,
+} from '../../../ipc/protocol'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
 
+/**
+ * The daemon always populates `lastLine` on `listTabs` summaries (it's cheap),
+ * but the field bloats the common poll, so we strip it unless `--verbose` was
+ * asked for. Keeping the default output byte-identical to pre-v13 avoids
+ * churning downstream consumers.
+ */
+function stripLastLine(tab: TabSessionSummary): TabSessionSummary {
+  const { lastLine: _lastLine, ...rest } = tab
+  return rest
+}
+
 export const tabList: CliCommand = {
   args: [],
-  flags: SHARED_FLAGS,
+  flags: [
+    ...SHARED_FLAGS,
+    {
+      description: "include each tab's last non-blank rendered line",
+      kind: 'boolean',
+      name: 'verbose',
+    },
+  ],
   group: 'tab',
   run: async (ctx) => {
     const workspace = ctx.getWorkspace()
     const daemon = await ctx.getDaemon()
+    const verbose = ctx.args.flags.verbose === true
+
+    if (verbose && !daemon.hasCapability(IPC_CAPABILITY_LIST_TABS_LAST_LINE)) {
+      throw new Error(
+        'daemon predates tab list --verbose (listTabsLastLine) — restart aimux to pick up the new daemon'
+      )
+    }
 
     if (daemon.hasCapability(IPC_CAPABILITY_LIST_TABS)) {
       const result = await daemon.listTabs(workspace.id)
-      writeJson({ activeTabId: result.activeTabId, tabs: result.tabs })
+      const tabs = verbose ? result.tabs : result.tabs.map(stripLastLine)
+      writeJson({ activeTabId: result.activeTabId, tabs })
       return EXIT_OK
     }
 

package/src/cli/commands/tab/prompt-io.ts

@@ -0,0 +1,83 @@
+/**
+ * Shared prompt-write plumbing for `tab send` and `tab run`. Both need to lower
+ * a chord/paste buffer into the protocol's string form and submit it with the
+ * bracketed-paste `\r` deferral, so the logic lives here once.
+ */
+import type { DaemonClient } from '../../client/daemon-client'
+
+import { bracketedPaste, notationToBytes } from '../../chord'
+
+/**
+ * Gap between the bracketed-paste write and the trailing carriage return when
+ * submitting a pasted block. Claude Code (and other paste-aware TUIs) buffer
+ * every byte between the paste-start/paste-end markers; a `\r` that arrives in
+ * the same burst as the paste-end marker is folded into the paste buffer as
+ * literal content instead of being read as a submit keystroke. A short settle
+ * lets the receiver exit paste mode before the Enter lands.
+ */
+export const PASTE_SUBMIT_SETTLE_MS = 50
+
+/**
+ * Lower a chord/paste buffer of bytes into the string the protocol expects.
+ * Every byte we emit is < 0x80 (control chars or printable ASCII), so a
+ * Latin-1 decode is faithful — the receiving PTY's UTF-8 path treats each
+ * single byte as itself.
+ */
+function bytesToString(bytes: Buffer): string {
+  let out = ''
+  for (const byte of bytes) {
+    out += String.fromCharCode(byte)
+  }
+  return out
+}
+
+export interface PromptPayload {
+  /** The protocol-ready string to write. */
+  data: string
+  /**
+   * Whether `data` is a bracketed-paste block. A trailing `\r` must be sent as
+   * a separate, settled write for these — see PASTE_SUBMIT_SETTLE_MS.
+   */
+  bracketed: boolean
+}
+
+/**
+ * Build the payload for a prompt. `asKeys` interprets the text as a vim-style
+ * chord (e.g. `<C-c>`); otherwise it's wrapped as a bracketed paste when
+ * multi-line.
+ */
+export function buildPromptPayload(text: string, asKeys: boolean): PromptPayload {
+  if (asKeys) {
+    return { bracketed: false, data: bytesToString(notationToBytes(text)) }
+  }
+  const data = bracketedPaste(text)
+  return { bracketed: data !== text, data }
+}
+
+/**
+ * Write a prompt payload to a tab, optionally appending a submit `\r`. The
+ * payload write and the Enter are always separate `write` requests; for a
+ * bracketed paste the Enter is deferred by PASTE_SUBMIT_SETTLE_MS so it isn't
+ * swallowed by the paste buffer. Returns the number of bytes written.
+ */
+export async function writePromptPayload(
+  daemon: DaemonClient,
+  tabId: string,
+  payload: PromptPayload,
+  appendEnter: boolean
+): Promise<number> {
+  await daemon.expectOk('write', { data: payload.data, tabId })
+  let bytesWritten = Buffer.byteLength(payload.data, 'utf8')
+  if (appendEnter) {
+    // A bracketed paste swallows a same-burst `\r`, so settle first, then
+    // submit as an independent write. Plain text / key chords carry no paste
+    // markers, so the Enter can follow immediately — but still as its own
+    // write so the two paths stay uniform.
+    if (payload.bracketed) {
+      await Bun.sleep(PASTE_SUBMIT_SETTLE_MS)
+    }
+    await daemon.expectOk('write', { data: '\r', tabId })
+    bytesWritten += 1
+  }
+  return bytesWritten
+}

package/src/cli/commands/tab/run.ts

@@ -0,0 +1,222 @@
+/**
+ * `aimux tab run <tabId>` — the one authoritative verb an orchestrator needs to
+ * drive a worker turn. It collapses the spawn→send→uptake→await→snapshot chain
+ * into a single event-driven call: stage the prompt, submit it, then block on
+ * the daemon's v13 turn-lifecycle events (`tabTurnComplete` / `tabQuestion`)
+ * until the turn ends, the worker asks something, the tab dies, or the overall
+ * timeout trips. Exactly one JSON object is emitted and the exit code encodes
+ * the outcome, so a driver can branch without re-snapshotting the screen.
+ */
+import type { QuestionKind } from '../../../state/types'
+import type { CliCommand } from '../../registry'
+
+import {
+  IPC_CAPABILITY_QUESTION_EVENTS,
+  IPC_CAPABILITY_THIN_ATTACH,
+  IPC_CAPABILITY_TURN_LIFECYCLE,
+} from '../../../ipc/protocol'
+import { SHARED_FLAGS } from '../../flags'
+import { EXIT_OK, EXIT_QUESTION, EXIT_RUNTIME, EXIT_TIMEOUT, writeJson } from '../../output'
+import { buildPromptPayload, writePromptPayload } from './prompt-io'
+
+/** Overall cap on a single turn — 15 min, long enough for a heavy build task. */
+const DEFAULT_TIMEOUT_MS = 900_000
+
+/**
+ * The four terminal shapes of a `tab run`. Modelled as a discriminated union so
+ * the JSON we emit and the exit code we return are derived from one value, and
+ * so the outcome→exit mapping can be unit-tested without a live daemon.
+ * `durationMs` is measured from prompt submit, not attach, so it reflects the
+ * worker's think time rather than our connection overhead.
+ */
+export type RunOutcome =
+  | { durationMs: number; outcome: 'completed' }
+  | { durationMs: number; error: string; outcome: 'error' }
+  | {
+      durationMs: number
+      kind: QuestionKind
+      options?: string[]
+      outcome: 'question'
+      question: string
+    }
+  | { durationMs: number; outcome: 'timeout' }
+
+/**
+ * Map an outcome to its process exit code. Pure and total over the union so a
+ * driver's `case $?` stays exhaustive: 0 completed, 10 question/permission
+ * (worker is blocked and wants input), 3 the tab errored/exited, 124 we hit the
+ * overall cap.
+ */
+export function outcomeExitCode(outcome: RunOutcome): number {
+  switch (outcome.outcome) {
+    case 'completed':
+      return EXIT_OK
+    case 'question':
+      return EXIT_QUESTION
+    case 'error':
+      return EXIT_RUNTIME
+    case 'timeout':
+      return EXIT_TIMEOUT
+  }
+}
+
+/**
+ * Resolve the prompt text from exactly one source. We require exactly one of
+ * `--prompt-file`, `--stdin`, or the positional `[text]` so an orchestrator
+ * never silently sends the wrong buffer when two sources are set (e.g. a stale
+ * positional plus a fresh `--prompt-file`).
+ */
+async function resolvePromptText(
+  promptFile: string | undefined,
+  fromStdin: boolean,
+  positionalText: string | undefined
+): Promise<string> {
+  const sources = [promptFile !== undefined, fromStdin, positionalText !== undefined].filter(
+    (present) => present
+  ).length
+  if (sources !== 1) {
+    throw new Error(
+      'provide exactly one prompt source: --prompt-file <f>, --stdin, or a [text] positional'
+    )
+  }
+  if (promptFile !== undefined) return Bun.file(promptFile).text()
+  if (fromStdin) return Bun.stdin.text()
+  return positionalText ?? ''
+}
+
+export const tabRun: CliCommand = {
+  args: [{ name: 'tabId', required: true }, { name: 'text' }],
+  flags: [
+    ...SHARED_FLAGS,
+    { description: 'read the prompt from this file', kind: 'string', name: 'prompt-file' },
+    { description: 'read the prompt from stdin', kind: 'boolean', name: 'stdin' },
+    {
+      description: 'overall turn cap in milliseconds (default 900000 = 15 min)',
+      kind: 'number',
+      name: 'timeout',
+    },
+    {
+      description: 'stage the prompt without submitting (still waits)',
+      kind: 'boolean',
+      name: 'no-enter',
+    },
+  ],
+  group: 'tab',
+  run: async (ctx) => {
+    const tabId = ctx.args.positionals[0]
+    if (typeof tabId !== 'string' || tabId.length === 0) {
+      throw new Error('tabId is required')
+    }
+
+    const promptFile =
+      typeof ctx.args.flags['prompt-file'] === 'string' ? ctx.args.flags['prompt-file'] : undefined
+    const fromStdin = ctx.args.flags.stdin === true
+    const text = await resolvePromptText(promptFile, fromStdin, ctx.args.positionals[1])
+
+    const timeoutMs =
+      typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS
+    const appendEnter = ctx.args.flags['no-enter'] !== true
+
+    const workspace = ctx.getWorkspace()
+    const daemon = await ctx.getDaemon()
+    if (
+      !daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH) ||
+      !daemon.hasCapability(IPC_CAPABILITY_TURN_LIFECYCLE) ||
+      !daemon.hasCapability(IPC_CAPABILITY_QUESTION_EVENTS)
+    ) {
+      throw new Error(
+        'daemon predates tab run (turnLifecycle/questionEvents) — restart aimux to pick up the new daemon'
+      )
+    }
+
+    const attach = await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
+    if (!attach.tabs.some((t) => t.id === tabId)) {
+      throw new Error(`tab not found: ${tabId}`)
+    }
+
+    const payload = buildPromptPayload(text, false)
+
+    return new Promise<number>((resolve) => {
+      // Subscribe BEFORE writing: these events fire only on transitions, so a
+      // late subscription would race the worker starting its turn.
+      let start = Date.now()
+      // Uptake guard. The tab may sit `idle` from a prior turn; a stale
+      // `tabTurnComplete` (or the settle window closing on that old idle) must
+      // not read as "this turn completed". Only honour completion once we've
+      // seen the tab go `working` after our submit.
+      let sawWorking = false
+
+      const settle = (outcome: RunOutcome): void => {
+        cleanup()
+        writeJson(outcome)
+        resolve(outcomeExitCode(outcome))
+      }
+      const durationMs = (): number => Date.now() - start
+
+      const offStatus = daemon.on('tabStatus', (p) => {
+        if (p.tabId !== tabId) return
+        if (p.status === 'working') sawWorking = true
+      })
+      const offTurn = daemon.on('tabTurnComplete', (p) => {
+        if (p.tabId !== tabId) return
+        // Ignore end-of-turn until the worker actually started working, so a
+        // lingering pre-submit idle can't be mis-read as completion.
+        if (!sawWorking) return
+        settle({ durationMs: durationMs(), outcome: 'completed' })
+      })
+      const offQuestion = daemon.on('tabQuestion', (p) => {
+        if (p.tabId !== tabId) return
+        // A question is honoured immediately — it can legitimately arrive
+        // before `working` (the worker asks before doing anything).
+        settle({
+          durationMs: durationMs(),
+          kind: p.kind,
+          options: p.options,
+          outcome: 'question',
+          question: p.prompt,
+        })
+      })
+      const offExit = daemon.on('tabExit', (p) => {
+        if (p.tabId !== tabId) return
+        settle({ durationMs: durationMs(), error: `exit ${p.exitCode}`, outcome: 'error' })
+      })
+      const offError = daemon.on('tabError', (p) => {
+        if (p.tabId !== tabId) return
+        settle({ durationMs: durationMs(), error: p.message, outcome: 'error' })
+      })
+
+      const timer = setTimeout(() => {
+        settle({ durationMs: durationMs(), outcome: 'timeout' })
+      }, timeoutMs)
+
+      const cleanup = (): void => {
+        offStatus()
+        offTurn()
+        offQuestion()
+        offExit()
+        offError()
+        clearTimeout(timer)
+      }
+
+      // Submit after subscribing, then reset the clock so `durationMs` measures
+      // the worker's turn rather than our attach/write overhead. On a write
+      // failure the tab likely died — surface it as an error outcome rather
+      // than sitting idle until the timeout.
+      const submit = async (): Promise<void> => {
+        try {
+          await writePromptPayload(daemon, tabId, payload, appendEnter)
+          start = Date.now()
+        } catch (error) {
+          settle({
+            durationMs: durationMs(),
+            error: error instanceof Error ? error.message : String(error),
+            outcome: 'error',
+          })
+        }
+      }
+      void submit()
+    })
+  },
+  summary: 'Submit a prompt and block until the turn completes or the worker asks',
+  verb: 'run',
+}

package/src/cli/commands/tab/send.ts

@@ -1,33 +1,12 @@
 import type { CliCommand } from '../../registry'
 
 import { IPC_CAPABILITY_THIN_ATTACH } from '../../../ipc/protocol'
-import { bracketedPaste, notationToBytes } from '../../chord'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
+import { buildPromptPayload, writePromptPayload } from './prompt-io'
 
-/**
- * Gap between the bracketed-paste write and the trailing carriage return when
- * `--enter` submits a pasted block. Claude Code (and other paste-aware TUIs)
- * buffer every byte between the paste-start/paste-end markers; a `\r` that
- * arrives in the same burst as the paste-end marker is folded into the paste
- * buffer as literal content instead of being read as a submit keystroke. A
- * short settle lets the receiver exit paste mode before the Enter lands.
- */
-const PASTE_SUBMIT_SETTLE_MS = 50
-
-/**
- * Lower a chord/paste buffer of bytes into the string the protocol expects.
- * Every byte we emit is < 0x80 (control chars or printable ASCII), so a
- * Latin-1 decode is faithful — the receiving PTY's UTF-8 path treats each
- * single byte as itself.
- */
-function bytesToString(bytes: Buffer): string {
-  let out = ''
-  for (const byte of bytes) {
-    out += String.fromCharCode(byte)
-  }
-  return out
-}
+/** Default ceiling for the submit→working transition under --await-submit. */
+const DEFAULT_AWAIT_TIMEOUT_MS = 15_000
 
 export const tabSend: CliCommand = {
   args: [{ name: 'tabId', required: true }, { name: 'text' }],
@@ -44,6 +23,18 @@ export const tabSend: CliCommand = {
       kind: 'boolean',
       name: 'stdin',
     },
+    {
+      description:
+        'after submitting, block until the tab transitions to working (uptake confirmed)',
+      kind: 'boolean',
+      name: 'await-submit',
+    },
+    {
+      description:
+        'milliseconds to wait for the working transition with --await-submit (default 15000)',
+      kind: 'number',
+      name: 'await-timeout',
+    },
   ],
   group: 'tab',
   run: async (ctx) => {
@@ -55,30 +46,25 @@ export const tabSend: CliCommand = {
     const fromStdin = ctx.args.flags.stdin === true
     const asKeys = ctx.args.flags.keys === true
     const appendEnter = ctx.args.flags.enter === true
+    const awaitSubmit = ctx.args.flags['await-submit'] === true
+    const awaitTimeoutMs =
+      typeof ctx.args.flags['await-timeout'] === 'number'
+        ? ctx.args.flags['await-timeout']
+        : DEFAULT_AWAIT_TIMEOUT_MS
 
-    let data: string
-    // Whether `data` is a bracketed-paste block (multi-line text that
-    // `bracketedPaste` wrapped in start/end markers). A trailing `\r` must be
-    // sent as a *separate*, settled write for these — see PASTE_SUBMIT_SETTLE_MS.
-    let bracketed = false
-    if (fromStdin) {
-      const stdinText = await Bun.stdin.text()
-      if (asKeys) {
-        data = bytesToString(notationToBytes(stdinText))
-      } else {
-        data = bracketedPaste(stdinText)
-        bracketed = data !== stdinText
-      }
-    } else {
-      const text = ctx.args.positionals[1] ?? ''
-      if (asKeys) {
-        if (text === '') throw new Error('--keys requires the chord notation as <text>')
-        data = bytesToString(notationToBytes(text))
-      } else {
-        data = bracketedPaste(text)
-        bracketed = data !== text
-      }
+    // Uptake only means something once we actually submit the prompt: the
+    // working transition is the receiving CLI accepting the Enter. Without
+    // --enter there is nothing to confirm, so fail loudly rather than block
+    // forever on a transition that can't come.
+    if (awaitSubmit && !appendEnter) {
+      throw new Error('--await-submit requires --enter')
+    }
+
+    const text = fromStdin ? await Bun.stdin.text() : (ctx.args.positionals[1] ?? '')
+    if (asKeys && text === '') {
+      throw new Error('--keys requires the chord notation as <text>')
     }
+    const payload = buildPromptPayload(text, asKeys)
 
     const workspace = ctx.getWorkspace()
     const daemon = await ctx.getDaemon()
@@ -89,22 +75,40 @@ export const tabSend: CliCommand = {
     }
 
     await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
-    await daemon.expectOk('write', { data, tabId })
 
-    let bytesWritten = Buffer.byteLength(data, 'utf8')
-    if (appendEnter) {
-      // A bracketed paste swallows a same-burst `\r`, so settle first, then
-      // submit as an independent write. Plain text / key chords carry no paste
-      // markers, so the Enter can follow immediately — but still as its own
-      // write so the two paths stay uniform.
-      if (bracketed) {
-        await Bun.sleep(PASTE_SUBMIT_SETTLE_MS)
-      }
-      await daemon.expectOk('write', { data: '\r', tabId })
-      bytesWritten += 1
+    if (!awaitSubmit) {
+      const bytesWritten = await writePromptPayload(daemon, tabId, payload, appendEnter)
+      writeJson({ bytesWritten, ok: true })
+      return EXIT_OK
     }
 
-    writeJson({ bytesWritten, ok: true })
+    // The daemon only emits tabStatus on TRANSITIONS, so we must be subscribed
+    // before the submit write lands — otherwise the working transition can fire
+    // between the write and our subscription and be lost forever. Arm the
+    // listener + a one-shot promise here, then start the clock right before the
+    // Enter so `ms` reflects submit→uptake latency, not setup overhead.
+    const uptake = new Promise<{ confirmed: true; ms: number } | { confirmed: false }>(
+      (resolve) => {
+        const off = daemon.on('tabStatus', (event) => {
+          if (event.tabId !== tabId || event.status !== 'working') return
+          off()
+          clearTimeout(timer)
+          resolve({ confirmed: true, ms: Date.now() - start })
+        })
+        const timer = setTimeout(() => {
+          off()
+          resolve({ confirmed: false })
+        }, awaitTimeoutMs)
+      }
+    )
+
+    const start = Date.now()
+    const bytesWritten = await writePromptPayload(daemon, tabId, payload, appendEnter)
+    const result = await uptake
+
+    // The bytes WERE written regardless of uptake — the working transition is
+    // advisory, so a missed transition is still EXIT_OK.
+    writeJson({ bytesWritten, ok: true, submitted: true, uptake: result })
     return EXIT_OK
   },
   summary: 'Write text or a key chord to a tab',

package/src/cli/index.ts

@@ -20,6 +20,7 @@ const EXIT_CODES_BLOCK = [
   '  2    usage error (bad flags, unknown command, missing argument)',
   '  3    runtime error (server replied with error, command failed)',
   '  4    daemon unreachable (socket missing and autostart failed)',
+  '  10   question (tab run: worker is blocked on a question/permission)',
   '  124  timeout (tab wait, tab tail --timeout, workspace switch --wait)',
 ].join('\n')
 

package/src/cli/output.ts

@@ -22,9 +22,11 @@ export function writeError(message: string): void {
 //   2   usage error (bad flags, unknown command, missing argument)
 //   3   runtime error (server replied with `error`, command failed)
 //   4   daemon unreachable (socket missing and autostart failed)
+//   10  question (`tab run`: worker is blocked on a question/permission)
 //   124 timeout (`tab wait`, `tab tail --timeout`, `workspace switch --wait`)
 export const EXIT_OK = 0
 export const EXIT_USAGE = 2
 export const EXIT_RUNTIME = 3
 export const EXIT_DAEMON_UNREACHABLE = 4
+export const EXIT_QUESTION = 10
 export const EXIT_TIMEOUT = 124

package/src/cli/registry.ts

@@ -5,6 +5,7 @@ import { tabClose } from './commands/tab/close'
 import { tabCreate } from './commands/tab/create'
 import { tabFocus } from './commands/tab/focus'
 import { tabList } from './commands/tab/list'
+import { tabRun } from './commands/tab/run'
 import { tabSend } from './commands/tab/send'
 import { tabSnapshot } from './commands/tab/snapshot'
 import { tabTail } from './commands/tab/tail'
@@ -31,6 +32,7 @@ export const COMMANDS: readonly CliCommand[] = [
   tabList,
   tabCreate,
   tabSend,
+  tabRun,
   tabFocus,
   tabClose,
   tabSnapshot,

package/src/daemon/daemon.ts

@@ -21,6 +21,7 @@ import {
 } from '../ipc/protocol'
 import { findSocketProcessPid, spawnDetachedTerminalManager } from '../platform/daemon-control'
 import { type LoopTabView, runStatusDetectionLoop } from '../pty/assistant-status-detection-loop'
+import { lastNonBlankLine } from '../pty/last-line'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
 import { TerminalManagerClient } from '../terminal-manager/manager-client'
 import {
@@ -108,6 +109,18 @@ export function mergeTabRegistryEntry(
   return entry
 }
 
+/**
+ * Turn-complete settle window for the status loop, overridable via
+ * `AIMUX_TURN_SETTLE_MS` for slow/loaded machines. Falls back to the loop's
+ * own default when unset or non-numeric.
+ */
+function turnCompleteSettleMs(): number | undefined {
+  const raw = process.env.AIMUX_TURN_SETTLE_MS
+  if (raw == null || raw === '') return undefined
+  const parsed = Number(raw)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined
+}
+
 function send(socket: Socket, message: ServerResponse | ServerEvent): void {
   socket.write(encodeMessage(message))
 }
@@ -376,6 +389,20 @@ export async function runDaemon(): Promise<void> {
       logDebug('daemon.status.session', { sessionId, status })
       broadcastAll({ payload: { sessionId, status }, type: 'sessionStatus' })
     },
+    onTabQuestion: (tabId, sessionId, detail) => {
+      logDebug('daemon.status.question', { kind: detail.kind, sessionId, tabId })
+      // v13 / capability `questionEvents`. Same v13 send-time gate as below.
+      broadcastAllVersioned(13, {
+        payload: {
+          kind: detail.kind,
+          options: detail.options,
+          prompt: detail.prompt,
+          sessionId,
+          tabId,
+        },
+        type: 'tabQuestion',
+      })
+    },
     onTabStatus: (tabId, status, sessionId) => {
       logDebug('daemon.status.tab', { sessionId, status, tabId })
       // Broadcast to every client. Clients silently ignore events for tabIds
@@ -385,6 +412,14 @@ export async function runDaemon(): Promise<void> {
       // client tears down its socket to switch sessions.
       broadcastAll({ payload: { sessionId, status, tabId }, type: 'tabStatus' })
     },
+    onTurnComplete: (tabId, sessionId, idleMs) => {
+      logDebug('daemon.status.turnComplete', { idleMs, sessionId, tabId })
+      // v13 / capability `turnLifecycle`. Gate at send time — pre-v13 parsers
+      // throw on unknown event types and would drop the connection. MIN stays
+      // at 10, so we fan this only to peers that negotiated at least v13.
+      broadcastAllVersioned(13, { payload: { idleMs, sessionId, tabId }, type: 'tabTurnComplete' })
+    },
+    turnSettleMs: turnCompleteSettleMs(),
   })
 
   // Local HTTP server that receives Claude Code hook callbacks for every PTY
@@ -789,6 +824,12 @@ export async function runDaemon(): Promise<void> {
                       assistant: entry.assistant,
                       command: entry.command,
                       id: tabId,
+                      // Additive v13 field (capability `listTabsLastLine`): the
+                      // tab's last non-blank rendered line, so a fleet poll can
+                      // read "what each worker is doing" without a per-tab
+                      // snapshot. Undefined when the tab has no viewport yet, in
+                      // which case the field is omitted from the JSON wire.
+                      lastLine: lastNonBlankLine(entry.viewport),
                       status: entry.status ?? 'running',
                       title: entry.title ?? '',
                       worktreeId: entry.worktreeId,