dsh-code 1.0.6 → 1.0.7

package/src/index.ts

@@ -76,13 +76,13 @@ import { SessionSwitchQueue } from './session-switch.ts'
 import { agentPresetsFrom, normalizePresetId, resolvePreset, selectPreset } from './presets.ts'
 import {
   applyPendingPermission,
-  cyclePermission as cyclePermissionPreset,
   effectivePermission,
   listPermissionRows,
   permissionPresetsFrom,
   selectPermission,
 } from './permissions.ts'
 import { listPluginRows } from './plugin-inventory.ts'
+import { applyLauncherUpdate, probeLauncherUpdate } from './update.ts'
 import { parseAnimationsPref } from './render/animations.ts'
 import { parseThemeName, setTheme, type ThemeName } from './theme.ts'
 import {
@@ -269,6 +269,38 @@ export function submissionBelongsToSession(origin: string | undefined, activeSes
   return origin === undefined || origin === '' || origin === activeSessionId
 }
 
+/** One Shift+Tab station decision for the mode cycle. */
+export type ModeCycleDecision =
+  | { readonly kind: 'permission'; readonly preset: string }
+  | { readonly kind: 'plan-on' }
+  | { readonly kind: 'plan-off'; readonly preset: string }
+
+/**
+ * Decide the next Shift+Tab station. The cycle keeps the preset table's
+ * own order (most restrictive first) and inserts ONE plan station between
+ * the most restrictive preset and the wrap target: with the shipped three
+ * presets the user sees workspace-write → danger-full-access → read-only
+ * → plan → workspace-write. Plan IS the most restrictive preset plus the
+ * plan prompt layer — entering it switches nothing (the cycle is already
+ * parked on read-only), and leaving it lands on the next preset after the
+ * most restrictive one. Without the /plan command the cycle is exactly the
+ * preset table.
+ */
+export function planCycleDecision(input: {
+  readonly names: readonly string[]
+  readonly current: string
+  readonly inPlan: boolean
+  readonly planAvailable: boolean
+}): ModeCycleDecision | undefined {
+  const names = input.names
+  if (names.length === 0) return undefined
+  const first = names[0]!
+  if (input.inPlan) return { kind: 'plan-off', preset: names[1] ?? first }
+  const at = names.indexOf(input.current)
+  if (at === 0 && input.planAvailable) return { kind: 'plan-on' }
+  return { kind: 'permission', preset: names[(at + 1) % names.length] ?? first }
+}
+
 /**
  * Order-preserving gate for composer input while the startup prompt/images
  * are still preparing. Anything submitted before the startup delivery settles
@@ -511,6 +543,38 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   let pendingModeWork: Promise<void> = Promise.resolve()
   /** Permission preset selected before the first session exists. */
   let pendingPermission: string | undefined
+  /**
+   * Plan-mode choice made before the first session exists: materialized as a
+   * /plan registry command delivered ahead of the first queued input when the
+   * session composes, so the first assembled step already plans.
+   */
+  let pendingPlan = false
+  /**
+   * Whether the pre-session effective preset composes plan mode, answered by
+   * the presets service composition inventory (minimal does not). Cached and
+   * refreshed whenever the pending mode moves; unknown reads as unavailable
+   * so one keypress at most lands before the answer arrives.
+   */
+  let preSessionPlanAvailable = false
+  let preSessionPlanKnown = false
+  const refreshPreSessionPlan = (): void => {
+    if (presets === undefined) {
+      preSessionPlanAvailable = false
+      preSessionPlanKnown = true
+      return
+    }
+    preSessionPlanKnown = false
+    void presets.compositionInventory().then(inventory => {
+      const id = pendingMode ?? normalizePresetId(presets.defaultId)
+      preSessionPlanAvailable = inventory.some(composition => composition.id === id
+        && composition.rows.some(row => row.moduleName === '@deepseek-ai/dsh-plan-mode' && row.enabled !== false))
+      preSessionPlanKnown = true
+    }, () => {
+      preSessionPlanAvailable = false
+      preSessionPlanKnown = true
+    })
+  }
+  refreshPreSessionPlan()
   /**
    * Monotonic session epoch: bumped on every successful activation, on every
    * first-session creation, and on quit. Async callbacks (mention prepares,
@@ -1063,6 +1127,13 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         abortPendingControllers()
         epoch += 1
         const queued = pendingInputs.splice(0)
+        if (pendingPlan) {
+          pendingPlan = false
+          // A pre-session plan choice materializes as the registry command
+          // delivered AHEAD of the queued lines, so the first assembled step
+          // of the user's opening message already runs in plan mode.
+          deliverLine('/plan', 'followup')
+        }
         for (const item of queued) deliverLine(item.text, item.mode, item.images)
       } finally {
         creating = false
@@ -1157,24 +1228,64 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   }
 
   /**
-   * Cycle to the next permission preset (Shift+Tab). Before the first session,
-   * the choice remains process-local and is materialized when Harness creates
-   * that session; afterwards the canonical service writes durable events.
+   * Shift+Tab mode cycle: permission presets in table order, then the plan
+   * station when the composition offers the /plan command (preset-mounted,
+   * so minimal sessions and the pre-session state cycle permissions only).
+   * Plan transitions submit the upstream registry command — it stays the
+   * single owner of plan state; the TUI renders the durable plan/mode event
+   * it appends. Returns the notice label, or '' when nothing changed.
    */
-  const cyclePermission = (): string => {
+  const cycleMode = (): string => {
     if (permissionPresets === undefined || permissionPresets.names.length === 0) {
       bridge.notify('permission presets are not mounted in this composition', 'warning')
       return ''
     }
     try {
-      const next = cyclePermissionPreset(permissionPresets, session, pendingPermission)
-      if (session === undefined && next !== '') {
-        pendingPermission = next
+      // Pre-session the plan station rides the pending choice; once a
+      // session exists the scoped /plan command descriptor decides, and the
+      // durable plan/mode event is the live truth.
+      const preSession = session === undefined
+      if (preSession && !preSessionPlanKnown) refreshPreSessionPlan()
+      const decision = planCycleDecision({
+        names: permissionPresets.names,
+        current: effectivePermission(permissionPresets, session, pendingPermission),
+        inPlan: preSession ? pendingPlan : store.getView().plan === true,
+        planAvailable: preSession ? preSessionPlanAvailable : commands.descriptors.some(descriptor => descriptor.name === 'plan'),
+      })
+      if (decision === undefined) return ''
+      if (decision.kind === 'permission') {
+        const next = selectPermission(permissionPresets, session, decision.preset)
+        if (preSession) {
+          pendingPermission = next
+          renderCurrent()
+        }
+        return `permission → ${next}`
+      }
+      if (decision.kind === 'plan-on') {
+        // Plan IS the most restrictive preset plus the plan prompt layer:
+        // the cycle arrives here from that preset, so permission needs no
+        // switch — only the plan mode itself toggles.
+        if (preSession) {
+          pendingPlan = true
+          renderCurrent()
+          return 'plan → on (applies to the first session)'
+        }
+        send('/plan', 'followup')
+        return 'plan → on'
+      }
+      // Leaving plan lands on the station after the most restrictive
+      // preset (workspace-write with the shipped table).
+      if (preSession) {
+        pendingPlan = false
+        pendingPermission = decision.preset
         renderCurrent()
+        return `plan → off · permission → ${decision.preset}`
       }
-      return next
+      send('/plan off', 'followup')
+      selectPermission(permissionPresets, session, decision.preset)
+      return `plan → off · permission → ${decision.preset}`
     } catch (error: unknown) {
-      bridge.notify(`permission change failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      bridge.notify(`mode change failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
       return ''
     }
   }
@@ -1478,6 +1589,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         subagents.reset()
         pendingMode = undefined
         pendingPermission = undefined
+        pendingPlan = false
       } catch (error: unknown) {
         active = previous
         agent = previous?.agent
@@ -1703,6 +1815,8 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       resumed: active?.resumed ?? false,
       mode: active?.mode ?? pendingMode ?? normalizePresetId(presets.defaultId),
       permission,
+      /** Pre-session plan choice for the status badge until a session composes. */
+      pendingPlan: session === undefined && pendingPlan,
       dispatch,
       steer,
       interrupt,
@@ -1729,7 +1843,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       prepareImages: (paths, signal) => saveImagePaths(paths, ctx.get('attachments'), signal),
       inspectFiles: paths => inspectFilePaths(paths, ctx.get('attachments'), session?.header.cwd ?? cwd),
       prepareFiles: (paths, signal) => saveFilePaths(paths, ctx.get('attachments'), signal),
-      cyclePermission,
+      cycleMode,
       setPermission: setPermissionAction,
       selectModel,
       subagentModel: subagentModelLabel(),
@@ -1759,6 +1873,10 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       switchSession,
       cancelSessionSwitch,
       loadPlugins: () => listPluginRows(ctx),
+      // The launcher owns every update decision; the TUI only drives its
+      // read-only probe and streamed apply as child processes.
+      probeUpdate: () => probeLauncherUpdate(),
+      applyUpdate: onLine => applyLauncherUpdate(onLine),
       loadJobs: () => listJobs(ctx, active?.agent),
       statusline: statuslineItems,
       saveStatusline,

package/src/internals.ts

@@ -19,6 +19,7 @@ import {
   shouldEnableKeyboardEnhancement,
 } from './keyboard.ts'
 import { createSplitStdin } from './input-split.ts'
+import { ensureVsCodeTabTitleSetting } from './terminal-title.ts'
 
 /** A mounted terminal app instance; the runner owns unmount ordering. */
 export interface TuiMount {
@@ -56,6 +57,10 @@ export const internals: {
         + BRACKETED_PASTE_ENABLE
         + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ''),
       )
+      // Cosmetic best effort: inside a VS Code integrated terminal the tab
+      // shows the process name ("node") unless the user settings map it to
+      // the sequence title; align them once. Total function, never throws.
+      ensureVsCodeTabTitleSetting()
       // App owns Ctrl+C's deliberate three-state contract (interrupt, clear
       // draft, quit). Ink's default `exitOnCtrlC: true` would intercept the
       // normalized control byte first, unmount only its renderer, and leave the

package/src/kernel-panels.ts

@@ -4,6 +4,7 @@ import { createElement, useEffect, useMemo, useRef, useState, type ReactElement
 import { Box, Text, useInput, useStdout } from 'ink'
 import type { ModelDirectory, ModelRow } from './models.ts'
 import type { SubagentRow } from './subagents.ts'
+import type { ScheduleRow } from './render/projection.ts'
 import type { PermissionRow } from './permissions.ts'
 import type { PresetRow } from './presets.ts'
 import type { PluginRow } from './plugin-inventory.ts'
@@ -123,7 +124,9 @@ export function ModePanel({ current, load, select, close }: {
   const visible = useMemo(() => rows.filter(row => `${row.id} ${row.name ?? ''} ${row.description ?? ''}`.toLowerCase().includes(query.toLowerCase())), [rows, query])
   useEffect(() => setCursor(value => Math.min(value, Math.max(0, visible.length - 1))), [visible.length])
   useInput((input, key) => {
-    if (key.escape || input === 'q') return close()
+    if (key.escape) return close()
+    // q closes only while the query is empty; mid-filter it is query text.
+    if (input === 'q' && query === '') return close()
     if (input === 'r' && query === '') return refresh()
     if (key.upArrow) return setCursor(value => visible.length === 0 ? 0 : (value + visible.length - 1) % visible.length)
     if (key.downArrow) return setCursor(value => visible.length === 0 ? 0 : (value + 1) % visible.length)
@@ -162,7 +165,9 @@ export function PermissionPanel({ current, load, select, close }: {
   const visible = useMemo(() => rows.filter(row => `${row.id} ${row.description ?? ''}`.toLowerCase().includes(query.toLowerCase())), [rows, query])
   useEffect(() => setCursor(value => Math.min(value, Math.max(0, visible.length - 1))), [visible.length])
   useInput((input, key) => {
-    if (key.escape || input === 'q') return close()
+    if (key.escape) return close()
+    // q closes only while the query is empty; mid-filter it is query text.
+    if (input === 'q' && query === '') return close()
     if (input === 'r' && query === '') return refresh()
     if (key.upArrow) return setCursor(value => visible.length === 0 ? 0 : (value + visible.length - 1) % visible.length)
     if (key.downArrow) return setCursor(value => visible.length === 0 ? 0 : (value + 1) % visible.length)
@@ -185,7 +190,9 @@ export function PluginPanel({ load, close, initialQuery = '' }: { load(): readon
   const rows = useMemo(() => load().filter(row => `${row.entryId} ${row.moduleName} ${row.phase ?? ''}`.toLowerCase().includes(query.toLowerCase())), [epoch, query])
   useEffect(() => setCursor(value => Math.min(value, Math.max(0, rows.length - 1))), [rows.length])
   useInput((input, key) => {
-    if (key.escape || input === 'q') return close()
+    if (key.escape) return close()
+    // q closes only while the query is empty; mid-filter it is query text.
+    if (input === 'q' && query === '') return close()
     if (input === 'r' && query === '') return setEpoch(value => value + 1)
     if (key.upArrow) return setCursor(value => rows.length === 0 ? 0 : (value + rows.length - 1) % rows.length)
     if (key.downArrow) return setCursor(value => rows.length === 0 ? 0 : (value + 1) % rows.length)
@@ -928,3 +935,82 @@ export function SubagentPanel({ current, load, pick, inherit, close }: {
     footer: '↑↓ choose · enter apply · r refresh · esc close',
   })
 }
+
+/**
+ * The /schedule panel: the read-only catalog of active reminders folded from
+ * durable schedule/change events (the web ui-schedule contract: overdue
+ * first, then ascending target; the model creates and cancels through its
+ * schedule_* tools, the panel only shows state). A local second-hand keeps
+ * the relative labels live while the panel is open.
+ */
+export interface ScheduleDisplayRow {
+  readonly key: string
+  readonly text: string
+  readonly tone?: 'error'
+}
+
+/** Human frequency label: one-shot kinds read as Once, every rows carry the interval. */
+export function scheduleFrequency(row: ScheduleRow): string {
+  if (row.kind !== 'every') return 'Once'
+  const seconds = row.everySeconds ?? 0
+  if (seconds >= 3600 && seconds % 3600 === 0) return `Every ${seconds / 3600}h`
+  if (seconds >= 60 && seconds % 60 === 0) return `Every ${seconds / 60}m`
+  return `Every ${seconds}s`
+}
+
+/** Relative label for the next target: in N unit, or N unit overdue. */
+export function scheduleRelative(targetAt: number, now: number): string {
+  const delta = Math.max(0, Math.abs(targetAt - now))
+  const minutes = Math.floor(delta / 60_000)
+  const unit = minutes === 0
+    ? '<1m'
+    : minutes >= 60
+      ? `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, '0')}`
+      : `${minutes}m`
+  return targetAt <= now ? `${unit} overdue` : `in ${unit}`
+}
+
+/** Ordered display rows: overdue first (error tone), then ascending target. */
+export function scheduleDisplayRows(rows: readonly ScheduleRow[], now: number): readonly ScheduleDisplayRow[] {
+  return [...rows]
+    .sort((left, right) => (Number(left.targetAt > now) - Number(right.targetAt > now)) || (left.targetAt - right.targetAt))
+    .map(row => ({
+      key: row.id,
+      text: `${row.prompt} · ${scheduleFrequency(row)} · ${new Date(row.targetAt).toLocaleString()} (${scheduleRelative(row.targetAt, now)})`,
+      tone: row.targetAt <= now ? 'error' as const : undefined,
+    }))
+}
+
+export function SchedulePanel({ rows, close }: { rows(): readonly ScheduleRow[]; close(): void }): ReactElement {
+  const [, setTick] = useState(0)
+  useEffect(() => {
+    const id = setInterval(() => setTick(value => value + 1), 1_000)
+    return () => clearInterval(id)
+  }, [])
+  const display = scheduleDisplayRows(rows(), Date.now())
+  const stdout = useStdout().stdout
+  const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
+  useInput((input, key) => {
+    if (key.escape || input === 'q') return close()
+  })
+  if (viewport.maxHeight === 0 || viewport.compact) {
+    const summary = display.length === 0 ? 'no active reminders' : singleLineText(display[0]!.text)
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`/schedule · ${summary}`, viewport.contentColumns))
+  }
+  const budget = Math.max(1, viewport.bodyRows)
+  const visible = display.slice(0, budget)
+  const hidden = display.length - visible.length
+  return createElement(
+    Box,
+    { width: viewport.outerColumns, borderStyle: 'round', borderColor: inkColor(getPalette().dim), flexDirection: 'column', paddingX: 1 },
+    createElement(Text, { color: inkColor(getPalette().brandBright), wrap: 'truncate-end' }, truncateColumns(`/schedule · ${display.length} active reminder${display.length === 1 ? '' : 's'}`, viewport.contentColumns)),
+    ...(display.length === 0
+      ? [createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns('  no active reminders — the model creates them with schedule_create', viewport.contentColumns))]
+      : visible.map(row => createElement(Text, {
+        key: row.key,
+        color: row.tone === 'error' ? inkColor(getPalette().error) : undefined,
+        wrap: 'truncate-end',
+      }, truncateColumns(`  ${singleLineText(row.text)}`, viewport.contentColumns)))),
+    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns(`esc/q close${hidden > 0 ? ` · +${hidden} more` : ''} · the model schedules via schedule_create`, viewport.contentColumns)),
+  )
+}

package/src/render/editor.ts

@@ -487,12 +487,13 @@ export function composerMaxRows(terminalRows: number): number {
 }
 
 /**
- * History navigation starts with Up on an empty draft, or after visual
- * movement has reached the directional text edge of an unchanged recalled
- * entry. Every other position remains under textarea movement.
+ * History navigation starts with Up on an empty draft, or continues from an
+ * unchanged recalled entry whenever the caret sits on either text edge
+ * (start or end) - moving the caret into the interior returns the keys to
+ * ordinary editing until an edge is reached again.
  */
 export function shouldRecallNavigate(value: string, cursor: number, lastRecalled: string | null, direction: -1 | 1): boolean {
   if (value === '') return direction < 0
   if (lastRecalled !== value) return false
-  return direction < 0 ? cursor === 0 : cursor === value.length
+  return cursor === 0 || cursor === value.length
 }

package/src/render/ime-cursor.ts

@@ -0,0 +1,147 @@
+/**
+ * IME cursor anchoring for the composer.
+ *
+ * Ink keeps the real terminal cursor hidden and parks it just below the
+ * dynamic tree (after the status row). IME composition text and candidate
+ * windows anchor to that real cursor cell - VS Code's integrated terminal
+ * positions its hidden IME textarea there, and Windows consoles behave the
+ * same - so CJK input appeared at the bottom of the screen instead of at the
+ * caret. The anchor moves the real cursor onto the caret cell without
+ * touching Ink's relative erase ledger:
+ *
+ * - the displacement is owned: before any foreign write or re-anchor, the
+ *   wrapper cancels it (cursor down, column 1), so every writer - Ink's
+ *   log-update rewrites, the resize replay, protocol pushes - keeps seeing
+ *   the cursor exactly where it was left;
+ * - log-update frame chunks (which start with the erase-line sequence) get
+ *   the anchor re-appended inside the same write, so a repaint can never
+ *   leave the cursor behind - in particular the caret blink keeps the anchor
+ *   stable while an IME composition is open, because the terminal parses the
+ *   rewrite and the re-anchor as one atomic update.
+ *
+ * @module @deepseek-ai/dsh-code/render/ime-cursor
+ */
+
+import { useEffect, useRef } from 'react'
+import { useStdout } from 'ink'
+
+/** Cancel `rows` of owned upward displacement and return to column 1. */
+export function imeCursorRestore(rows: number): string {
+  return rows > 0 ? `\x1b[${rows}B\r` : ''
+}
+
+/** Move onto the caret cell: `rows` up from Ink's parked row, 0-based column. */
+export function imeCursorMove(rows: number, column: number): string {
+  return rows > 0 ? `\x1b[${rows}A\x1b[${column + 1}G` : ''
+}
+
+/**
+ * Rows between the caret cell and Ink's parked cursor row: the band's bottom
+ * blank row, the editor window rows below the caret, the status footer, and
+ * Ink's own below-frame row. Rows above the composer (gutter, live content)
+ * never enter this distance.
+ */
+export function imeCursorRowsUp(input: {
+  editorWindowRows: number
+  caretRowInWindow: number
+  rowsBelowComposer: number
+}): number {
+  return Math.max(1, input.editorWindowRows - input.caretRowInWindow + input.rowsBelowComposer)
+}
+
+/** log-update chunks start with the erase-line sequence; a chunk without it
+ * leaves no frame behind, so the next commit re-applies the anchor. */
+const FRAME_CHUNK_MARKER = '\x1b[2K'
+
+/** The installed anchor handle. */
+export interface ImeCursorAnchor {
+  /** Anchor on the caret cell: `rows` above Ink's parked row at the 0-based
+   * `column`; `rows <= 0` releases the anchor. */
+  anchor(rows: number, column: number): void
+  /** Cancel the displacement, restore the original write path, and detach. */
+  release(): void
+}
+
+const ANCHOR_STATE = Symbol.for('dsh-code.ime-cursor-anchor')
+
+/**
+ * Take over `stream.write` so the anchor displacement stays invisible to every
+ * other writer. Idempotent per stream: a second install returns the live
+ * handle. Returns `undefined` on non-TTY streams where anchoring is meaningless.
+ */
+export function installImeCursorAnchor(stream: NodeJS.WriteStream): ImeCursorAnchor | undefined {
+  if (stream?.isTTY !== true) return undefined
+  const target = stream as NodeJS.WriteStream & { [ANCHOR_STATE]?: ImeCursorAnchor | undefined }
+  const installed = target[ANCHOR_STATE]
+  if (installed !== undefined) return installed
+  const originalWrite = target.write.bind(target) as (...args: unknown[]) => unknown
+  let rows = 0
+  let column = -1
+  let detached = false
+  const anchor: ImeCursorAnchor = {
+    anchor(nextRows, nextColumn) {
+      if (detached) return
+      if (nextRows <= 0) {
+        if (rows !== 0) originalWrite(imeCursorRestore(rows))
+        rows = 0
+        column = -1
+        return
+      }
+      if (rows === nextRows && column === nextColumn) return
+      originalWrite(imeCursorRestore(rows) + imeCursorMove(nextRows, nextColumn))
+      rows = nextRows
+      column = nextColumn
+    },
+    release() {
+      if (detached) return
+      detached = true
+      if (rows !== 0) originalWrite(imeCursorRestore(rows))
+      rows = 0
+      column = -1
+      target.write = originalWrite as typeof target.write
+      delete target[ANCHOR_STATE]
+    },
+  }
+  target.write = ((chunk: unknown, ...rest: unknown[]) => {
+    const ownedRows = rows
+    const ownedColumn = column
+    if (ownedRows === 0 || typeof chunk !== 'string') {
+      if (ownedRows !== 0) {
+        originalWrite(imeCursorRestore(ownedRows))
+        rows = 0
+        column = -1
+      }
+      return originalWrite(chunk, ...rest)
+    }
+    const reanchor = chunk.startsWith(FRAME_CHUNK_MARKER)
+    rows = reanchor ? ownedRows : 0
+    column = reanchor ? ownedColumn : -1
+    return originalWrite(imeCursorRestore(ownedRows) + chunk + (reanchor ? imeCursorMove(ownedRows, ownedColumn) : ''), ...rest)
+  }) as typeof target.write
+  target[ANCHOR_STATE] = anchor
+  return anchor
+}
+
+/**
+ * Keep the real terminal cursor on the composer's caret cell while `active`
+ * (the editable composer). The second effect runs after every commit without
+ * a dep list: frame rewrites restore the anchor themselves, but any other
+ * write (protocol push, resize replay) leaves the cursor at Ink's parked
+ * position, and the next commit re-anchors it.
+ */
+export function useImeCursorAnchor(active: boolean, rows: number, column: number): void {
+  const { stdout } = useStdout()
+  const anchorRef = useRef<ImeCursorAnchor | undefined>(undefined)
+  useEffect(() => {
+    if (stdout === undefined) return undefined
+    const installed = installImeCursorAnchor(stdout)
+    anchorRef.current = installed
+    return () => {
+      installed?.release()
+      if (anchorRef.current === installed) anchorRef.current = undefined
+    }
+  }, [stdout])
+  useEffect(() => {
+    anchorRef.current?.anchor(active && rows > 0 ? rows : 0, column)
+  })
+}