Add files using upload-large-folder tool

mods/diff/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "diff",
+  "version": "0.1.0",
+  "description": "The diff pane as a plugin: /diff opens the session's uncommitted changes beside the transcript, file by file with their hunks, refreshed as Claude edits and runs commands; the first edit opens it where the terminal is wide enough, and a file's ask button rides its hunks on the next prompt.",
+  "author": {
+    "name": "Anthropic"
+  }
+}

mods/diff/hooks/array-of/array-of.ts

@@ -0,0 +1,9 @@
+/**
+ * A value a tool stored as the array it is, or an empty one when it is
+ * anything else.
+ *
+ * @param value a field of a tool's input or result
+ * @returns the array's items, unknown each
+ */
+export const arrayOf = (value: unknown): readonly unknown[] =>
+  Array.isArray(value) ? value : []

mods/diff/hooks/array-of/index.ts

@@ -0,0 +1,3 @@
+export * from './array-of.js'
+
+export * as default from '.'

mods/diff/hooks/ask/armed-ask-of.ts

@@ -0,0 +1,31 @@
+import type Git from '../git'
+import Limits from '../limits'
+import type { ArmedAsk } from './armed-ask'
+
+/**
+ * A file's diff as the context block the next prompt carries when the
+ * person presses ask.
+ *
+ * A line saying where it came from, then the hunks in unified form, cut at
+ * MAX_LINES_PER_FILE lines.
+ *
+ * @param path the file's repository-relative path
+ * @param hunks its hunks as the pane shows them
+ * @returns the armed ask
+ */
+export function armedAskOf(path: string, hunks: readonly Git.Hunk[]): ArmedAsk {
+  const body = hunks
+    .flatMap(hunk => [
+      `@@ -${hunk.oldStart} +${hunk.newStart} @@`,
+      ...hunk.lines,
+    ])
+    .slice(0, Limits.MAX_LINES_PER_FILE)
+
+  return {
+    path,
+    text:
+      `The user attached the diff of ${path} from the diff pane to this ` +
+      `prompt:\n${body.join('\n')}`,
+    lines: body.length,
+  }
+}

mods/diff/hooks/ask/fitted-ask-text-of.ts

@@ -0,0 +1,37 @@
+import { ASK_CUT_NOTE } from './ask-cut-note'
+
+/**
+ * An armed ask's text as it fits in the room a prompt's context has left:
+ * whole when it fits, else its first lines and ASK_CUT_NOTE.
+ *
+ * @param text the armed ask's text
+ * @param room the characters the context has left
+ * @returns the text to attach, or undefined when not even its first line fits
+ */
+export function fittedAskTextOf(
+  text: string,
+  room: number,
+): string | undefined {
+  if (text.length <= room) {
+    return text
+  }
+
+  const kept: string[] = []
+
+  let used = ASK_CUT_NOTE.length
+
+  for (const line of text.split('\n')) {
+    const cost = line.length + 1
+
+    if (used + cost > room) {
+      break
+    }
+
+    kept.push(line)
+    used += cost
+  }
+
+  const hasBody = kept.length > 1
+
+  return hasBody ? `${kept.join('\n')}\n${ASK_CUT_NOTE}` : undefined
+}

mods/diff/hooks/ask/index.ts

@@ -0,0 +1,6 @@
+export * from './armed-ask'
+export * from './armed-ask-of.js'
+export * from './ask-cut-note'
+export * from './fitted-ask-text-of.js'
+
+export * as default from '.'

mods/diff/hooks/backend/backend-of.ts

@@ -0,0 +1,30 @@
+import Git from '../git'
+import type { Backend, BackendHost, BackendProbe } from './types'
+
+/**
+ * The backend holding the session's directory: another system's when its
+ * probe answers first, else git when a git working tree holds it, else none.
+ *
+ * Other systems are asked first so one may claim a working copy by its own
+ * rule (the nearer of two markers, say); each answers null wherever git
+ * should govern.
+ *
+ * @param host the bound host's runner and probes
+ * @param probes probes for other version-control systems, in order
+ * (INSTALLED_BACKEND_PROBES at the pane; none as published)
+ * @returns the pinned backend, or null outside any working tree
+ */
+export async function backendOf(
+  host: BackendHost,
+  probes: Iterable<BackendProbe>,
+): Promise<Backend | null> {
+  for (const probe of probes) {
+    const backend = await probe(host)
+
+    if (backend) {
+      return backend
+    }
+  }
+
+  return Git.gitBackendOf(host)
+}

mods/diff/hooks/backend/index.ts

@@ -0,0 +1,5 @@
+export * from './backend-of.js'
+export * from './installed-backend-probes.js'
+export * from './types'
+
+export * as default from '.'

mods/diff/hooks/backend/installed-backend-probes.ts

@@ -0,0 +1,12 @@
+import type { BackendProbe } from './types'
+
+/**
+ * Where a host adds backends: probes for version-control systems other than
+ * git, asked in insertion order before git (backendOf). Empty as shipped.
+ *
+ * A host compiling the module in adds a probe once, before the plugin
+ * registers: the module runs natively, and there is no other channel (the
+ * options are the manifest's userConfig; the scan wants a plain function).
+ */
+// module-state-allow: module-evaluation code wiring — a compiling host adds its probe functions (code references, not runtime input) once before registration and never removes or rebinds them; tests pass probes to backendOf directly; a per-Host copy would hold the same functions
+export const INSTALLED_BACKEND_PROBES = new Set<BackendProbe>()

mods/diff/hooks/classify/index.ts

@@ -0,0 +1,7 @@
+export * from './base-name-of'
+export * from './is-generated-file'
+export * from './is-noise-file.js'
+export * from './is-test-file'
+export * from './rooted-path-of'
+
+export * as default from '.'

mods/diff/hooks/classify/is-noise-file.ts

@@ -0,0 +1,12 @@
+import { isGeneratedFile } from './is-generated-file'
+import { isTestFile } from './is-test-file'
+
+/**
+ * Whether a changed file is hidden behind the pane's tests-and-generated
+ * line until the person asks to see it.
+ *
+ * @param path the file's path from the repository root
+ * @returns whether it is a test or a generated file
+ */
+export const isNoiseFile = (path: string) =>
+  isTestFile(path) || isGeneratedFile(path)

mods/diff/hooks/command-spec/command-spec.ts

@@ -0,0 +1,10 @@
+import Names from '../names'
+
+/**
+ * What `session.start` hands `$.command.register`: the one place the
+ * `/diff` spec is built, where a later CommandSpec field joins.
+ */
+export const COMMAND_SPEC = {
+  name: Names.COMMAND_NAME,
+  description: Names.COMMAND_DESCRIPTION,
+} as const

mods/diff/hooks/command-spec/index.ts

@@ -0,0 +1,3 @@
+export * from './command-spec.js'
+
+export * as default from '.'

mods/diff/hooks/count-of/count-of.ts

@@ -0,0 +1,10 @@
+/**
+ * How many items of a list pass a test, without the intermediate array a
+ * filter would build.
+ *
+ * @param items the list
+ * @param passes the test
+ * @returns the number of passing items
+ */
+export const countOf = <T>(items: readonly T[], passes: (item: T) => boolean) =>
+  items.reduce((total, item) => total + (passes(item) ? 1 : 0), 0)

mods/diff/hooks/count-of/index.ts

@@ -0,0 +1,3 @@
+export * from './count-of.js'
+
+export * as default from '.'

mods/diff/hooks/drawn-files-of/drawn-files-of.ts

@@ -0,0 +1,31 @@
+import type Git from '../git'
+import Limits from '../limits'
+import PaneState from '../pane-state'
+
+/**
+ * The files whose bodies the pane draws now, in drawing order: the listed
+ * session rows, then the pre-session rows while their section is open.
+ *
+ * Past PRE_SESSION_BODY_CAP pre-session files only their legend shows, so
+ * none of their bodies is wanted.
+ *
+ * @param model the pane's state: its fetch and its two toggles
+ * @returns the rows, none without a fetch
+ */
+export function drawnFilesOf(
+  model: Pick<
+    PaneState.PaneModel,
+    'data' | 'isNoiseShown' | 'isPreSessionShown'
+  >,
+): readonly Git.FileStat[] {
+  const partition = PaneState.partitionOf(
+    model.data?.files ?? [],
+    model.isNoiseShown ? 'shown' : 'hidden',
+  )
+
+  const isBodied =
+    model.isPreSessionShown &&
+    partition.preSession.length <= Limits.PRE_SESSION_BODY_CAP
+
+  return [...partition.shown, ...(isBodied ? partition.preSession : [])]
+}

mods/diff/hooks/drawn-files-of/index.ts

@@ -0,0 +1,3 @@
+export * from './drawn-files-of.js'
+
+export * as default from '.'

mods/diff/hooks/entry-kinds-of/index.ts

@@ -0,0 +1,3 @@
+export * from './entry-kinds-of.js'
+
+export * as default from '.'

mods/diff/hooks/hooks.json

@@ -0,0 +1,4 @@
+{
+  "description": "The diff pane: /diff and its Pane drawing, a refresh on Claude's edits, shell commands and finished turns, the pane's opening on the first edit, and the ask that rides a file's hunks on the next prompt",
+  "modules": ["./register.ts"]
+}

mods/diff/hooks/host/host.ts

@@ -0,0 +1,116 @@
+import type {
+  CommandSpec,
+  EngineInterface,
+  FsEntry,
+  FsStat,
+  PaneCloseArgs,
+  PaneOpenArgs,
+  ProcessRunInit,
+  ProcessRunResult,
+  SessionMessage,
+  TimerCall,
+} from 'claude-code'
+
+/**
+ * The engine as `session.start` bound it from its `$`, each member spelled
+ * `$.noun.event(...)` there; used by every later hook, timer and press.
+ */
+export type Host = {
+  /**
+   * `$.clock.now`.
+   */
+  now: () => Promise<number>
+
+  /**
+   * `$.clock.after`.
+   */
+  after: TimerCall
+
+  /**
+   * `$.clock.every`.
+   */
+  every: TimerCall
+
+  /**
+   * `$.process.run`.
+   */
+  run: (
+    argv: readonly string[],
+    init: ProcessRunInit,
+  ) => Promise<ProcessRunResult>
+
+  /**
+   * `$.fs.stat`.
+   */
+  stat: (path: string) => Promise<FsStat>
+
+  /**
+   * `$.fs.list`: a directory's entries by kind, links never followed.
+   */
+  listDir: (path: string) => Promise<FsEntry[]>
+
+  /**
+   * `$.fs.read`.
+   */
+  readFile: (path: string) => Promise<string>
+
+  /**
+   * Reads the plugin's store (`$.store.get`).
+   */
+  storeGet: (key: string) => Promise<unknown>
+
+  /**
+   * Writes the plugin's store (`$.store.set`).
+   */
+  storeSet: (key: string, value: unknown) => Promise<void>
+
+  /**
+   * `$.session.messages`.
+   */
+  messages: () => Promise<SessionMessage[]>
+
+  /**
+   * `$.ui.invalidate("ui.render")`: every pane instance draws again.
+   */
+  invalidate: () => void
+
+  /**
+   * `$.ui.status`: the plugin's line under the prompt.
+   */
+  status: (text: string | undefined) => void
+
+  /**
+   * One debug line under the plugin's name (`$.ui.log`).
+   */
+  uiLog: (text: string) => void
+
+  /**
+   * `$.ui.open`.
+   */
+  openPane: (pane: PaneOpenArgs) => Promise<void>
+
+  /**
+   * `$.ui.close`.
+   */
+  closePane: (pane: PaneCloseArgs) => Promise<void>
+
+  /**
+   * `$.command.register`; rejects while another `/diff` is listed.
+   */
+  registerCommand: (spec: CommandSpec) => Promise<unknown>
+
+  /**
+   * Which session the pane-shown row is latched to, as `$.session.id` says.
+   */
+  sessionId: () => Promise<string>
+
+  /**
+   * `$.telemetry.mark`; rejects where the telemetry built-in is absent.
+   */
+  mark: EngineInterface['telemetry']['mark']
+
+  /**
+   * `$.telemetry.log`; rejects where the telemetry built-in is absent.
+   */
+  log: EngineInterface['telemetry']['log']
+}

mods/diff/hooks/host/index.ts

@@ -0,0 +1,3 @@
+export type * from './host.js'
+
+export * as default from '.'

mods/diff/hooks/index.ts

@@ -0,0 +1,28 @@
+export * from './array-of'
+export * from './ask'
+export * from './backend'
+export * from './classify'
+export * from './command-spec'
+export * from './count-of'
+export * from './drawn-files-of'
+export * from './entry-kinds-of'
+export * from './git'
+export * from './host'
+export * from './is-on-pane-surface'
+export * from './is-record'
+export * from './kept-of'
+export * from './limits'
+export * from './map-limited'
+export * from './message-of'
+export * from './mtime-of'
+export * from './names'
+export * from './pane-state'
+export * from './pane-toggle'
+export * from './record'
+export * from './register.js'
+export * from './todos'
+export * from './tools'
+export * from './turns'
+export * from './views'
+
+export * as default from '.'

mods/diff/hooks/is-on-pane-surface/index.ts

@@ -0,0 +1,3 @@
+export * from './is-on-pane-surface.js'
+
+export * as default from '.'

mods/diff/hooks/is-on-pane-surface/is-on-pane-surface.ts

@@ -0,0 +1,12 @@
+import type { RenderSurface } from 'claude-code'
+
+/**
+ * Whether a render event comes from a surface that draws the pane: every
+ * one but the mobile app, which has no Select and is not terminal-wide.
+ *
+ * @param e the render event, or anything naming its surface
+ * @returns false on `mobile`, true otherwise, narrowing `e` to the rest
+ */
+export const isOnPaneSurface = <E extends Record<'surface', RenderSurface>>(
+  e: E,
+): e is Exclude<E, Record<'surface', 'mobile'>> => e.surface !== 'mobile'

mods/diff/hooks/is-record/index.ts

@@ -0,0 +1,3 @@
+export * from './is-record.js'
+
+export * as default from '.'

mods/diff/hooks/is-record/is-record.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether a value is a plain object that can be read field by field.
+ *
+ * @param value anything a tool result may be
+ * @returns whether it is a non-null, non-array object
+ */
+export const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)

mods/diff/hooks/kept-of/index.ts

@@ -0,0 +1,3 @@
+export * from './kept-of.js'
+
+export * as default from '.'

mods/diff/hooks/limits/dialog-path-floor.ts

@@ -0,0 +1,5 @@
+/**
+ * The fewest cells an inline file row gives its path, however narrow the
+ * pane (DiffFileList's 20).
+ */
+export const DIALOG_PATH_FLOOR = 20

mods/diff/hooks/limits/index.ts

@@ -0,0 +1,8 @@
+export * from './columns'
+export * from './dialog-path-floor.js'
+export * from './sizes'
+export * from './timing'
+export * from './todo-bar-cells.js'
+export * from './todo-bar-reserve.js'
+
+export * as default from '.'

mods/diff/hooks/limits/todo-bar-cells.ts

@@ -0,0 +1,4 @@
+/**
+ * The widest the todo progress bar draws (ReplDiffSidebar's 20).
+ */
+export const TODO_BAR_CELLS = 20

mods/diff/hooks/limits/todo-bar-reserve.ts

@@ -0,0 +1,4 @@
+/**
+ * The cells kept beside the todo bar for its `done/total` count.
+ */
+export const TODO_BAR_RESERVE = 12

mods/diff/hooks/map-limited/index.ts

@@ -0,0 +1,3 @@
+export * from './map-limited.js'
+
+export * as default from '.'

mods/diff/hooks/map-limited/map-limited.ts

@@ -0,0 +1,30 @@
+/**
+ * Maps every item through an async function, a bounded number of them in
+ * flight at once, and resolves to the results in the items' order.
+ *
+ * @param items the inputs
+ * @param limit how many may run at once, at least one
+ * @param fn the work for one item
+ * @returns the results, in order
+ */
+export async function mapLimited<T, R>(
+  items: readonly T[],
+  limit: number,
+  fn: (item: T) => Promise<R>,
+): Promise<R[]> {
+  const results: R[] = []
+
+  let next = 0
+
+  async function worker(): Promise<void> {
+    for (let at = next++; at < items.length; at = next++) {
+      results[at] = await fn(items[at] as T)
+    }
+  }
+
+  await Promise.all(
+    Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker),
+  )
+
+  return results
+}

mods/diff/hooks/mtime-of/index.ts

@@ -0,0 +1,3 @@
+export * from './mtime-of.js'
+
+export * as default from '.'

mods/diff/hooks/mtime-of/mtime-of.ts

@@ -0,0 +1,16 @@
+import type { Host } from '../host'
+
+/**
+ * A path's modification time through the host, or null when the path
+ * cannot be read (GitDeps `mtimeOf`).
+ *
+ * @param engine the bound host
+ * @returns the probe
+ */
+export const mtimeOf =
+  (engine: Host) =>
+  (path: string): Promise<number | null> =>
+    engine.stat(path).then(
+      stat => stat.mtimeMs,
+      () => null,
+    )

mods/diff/hooks/names/command-description.ts

@@ -0,0 +1,6 @@
+/**
+ * What the typeahead and `/help` show for `/diff` (the built-in's fullscreen
+ * wording: the pane is the panel's successor).
+ */
+export const COMMAND_DESCRIPTION =
+  'Toggle the diff panel showing uncommitted changes'

mods/diff/hooks/names/command-name.ts

@@ -0,0 +1,4 @@
+/**
+ * The slash command the plugin serves once the built-in `/diff` stands down.
+ */
+export const COMMAND_NAME = 'diff'

mods/diff/hooks/names/index.ts

@@ -0,0 +1,9 @@
+export * from './command-description.js'
+export * from './command-name.js'
+export * from './keys'
+export * from './pane-id.js'
+export * from './pane-title.js'
+export * from './plugin-name.js'
+export * from './texts'
+
+export * as default from '.'

mods/diff/hooks/names/pane-id.ts

@@ -0,0 +1,4 @@
+/**
+ * The one pane the plugin opens; its `requestId` at `ui.render`.
+ */
+export const PANE_ID = 'diff'

mods/diff/hooks/names/pane-title.ts

@@ -0,0 +1,4 @@
+/**
+ * The pane's title: its tab while another pane is open too.
+ */
+export const PANE_TITLE = 'Diff'

mods/diff/hooks/names/plugin-name.ts

@@ -0,0 +1,5 @@
+/**
+ * The plugin's own name, as the engine stamps it on the elements its render
+ * hooks draw (`ui.press`, `ui.focus`).
+ */
+export const PLUGIN_NAME = 'diff'

mods/diff/hooks/pane-state/dialog-title-of.ts

@@ -0,0 +1,37 @@
+import type { DialogTitle } from './dialog-title'
+import type { PaneModel } from './pane-model'
+import { pickedTurnOf } from './picked-turn-of'
+import { turnTitleOf } from './turn-title-of'
+
+/**
+ * The inline pane's heading (DiffDialog's title): the picked turn and its
+ * prompt's opening words, or what the working tree is compared with.
+ *
+ * An unborn HEAD lists staged and new files; a branch diff names its base;
+ * anything else is the uncommitted changes against HEAD.
+ *
+ * @param model the pane's state
+ * @returns the title and its dim subtitle
+ */
+export function dialogTitleOf(model: PaneModel): DialogTitle {
+  const turn = pickedTurnOf(model)
+  const source = model.data?.source
+  const isUnborn = model.data?.isUnborn === true
+  const isBranch = source?.kind === 'branch'
+
+  function currentOf(): DialogTitle {
+    switch (true) {
+      case isUnborn:
+        return { title: 'Staged and new files', subtitle: '(no commits yet)' }
+      case isBranch && source?.kind === 'branch':
+        return {
+          title: 'Branch changes',
+          subtitle: `(vs ${source.baseBranch})`,
+        }
+      default:
+        return { title: 'Uncommitted changes', subtitle: '(git diff HEAD)' }
+    }
+  }
+
+  return turn ? turnTitleOf(turn) : currentOf()
+}

mods/diff/hooks/pane-state/empty-state-of.ts

@@ -0,0 +1,70 @@
+import Names from '../names'
+import type { EmptyState } from './empty-state'
+import type { PaneModel } from './pane-model'
+
+/**
+ * The headline that replaces the count when nothing is listed, worded as
+ * ReplDiffSidebar words it, keyed on the mode the data was FETCHED in.
+ *
+ * Null while there are files to count. No data after a settled fetch is
+ * "Diff unavailable"; no tracked rows while the untracked listing was
+ * withheld claims nothing about new files.
+ *
+ * @param model the last good fetch (null when none ever settled), the words
+ * @param filesCount the header's session file count
+ * @returns the empty state, or null
+ */
+export function emptyStateOf(
+  model: Pick<PaneModel, 'data' | 'words'>,
+  filesCount: number,
+): EmptyState | null {
+  const { data, words } = model
+
+  if (!data) {
+    return {
+      headline: 'Diff unavailable',
+      hint:
+        `Couldn't read the ${words.diffCommand} — it will retry on the ` +
+        'next change',
+    }
+  }
+
+  if (filesCount > 0) {
+    return null
+  }
+
+  if (data.isUntrackedWithheld) {
+    return {
+      headline: 'No tracked changes',
+      hint: Names.untrackedWithheldTextOf(model),
+    }
+  }
+
+  if (data.isUnborn) {
+    return {
+      headline: 'No commits yet',
+      hint: "Nothing to diff against until the repo's first commit",
+    }
+  }
+
+  switch (data.mode) {
+    case 'uncommitted':
+      return { headline: 'No uncommitted changes', hint: null }
+    case 'branch':
+      if (data.source.kind === 'branch') {
+        return {
+          headline: `No changes vs ${data.source.baseBranch}`,
+          hint: null,
+        }
+      }
+
+      return {
+        headline: `No changes vs ${data.source.base}`,
+        hint:
+          'No base branch to compare against — showing changes vs ' +
+          data.source.base,
+      }
+    case 'session':
+      return { headline: 'No changes this session', hint: null }
+  }
+}

mods/diff/hooks/pane-state/header-totals-of.ts

@@ -0,0 +1,32 @@
+import type Git from '../git'
+import type { HeaderTotals } from './header-totals'
+import type { Partition } from './partition'
+
+/**
+ * The header's counts (ReplDiffSidebar): the fetched totals less the
+ * pre-session rows, and how many session files fell past the row cap.
+ *
+ * Files past the cap were never dated, so they always count and always
+ * show as `notShown`: an edit that sorts after fifty older ones stays seen.
+ *
+ * @param data the fetch
+ * @param partition its rows, grouped
+ * @returns the counts and how many session files are past the cap
+ */
+export function headerTotalsOf(
+  data: Git.DiffData,
+  partition: Partition,
+): HeaderTotals {
+  const { stats, files } = data
+  const before = partition.preSession
+  const filesCount = stats.filesCount - before.length
+
+  return {
+    filesCount,
+    linesAdded:
+      stats.linesAdded - before.reduce((sum, file) => sum + file.added, 0),
+    linesRemoved:
+      stats.linesRemoved - before.reduce((sum, file) => sum + file.removed, 0),
+    notShown: Math.max(0, filesCount - (files.length - before.length)),
+  }
+}

mods/diff/hooks/pane-state/index.ts

@@ -0,0 +1,25 @@
+export * from './after-fetch'
+export * from './after-new-session'
+export * from './base-mode-of'
+export * from './bodies'
+export * from './dialog-focus'
+export * from './dialog-title'
+export * from './dialog-title-of.js'
+export * from './empty-state'
+export * from './empty-state-of.js'
+export * from './header-totals'
+export * from './header-totals-of.js'
+export * from './initial-model'
+export * from './mode-label-of'
+export * from './no-bodies'
+export * from './pane-model'
+export * from './partition'
+export * from './partition-of.js'
+export * from './picked-turn-of'
+export * from './source'
+export * from './turn-title-of'
+export * from './turn-totals-of'
+export * from './unborn-note-of.js'
+export * from './zero-totals'
+
+export * as default from '.'

mods/diff/hooks/pane-state/partition-of.ts

@@ -0,0 +1,32 @@
+import Classify from '../classify'
+import Git from '../git'
+import type { Partition } from './partition'
+
+/**
+ * A fetch's rows split as ReplDiffSidebar splits them, in its order (by
+ * name): pre-session apart, tests and generated files hidden unless shown.
+ *
+ * No read-deny bucket: the pane feeds nothing to the model on its own.
+ *
+ * @param files the fetched rows
+ * @param noise `shown` keeps tests and generated files in the list
+ * @returns the groups
+ */
+export function partitionOf(
+  files: readonly Git.FileStat[],
+  noise: 'shown' | 'hidden',
+): Partition {
+  const sorted = [...files].sort((a, b) =>
+    Git.displayPathOf(a).localeCompare(Git.displayPathOf(b)),
+  )
+
+  const preSession = sorted.filter(file => file.isPreSession)
+  const session = sorted.filter(file => !file.isPreSession)
+  const quiet = session.filter(file => !Classify.isNoiseFile(file.path))
+
+  return {
+    shown: noise === 'shown' ? session : quiet,
+    preSession,
+    noiseCount: session.length - quiet.length,
+  }
+}

mods/diff/hooks/pane-state/unborn-note-of.ts

@@ -0,0 +1,22 @@
+import type { PaneModel } from './pane-model'
+
+/**
+ * The dim line under the header on an unborn HEAD that still lists rows:
+ * what the rows are, since no comparison runs before the first commit.
+ *
+ * ReplDiffSidebar's no-commits qualifier; null with commits or no rows.
+ *
+ * @param model the last good fetch
+ * @param filesCount the header's session file count
+ * @returns the line, or null
+ */
+export function unbornNoteOf(
+  model: Pick<PaneModel, 'data'>,
+  filesCount: number,
+): string | null {
+  const isUnbornListing = model.data?.isUnborn === true && filesCount > 0
+
+  return isUnbornListing
+    ? 'no commits yet — showing staged and new files'
+    : null
+}

mods/diff/hooks/record/index.ts

@@ -0,0 +1,12 @@
+export * from './base-outcomes'
+export * from './features'
+export * from './mark-outcome'
+export * from './recorder'
+export * from './recorder-of.js'
+export * from './safely'
+export * from './shown-triggers'
+export * from './tabs'
+export * from './width-bucket-of'
+export * from './width-buckets'
+
+export * as default from '.'

mods/diff/hooks/record/recorder-of.ts

@@ -0,0 +1,31 @@
+import type { Host } from '../host'
+import { FEATURES } from './features'
+import type { Recorder } from './recorder'
+import { safely } from './safely'
+import { SHOWN_TRIGGERS } from './shown-triggers'
+import { WIDTH_BUCKETS } from './width-buckets'
+
+/**
+ * The plugin's Recorder over the host: each row goes through the telemetry
+ * built-in's `$.telemetry`, named and shaped as the built-in panel's own.
+ *
+ * A missing noun or a refused row is dropped.
+ *
+ * @param host the engine as session.start bound it
+ * @returns the recorder
+ */
+export const recorderOf = (host: Host): Recorder => ({
+  mark: (feature, outcome) => safely(() => host.mark({ feature, ...outcome })),
+  shown: (trigger, bucket) =>
+    safely(() =>
+      host.log({
+        event: 'tengu_repl_diff_panel_shown',
+        props: {
+          trigger: { value: trigger, of: SHOWN_TRIGGERS },
+          terminal_width_bucket: { value: bucket, of: WIDTH_BUCKETS },
+        },
+      }),
+    ),
+  asked: () =>
+    safely(() => host.mark({ feature: FEATURES.selectionAttach, kind: 'ok' })),
+})

mods/diff/hooks/register.ts

@@ -0,0 +1,907 @@
+import type {
+  On,
+  PaneOpenArgs,
+  ResultOf,
+  SessionMessage,
+  Timer,
+} from 'claude-code'
+
+import Ask from './ask'
+import Backend from './backend'
+import { COMMAND_SPEC } from './command-spec'
+import { drawnFilesOf } from './drawn-files-of'
+import { entryKindsOf } from './entry-kinds-of'
+import type Git from './git'
+import type { Host } from './host'
+import { isOnPaneSurface } from './is-on-pane-surface'
+import Limits from './limits'
+import { mapLimited } from './map-limited'
+import { messageOf } from './message-of'
+import { mtimeOf } from './mtime-of'
+import Names from './names'
+import PaneState from './pane-state'
+import PaneToggle from './pane-toggle'
+import Record from './record'
+import Tools from './tools'
+import Views from './views'
+
+/**
+ * Registers the diff pane: `/diff` once the built-in stands down, the
+ * pane's drawing and refresh, its opening on Claude's first edit, the ask.
+ *
+ * Git runs when the built-in's would: `session.start` binds the host and
+ * registers `/diff`; `/diff` or the first edit with room pins the backend
+ * where the session started, until `/clear`; an open pane alone fetches.
+ *
+ * @param on the engine's registrar
+ */
+export function register(on: On) {
+  let host: Host | null = null
+  let backend: Backend.Backend | null = null
+  let probing: Promise<boolean> | null = null
+  let sessionStartMs = 0
+  let isPaneOpen = false
+  let dialogRows: number | null = null
+  let hasAutoOpened = false
+  let columns: number | null = null
+  let shownSessionId: string | null = null
+  let armed: Ask.ArmedAsk | null = null
+  let carrying: Ask.ArmedAsk | null = null
+  let isRefreshing = false
+  let isRefreshQueued = false
+  let generation = 0
+  let bodyStamp: string | null = null
+  let bodyBase: string | null = null
+
+  const bodyLoads = new Map<string, Promise<Git.FileHunks | null>>()
+
+  const polled = { toplevel: '', headKey: '' }
+  const pin = { cwd: '', isEmpty: false, epoch: 0 }
+
+  let model: PaneState.PaneModel = PaneState.INITIAL_MODEL
+
+  const timers = new Map<'refresh' | 'redraw' | 'poll', Timer>()
+  const loggedBaseKinds = new Set<'ok' | 'sad'>()
+
+  const currentOf = (engine: Host): Host => host ?? engine
+
+  const backendHostOf = (engine: Host): Backend.BackendHost => ({
+    run: (argv, init) =>
+      currentOf(engine).run(
+        argv,
+        pin.cwd === '' ? init : { cwd: pin.cwd, ...init },
+      ),
+    readFile: path => currentOf(engine).readFile(path),
+    mtimeOf: path => mtimeOf(currentOf(engine))(path),
+    entryKindsOf: dir => entryKindsOf(currentOf(engine))(dir),
+    nowMs: () => currentOf(engine).now(),
+    sessionStartMsOf: () => sessionStartMs,
+    onBranchBase: base => {
+      const isError = base.kind === 'error'
+
+      const outcome: Record.MarkOutcome = isError
+        ? { kind: 'sad', reason: base.reason }
+        : {
+            kind: 'ok',
+            props: {
+              outcome: { value: base.kind, of: Record.BASE_OUTCOMES },
+            },
+          }
+
+      if (!loggedBaseKinds.has(outcome.kind)) {
+        loggedBaseKinds.add(outcome.kind)
+
+        Record.recorderOf(currentOf(engine)).mark(
+          Record.FEATURES.baseResolve,
+          outcome,
+        )
+      }
+    },
+  })
+
+  function pinBackend(engine: Host): Promise<boolean> {
+    if (backend || pin.isEmpty) {
+      return Promise.resolve(true)
+    }
+
+    probing ??= probeBackend(engine).finally(() => {
+      probing = null
+    })
+
+    return probing
+  }
+
+  async function probeBackend(engine: Host): Promise<boolean> {
+    const asked = { isAnswered: true }
+    const probeHost = backendHostOf(engine)
+    const { epoch } = pin
+
+    const probed = await Backend.backendOf(
+      {
+        ...probeHost,
+        run: (argv, init) =>
+          probeHost.run(argv, init).catch((error: unknown) => {
+            asked.isAnswered &&=
+              argv[0] !== 'git' || !/\baborted\b/.test(messageOf(error))
+
+            throw error
+          }),
+      },
+      Backend.INSTALLED_BACKEND_PROBES,
+    )
+
+    if (epoch !== pin.epoch) {
+      return false
+    }
+
+    backend ??= probed
+    pin.isEmpty = backend === null && asked.isAnswered
+
+    if (!probed || backend !== probed) {
+      return asked.isAnswered || backend !== null
+    }
+
+    const stored = PaneState.baseModeOf(
+      await engine
+        .storeGet(Names.baseStoreKeyOf(probed.repository.toplevel))
+        .catch(() => undefined),
+    )
+
+    const mode = stored && probed.baseModes.includes(stored) ? stored : null
+
+    model = {
+      ...model,
+      words: probed.words,
+      baseModes: probed.baseModes,
+      ...(mode && { requestedMode: mode }),
+    }
+
+    return true
+  }
+
+  function unpin() {
+    backend = null
+    pin.isEmpty = false
+    pin.epoch += 1
+    polled.toplevel = ''
+    polled.headKey = ''
+    timers.get('poll')?.cancel()
+    timers.delete('poll')
+  }
+
+  function dialogPane(): PaneOpenArgs {
+    return {
+      id: Names.PANE_ID,
+      title: Names.PANE_TITLE,
+      holdToasts: true,
+      closeOnEscape: true,
+      rows: Views.dialogRowsOf(model),
+    }
+  }
+
+  function fitDialog(engine: Host) {
+    const rows = Views.dialogRowsOf(model)
+
+    const isStale =
+      isPaneOpen && model.isFullscreen === false && rows !== dialogRows
+
+    if (isStale) {
+      dialogRows = rows
+      void engine.openPane(dialogPane()).catch(() => undefined)
+    }
+  }
+
+  function redraw(engine: Host) {
+    fitDialog(engine)
+
+    if (timers.has('redraw')) {
+      return
+    }
+
+    timers.set(
+      'redraw',
+      engine.after(Limits.REDRAW_COALESCE_MS, () => {
+        timers.delete('redraw')
+        engine.invalidate()
+      }),
+    )
+  }
+
+  async function loadBodies(engine: Host): Promise<boolean> {
+    const { data } = model
+    const pinned = backend
+
+    if (!data || !pinned) {
+      bodyStamp = null
+      bodyBase = null
+      bodyLoads.clear()
+      model = { ...model, bodies: PaneState.NO_BODIES }
+
+      return false
+    }
+
+    const stamp = bodyStampOf(data)
+    const isNewBase = data.baseRef !== bodyBase
+
+    if (stamp !== bodyStamp) {
+      bodyStamp = stamp
+      bodyLoads.clear()
+    }
+
+    if (isNewBase) {
+      bodyBase = data.baseRef
+      model = { ...model, bodies: PaneState.NO_BODIES }
+      redraw(engine)
+    }
+
+    return fetchBodies(engine, pinned, data)
+  }
+
+  const bodyStampOf = (data: Git.DiffData) => `${generation}|${data.baseRef}`
+
+  async function fetchBodies(
+    engine: Host,
+    pinned: Backend.Backend,
+    data: Git.DiffData,
+  ): Promise<boolean> {
+    const stamp = bodyStampOf(data)
+
+    function loadOf(file: Git.FileStat): Promise<Git.FileHunks | null> {
+      const load = pinned.fetchFileHunks(data, file)
+      bodyLoads.set(file.path, load)
+
+      return load.then(body => {
+        if (bodyStamp === stamp) {
+          model = {
+            ...model,
+            bodies: new Map(model.bodies).set(file.path, body),
+          }
+
+          redraw(engine)
+        }
+
+        return body
+      })
+    }
+
+    return (
+      await mapLimited(
+        drawnFilesOf(model).filter(file => !bodyLoads.has(file.path)),
+        Limits.BODY_FETCH_CONCURRENCY,
+        loadOf,
+      )
+    ).includes(null)
+  }
+
+  function startPoll(engine: Host, pinned: Backend.Backend) {
+    const readHeadKey = () => pinned.headKeyOf().catch(() => '')
+
+    if (polled.toplevel === pinned.repository.toplevel) {
+      return
+    }
+
+    timers.get('poll')?.cancel()
+    polled.toplevel = pinned.repository.toplevel
+    polled.headKey = ''
+
+    timers.set(
+      'poll',
+      engine.every(Limits.HEAD_POLL_MS, () => {
+        if (!isPaneOpen) {
+          return
+        }
+
+        void readHeadKey().then(key => {
+          const hasMoved = polled.headKey !== '' && key !== polled.headKey
+
+          polled.headKey = key
+
+          if (hasMoved) {
+            scheduleRefresh(engine)
+          }
+        })
+      }),
+    )
+  }
+
+  async function refresh(engine: Host): Promise<void> {
+    if (isRefreshing) {
+      isRefreshQueued = true
+
+      return
+    }
+
+    isRefreshing = true
+
+    const record = Record.recorderOf(engine)
+    const pinned = backend
+
+    const fetched = (): Promise<Git.FetchOutcome> =>
+      pinned
+        ? pinned.fetchDiff(model.requestedMode)
+        : Promise.resolve({ kind: 'no-repository' })
+
+    try {
+      model = { ...model, isLoading: model.data === null }
+
+      const [outcome, messages] = await Promise.all([
+        fetched(),
+        engine.messages().catch((): SessionMessage[] => []),
+      ])
+
+      model = PaneState.afterFetch(model, { outcome, messages })
+
+      switch (outcome.kind) {
+        case 'no-repository':
+          break
+        case 'unavailable':
+          record.mark(Record.FEATURES.read, {
+            kind: 'sad',
+            reason: 'git_diff_failed',
+          })
+
+          break
+        case 'data':
+          generation += 1
+
+          if (pinned) {
+            startPoll(engine, pinned)
+          }
+
+          break
+      }
+
+      const hasHunksFailed = await loadBodies(engine)
+
+      if (outcome.kind === 'data') {
+        record.mark(
+          Record.FEATURES.read,
+          hasHunksFailed
+            ? { kind: 'sad', reason: 'git_hunks_failed' }
+            : { kind: 'ok' },
+        )
+      }
+    } catch (error) {
+      record.mark(Record.FEATURES.read, {
+        kind: 'sad',
+        reason: 'git_diff_threw',
+      })
+
+      throw error
+    } finally {
+      isRefreshing = false
+      redraw(engine)
+
+      if (isRefreshQueued) {
+        isRefreshQueued = false
+        scheduleRefresh(engine)
+      }
+    }
+  }
+
+  function scheduleRefresh(engine: Host): void {
+    timers.get('refresh')?.cancel()
+
+    timers.set(
+      'refresh',
+      engine.after(Limits.REFRESH_DEBOUNCE_MS, () => {
+        timers.delete('refresh')
+        void refresh(engine)
+      }),
+    )
+  }
+
+  async function openPane(
+    engine: Host,
+    trigger: (typeof Record.SHOWN_TRIGGERS)[number],
+  ): Promise<void> {
+    const isDialog = model.isFullscreen === false
+
+    model = {
+      ...model,
+      selectedPath: null,
+      dialogView: 'list',
+      place: { ...model.place, top: 0, listStart: 0 },
+    }
+
+    dialogRows = isDialog ? Views.dialogRowsOf(model) : null
+
+    await engine.openPane(
+      isDialog
+        ? { ...dialogPane(), focus: true }
+        : { id: Names.PANE_ID, title: Names.PANE_TITLE, holdToasts: true },
+    )
+
+    isPaneOpen = true
+
+    const sessionId = await engine.sessionId().catch(() => null)
+
+    if (sessionId !== null && sessionId !== shownSessionId) {
+      shownSessionId = sessionId
+      Record.recorderOf(engine).shown(trigger, Record.widthBucketOf(columns))
+    }
+
+    void refresh(engine)
+  }
+
+  async function closePane(engine: Host): Promise<void> {
+    await engine.closePane({ id: Names.PANE_ID })
+    isPaneOpen = false
+  }
+
+  function markTabSwitch(engine: Host, tab: (typeof Record.TABS)[number]) {
+    Record.recorderOf(engine).mark(Record.FEATURES.tabSwitch, {
+      kind: 'ok',
+      props: { tab: { value: tab, of: Record.TABS } },
+    })
+  }
+
+  async function openOnFirstEdit(engine: Host): Promise<void> {
+    const isTaken = () => isPaneOpen || hasAutoOpened
+
+    if (isTaken()) {
+      return
+    }
+
+    const preference = await engine.storeGet(Names.STORE_OPEN_KEY)
+    const isKeptOpen = preference === true
+
+    const floor = isKeptOpen
+      ? Limits.OPEN_MIN_COLUMNS
+      : Limits.AUTO_OPEN_MIN_COLUMNS
+
+    const hasRoom =
+      preference !== false &&
+      model.isFullscreen === true &&
+      columns !== null &&
+      columns >= floor
+
+    if (!hasRoom || isTaken()) {
+      return
+    }
+
+    await pinBackend(engine)
+
+    if (!backend || isTaken()) {
+      return
+    }
+
+    hasAutoOpened = true
+    await openPane(engine, 'auto_open')
+  }
+
+  function disarm(engine: Host) {
+    armed = null
+    model = { ...model, armedPath: null }
+    engine.status(undefined)
+  }
+
+  const actionsOf = (engine: Host): Views.PaneActions => ({
+    selectFile: path => {
+      const isDocked = model.placement === 'dock'
+
+      model = {
+        ...model,
+        selectedPath: path,
+        dialogView: isDocked ? model.dialogView : 'detail',
+        place: isDocked ? Views.placeAtFile(model, path) : model.place,
+      }
+
+      redraw(engine)
+    },
+    scrollList: delta => {
+      model = { ...model, place: Views.listScrolledBy(model, delta) }
+      redraw(engine)
+    },
+    toggleNoise: () => {
+      model = { ...model, isNoiseShown: !model.isNoiseShown }
+      void loadBodies(engine)
+      redraw(engine)
+    },
+    togglePreSession: () => {
+      model = { ...model, isPreSessionShown: !model.isPreSessionShown }
+      void loadBodies(engine)
+      redraw(engine)
+    },
+    cycleBase: () => {
+      const { baseModes, requestedMode } = model
+
+      const mode =
+        baseModes[(baseModes.indexOf(requestedMode) + 1) % baseModes.length] ??
+        requestedMode
+
+      if (mode === requestedMode) {
+        return
+      }
+
+      model = { ...model, requestedMode: mode }
+
+      Record.recorderOf(engine).mark(Record.FEATURES.baseSwitch, {
+        kind: 'ok',
+        props: { mode: { value: mode, of: model.baseModes } },
+      })
+
+      const toplevel = model.data?.repository.toplevel
+
+      if (toplevel !== undefined) {
+        void engine
+          .storeSet(Names.baseStoreKeyOf(toplevel), mode)
+          .catch(() => undefined)
+      }
+
+      void refresh(engine)
+      redraw(engine)
+    },
+    chooseSource: value => {
+      const index = Number(value)
+      const isTurn = value !== 'current' && Number.isInteger(index)
+
+      const source: PaneState.Source = isTurn
+        ? { kind: 'turn', index }
+        : { kind: 'current' }
+
+      model = { ...model, source, selectedPath: null, dialogView: 'list' }
+      redraw(engine)
+    },
+    toggleAsk: path => {
+      if (armed?.path === path) {
+        disarm(engine)
+        redraw(engine)
+
+        return
+      }
+
+      arm(engine, path)
+    },
+  })
+
+  function arm(engine: Host, path: string) {
+    armed = Ask.armedAskOf(
+      path,
+      PaneState.pickedTurnOf(model)?.files.find(file => file.path === path)
+        ?.hunks ??
+        model.bodies.get(path)?.hunks ??
+        [],
+    )
+
+    model = { ...model, armedPath: path }
+
+    engine.status(
+      `${Views.sanitizeName(path)} rides your next prompt (press ` +
+        `asked ✓ to drop it)`,
+    )
+
+    redraw(engine)
+  }
+
+  async function bind(engine: Host, cwd: string): Promise<void> {
+    sessionStartMs = await engine.now()
+    pin.cwd = cwd
+
+    try {
+      await engine.registerCommand(COMMAND_SPEC)
+      host = engine
+    } catch (error) {
+      const reason = messageOf(error)
+
+      if (!Names.BUILTIN_HOLDS_PATTERN.test(reason)) {
+        engine.uiLog(Names.registerFailedTextOf(Views.sanitizeName(reason)))
+      }
+    }
+  }
+
+  on('session.start', async ($, e, next) => {
+    await bind(
+      {
+        now: () => $.clock.now(),
+        after: (ms, fn) => $.clock.after(ms, fn),
+        every: (ms, fn) => $.clock.every(ms, fn),
+        run: (argv, init) => $.process.run(argv, init),
+        stat: path => $.fs.stat(path),
+        listDir: path => $.fs.list(path),
+        readFile: path => $.fs.read(path),
+        storeGet: key => $.store.get(key),
+        storeSet: (key, value) => $.store.set(key, value),
+        messages: () => $.session.messages(),
+        invalidate: () => $.ui.invalidate('ui.render'),
+        status: text => $.ui.status(text),
+        uiLog: text => $.ui.log(text),
+        openPane: pane => $.ui.open(pane),
+        closePane: pane => $.ui.close(pane),
+        registerCommand: spec => $.command.register(spec),
+        sessionId: () => $.session.id(),
+        mark: entry => $.telemetry.mark(entry),
+        log: entry => $.telemetry.log(entry),
+      },
+      e.cwd,
+    )
+
+    return next(e)
+  })
+
+  on('ui.render', { component: 'PromptHint' }, ($, e, next) => {
+    if (isOnPaneSurface(e)) {
+      columns = e.viewport?.columns ?? columns
+
+      model = {
+        ...model,
+        isFullscreen: e.viewport?.isFullscreen ?? model.isFullscreen,
+      }
+    }
+
+    return next(e)
+  })
+
+  on('ui.render', { component: 'Pane' }, async ($, e, next) => {
+    if (e.requestId !== Names.PANE_ID || !host || !isOnPaneSurface(e)) {
+      return next(e)
+    }
+
+    const { Box, Text, Button, Select, Code } = await $.ui.resolve(e)
+
+    columns = e.viewport?.columns ?? columns
+
+    model = {
+      ...model,
+      placement: e.props.placement,
+      place: {
+        ...model.place,
+        columns: Math.max(
+          1,
+          e.props.bodyColumns - Limits.PANE_RIGHT_PAD_COLUMNS,
+        ),
+        rows: e.props.scroll.bodyRows,
+      },
+    }
+
+    return Views.paneView(
+      {
+        ui: { Box, Text, Button, Select, Code },
+        actions: actionsOf(host),
+        columns: e.props.bodyColumns,
+        rows: e.props.scroll.bodyRows,
+      },
+      model,
+      { placement: e.props.placement, terminalColumns: columns },
+    )
+  })
+
+  on('command.run', { command: Names.COMMAND_NAME }, async ($, e, next) => {
+    if (!host) {
+      return next(e)
+    }
+
+    const isAnswered = (await pinBackend(host)) || (await pinBackend(host))
+
+    if (!backend) {
+      return {
+        text: isAnswered
+          ? Names.NOT_IN_REPOSITORY_TEXT
+          : Names.GIT_UNANSWERED_TEXT,
+      }
+    }
+
+    const { isFullscreen } = e.presentation
+
+    columns = e.presentation.columns
+    model = { ...model, isFullscreen }
+
+    const toggle = PaneToggle.paneToggleOf({
+      isOpen: isPaneOpen,
+      columns: isFullscreen ? columns : null,
+    })
+
+    if (toggle === 'too-narrow') {
+      return { text: Names.RESIZE_TERMINAL_TEXT }
+    }
+
+    const isOpening = toggle === 'open'
+    await (isOpening ? openPane(host, 'manual') : closePane(host))
+
+    if (!isFullscreen) {
+      return isOpening ? {} : { text: Names.DIALOG_DISMISSED_TEXT }
+    }
+
+    markTabSwitch(host, isOpening ? 'diff' : 'convo')
+    await host.storeSet(Names.STORE_OPEN_KEY, isOpening).catch(() => undefined)
+
+    return {
+      text: isOpening ? Names.PANEL_SHOWN_TEXT : Names.PANEL_HIDDEN_TEXT,
+    }
+  })
+
+  on('ui.close', { id: Names.PANE_ID }, async ($, e, next) => {
+    const isBack =
+      e.origin.kind === 'person' &&
+      model.placement === 'inline' &&
+      model.dialogView === 'detail'
+
+    if (isBack && host) {
+      model = { ...model, dialogView: 'list' }
+      redraw(host)
+
+      dialogRows = Views.dialogRowsOf(model)
+
+      void host
+        .openPane({ ...dialogPane(), focus: true })
+        .catch(() => undefined)
+
+      return { deny: 'back to the file list' }
+    }
+
+    const result = await next(e)
+    const isClosed = result.deny === undefined
+    const isPersons = isClosed && e.origin.kind === 'person'
+
+    if (isClosed) {
+      isPaneOpen = false
+    }
+
+    const isDialog = model.isFullscreen === false
+
+    if (isPersons && host && isDialog) {
+      host.uiLog(Names.DIALOG_DISMISSED_TEXT)
+    }
+
+    if (isPersons && host && !isDialog) {
+      markTabSwitch(host, 'convo')
+      await host.storeSet(Names.STORE_OPEN_KEY, false).catch(() => undefined)
+    }
+
+    return result
+  })
+
+  on('ui.focus', { plugin: Names.PLUGIN_NAME }, ($, e, next) => {
+    const isListed =
+      model.placement === 'inline' && model.dialogView === 'list' && host
+
+    const focus = isListed ? Views.dialogFocusOf(model, e.element) : null
+
+    if (focus === 'stay') {
+      return {}
+    }
+
+    if (!focus || !host) {
+      return next(e)
+    }
+
+    model = { ...model, selectedPath: focus.selectedPath }
+    fitDialog(host)
+    host.invalidate()
+
+    return next({ ...e, element: focus.landing })
+  })
+
+  on('ui.scroll', { requestId: Names.PANE_ID }, ($, e, next) => {
+    const isOwnBody = e.origin.kind === 'person' && model.placement === 'dock'
+
+    if (!isOwnBody || !host) {
+      return next(e)
+    }
+
+    const isOverList = Views.isWheelOverList(model, e)
+
+    model = {
+      ...model,
+      place: isOverList
+        ? Views.listScrolledBy(model, e.by)
+        : Views.bodyScrolledBy(model, e),
+    }
+
+    host.invalidate()
+
+    return {}
+  })
+
+  on('command.run', { command: ['clear', 'resume'] }, async ($, e, next) => {
+    const result = await next(e)
+
+    if (host) {
+      if (isPaneOpen) {
+        await closePane(host).catch(() => undefined)
+      }
+
+      unpin()
+      hasAutoOpened = false
+      bodyStamp = null
+      bodyBase = null
+      bodyLoads.clear()
+      disarm(host)
+      model = PaneState.afterNewSession(model)
+    }
+
+    return result
+  })
+
+  function afterTool(
+    engine: Host,
+    tool: string,
+    result: ResultOf['tool.call'] | undefined,
+  ) {
+    const isEdit = Tools.EDITING_TOOLS.some(name => name === tool)
+
+    const hasEdited =
+      isEdit &&
+      result !== undefined &&
+      result.deny === undefined &&
+      result.isError !== true
+
+    const isStale =
+      isPaneOpen &&
+      (isEdit ? hasEdited : result === undefined || result.deny === undefined)
+
+    if (isStale) {
+      scheduleRefresh(engine)
+    }
+
+    if (hasEdited) {
+      void openOnFirstEdit(engine).catch(() => undefined)
+    }
+  }
+
+  on(
+    'tool.call',
+    { tool: [...Tools.EDITING_TOOLS, ...Tools.SHELL_TOOLS] },
+    async ($, e, next) => {
+      let result: ResultOf['tool.call'] | undefined
+
+      try {
+        result = await next(e)
+
+        return result
+      } finally {
+        if (host) {
+          afterTool(host, e.tool, result)
+        }
+      }
+    },
+  )
+
+  on('prompt.submit', async ($, e, next) => {
+    const asked = armed
+
+    if (!host || !asked || carrying === asked) {
+      return next(e)
+    }
+
+    const context = e.context ?? []
+
+    const text = Ask.fittedAskTextOf(
+      asked.text,
+      Limits.PROMPT_CONTEXT_MAX_CHARS -
+        context.reduce((sum, entry) => sum + entry.length, 0),
+    )
+
+    if (text === undefined) {
+      disarm(host)
+
+      host.status(
+        `${Views.sanitizeName(asked.path)}'s diff did not fit in the prompt ` +
+          `and was dropped`,
+      )
+
+      redraw(host)
+
+      return next(e)
+    }
+
+    carrying = asked
+
+    try {
+      const result = await next({ ...e, context: [...context, text] })
+
+      if (result.drop === undefined) {
+        Record.recorderOf(host).asked()
+
+        if (armed === asked) {
+          disarm(host)
+          redraw(host)
+        }
+      }
+
+      return result
+    } finally {
+      carrying = null
+    }
+  })
+}