refactor(tui): simplify theme palette lifecycle

feat(session): add turn diff route (#47821 )
Co-authored-by: Dax Raad <d@ironbay.co>
2026-09-13 04:16:22 +00:00 · 2026-09-12 17:50:32 -04:00 · 2026-09-12 21:26:52 +00:00 · 2026-09-12 17:25:44 -04:00 · 2026-09-12 17:24:04 -04:00 · 2026-09-12 17:20:09 -04:00
35 changed files with 2866 additions and 273 deletions
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-QJn59dTbxspHl35vGxs6akynlfaWaPqvbMNsi0EqnbM=",
-    "aarch64-linux": "sha256-wa54uUIAth/ZOyejZ/TfU0zZdkhNirwq7yK1218jhBQ=",
-    "aarch64-darwin": "sha256-VvsfVdtxcVijCvlrWpBUkgmkYFoXX7QiXM0Fhz1t2VE=",
-    "x86_64-darwin": "sha256-IxYFBG5I+znXcTVqrAWKhG2qvVtjM+Amp68xIGKZogE="
+    "x86_64-linux": "sha256-euVUyj0CzjCA1nYbN2vKctEPzLkUlNGTK2dMNbackqM=",
+    "aarch64-linux": "sha256-qQkjqaxpjAae+rohoWI601QnrgKYghJ+ttqeiQBTwCM=",
+    "aarch64-darwin": "sha256-HYWs31TJlDZsDBNmbPARo16r7zNKy9x840uHGcUMYsk=",
+    "x86_64-darwin": "sha256-89FOrX813FENk3u8RAHCfyD7voaZWW++Z4Gpa3SkOJs="
  }
 }
@@ -248,7 +248,7 @@ for (const direction of ["ltr", "rtl"]) {
    expect(messageAfter).toEqual(messageBefore)
    await page.locator('[data-component="composer-editor"]').pressSequentially("Also: ")
    await expect(page.locator('[data-component="composer-editor"]')).toHaveText(`Also: ${followUp}`)
-    expect(mock.calls).toEqual(["worktree", "session", "prompt"])
+    await expect.poll(() => mock.calls).toEqual(["worktree", "session", "prompt"])
  })
 }

@@ -55,6 +55,8 @@ for (const direction of ["ltr", "rtl"] as const) {
        "href",
        `#opencode-v2-icon-${workspace ? "outline-worktree" : "monitor"}`,
      )
+      // Initial layout scrolls this sticky header's ancestor and dismisses its tooltip.
+      await expect(page.locator("[data-timeline-virtual-content]")).toHaveCSS("visibility", "visible")
      const background = await trigger.evaluate((element) => getComputedStyle(element).backgroundColor)
      await trigger.hover()
      await expect(trigger).not.toHaveCSS("background-color", background)
@@ -103,7 +103,7 @@ export function createTimelineVirtualizer(input: Input) {
      { defer: true },
    ),
  )
-  const [rendering, setRendering] = createStore({ initialTail: coldBottomMount })
+  const [rendering, setRendering] = createStore({ initialTail: coldBottomMount, scrollAdjustment: 0 })
  const rows = input.projection.rows
  const rowByKey = input.projection.rowByKey
  const rowKeys = createMemo(() => rows().map(TimelineRow.key), undefined, {
@@ -154,6 +154,10 @@ export function createTimelineVirtualizer(input: Input) {
  })
  const measuredElements = new WeakSet<Element>()
  let touchStart: number | undefined
+  let touchTarget: EventTarget | null = null
+  let touchNested = false
+  let touchScrolling = false
+  let touchAdjustment = 0
  let pointerHeld = false
  let maxScroll = 0
  let virtualContent: HTMLDivElement | undefined
@@ -177,7 +181,23 @@ export function createTimelineVirtualizer(input: Input) {
    observeElementOffset: (instance, callback) => {
      reportOffset = (offset, scrolling) => {
        if (!active()) return
-        callback(offset, scrolling)
+        // Rows and the sizer use the opposite translation while native touch
+        // scrolling keeps its own offset. Range selection uses the logical offset.
+        batch(() => {
+          const logicalOffset = offset + rendering.scrollAdjustment
+          callback(rendering.scrollAdjustment ? Math.max(0, logicalOffset) : offset, scrolling)
+          // Reconcile both start boundaries in one native write. Gradually
+          // clamping row translations lets the compositor paint between
+          // corrections and makes the content oscillate at the top.
+          const root = listRoot()
+          if (
+            rendering.scrollAdjustment !== 0 &&
+            root &&
+            (logicalOffset <= 0 || offset <= 0 || (touchStart !== undefined && offset <= root.clientHeight))
+          )
+            flushTouchAdjustment()
+          if (!scrolling && touchStart === undefined) finishTouchScroll()
+        })
        settleColdBottom()
      }
      return observeElementOffsetReconnectAware(instance, reportOffset, () => {
@@ -212,6 +232,7 @@ export function createTimelineVirtualizer(input: Input) {
    scrollToFn: (offset, options, instance) => {
      if (!active()) return
      if (batchingColdSizes && input.pinned()) return
+      setRendering("scrollAdjustment", 0)
      if (virtualContent) virtualContent.style.height = `${instance.getTotalSize()}px`
      elementScroll(offset, options, instance)
    },
@@ -263,7 +284,15 @@ export function createTimelineVirtualizer(input: Input) {
      batch(() => {
        sizes.forEach(([index, value]) => {
          const row = rows()[index]
-          if (row && TimelineRow.key(row) === value.key) resizeItem(index, value.size)
+          if (!row || TimelineRow.key(row) !== value.key) return
+          resizeItem(index, value.size)
+          // TanStack recalculates its range after each resize. Advance the
+          // logical fold before deciding whether the next row needs anchoring.
+          if (!touchAdjustment) return
+          setRendering("scrollAdjustment", (value) => value + touchAdjustment)
+          touchAdjustment = 0
+          const root = listRoot()
+          if (root) reportOffset?.(root.scrollTop, virtualizer.isScrolling)
        })
      })
      batchingColdSizes = false
@@ -278,13 +307,40 @@ export function createTimelineVirtualizer(input: Input) {
    })
  }
  onCleanup(() => pendingSizes.clear())
-  virtualizer.shouldAdjustScrollPositionOnItemSizeChange = (item, _delta, instance) => {
+  virtualizer.shouldAdjustScrollPositionOnItemSizeChange = (item, delta, instance) => {
    // Prepended rows can resize more than once as deferred content mounts. Keep
    // compensating while they remain entirely above the visible content fold.
-    if (addedKeys.has(String(item.key)))
-      return item.end <= (instance.scrollOffset ?? 0) + instance.scrollAdjustments + instance.options.scrollMargin
    const first = instance.range?.startIndex
-    return first !== undefined && item.index < first
+    const adjust = addedKeys.has(String(item.key))
+      ? item.end <= (instance.scrollOffset ?? 0) + instance.scrollAdjustments + instance.options.scrollMargin
+      : first !== undefined && item.index < first
+    if (!touchScrolling || input.pinned()) return adjust
+    // iOS defers native scroll writes until momentum ends. Keep the same visual
+    // anchor now, rather than moving rows now and snapping the viewport back later.
+    if (adjust) touchAdjustment += delta
+    return false
+  }
+
+  function finishTouchScroll() {
+    touchScrolling = false
+    flushTouchAdjustment()
+  }
+
+  function prepareNavigation() {
+    if (touchStart === undefined) touchScrolling = false
+    flushTouchAdjustment()
+  }
+
+  function flushTouchAdjustment() {
+    const adjustment = rendering.scrollAdjustment
+    const root = listRoot()
+    if (!adjustment || !root) return
+    // Transfer the translation into the native offset in the same paint.
+    batch(() => {
+      setRendering("scrollAdjustment", 0)
+      if (virtualContent) virtualContent.style.height = `${virtualizer.getTotalSize()}px`
+      elementScroll(Math.max(0, root.scrollTop + adjustment), {}, virtualizer)
+    })
  }
  const virtualItemByKey = createMemo(
    () => new Map(virtualizer.getVirtualItems().map((item) => [item.key, item] as const)),
@@ -314,10 +370,12 @@ export function createTimelineVirtualizer(input: Input) {
        : -1
      const index = partIndex >= 0 ? partIndex : input.projection.messageRowIndex().get(id)
      if (index === undefined) return
+      prepareNavigation()
      virtualizer.scrollToIndex(index, { align: "center" })
    })
    input.setScrollToEnd?.(() => {
      if (!active() || !listRoot()?.isConnected) return
+      prepareNavigation()
      input.onPin()
      virtualizer.scrollToEnd()
    })
@@ -422,19 +480,53 @@ export function createTimelineVirtualizer(input: Input) {
  }

  const handleListTouchStart = (event: TouchEvent) => {
+    clearTouchTarget()
    input.onUserScroll(event.target)
+    touchScrolling = true
    touchStart = event.touches[0]?.clientY
+    const root = listRoot()
+    const nested = event.target instanceof Element ? event.target.closest<HTMLElement>("[data-scrollable]") : null
+    touchNested = !!nested && nested !== root && nested.scrollHeight > nested.clientHeight
+    // Native touch events keep their original target, even when streaming or
+    // virtualization detaches it. Listen there instead of relying on bubbling.
+    touchTarget = event.target
+    touchTarget?.addEventListener("touchmove", handleListTouchMove, { passive: true })
+    touchTarget?.addEventListener("touchend", handleListTouchEnd, { passive: true })
+    touchTarget?.addEventListener("touchcancel", handleListTouchEnd, { passive: true })
+    if (root) reportOffset?.(root.scrollTop, virtualizer.isScrolling)
  }

-  const handleListTouchMove = (event: TouchEvent & { currentTarget: HTMLDivElement }) => {
+  const handleListTouchMove = (event: Event) => {
+    if (!(event instanceof TouchEvent)) return
    const current = event.touches[0]?.clientY
    if (current === undefined || touchStart === undefined) return
-    // Dragging the content downward reveals earlier messages.
-    if (current <= touchStart) return
+    const previous = touchStart
    touchStart = current
+    // A retained target can outlive its whole session view. Only the active
+    // timeline may change the shared follow state; release still cleans up below.
+    if (!active()) return
+    // Dragging the content downward reveals earlier messages.
+    if (current <= previous) return
+    // A nested scrollport owns the intent. If it chains into the timeline at a
+    // boundary, the resulting native timeline scroll below will unpin instead.
+    if (touchNested) return
    input.onUnpin()
  }

+  const handleListTouchEnd = () => {
+    clearTouchTarget()
+    touchStart = undefined
+    if (!virtualizer.isScrolling) finishTouchScroll()
+  }
+
+  function clearTouchTarget() {
+    touchTarget?.removeEventListener("touchmove", handleListTouchMove)
+    touchTarget?.removeEventListener("touchend", handleListTouchEnd)
+    touchTarget?.removeEventListener("touchcancel", handleListTouchEnd)
+    touchTarget = null
+  }
+  onCleanup(clearTouchTarget)
+
  // Drag-selecting past the edge and dragging the scrollbar both scroll without a wheel or key,
  // so a held pointer is what separates those from the virtualizer's own measurement adjustments.
  const handleListPointerDown = (event: PointerEvent & { currentTarget: HTMLDivElement }) => {
@@ -475,7 +567,7 @@ export function createTimelineVirtualizer(input: Input) {
    const atEnd = maxScroll - scrollTop <= endEpsilon
    const arrived = scrollTop > previousTop + endEpsilon || maxScroll < previousMaxScroll
    if (maxScroll <= 1 || (atEnd && arrived)) input.onPin()
-    else if (pointerHeld && scrollTop < previousTop - endEpsilon) input.onUnpin()
+    else if ((pointerHeld || touchScrolling) && scrollTop < previousTop - endEpsilon) input.onUnpin()
    settleColdBottom()
    input.onScheduleScrollState(root)
    input.onHistoryScroll()
@@ -504,7 +596,7 @@ export function createTimelineVirtualizer(input: Input) {
          data-timeline-key={rowProps.rowKey}
          style={{
            position: "absolute",
-            top: `${item().start - topOffset()}px`,
+            top: `${item().start - topOffset() - rendering.scrollAdjustment}px`,
            left: "0",
            width: "100%",
            height: `${item().size}px`,
@@ -582,9 +674,10 @@ export function createTimelineVirtualizer(input: Input) {
        <ScrollView
          data-slot="session-timeline-scroll"
          viewportRef={bindListRoot}
+          onBeforeScroll={prepareNavigation}
+          verticalScrollAdjustment={rendering.scrollAdjustment}
          onWheel={handleListWheel}
          onTouchStart={handleListTouchStart}
-          onTouchMove={handleListTouchMove}
          onPointerDown={handleListPointerDown}
          onKeyDown={handleListKeyDown}
          onScroll={handleListScroll}
@@ -602,7 +695,7 @@ export function createTimelineVirtualizer(input: Input) {
              if (active()) input.setContentRef(element)
            }}
            style={{
-              height: `${virtualizer.getTotalSize()}px`,
+              height: `${virtualizer.getTotalSize() - rendering.scrollAdjustment}px`,
              position: "relative",
              width: "100%",
              visibility: coldBottomMount ? "hidden" : undefined,
@@ -612,7 +705,7 @@ export function createTimelineVirtualizer(input: Input) {
            <div
              data-timeline-row="bottom-spacer"
              class="h-16 absolute top-0 left-0 w-full"
-              style={{ transform: `translateY(${virtualizer.getTotalSize() - 64}px)` }}
+              style={{ transform: `translateY(${virtualizer.getTotalSize() - 64 - rendering.scrollAdjustment}px)` }}
            >
              {props.bottomSpacer}
            </div>
@@ -18,6 +18,7 @@ import type { PromptInput } from "@opencode/schema/prompt-input"
 import type { AgentAttachment } from "@opencode/schema/prompt"
 import type { Skill } from "@opencode/schema/skill"
 import type { Event } from "@opencode/schema/event"
+import type { FileDiff } from "@opencode/schema/file-diff"
 import type { InstructionEntry } from "@opencode/schema/instruction-entry"
 import type { Schema } from "effect"
 import type { EventLog } from "@opencode/schema/event-log"
@@ -36,7 +37,6 @@ import type { PtyTicket } from "@opencode/schema/pty-ticket"
 import type { Reference } from "@opencode/schema/reference"
 import type { Worktree } from "@opencode/schema/worktree"
 import type { Vcs } from "@opencode/schema/vcs"
-import type { FileDiff } from "@opencode/schema/file-diff"
 import type { WebSearch } from "@opencode/schema/websearch"
 import type { Config } from "@opencode/schema/config"

@@ -361,6 +361,15 @@ export type SessionContextInput = { readonly sessionID: Session.ID }
 export type SessionContextOutput = ReadonlyArray<SessionMessage.Info>
 export type SessionContextOperation<E = never> = (input: SessionContextInput) => Effect.Effect<SessionContextOutput, E>

+export type SessionDiffInput = {
+  readonly sessionID: Session.ID
+  readonly from?: SessionMessage.ID | undefined
+  readonly to?: SessionMessage.ID | undefined
+  readonly context?: number | undefined
+}
+export type SessionDiffOutput = ReadonlyArray<FileDiff.Info>
+export type SessionDiffOperation<E = never> = (input: SessionDiffInput) => Effect.Effect<SessionDiffOutput, E>
+
 export type SessionInboxListInput = { readonly sessionID: Session.ID }
 export type SessionInboxListOutput = ReadonlyArray<SessionInbox.Info>
 export type SessionInboxListOperation<E = never> = (
@@ -1150,6 +1159,7 @@ export interface SessionApi<E = never> {
    readonly commit: SessionRevertCommitOperation<E>
  }
  readonly context: SessionContextOperation<E>
+  readonly diff: SessionDiffOperation<E>
  readonly inbox: {
    readonly list: SessionInboxListOperation<E>
    readonly cancel: SessionInboxCancelOperation<E>
@@ -68,6 +68,8 @@ import type {
  SessionRevertCommitOutput,
  SessionContextInput,
  SessionContextOutput,
+  SessionDiffInput,
+  SessionDiffOutput,
  SessionInboxListInput,
  SessionInboxListOutput,
  SessionInboxCancelInput,
@@ -599,6 +601,17 @@ const EndpointSessionContext = (raw: RawClient["server.session"]) => (input: Ses
    ),
  )

+const EndpointSessionDiff = (raw: RawClient["server.session"]) => (input: SessionDiffInput) =>
+  preserveEffect<SessionDiffOutput>()(
+    raw["session.diff"]({
+      params: { sessionID: input["sessionID"] },
+      query: { from: input["from"], to: input["to"], context: input["context"] },
+    }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
 const EndpointSessionInboxList = (raw: RawClient["server.session"]) => (input: SessionInboxListInput) =>
  preserveEffect<SessionInboxListOutput>()(
    raw["session.inbox.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
@@ -738,6 +751,7 @@ const adaptGroupSession = (raw: RawClient["server.session"]) => ({
    commit: EndpointSessionRevertCommit(raw),
  },
  context: EndpointSessionContext(raw),
+  diff: EndpointSessionDiff(raw),
  inbox: {
    list: EndpointSessionInboxList(raw),
    cancel: EndpointSessionInboxCancel(raw),
@@ -62,6 +62,8 @@ import type {
  SessionRevertCommitOutput,
  SessionContextInput,
  SessionContextOutput,
+  SessionDiffInput,
+  SessionDiffOutput,
  SessionInboxListInput,
  SessionInboxListOutput,
  SessionInboxCancelInput,
@@ -849,6 +851,18 @@ export function make(options: ClientOptions) {
          },
          requestOptions,
        ).then((value) => value.data),
+      diff: (input: SessionDiffInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionDiffOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/diff`,
+            query: { from: input["from"], to: input["to"], context: input["context"] },
+            successStatus: 200,
+            declaredStatuses: [400, 401, 404, 500],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
      inbox: {
        list: (input: SessionInboxListInput, requestOptions?: RequestOptions) =>
          request<{ readonly data: SessionInboxListOutput }>(
@@ -147,6 +147,14 @@ export type SessionProviderContextProvenance = {
  endpoint: string
 }

+export type SessionMessageIdle = {
+  id: string
+  metadata?: { [x: string]: JsonValue }
+  time: { created: number }
+  type: "idle"
+  outcome: "succeeded" | "failed" | "interrupted"
+}
+
 export type SessionActive = { type: "running" }

 export type SessionInboxDelivery = "steer" | "queue"
@@ -2210,6 +2218,7 @@ export type SessionMessageInfo =
  | SessionMessageShell
  | SessionMessageAssistant
  | SessionMessageCompaction
+  | SessionMessageIdle

 export type SessionMessageContentUpdated = {
  id: string
@@ -3222,6 +3231,13 @@ export type SessionImportInput = {
              }
            }
        )
+      | {
+          readonly id: string
+          readonly metadata?: { readonly [x: string]: JsonValue }
+          readonly time: { readonly created: number }
+          readonly type: "idle"
+          readonly outcome: "succeeded" | "failed" | "interrupted"
+        }
    >
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
  }["info"]
@@ -3532,6 +3548,13 @@ export type SessionImportInput = {
              }
            }
        )
+      | {
+          readonly id: string
+          readonly metadata?: { readonly [x: string]: JsonValue }
+          readonly time: { readonly created: number }
+          readonly type: "idle"
+          readonly outcome: "succeeded" | "failed" | "interrupted"
+        }
    >
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
  }["messages"]
@@ -3842,6 +3865,13 @@ export type SessionImportInput = {
              }
            }
        )
+      | {
+          readonly id: string
+          readonly metadata?: { readonly [x: string]: JsonValue }
+          readonly time: { readonly created: number }
+          readonly type: "idle"
+          readonly outcome: "succeeded" | "failed" | "interrupted"
+        }
    >
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
  }["location"]
@@ -4331,6 +4361,27 @@ export type SessionContextInput = { readonly sessionID: { readonly sessionID: st

 export type SessionContextOutput = { data: Array<SessionMessageInfo> }["data"]

+export type SessionDiffInput = {
+  readonly sessionID: { readonly sessionID: string }["sessionID"]
+  readonly from?: {
+    readonly from?: string | undefined
+    readonly to?: string | undefined
+    readonly context?: number | undefined
+  }["from"]
+  readonly to?: {
+    readonly from?: string | undefined
+    readonly to?: string | undefined
+    readonly context?: number | undefined
+  }["to"]
+  readonly context?: {
+    readonly from?: string | undefined
+    readonly to?: string | undefined
+    readonly context?: number | undefined
+  }["context"]
+}
+
+export type SessionDiffOutput = { data: Array<FileDiffInfo> }["data"]
+
 export type SessionInboxListInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }

 export type SessionInboxListOutput = { data: Array<SessionInboxInfo> }["data"]
@@ -1028,6 +1028,18 @@ export function createData(config: CreateDataInput) {
          if (currentAssistant) currentAssistant.retry = undefined
        })
        if (event.type === "session.execution.interrupted" && event.data.reason === "shutdown") return
+        // Mirror the projected idle marker so turn boundaries match before the next message read.
+        message.insert(event.data.sessionID, {
+          id: messageIDFromEvent(event.id),
+          type: "idle",
+          outcome:
+            event.type === "session.execution.succeeded"
+              ? "succeeded"
+              : event.type === "session.execution.failed"
+                ? "failed"
+                : "interrupted",
+          time: { created: event.created },
+        })
        // An event can overtake the first read; queue a revalidation when that read is still active.
        if (!store.session.info[event.data.sessionID] && !sync.has(`session:${event.data.sessionID}`)) return
        result.session.invalidate(event.data.sessionID)
@@ -9,6 +9,7 @@ import { AppProcess } from "@opencode/util/process"
 import { makeGlobalNode } from "@opencode/util/effect/app-node"
 import { File } from "./file.js"
 import { KeyedMutex } from "./effect/keyed-mutex.js"
+import { VcsPatch } from "./vcs/patch.js"

 export class Repository extends Schema.Class<Repository>("Git.Repository")({
  worktree: AbsolutePath,
@@ -308,7 +309,7 @@ const layer = Layer.effect(
      operationName: OperationError["operation"],
      repository: Repository,
      args: string[],
-      options?: { stdin?: string; env?: Record<string, string> },
+      options?: { stdin?: string; env?: Record<string, string>; maxOutputBytes?: number },
    ) {
      const result = yield* proc
        .run(
@@ -317,7 +318,7 @@ const layer = Layer.effect(
            env: options?.env,
            extendEnv: true,
          }),
-          { stdin: options?.stdin },
+          { stdin: options?.stdin, maxOutputBytes: options?.maxOutputBytes },
        )
        .pipe(
          Effect.mapError(
@@ -331,7 +332,8 @@ const layer = Layer.effect(
          ),
        )
      const text = result.stdout.toString("utf8")
-      if (result.exitCode === 0) return { text, stderr: result.stderr.toString("utf8") }
+      if (result.exitCode === 0)
+        return { text, stderr: result.stderr.toString("utf8"), truncated: result.stdoutTruncated }
      return yield* new OperationError({
        operation: operationName,
        directory: repository.worktree,
@@ -385,9 +387,7 @@ const layer = Layer.effect(
      maximumUntrackedFileBytes?: number
    }) {
      const list = (args: string[]) =>
-        repositoryOperation("refresh", input.repository, args).pipe(
-          Effect.map((result) => result.text.split("\0").filter(Boolean)),
-        )
+        repositoryOperation("refresh", input.repository, args).pipe(Effect.map((result) => nuls(result.text)))
      const [tracked, untracked] = yield* Effect.all(
        [
          list(["diff-files", "--name-only", "-z", "--", input.scope]),
@@ -464,13 +464,7 @@ const layer = Layer.effect(
          directory: input.repository.worktree,
          message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths",
        })
-      return new Set(
-        result.stdout
-          .toString("utf8")
-          .split("\0")
-          .filter(Boolean)
-          .map((file) => RelativePath.make(file)),
-      )
+      return new Set(nuls(result.stdout.toString("utf8")).map((file) => RelativePath.make(file)))
    })

    const writeTree = Effect.fn("Git.tree.write")(function* (repository: Repository) {
@@ -499,19 +493,23 @@ const layer = Layer.effect(
      to: TreeID
    }) {
      // Undo needs both paths of a rename, not only its destination.
-      return (yield* repositoryOperation("list_files", input.repository, [
-        "diff",
-        "--name-only",
-        "--no-renames",
-        "-z",
-        input.from,
-        input.to,
-      ])).text
-        .split("\0")
-        .filter(Boolean)
-        .map((file) => RelativePath.make(file))
+      return nuls(
+        (yield* repositoryOperation("list_files", input.repository, [
+          "diff",
+          "--name-only",
+          "--no-renames",
+          "-z",
+          input.from,
+          input.to,
+        ])).text,
+      ).map((file) => RelativePath.make(file))
    })

+    /**
+     * Three batched invocations over the tree pair instead of three per file. An
+     * explicit empty selection diffs nothing; an absent one diffs every changed path.
+     * Patch output is capped like VCS diffs: files past the cap get an empty patch.
+     */
    const treeDiff = Effect.fn("Git.tree.diff")(function* (input: {
      repository: Repository
      from: TreeID
@@ -519,49 +517,57 @@ const layer = Layer.effect(
      context?: number
      paths?: readonly RelativePath[]
    }) {
-      const paths = input.paths ?? (yield* treeFiles(input))
-      return yield* Effect.forEach(paths, (file) =>
-        Effect.gen(function* () {
-          const statusText = (yield* repositoryOperation("diff", input.repository, [
+      if (input.paths?.length === 0) return []
+      const args = ["--no-renames", input.from, input.to, "--", ...(input.paths ?? [])]
+      // Patch headers have no -z form: unquoted paths keep chunksByFile matching non-ASCII names.
+      const [names, numbers, patch] = yield* Effect.all(
+        [
+          repositoryOperation("diff", input.repository, ["diff", "--name-status", "-z", ...args]),
+          repositoryOperation("diff", input.repository, ["diff", "--numstat", "-z", ...args]),
+          repositoryOperation(
            "diff",
-            "--name-status",
-            "--no-renames",
-            input.from,
-            input.to,
-            "--",
-            file,
-          ])).text.trim()
-          const status = statusText.startsWith("A") ? "added" : statusText.startsWith("D") ? "deleted" : "modified"
-          const stats = (yield* repositoryOperation("diff", input.repository, [
-            "diff",
-            "--numstat",
-            "--no-renames",
-            input.from,
-            input.to,
-            "--",
-            file,
-          ])).text.split("\t")
-          const binary = stats[0] === "-" || stats[1] === "-"
-          const patch = binary
-            ? ""
-            : (yield* repositoryOperation("diff", input.repository, [
-                "diff",
-                `--unified=${input.context ?? 3}`,
-                "--no-renames",
-                input.from,
-                input.to,
-                "--",
-                file,
-              ])).text
-          return {
-            file,
-            status,
-            additions: binary ? 0 : Number(stats[0] ?? 0),
-            deletions: binary ? 0 : Number(stats[1] ?? 0),
-            patch,
-          } satisfies File.Diff
+            input.repository,
+            ["-c", "core.quotepath=false", "diff", "--no-ext-diff", `--unified=${input.context ?? 3}`, ...args],
+            { maxOutputBytes: VcsPatch.MAX_TOTAL_PATCH_BYTES },
+          ),
+        ],
+        { concurrency: 3 },
+      )
+      const statuses = nuls(names.text)
+      const files = statuses.flatMap((code, index) => {
+        const file = statuses[index + 1]
+        if (index % 2 !== 0 || !file) return []
+        return [
+          {
+            file: RelativePath.make(file),
+            status: code.startsWith("A") ? "added" : code.startsWith("D") ? "deleted" : "modified",
+          } as const,
+        ]
+      })
+      const stats = new Map(
+        nuls(numbers.text).flatMap((line) => {
+          const [additions, deletions, ...file] = line.split("\t")
+          if (!additions || !deletions || file.length === 0) return []
+          return [
+            [
+              file.join("\t"),
+              additions === "-" || deletions === "-"
+                ? { binary: true, additions: 0, deletions: 0 }
+                : { binary: false, additions: Number(additions), deletions: Number(deletions) },
+            ] as const,
+          ]
        }),
      )
+      const patches = VcsPatch.chunksByFile(patch, (index) => files[index]?.file)
+      return files.map((entry) => {
+        const stat = stats.get(entry.file)
+        return {
+          ...entry,
+          additions: stat?.additions ?? 0,
+          deletions: stat?.deletions ?? 0,
+          patch: stat?.binary ? "" : (patches.get(entry.file) ?? VcsPatch.emptyPatch(entry.file)),
+        } satisfies File.Diff
+      })
    })

    const hasEntry = Effect.fnUntraced(function* (repository: Repository, tree: TreeID, file: RelativePath) {
@@ -733,6 +739,11 @@ function execute(cwd: string, proc: AppProcess.Interface, args: string[]) {
    )
 }

+/** Split NUL-terminated git output into its records. */
+function nuls(text: string) {
+  return text.split("\0").filter(Boolean)
+}
+
 function resolvePath(cwd: string, value: string) {
  const trimmed = value.replace(/[\r\n]+$/, "")
  if (!trimmed) return cwd
@@ -55,8 +55,11 @@ import { SessionModelTransport } from "./session/model-transport.js"
 import { llmClient } from "./effect/app-node-platform.js"
 import { Snapshot } from "./snapshot.js"
 import { Session } from "./session/session.js"
+import { SessionDiff, TurnRangeError } from "./session/diff.js"
+import { LocationServiceMap } from "./location-service-map.js"
 import { FSUtil } from "@opencode/util/fs-util"
 import type { EventLog } from "@opencode/schema/event-log"
+import type { FileDiff } from "@opencode/schema/file-diff"
 import { Job } from "./job.js"
 import type { Command } from "./command.js"
 import { SessionEnvironment } from "./session/environment.js"
@@ -109,6 +112,7 @@ export {
 type InboxItemRef = { readonly sessionID: SessionSchema.ID; readonly inboxID: SessionMessage.ID }

 export { DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError }
+export { TurnRangeError }

 export interface Interface {
  readonly list: (input?: ListInput) => Effect.Effect<{
@@ -135,6 +139,13 @@ export interface Interface {
  readonly context: (
    sessionID: SessionSchema.ID,
  ) => Effect.Effect<SessionMessage.Info[], NotFoundError | MessageDecodeError>
+  /** Structured diffs of the files changed by a turn or range of turns; see `SessionDiff.turn`. */
+  readonly diff: (input: {
+    readonly sessionID: SessionSchema.ID
+    readonly from?: SessionMessage.ID
+    readonly to?: SessionMessage.ID
+    readonly context?: number
+  }) => Effect.Effect<readonly FileDiff.Info[], NotFoundError | MessageNotFoundError | TurnRangeError | Snapshot.Error>
  /**
   * Durable admitted session work not yet visible in projected history,
   * ordered by admission. Includes unpromoted user and synthetic inputs and
@@ -227,6 +238,7 @@ const layer = Layer.effect(
    const moves = yield* SessionMove.Service
    const jobs = yield* Job.Service
    const environments = yield* SessionEnvironment.Service
+    const locations = yield* LocationServiceMap.Service
    const sessions = yield* Session.make()
    const isDurableSessionEvent = Schema.is(SessionEvent.Durable)

@@ -359,6 +371,17 @@ const layer = Layer.effect(
        yield* result.get(sessionID)
        return yield* store.context(sessionID)
      }),
+      diff: Effect.fn("Session.diff")(function* (input) {
+        const session = yield* result.get(input.sessionID)
+        const active = yield* execution.isActive(input.sessionID)
+        return yield* SessionDiff.turn(db, locations, {
+          session,
+          active,
+          from: input.from,
+          to: input.to,
+          context: input.context,
+        })
+      }),
      inbox: (sessionID) => sessions.forSession(sessionID).inbox(),
      cancelInbox: (input) => sessions.forSession(input.sessionID).cancelInbox(input.inboxID),
      steerInbox: (input) => sessions.forSession(input.sessionID).steerInbox(input.inboxID),
@@ -448,6 +471,7 @@ export const node: LayerNode.Provider<Service, never, typeof Node.tags.values.gl
    SessionInbox.node,
    SessionMove.node,
    SessionProjector.node,
+    LocationServiceMap.node,
    FSUtil.node,
    App.node,
  ],
@@ -0,0 +1,138 @@
+export * as SessionDiff from "./diff.js"
+
+import { and, asc, eq, gt, inArray, lt, or, sql } from "drizzle-orm"
+import { Context, Effect, Schema } from "effect"
+import { Location } from "@opencode/schema/location"
+import { Database } from "../database/database.js"
+import { LocationServiceMap } from "../location-service-map.js"
+import { Snapshot } from "../snapshot.js"
+import { PATCH_CONTEXT_LINES } from "../vcs/patch.js"
+import { MessageNotFoundError } from "./error.js"
+import { SessionMessage } from "./message.js"
+import { SessionSchema } from "./schema.js"
+import { SessionMessageTable } from "./sql.js"
+
+export class TurnRangeError extends Schema.TaggedError<TurnRangeError>()("Session.TurnRangeError", {
+  sessionID: SessionSchema.ID,
+  field: Schema.Literals(["from", "to"]),
+  message: Schema.String,
+}) {}
+
+const decodeLocation = Schema.decodeUnknownSync(Schema.fromJsonString(Location.Ref))
+
+/**
+ * Diff the files changed by the turn containing a user message. A turn runs from
+ * the first prompt after the Session was last idle until the next idle marker, so
+ * prompts steered in while it was busy belong to the same turn; `to` extends the
+ * range through the turn containing a later user message. Compares the range's
+ * first recorded start snapshot with its last recorded end snapshot; only a step
+ * still running in the active Session compares against the working copy. Like VCS
+ * diffs, an omitted `context` yields full-file patches.
+ *
+ * A Session without any idle marker predates them, so its prompts span until the
+ * next user message instead.
+ *
+ * Snapshot trees live in the repository of the Location that captured them, so a
+ * range spanning a location switch is rejected rather than diffed wrongly.
+ */
+export const turn = Effect.fn("SessionDiff.turn")(function* (
+  db: Database.Interface["db"],
+  locations: Context.Service.Shape<typeof LocationServiceMap.Service>,
+  input: {
+    readonly session: SessionSchema.Info
+    /** The process is currently executing this Session. */
+    readonly active: boolean
+    readonly from?: SessionMessage.ID
+    readonly to?: SessionMessage.ID
+    readonly context?: number
+  },
+) {
+  const sessionID = input.session.id
+  const rows = yield* db
+    .select({ id: SessionMessageTable.id, type: SessionMessageTable.type, seq: SessionMessageTable.seq })
+    .from(SessionMessageTable)
+    .where(
+      and(
+        eq(SessionMessageTable.session_id, sessionID),
+        or(
+          inArray(SessionMessageTable.type, ["user", "idle"]),
+          input.from ? eq(SessionMessageTable.id, input.from) : undefined,
+          input.to ? eq(SessionMessageTable.id, input.to) : undefined,
+        ),
+      ),
+    )
+    .orderBy(asc(SessionMessageTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+  const users = rows.filter((row) => row.type === "user")
+  const markers = rows.filter((row) => row.type === "idle")
+  const resolve = Effect.fn(function* (field: "from" | "to", id: SessionMessage.ID) {
+    const row = rows.find((row) => row.id === id)
+    if (!row) return yield* new MessageNotFoundError({ sessionID, messageID: id })
+    if (row.type !== "user")
+      return yield* new TurnRangeError({ sessionID, field, message: `Message ${id} is not a user message` })
+    return row
+  })
+  const anchor = input.from ? yield* resolve("from", input.from) : users[users.length - 1]
+  if (!anchor) return []
+  const last = input.to ? yield* resolve("to", input.to) : anchor
+  if (last.seq < anchor.seq)
+    return yield* new TurnRangeError({ sessionID, field: "to", message: `Message ${last.id} precedes ${anchor.id}` })
+  // Without any marker, history predates idle markers and a prompt's turn ends at the next prompt.
+  const legacy = markers.length === 0
+  // The turn opens with the first prompt after the previous idle marker; the anchor itself is the latest candidate.
+  const opened = markers.findLast((row) => row.seq < anchor.seq)?.seq ?? -1
+  const start = legacy ? anchor.seq : (users.find((row) => row.seq > opened)?.seq ?? anchor.seq)
+  const end = legacy ? users.find((row) => row.seq > last.seq)?.seq : markers.find((row) => row.seq > last.seq)?.seq
+  const steps = yield* db
+    .select({
+      seq: SessionMessageTable.seq,
+      start: sql<string | null>`json_extract(${SessionMessageTable.data}, '$.snapshot.start')`,
+      end: sql<string | null>`json_extract(${SessionMessageTable.data}, '$.snapshot.end')`,
+      completed: sql<number | null>`json_extract(${SessionMessageTable.data}, '$.time.completed')`,
+    })
+    .from(SessionMessageTable)
+    .where(
+      and(
+        eq(SessionMessageTable.session_id, sessionID),
+        eq(SessionMessageTable.type, "assistant"),
+        gt(SessionMessageTable.seq, start),
+        end === undefined ? undefined : lt(SessionMessageTable.seq, end),
+      ),
+    )
+    .orderBy(asc(SessionMessageTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+  const first = steps[0]
+  const final = steps[steps.length - 1]
+  const from = steps.find((step) => step.start)?.start
+  if (!first || !final || !from) return []
+  const switches = yield* db
+    .select({
+      seq: SessionMessageTable.seq,
+      location: sql<string>`json_extract(${SessionMessageTable.data}, '$.location')`,
+      previous: sql<string | null>`json_extract(${SessionMessageTable.data}, '$.previous.location')`,
+    })
+    .from(SessionMessageTable)
+    .where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "location-switched")))
+    .orderBy(asc(SessionMessageTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+  if (switches.some((row) => row.seq > first.seq && row.seq < final.seq))
+    return yield* new TurnRangeError({ sessionID, field: "to", message: "Turn range spans a location change" })
+  const before = switches.findLast((row) => row.seq < first.seq)?.location
+  const after = switches.find((row) => row.seq > first.seq)?.previous
+  const location = before ? decodeLocation(before) : after ? decodeLocation(after) : input.session.location
+  const recorded = steps.findLast((step) => step.end)?.end
+  return yield* Effect.gen(function* () {
+    const snapshot = yield* Snapshot.Service
+    const running = input.active && final.completed === null
+    const to = running ? ((yield* snapshot.capture()) ?? recorded) : recorded
+    if (!to) return []
+    return yield* snapshot.diff({
+      from: Snapshot.ID.make(from),
+      to: Snapshot.ID.make(to),
+      context: input.context ?? PATCH_CONTEXT_LINES,
+    })
+  }).pipe(Effect.provide(locations.get(location)))
+})
@@ -60,6 +60,21 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
    )
  })

+  const idle = (outcome: SessionMessage.Idle["outcome"]) =>
+    clearCurrentRetry.pipe(
+      Effect.andThen(
+        adapter.appendMessage(
+          SessionMessage.Idle.make({
+            id: SessionMessage.ID.fromEvent(event.id),
+            type: "idle",
+            outcome,
+            metadata: event.metadata,
+            time: { created },
+          }),
+        ),
+      ),
+    )
+
  const project = pipe(
    Match.type<SessionEvent.DurableEvent>(),
    Match.discriminatorsExhaustive("type")({
@@ -124,9 +139,11 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
      "session.inbox.cancelled": () => Effect.void,
      "session.inbox.delivery.changed": () => Effect.void,
      "session.execution.started": () => Effect.void,
-      "session.execution.succeeded": () => clearCurrentRetry,
-      "session.execution.failed": () => clearCurrentRetry,
-      "session.execution.interrupted": () => clearCurrentRetry,
+      "session.execution.succeeded": () => idle("succeeded"),
+      "session.execution.failed": () => idle("failed"),
+      // Shutdown keeps the execution claim and the resumed drain continues the turn.
+      "session.execution.interrupted": (event) =>
+        event.data.reason === "shutdown" ? clearCurrentRetry : idle("interrupted"),
      "session.instructions.updated": (event) => {
        if (event.data.text === undefined) return Effect.void
        return adapter.appendMessage(
@@ -226,6 +226,7 @@ function toLLMMessage(message: SessionMessage.Info, model: Model.Ref, providerMe
  switch (message.type) {
    case "agent-switched":
    case "model-switched":
+    case "idle":
      return []
    case "location-switched":
      return [
@@ -131,38 +131,55 @@ const layer = Layer.effect(
      )
    })

-    const compare = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
+    const comparison = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
      const repo = yield* repository.pipe(Effect.mapError((cause) => failure(operation, cause)))
-      const comparison = {
+      return {
+        source: repo.source,
        repository: repo.snapshotRepository,
        from: Git.TreeID.make(input.from),
        to: Git.TreeID.make(input.to),
      }
-      const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure(operation, cause)))
-      const ignored = yield* git.index
-        .ignored({ repository: repo.source, paths: files })
+    })
+
+    // Snapshots track every scoped file; the source repository's ignore rules decide what callers see.
+    const ignored = Effect.fnUntraced(function* (
+      operation: "files" | "diff",
+      source: Git.Repository,
+      paths: readonly RelativePath[],
+    ) {
+      return yield* git.index
+        .ignored({ repository: source, paths })
        .pipe(Effect.mapError((cause) => failure(operation, cause)))
-      return {
-        input: comparison,
-        files,
-        ignored,
-      }
    })

    const files = Effect.fn("Snapshot.files")(function* (input: CompareInput) {
-      const comparison = yield* compare("files", input)
-      return comparison.files.filter((file) => !comparison.ignored.has(file))
+      const compared = yield* comparison("files", input)
+      const changed = yield* git.tree
+        .files({ repository: compared.repository, from: compared.from, to: compared.to })
+        .pipe(Effect.mapError((cause) => failure("files", cause)))
+      const skipped = yield* ignored("files", compared.source, changed)
+      return changed.filter((file) => !skipped.has(file))
    })

    const diff = Effect.fn("Snapshot.diff")(function* (input: DiffInput) {
-      const comparison = yield* compare("diff", input)
-      return yield* git.tree
+      if (input.paths?.length === 0) return []
+      const compared = yield* comparison("diff", input)
+      // Only an explicit selection becomes a pathspec; ignored paths are dropped from the result instead.
+      const diffs = yield* git.tree
        .diff({
-          ...comparison.input,
+          repository: compared.repository,
+          from: compared.from,
+          to: compared.to,
          context: input.context,
-          paths: (input.paths ?? comparison.files).filter((file) => !comparison.ignored.has(file)),
+          paths: input.paths,
        })
        .pipe(Effect.mapError((cause) => failure("diff", cause)))
+      const skipped = yield* ignored(
+        "diff",
+        compared.source,
+        diffs.map((file) => RelativePath.make(file.file)),
+      )
+      return diffs.filter((file) => !skipped.has(RelativePath.make(file.file)))
    })

    const plan = Effect.fnUntraced(function* (worktree: AbsolutePath, input: RestoreInput) {
@@ -6,6 +6,7 @@ import { Effect } from "effect"
 import { LayerNode } from "@opencode/util/effect/layer-node"
 import { Git } from "@opencode/core/git"
 import { AbsolutePath, RelativePath } from "@opencode/core/schema"
+import { VcsPatch } from "@opencode/core/vcs/patch"
 import { branch, commit, initRepo, read, withRemote } from "./fixture/git"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
@@ -196,6 +197,42 @@ describe("Git trees", () => {
    }),
  )

+  it.live("caps batched tree patches, keeps per-file stats past the cap, and matches non-ASCII names", () =>
+    Effect.gen(function* () {
+      const root = yield* Effect.acquireRelease(
+        Effect.promise(() => tmpdir()),
+        (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+      )
+      yield* Effect.promise(() => initRepo(root.path))
+      const git = yield* Git.Service
+      const repository = yield* git.repo.discover(AbsolutePath.make(root.path))
+      if (!repository) throw new Error("Repository not found")
+      const before = yield* git.tree.capture({ repository, scopes: [RelativePath.make(".")] })
+      const lines = Math.ceil(VcsPatch.MAX_TOTAL_PATCH_BYTES / 80) + 1
+      yield* Effect.promise(async () => {
+        await Bun.write(path.join(root.path, "a-small.txt"), "small\n")
+        await Bun.write(path.join(root.path, "b-large.txt"), `${"x".repeat(79)}\n`.repeat(lines))
+        await Bun.write(path.join(root.path, "c-binary.bin"), new Uint8Array([0, 1, 2, 3]))
+        await Bun.write(path.join(root.path, "a-caf\u00e9.txt"), "caf\u00e9\n")
+      })
+      const after = yield* git.tree.capture({ repository, scopes: [RelativePath.make(".")] })
+
+      const diffs = yield* git.tree.diff({ repository, from: before, to: after, context: 0 })
+      expect(diffs.map((item) => [item.file, item.status, item.additions, item.deletions])).toEqual([
+        ["a-caf\u00e9.txt", "added", 1, 0],
+        ["a-small.txt", "added", 1, 0],
+        ["b-large.txt", "added", lines, 0],
+        ["c-binary.bin", "added", 0, 0],
+      ])
+      // Patch headers are not NUL-delimited; a quoted (octal-escaped) header would orphan this chunk.
+      expect(diffs[0]?.patch).toContain("+caf\u00e9\n")
+      expect(diffs[1]?.patch).toContain("+small\n")
+      expect(diffs[2]?.patch).toBe(VcsPatch.emptyPatch("b-large.txt"))
+      expect(diffs[3]?.patch).toBe("")
+      expect(yield* git.tree.diff({ repository, from: before, to: after, paths: [] })).toEqual([])
+    }),
+  )
+
  it.live("captures, compares, previews, and restores scoped trees", () =>
    Effect.gen(function* () {
      const root = yield* Effect.acquireRelease(
@@ -0,0 +1,198 @@
+import { $ } from "bun"
+import { describe, expect } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { Effect } from "effect"
+import { Agent } from "@opencode/core/agent"
+import { Bus } from "@opencode/core/bus"
+import { Database } from "@opencode/core/database/database"
+import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder"
+import { LocationServiceMap } from "@opencode/core/location-service-map"
+import { Model } from "@opencode/core/model"
+import { Plugin } from "@opencode/core/plugin"
+import { Provider } from "@opencode/core/provider"
+import { AbsolutePath } from "@opencode/core/schema"
+import { Session } from "@opencode/core/session"
+import { SessionDiff } from "@opencode/core/session/diff"
+import { SessionEvent } from "@opencode/core/session/event"
+import { SessionExecution } from "@opencode/core/session/execution"
+import { SessionInbox } from "@opencode/core/session/inbox"
+import { SessionMessage } from "@opencode/core/session/message"
+import { SessionProjector } from "@opencode/core/session/projector"
+import { Snapshot } from "@opencode/core/snapshot"
+import { Money } from "@opencode/schema/money"
+import { LayerNode } from "@opencode/util/effect/layer-node"
+import { Global } from "@opencode/util/global"
+import { tempGlobalLayer } from "./fixture/global"
+import { offlineModels } from "./fixture/models"
+import { tmpdirScoped } from "./fixture/tmpdir"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(
+  AppNodeBuilder.build(
+    LayerNode.group([Database.node, Bus.node, SessionProjector.node, Session.node, LocationServiceMap.node]),
+    [Global.node.replace(tempGlobalLayer), SessionExecution.node.replace(SessionExecution.noopLayer), offlineModels],
+  ),
+)
+
+const summarize = (file: { file: string; status: string; additions: number; deletions: number }) => [
+  file.file,
+  file.status,
+  file.additions,
+  file.deletions,
+]
+
+describe("Session.diff", () => {
+  it.live(
+    "diffs the busy period containing a user message and ranges across later turns",
+    () =>
+      Effect.gen(function* () {
+        const tmp = yield* tmpdirScoped()
+        const directory = path.join(tmp.path, "project")
+        const write = (name: string, content: string) => () => Bun.write(path.join(directory, name), content)
+        yield* Effect.promise(async () => {
+          await fs.mkdir(directory)
+          await write("first.txt", "first\n")()
+          await write("second.txt", "second\n")()
+          await write("manual.txt", "manual\n")()
+          await $`git init -q`.cwd(directory).quiet()
+          await $`git -c core.fsmonitor=false add .`.cwd(directory).quiet()
+        })
+        const sessions = yield* Session.Service
+        const database = yield* Database.Service
+        const bus = yield* Bus.Service
+        const locations = yield* LocationServiceMap.Service
+        const created = yield* sessions.create({ location: { directory: AbsolutePath.make(directory) } })
+        const diff = (input?: { from?: SessionMessage.ID; to?: SessionMessage.ID }) =>
+          sessions
+            .diff({ sessionID: created.id, context: 0, ...input })
+            .pipe(Effect.map((files) => files.map(summarize)))
+        expect(yield* diff()).toEqual([])
+
+        yield* Effect.gen(function* () {
+          const plugins = yield* Plugin.Service
+          yield* plugins.awaitActivation
+          const snapshot = yield* Snapshot.Service
+          const usage = {
+            cost: Money.USD.zero,
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          }
+          const prompt = Effect.fn(function* (text: string) {
+            const admitted = yield* sessions.prompt({ sessionID: created.id, text, resume: false })
+            yield* SessionInbox.promote(database.db, bus, created.id, "steer")
+            return admitted.id
+          })
+          const step = Effect.fn(function* (edit: () => Promise<unknown>, end: "recorded" | "unrecorded" | "running") {
+            const before = yield* snapshot.capture()
+            if (!before) throw new Error("Start snapshot missing")
+            const assistantMessageID = SessionMessage.ID.create()
+            yield* bus.publish(SessionEvent.Step.Started, {
+              sessionID: created.id,
+              assistantMessageID,
+              agent: Agent.defaultID,
+              model: { id: Model.ID.make("test-model"), providerID: Provider.ID.make("test-provider") },
+              snapshot: before,
+            })
+            yield* Effect.promise(edit)
+            if (end === "running") return assistantMessageID
+            const after = end === "recorded" ? yield* snapshot.capture() : undefined
+            yield* bus.publish(SessionEvent.Step.Ended, {
+              sessionID: created.id,
+              assistantMessageID,
+              finish: "stop",
+              ...usage,
+              snapshot: after,
+              files: after && before ? yield* snapshot.files({ from: before, to: after }) : undefined,
+            })
+            return assistantMessageID
+          })
+
+          const idle = (outcome: "succeeded" | "failed") =>
+            outcome === "succeeded"
+              ? bus.publish(SessionEvent.Execution.Succeeded, { sessionID: created.id })
+              : bus.publish(SessionEvent.Execution.Failed, {
+                  sessionID: created.id,
+                  error: { type: "unknown", message: "failed" },
+                })
+
+          // Before any idle marker exists, a prompt's turn ends at the next prompt.
+          const first = yield* prompt("Edit the first file")
+          const firstStep = yield* step(write("first.txt", "first edited\n"), "recorded")
+          // Edits made while idle are not a turn's work, but a range spanning them still sees them.
+          yield* Effect.promise(write("manual.txt", "manual edited\n"))
+          const second = yield* prompt("Edit the second file")
+          yield* step(write("second.txt", "second edited\n"), "recorded")
+          expect(yield* diff()).toEqual([["second.txt", "modified", 1, 1]])
+          expect(yield* diff({ from: first })).toEqual([["first.txt", "modified", 1, 1]])
+
+          // Once markers exist, a turn spans a whole busy period, steers included; earlier history merges into the first one.
+          yield* idle("succeeded")
+          const third = yield* prompt("Add a third file")
+          yield* step(write("third.txt", "third\n"), "recorded")
+          const steer = yield* prompt("Also add a fourth file")
+          yield* step(write("fourth.txt", "fourth\n"), "recorded")
+          yield* idle("failed")
+          const busy = [
+            ["fourth.txt", "added", 1, 0],
+            ["third.txt", "added", 1, 0],
+          ]
+          expect(yield* diff()).toEqual(busy)
+          expect(yield* diff({ from: steer })).toEqual(busy)
+          expect(yield* diff({ from: second })).toEqual([
+            ["first.txt", "modified", 1, 1],
+            ["manual.txt", "modified", 1, 1],
+            ["second.txt", "modified", 1, 1],
+          ])
+          expect(yield* diff({ from: first, to: third })).toEqual([
+            ["first.txt", "modified", 1, 1],
+            ["fourth.txt", "added", 1, 0],
+            ["manual.txt", "modified", 1, 1],
+            ["second.txt", "modified", 1, 1],
+            ["third.txt", "added", 1, 0],
+          ])
+          const full = yield* sessions.diff({ sessionID: created.id, from: first })
+          expect(full[0]?.patch).toContain("-first\n+first edited\n")
+          expect(yield* diff({ from: steer, to: second }).pipe(Effect.flip)).toMatchObject({
+            _tag: "Session.TurnRangeError",
+            field: "to",
+          })
+          expect(yield* diff({ from: firstStep }).pipe(Effect.flip)).toMatchObject({
+            _tag: "Session.TurnRangeError",
+            field: "from",
+          })
+          expect(yield* diff({ from: SessionMessage.ID.create() }).pipe(Effect.flip)).toMatchObject({
+            _tag: "Session.MessageNotFoundError",
+          })
+
+          // A completed step without an end snapshot falls back to the last recorded end.
+          yield* prompt("Edit both files again")
+          yield* step(write("first.txt", "first edited twice\n"), "recorded")
+          yield* step(write("second.txt", "second edited twice\n"), "unrecorded")
+          yield* idle("succeeded")
+          expect(yield* diff()).toEqual([["first.txt", "modified", 1, 1]])
+
+          // Only a step still running in the active session compares against the working copy.
+          yield* prompt("Delete the manual file")
+          yield* step(() => fs.rm(path.join(directory, "manual.txt")), "running")
+          expect(yield* diff()).toEqual([])
+          const session = yield* sessions.get(created.id)
+          const live = yield* SessionDiff.turn(database.db, locations, { session, active: true, context: 0 })
+          expect(live.map(summarize)).toEqual([["manual.txt", "deleted", 0, 1]])
+
+          // Reverting removes later history, markers included; a fork keeps the copied turns.
+          yield* sessions.revert.stage({ sessionID: created.id, messageID: steer, files: false })
+          yield* sessions.revert.commit(created.id)
+          expect(yield* diff()).toEqual([["third.txt", "added", 1, 0]])
+          expect(yield* diff({ from: steer }).pipe(Effect.flip)).toMatchObject({
+            _tag: "Session.MessageNotFoundError",
+          })
+          const forked = yield* sessions.fork({ sessionID: created.id, boundary: { type: "through" } })
+          expect((yield* sessions.diff({ sessionID: forked.id, context: 0 })).map(summarize)).toEqual([
+            ["third.txt", "added", 1, 0],
+          ])
+        }).pipe(Effect.provide(LocationServiceMap.Service.get(created.location)))
+      }),
+    // Real Location/plugin startup and Git snapshots can exceed five seconds under CI load.
+    { timeout: 30_000 },
+  )
+})
@@ -561,7 +561,9 @@ describe("SessionRestart background recovery", () => {
        expect(yield* restarted.pendingBackground).toEqual([])
        expect(yield* SessionInbox.list(database.db, sessionID)).toHaveLength(delivered ? 0 : 1)
        yield* SessionInbox.promote(database.db, bus, sessionID, "steer")
-        expect(yield* sessions.messages({ sessionID })).toMatchObject([
+        // Recovery ends a busy period, so an idle marker follows the notification.
+        const messages = (yield* sessions.messages({ sessionID })).filter((message) => message.type !== "idle")
+        expect(messages).toMatchObject([
          {
            id: background.notificationID,
            type: "synthetic",
@@ -569,7 +571,6 @@ describe("SessionRestart background recovery", () => {
            metadata: { state: "completed" },
          },
        ])
-        expect(yield* sessions.messages({ sessionID })).toHaveLength(1)
      }),
    )
  }
@@ -3242,6 +3242,152 @@
        "summary": "Get session context"
      }
    },
+    "/api/session/{sessionID}/diff": {
+      "get": {
+        "tags": ["session"],
+        "operationId": "v2.session.diff",
+        "parameters": [
+          {
+            "name": "sessionID",
+            "in": "path",
+            "schema": {
+              "type": "string",
+              "pattern": "^ses"
+            },
+            "required": true
+          },
+          {
+            "name": "from",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "pattern": "^msg_"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "User message whose turn to diff. Defaults to the turn of the newest user message."
+            },
+            "required": false
+          },
+          {
+            "name": "to",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "pattern": "^msg_"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Later user message whose turn ends the range. Defaults to the turn of `from` alone."
+            },
+            "required": false
+          },
+          {
+            "name": "context",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Unchanged lines around each hunk. Omit for full-file patches."
+            },
+            "required": false
+          }
+        ],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/components/schemas/FileDiff.Info"
+                      }
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "MessageNotFoundError | SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/MessageNotFoundErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "UnknownError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnknownErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Structured per-file diffs of the files a turn changed. A turn runs from the first prompt after the session was last idle until its next idle marker, so prompts steered in while it was busy belong to the same turn; `to` extends the range through a later turn. Compares the range's first recorded snapshot with its last; a step still running in the active session compares against the working copy. Ranges that span a location change are rejected. In sessions without any idle marker, a prompt's turn spans until the next user message.",
+        "summary": "Diff session turns"
+      }
+    },
    "/api/session/{sessionID}/inbox": {
      "get": {
        "tags": ["session"],
@@ -18421,6 +18567,38 @@
        "required": ["type", "id", "time", "status", "reason", "summary", "recent"],
        "additionalProperties": false
      },
+      "Session.Message.Idle": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^msg_"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "time": {
+            "type": "object",
+            "properties": {
+              "created": {
+                "type": "number"
+              }
+            },
+            "required": ["created"],
+            "additionalProperties": false
+          },
+          "type": {
+            "type": "string",
+            "enum": ["idle"]
+          },
+          "outcome": {
+            "type": "string",
+            "enum": ["succeeded", "failed", "interrupted"]
+          }
+        },
+        "required": ["id", "time", "type", "outcome"],
+        "additionalProperties": false
+      },
      "Session.Message.Info": {
        "anyOf": [
          {
@@ -18452,6 +18630,9 @@
          },
          {
            "$ref": "#/components/schemas/Session.Message.Compaction"
+          },
+          {
+            "$ref": "#/components/schemas/Session.Message.Idle"
          }
        ]
      },
@@ -31,6 +31,7 @@ import { Permission } from "@opencode/schema/permission"
 import { Location } from "@opencode/schema/location"
 import { SessionEvent } from "@opencode/schema/session-event"
 import { EventLog } from "@opencode/schema/event-log"
+import { FileDiff } from "@opencode/schema/file-diff"

 const ParentIDFilter = Schema.Union([
  Session.ID,
@@ -523,6 +524,31 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
        }),
      ),
    )
+    .add(
+      HttpApiEndpoint.get("session.diff", "/api/session/:sessionID/diff", {
+        params: { sessionID: Session.ID },
+        query: Schema.Struct({
+          from: Schema.optional(SessionMessage.ID).annotate({
+            description: "User message whose turn to diff. Defaults to the turn of the newest user message.",
+          }),
+          to: Schema.optional(SessionMessage.ID).annotate({
+            description: "Later user message whose turn ends the range. Defaults to the turn of `from` alone.",
+          }),
+          context: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional).annotate({
+            description: "Unchanged lines around each hunk. Omit for full-file patches.",
+          }),
+        }),
+        success: Schema.Struct({ data: Schema.Array(FileDiff.Info) }),
+        error: [InvalidRequestError, MessageNotFoundError, SessionNotFoundError, UnknownError],
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.session.diff",
+          summary: "Diff session turns",
+          description:
+            "Structured per-file diffs of the files a turn changed. A turn runs from the first prompt after the session was last idle until its next idle marker, so prompts steered in while it was busy belong to the same turn; `to` extends the range through a later turn. Compares the range's first recorded snapshot with its last; a step still running in the active session compares against the working copy. Ranges that span a location change are rejected. In sessions without any idle marker, a prompt's turn spans until the next user message.",
+        }),
+      ),
+    )
    .add(
      HttpApiEndpoint.get("session.inbox.list", "/api/session/:sessionID/inbox", {
        params: { sessionID: Session.ID },
@@ -280,6 +280,18 @@ export const Compaction = Schema.Union([CompactionRunning, CompactionCompleted,
 )
 export type Compaction = CompactionRunning | CompactionCompleted | CompactionFailed

+/**
+ * Marks the Session going idle: every step since the previous marker belongs to
+ * one turn, including prompts steered in while it was busy. A shutdown does not
+ * record one, since the resumed execution continues the same turn.
+ */
+export interface Idle extends Schema.Schema.Type<typeof Idle> {}
+export const Idle = Schema.Struct({
+  ...Base,
+  type: Schema.tag("idle"),
+  outcome: Schema.Literals(["succeeded", "failed", "interrupted"]),
+}).annotate({ identifier: "Session.Message.Idle" })
+
 export const Info = Schema.Union([
  AgentSelected,
  ModelSelected,
@@ -291,6 +303,7 @@ export const Info = Schema.Union([
  Shell,
  Assistant,
  Compaction,
+  Idle,
 ]).annotate({ identifier: "Session.Message.Info" })
 export type Info =
  | AgentSelected
@@ -303,4 +316,5 @@ export type Info =
  | Shell
  | Assistant
  | Compaction
+  | Idle
 export type Type = Info["type"]
@@ -1,5 +1,6 @@
 import { Session } from "@opencode/core/session"
-import { SessionNotFoundError, UnknownError } from "@opencode/protocol/errors"
+import type { Snapshot } from "@opencode/core/snapshot"
+import { MessageNotFoundError, SessionNotFoundError, UnknownError } from "@opencode/protocol/errors"
 import { Effect } from "effect"

 export function missingSession(error: Session.NotFoundError) {
@@ -9,6 +10,14 @@ export function missingSession(error: Session.NotFoundError) {
  })
 }

+export function missingMessage(error: Session.MessageNotFoundError) {
+  return new MessageNotFoundError({
+    sessionID: error.sessionID,
+    messageID: error.messageID,
+    message: `Message not found: ${error.messageID}`,
+  })
+}
+
 export function failedMessageDecode(error: Session.MessageDecodeError) {
  const ref = `err_${crypto.randomUUID().slice(0, 8)}`
  return Effect.logError("failed to decode session message").pipe(
@@ -18,3 +27,16 @@ export function failedMessageDecode(error: Session.MessageDecodeError) {
    ),
  )
 }
+
+/** Snapshot repositories are host state clients cannot repair, so surface only a log reference. */
+export function failedSnapshot(operation: string, sessionID: Session.ID) {
+  return (error: Snapshot.Error) => {
+    const ref = `err_${crypto.randomUUID().slice(0, 8)}`
+    return Effect.logError(`failed to ${operation}`, { cause: error }).pipe(
+      Effect.annotateLogs({ ref, sessionID }),
+      Effect.andThen(
+        Effect.fail(new UnknownError({ message: "Unexpected server error. Check server logs for details.", ref })),
+      ),
+    )
+  }
+}
@@ -17,10 +17,9 @@ import {
  ServiceUnavailableError,
  SessionBusyError,
  SkillNotFoundError,
-  UnknownError,
 } from "@opencode/protocol/errors"
 import { AbsolutePath } from "@opencode/core/schema"
-import { failedMessageDecode, missingSession } from "./session-error"
+import { failedMessageDecode, failedSnapshot, missingMessage, missingSession } from "./session-error"

 const DefaultSessionsLimit = 50

@@ -213,15 +212,7 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
          return {
            data: yield* session.fork({ sessionID: ctx.params.sessionID, boundary: ctx.payload.boundary }).pipe(
              Effect.catchTag("Session.NotFoundError", missingSession),
-              Effect.catchTag(
-                "Session.MessageNotFoundError",
-                (error) =>
-                  new MessageNotFoundError({
-                    sessionID: error.sessionID,
-                    messageID: error.messageID,
-                    message: `Message not found: ${error.messageID}`,
-                  }),
-              ),
+              Effect.catchTag("Session.MessageNotFoundError", missingMessage),
              Effect.catchTag(
                "Session.ForkEmptyError",
                (error) => new InvalidRequestError({ message: error.message, kind: "empty_session" }),
@@ -449,32 +440,14 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
            files: ctx.payload.files,
          })
          return {
-            data: yield* session.revert.stage({ ...ctx.params, ...ctx.payload }).pipe(
-              Effect.catchTag("Session.NotFoundError", missingSession),
-              Effect.catchTag(
-                "Session.MessageNotFoundError",
-                (error) =>
-                  new MessageNotFoundError({
-                    sessionID: error.sessionID,
-                    messageID: error.messageID,
-                    message: `Message not found: ${error.messageID}`,
-                  }),
+            data: yield* session.revert
+              .stage({ ...ctx.params, ...ctx.payload })
+              .pipe(
+                Effect.catchTag("Session.NotFoundError", missingSession),
+                Effect.catchTag("Session.MessageNotFoundError", missingMessage),
+                Effect.catchTag("Session.BusyError", busySession),
+                Effect.catchTag("Snapshot.Error", failedSnapshot("stage session revert", ctx.params.sessionID)),
              ),
-              Effect.catchTag("Session.BusyError", busySession),
-              Effect.catchTag("Snapshot.Error", (error) => {
-                const ref = `err_${crypto.randomUUID().slice(0, 8)}`
-                return Effect.logError("failed to stage session revert", { cause: error }).pipe(
-                  Effect.andThen(
-                    Effect.fail(
-                      new UnknownError({
-                        message: "Unexpected server error. Check server logs for details.",
-                        ref,
-                      }),
-                    ),
-                  ),
-                )
-              }),
-            ),
          }
        }),
      )
@@ -482,23 +455,13 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
        "session.revert.clear",
        Effect.fn(function* (ctx) {
          yield* Effect.log("session.revert.clear", { sessionID: ctx.params.sessionID })
-          yield* session.revert.clear(ctx.params.sessionID).pipe(
-            Effect.catchTag("Session.NotFoundError", missingSession),
-            Effect.catchTag("Session.BusyError", busySession),
-            Effect.catchTag("Snapshot.Error", (error) => {
-              const ref = `err_${crypto.randomUUID().slice(0, 8)}`
-              return Effect.logError("failed to clear session revert", { cause: error }).pipe(
-                Effect.andThen(
-                  Effect.fail(
-                    new UnknownError({
-                      message: "Unexpected server error. Check server logs for details.",
-                      ref,
-                    }),
-                  ),
-                ),
-              )
-            }),
-          )
+          yield* session.revert
+            .clear(ctx.params.sessionID)
+            .pipe(
+              Effect.catchTag("Session.NotFoundError", missingSession),
+              Effect.catchTag("Session.BusyError", busySession),
+              Effect.catchTag("Snapshot.Error", failedSnapshot("clear session revert", ctx.params.sessionID)),
+            )
          return HttpApiSchema.NoContent.make()
        }),
      )
@@ -528,6 +491,22 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
          }
        }),
      )
+      .handle(
+        "session.diff",
+        Effect.fn(function* (ctx) {
+          return {
+            data: yield* session.diff({ sessionID: ctx.params.sessionID, ...ctx.query }).pipe(
+              Effect.catchTag("Session.NotFoundError", missingSession),
+              Effect.catchTag("Session.MessageNotFoundError", missingMessage),
+              Effect.catchTag(
+                "Session.TurnRangeError",
+                (error) => new InvalidRequestError({ message: error.message, field: error.field }),
+              ),
+              Effect.catchTag("Snapshot.Error", failedSnapshot("diff session turn", ctx.params.sessionID)),
+            ),
+          }
+        }),
+      )
      .handle(
        "session.inbox.list",
        Effect.fn(function* (ctx) {
@@ -0,0 +1,98 @@
+import { expect, setDefaultTimeout } from "bun:test"
+import { Agent } from "@opencode/core/agent"
+import { Bus } from "@opencode/core/bus"
+import { Model } from "@opencode/core/model"
+import { Provider } from "@opencode/core/provider"
+import { Session } from "@opencode/core/session"
+import { SessionEvent } from "@opencode/core/session/event"
+import { SessionExecution } from "@opencode/core/session/execution"
+import { SessionMessage } from "@opencode/core/session/message"
+import { Money } from "@opencode/schema/money"
+import { makeGlobalNode } from "@opencode/util/effect/app-node"
+import { Effect, Layer } from "effect"
+import { tmpdir } from "../../core/test/fixture/tmpdir"
+import { it } from "../../core/test/lib/effect"
+import { ServerFetch } from "../src/fetch"
+
+setDefaultTimeout(30_000)
+
+it.live("serves turn diffs by user message with range validation", () =>
+  Effect.gen(function* () {
+    const tmp = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-session-diff-")))
+    const ids = { user: SessionMessage.ID.create(), assistant: SessionMessage.ID.create() }
+    // Deliver the prompt and one step the way the runner would, without a model.
+    const execution = Layer.effect(
+      SessionExecution.Service,
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        return SessionExecution.Service.of({
+          active: Effect.succeed(new Set()),
+          isActive: () => Effect.succeed(false),
+          resume: () => Effect.void,
+          wake: (sessionID) =>
+            Effect.gen(function* () {
+              yield* bus.publish(SessionEvent.InboxDelivered, { sessionID, inboxID: ids.user })
+              yield* bus.publish(SessionEvent.Step.Started, {
+                sessionID,
+                assistantMessageID: ids.assistant,
+                agent: Agent.defaultID,
+                model: { id: Model.ID.make("model"), providerID: Provider.ID.make("provider") },
+              })
+              yield* bus.publish(SessionEvent.Step.Ended, {
+                sessionID,
+                assistantMessageID: ids.assistant,
+                finish: "stop",
+                cost: Money.USD.zero,
+                tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+              })
+            }),
+          interrupt: () => Effect.succeed(false),
+          awaitIdle: () => Effect.void,
+        })
+      }),
+    )
+    const handler = yield* ServerFetch.make(
+      {
+        app: { version: "test-version" },
+        database: { path: ":memory:" },
+        fs: { filewatcher: false },
+        models: { fetch: false },
+      },
+      {
+        overrides: [
+          SessionExecution.node.replace(
+            makeGlobalNode({ service: SessionExecution.Service, layer: execution, deps: [Bus.node] }),
+          ),
+        ],
+      },
+    )
+    const request = (path: string, body?: unknown) =>
+      Effect.promise(async () => {
+        const response = await handler(
+          new Request(`http://opencode.local${path}`, {
+            method: body === undefined ? "GET" : "POST",
+            headers: body === undefined ? undefined : { "content-type": "application/json" },
+            body: body === undefined ? undefined : JSON.stringify(body),
+          }),
+        )
+        return { status: response.status, body: (await response.json()) as Record<string, unknown> }
+      })
+    const created = yield* request("/api/session", { location: { directory: tmp.path } })
+    const sessionID = Session.ID.make((created.body.data as { id: string }).id)
+    const diff = (query = "") => request(`/api/session/${sessionID}/diff${query}`)
+
+    expect(yield* diff()).toEqual({ status: 200, body: { data: [] } })
+    expect((yield* request(`/api/session/${sessionID}/prompt`, { id: ids.user, text: "prompt" })).status).toBe(200)
+    // Not a git repository, so steps record no snapshots and the turn has no diff.
+    expect(yield* diff(`?from=${ids.user}&context=3`)).toEqual({ status: 200, body: { data: [] } })
+    expect(yield* diff(`?from=${ids.assistant}`)).toMatchObject({
+      status: 400,
+      body: { _tag: "InvalidRequestError", field: "from" },
+    })
+    expect(yield* diff(`?from=${SessionMessage.ID.create()}`)).toMatchObject({
+      status: 404,
+      body: { _tag: "MessageNotFoundError" },
+    })
+    expect((yield* request(`/api/session/${Session.ID.create()}/diff`)).status).toBe(404)
+  }),
+)
@@ -16,7 +16,7 @@ export { TimelineRow, type PartGroup, type PartRef, type TimelineRowMap }

 export type ReasoningMode = "hidden" | "compact" | "full"

-type Notice = Exclude<SessionMessageInfo, { type: "user" | "assistant" | "shell" }>
+type Notice = Exclude<SessionMessageInfo, { type: "user" | "assistant" | "shell" | "idle" }>
 type Entry = { type: "assistant"; message: SessionMessageAssistant } | { type: "notice"; message: Notice }
 type Content = SessionMessageAssistant["content"][number]
 type GroupRow = Extract<TimelineRow.TimelineRow, { _tag: "AssistantPart" }>
@@ -763,7 +763,8 @@ function record(value: unknown): value is Record<string, unknown> {
 }

 function isNotice(message: SessionMessageInfo): message is Notice {
-  if (message.type === "user" || message.type === "assistant" || message.type === "shell") return false
+  if (message.type === "user" || message.type === "assistant" || message.type === "shell" || message.type === "idle")
+    return false
  if (message.type !== "synthetic") return true
  return !!message.description?.trim() || timelineNoticeRequired(message)
 }
@@ -285,8 +285,6 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
      )
      renderer.once("destroy", () => shutdown.openUnsafe())
      yield* Effect.tryPromise(async () => {
-        // Prewarm palette before ThemeProvider mounts so `system` theme avoids a first-paint fallback flash.
-        void renderer.getPalette({ size: 16 }).catch(() => undefined)
        const mode = handoff?.mode ?? (await renderer.waitForThemeMode(1000)) ?? "dark"
        if (renderer.isDestroyed) return

@@ -484,7 +482,7 @@ function App(props: { pair?: DialogPairCredentials }) {
  const toast = useToast()
  const updater = useUpdateNotification()
  const theme = useTheme()
-  const { mode, supports, setMode, locked, lock, unlock } = useThemes()
+  const { mode, supports, setMode, locked, lock, unlock, afterPaint } = useThemes()
  const data = useData()
  const location = useLocation()
  const exit = useExit()
@@ -492,6 +490,16 @@ function App(props: { pair?: DialogPairCredentials }) {
  const plugins = usePlugin()
  const clipboard = useClipboard()
  const terminalEnvironment = useTuiTerminalEnvironment()
+  let paletteTimer: ReturnType<typeof setTimeout> | undefined
+  const afterFrame = () => {
+    // The native writer can still be flushing the frame when FRAME fires. Keep OSC probes behind visible app output.
+    paletteTimer = setTimeout(afterPaint, 50)
+  }
+  onMount(() => renderer.once(CliRenderEvents.FRAME, afterFrame))
+  onCleanup(() => {
+    renderer.off(CliRenderEvents.FRAME, afterFrame)
+    if (paletteTimer) clearTimeout(paletteTimer)
+  })
  createEffect(() => {
    if (client.connection.status() !== "connected") return
    if (route.data.type !== "session") return
@@ -139,3 +139,7 @@ export function useStorage() {
  if (!storage) throw new Error("StorageProvider is missing")
  return storage
 }
+
+export function useStorageOptional() {
+  return useContext(Context)
+}
@@ -24,10 +24,11 @@ import {
 import { generateSystem, terminalMode } from "../theme/system"
 import { discoverThemes } from "../theme/discovery"
 import { createComponentTheme, createComponentThemeView, type ComponentTheme } from "../theme/component"
-import { createEffect, createMemo, onCleanup, onMount, type Accessor, type ParentProps } from "solid-js"
+import { createEffect, createMemo, createSignal, onCleanup, onMount, type Accessor, type ParentProps } from "solid-js"
 import { createStore, produce } from "solid-js/store"
 import { createSimpleContext } from "./helper"
 import { useConfig } from "../config"
+import { useStorageOptional } from "./storage"
 import { DevTools } from "../devtools"
 import { configDirectories } from "../util/config-directories"

@@ -94,7 +95,6 @@ export {
 const THEME_REFRESH_DELAYS = [250, 1000] as const

 type State = {
-  themes: Record<string, ThemeDocumentSource>
  mode: "dark" | "light"
  lock: "dark" | "light" | undefined
  active: string
@@ -116,6 +116,7 @@ type Themes = {
  unlock(): void
  setMode(mode?: "dark" | "light", persist?: boolean): boolean
  set(theme: string): boolean
+  afterPaint(): void
  onError(handler: ThemeErrorHandler): () => void
  readonly ready: boolean
 }
@@ -127,14 +128,14 @@ type ThemeContextValue = {
 }

 const [store, setStore] = createStore<State>({
-  themes: allThemes(),
  mode: "dark",
  lock: undefined,
  active: "opencode",
  ready: false,
 })
+const [themeSources, setThemeSources] = createSignal(allThemes())

-subscribeThemes((themes) => setStore("themes", themes))
+subscribeThemes(setThemeSources)

 const themeContext = createSimpleContext({
  name: "Theme",
@@ -143,19 +144,15 @@ const themeContext = createSimpleContext({
    const configState = useConfig()
    const config = configState.data
    const themes = props.source
-    const pick = (value: unknown) => {
-      if (value === "dark" || value === "light") return value
-      return
-    }
+    const cache = useStorageOptional()?.store<{ colors?: TerminalColors }>("system-theme", { initial: {} })

    setStore(
      produce((draft) => {
-        const lock = pick(config.theme?.mode)
-        const mode = lock ?? pick(renderer.themeMode) ?? props.mode
+        const lock = config.theme?.mode === "dark" || config.theme?.mode === "light" ? config.theme.mode : undefined
+        const mode = lock ?? renderer.themeMode ?? props.mode
        draft.mode = mode
        draft.lock = lock
-        const active = config.theme?.name ?? "opencode"
-        draft.active = typeof active === "string" ? active : "opencode"
+        draft.active = config.theme?.name ?? "opencode"
        draft.ready = false
      }),
    )
@@ -184,70 +181,68 @@ const themeContext = createSimpleContext({
    }

    onMount(() => {
-      const systemTheme = resolveSystemTheme(store.mode)
-      void Promise.allSettled([
-        store.active === "system" ? systemTheme : Promise.resolve(),
-        syncCustomThemes(),
-      ]).finally(() => {
-        valuesV2()
+      // Terminal palette queries serialize with frame output. First paint uses the cached palette or built-in fallback.
+      void syncCustomThemes().finally(() => {
+        tokens()
        setStore("ready", true)
      })
    })

-    let systemThemeSignature: string | undefined
-    let systemThemeMode: "dark" | "light" | undefined
-    let hasResolvedSystemTheme = false
-    function resolveSystemTheme(mode: "dark" | "light" = store.mode) {
-      return renderer
+    const cachedPalette = cache?.[0].colors
+    let palette = usablePalette(cachedPalette) ? cachedPalette : undefined
+    const applyPalette = () => {
+      if (palette) setSystemTheme(generateSystem(palette, store.mode))
+    }
+    if (palette) {
+      const mode = store.lock ?? terminalMode(palette) ?? store.mode
+      if (store.mode !== mode) setStore("mode", mode)
+      applyPalette()
+    } else setSystemTheme(undefined)
+
+    let canProbe = false
+    let probing = false
+    let queued = false
+    let disposed = false
+    function refreshPalette() {
+      queued = true
+      if (!canProbe || probing || disposed) return
+
+      queued = false
+      probing = true
+      // Clearing does not cancel a query already owned by the renderer. Share it, then run one fresh query.
+      const retry = renderer.paletteDetectionStatus === "detecting"
+      renderer.clearPaletteCache()
+      void renderer
        .getPalette({ size: 16 })
-        .then((colors: TerminalColors) => {
-          if (!colors.palette[0]) {
-            if (hasResolvedSystemTheme) return
-            setSystemTheme(undefined)
-            if (store.active === "system") setStore("active", "opencode")
-            return
-          }
-          const next = store.lock ?? terminalMode(colors) ?? mode
-          if (store.mode !== next) setStore("mode", next)
-          const signature = JSON.stringify(colors)
-          hasResolvedSystemTheme = true
-          if (store.themes.system && systemThemeSignature === signature && systemThemeMode === next) return
-          systemThemeSignature = signature
-          systemThemeMode = next
-          setSystemTheme(generateSystem(colors, next))
+        .then((colors) => {
+          if (disposed || !usablePalette(colors)) return
+          palette = colors
+          const mode = store.lock ?? terminalMode(colors) ?? store.mode
+          if (store.mode !== mode) setStore("mode", mode)
+          applyPalette()
+          void cache?.[1]((draft) => {
+            draft.colors = colors
+          }).catch(() => {})
        })
-        .catch(() => {
-          if (hasResolvedSystemTheme) return
-          setSystemTheme(undefined)
-          if (store.active === "system") setStore("active", "opencode")
+        .catch(() => {})
+        .finally(() => {
+          probing = false
+          if (disposed || (!retry && !queued)) return
+          refreshPalette()
        })
    }

-    let systemRefreshRunning = false
-    let systemRefreshQueued = false
-    let systemRefreshMode = store.mode
-    function refreshSystemTheme(mode: "dark" | "light" = store.mode) {
-      systemRefreshMode = mode
-      if (systemRefreshRunning) {
-        systemRefreshQueued = true
-        return
-      }
-
-      systemRefreshRunning = true
-      const retry = renderer.paletteDetectionStatus === "detecting"
-      renderer.clearPaletteCache()
-      void resolveSystemTheme(mode).finally(() => {
-        systemRefreshRunning = false
-        if (!retry && !systemRefreshQueued) return
-        systemRefreshQueued = false
-        refreshSystemTheme(systemRefreshMode)
-      })
+    function afterPaint() {
+      canProbe = true
+      refreshPalette()
    }

    function apply(mode: "dark" | "light") {
-      if (store.mode === mode) return
-      setStore("mode", mode)
-      refreshSystemTheme(mode)
+      if (store.mode !== mode) {
+        setStore("mode", mode)
+        applyPalette()
+      }
+      refreshPalette()
    }

    function pin(mode: "dark" | "light" = store.mode, persist = true) {
@@ -263,7 +258,7 @@ const themeContext = createSimpleContext({

    function free(persist = true) {
      setStore("lock", undefined)
-      refreshSystemTheme(renderer.themeMode ?? store.mode)
+      apply(renderer.themeMode ?? store.mode)
      if (!persist) return
      void configState
        .update((draft) => {
@@ -272,33 +267,34 @@ const themeContext = createSimpleContext({
        .catch(() => {})
    }

-    const handle = (mode: "dark" | "light") => {
+    const handleMode = (mode: "dark" | "light") => {
      if (store.lock) return
      apply(mode)
    }
-    renderer.on(CliRenderEvents.THEME_MODE, handle)
+    renderer.on(CliRenderEvents.THEME_MODE, handleMode)

    const handleThemeNotification = (sequence: string) => {
      if (sequence !== "\x1b[?997;1n" && sequence !== "\x1b[?997;2n") return false
-      queueMicrotask(() => refreshSystemTheme())
+      queueMicrotask(refreshPalette)
      return false
    }
    renderer.prependInputHandler(handleThemeNotification)

    let themeRefreshTimeouts: ReturnType<typeof setTimeout>[] = []
-    const refresh = () => {
+    const refreshThemes = () => {
      for (const timeout of themeRefreshTimeouts) clearTimeout(timeout)
      themeRefreshTimeouts = THEME_REFRESH_DELAYS.map((delay) =>
        setTimeout(() => {
-          refreshSystemTheme()
+          refreshPalette()
          if (delay === THEME_REFRESH_DELAYS[THEME_REFRESH_DELAYS.length - 1]) void syncCustomThemes()
        }, delay),
      )
    }
-    const unsubscribeRefresh = themes.subscribeRefresh?.(refresh)
+    const unsubscribeRefresh = themes.subscribeRefresh?.(refreshThemes)

    onCleanup(() => {
-      renderer.off(CliRenderEvents.THEME_MODE, handle)
+      disposed = true
+      renderer.off(CliRenderEvents.THEME_MODE, handleMode)
      renderer.removeInputHandler(handleThemeNotification)
      unsubscribeRefresh?.()
      for (const timeout of themeRefreshTimeouts) clearTimeout(timeout)
@@ -307,29 +303,30 @@ const themeContext = createSimpleContext({

    const initStarted = performance.now()
    const selected = createMemo(() => {
-      const name = store.themes[store.active] ? store.active : "opencode"
+      const sources = themeSources()
+      const name = sources[store.active] ? store.active : "opencode"
      try {
-        return loadTheme(store.themes[name], name, store.mode)
+        return loadTheme(sources[name], name, store.mode)
      } catch (error) {
        if (name === "opencode") throw error
        themeErrors.emit(name, error)
        setStore("active", "opencode")
-        return loadTheme(store.themes.opencode, "opencode", store.mode)
+        return loadTheme(sources.opencode, "opencode", store.mode)
      }
    })
    const modes = () => selected().modes
    const mode = () => selected().mode
-    const valuesV2 = () => selected().theme
-    valuesV2()
+    const tokens = () => selected().theme
+    tokens()
    themePerformance.set("Init", `${(performance.now() - initStarted).toFixed(2)} ms`)
-    const current = createComponentTheme(valuesV2, mode)
+    const current = createComponentTheme(tokens, mode)

-    createEffect(() => renderer.setBackgroundColor(valuesV2().background.default))
+    createEffect(() => renderer.setBackgroundColor(tokens().background.default))

-    const currentSyntax = createSyntaxStyleMemo(() => generateSyntax(valuesV2(), mode()))
+    const currentSyntax = createSyntaxStyleMemo(() => generateSyntax(tokens(), mode()))
    const service: Themes = {
      current,
-      currentTokens: valuesV2,
+      currentTokens: tokens,
      currentSyntax,
      get selected() {
        return store.active
@@ -357,6 +354,7 @@ const themeContext = createSimpleContext({
          .catch(() => {})
        return true
      },
+      afterPaint,
      onError: themeErrors.onError,
      get ready() {
        return store.ready
@@ -383,6 +381,12 @@ export function useTheme(context?: ContextName) {
 }
 export const ThemeProvider = themeContext.provider

+function usablePalette(colors: TerminalColors | undefined): colors is TerminalColors {
+  return Boolean(
+    colors && (colors.defaultBackground ?? colors.palette[0]) && (colors.defaultForeground ?? colors.palette[7]),
+  )
+}
+
 /** Switches context without remounting children; undefined inherits the enclosing view. */
 export function ThemeContextProvider(props: ParentProps<{ context: ContextName | undefined }>) {
  const value = themeContext.use()
@@ -34,6 +34,7 @@ import { discoverPluginTargets, localSource } from "./discovery"
 import { createPluginSources } from "./source"
 import { isMissingPath } from "../util/config-directories"
 import { createMarkdownRenderer } from "./markdown"
+import { useLog, type LogTags } from "../context/log"

 export interface PackageSource {
  readonly prepare: (spec: string, install?: boolean) => Promise<Host.Target>
@@ -81,11 +82,13 @@ type Registration = {

 // One entry of the desired plugin generation produced by the resolve phase.
 type Desired = Pick<Registration, "plugin" | "source" | "target" | "version" | "options"> & { enabled: boolean }
+type Trace = <T>(stage: string, tags: LogTags, task: () => Promise<T>) => Promise<T>

 const PluginContext = createContext<Value>()

 export function PluginProvider(props: ParentProps<{ packages: PackageSource; directories: string[] }>) {
  const host = usePluginHost()
+  const log = useLog({ component: "plugin" })
  const config = useConfig()
  const lifecycle = useTuiLifecycle()
  const client = useClient()
@@ -108,6 +111,34 @@ export function PluginProvider(props: ParentProps<{ packages: PackageSource; dir
  // One save can emit several watch events. Remember setup failures so those
  // events do not repeatedly tear down and restore the last good generation.
  const setupFailures = new Map<string, { version: string; options: Registration["options"]; error: string }>()
+  let operationID = 0
+  const trace: Trace = (stage, tags, task) => {
+    const id = ++operationID
+    const started = Date.now()
+    log.debug("plugin operation started", { id, stage, ...tags })
+    const stalled = setTimeout(
+      () => log.warn("plugin operation stalled", { id, stage, elapsedMs: Date.now() - started, ...tags }),
+      5_000,
+    )
+    return task()
+      .then(
+        (value) => {
+          log.debug("plugin operation completed", { id, stage, durationMs: Date.now() - started, ...tags })
+          return value
+        },
+        (error) => {
+          log.warn("plugin operation failed", {
+            id,
+            stage,
+            durationMs: Date.now() - started,
+            error: errorMessage(error),
+            ...tags,
+          })
+          throw error
+        },
+      )
+      .finally(() => clearTimeout(stalled))
+  }
  const markdown = createMarkdownRenderer(() =>
    Object.values(store.registrations).flatMap((registration) => (registration.active ? [registration.markdown] : [])),
  )
@@ -149,7 +180,9 @@ export function PluginProvider(props: ParentProps<{ packages: PackageSource; dir
        active: () => Boolean(store.registrations[id]?.active),
      },
    })
-    const cleanup = await setup(item.plugin, context, owned).catch((error) => {
+    const cleanup = await trace("setup", { plugin: id, target: item.target }, () =>
+      setup(item.plugin, context, owned),
+    ).catch((error) => {
      clearContributions(id)
      if (item.target)
        setupFailures.set(item.target, {
@@ -181,7 +214,9 @@ export function PluginProvider(props: ParentProps<{ packages: PackageSource; dir
      setStore("registrations", id, "active", false)
      setStore("registrations", id, "cleanups", [])
    })
-    await disposeAll(cleanups).finally(() =>
+    await trace("cleanup", { plugin: id, target: item.target, cleanups: cleanups.length }, () =>
+      disposeAll(cleanups),
+    ).finally(() =>
      batch(() => {
        if (store.registrations[id]) {
          clearContributions(id)
@@ -243,10 +278,20 @@ export function PluginProvider(props: ParentProps<{ packages: PackageSource; dir
  // Package resolution failures would otherwise retry a full npm install on
  // every watch event; remember them until the configuration changes.
  const npmFailures = new Map<string, string>()
+  let reconciliationID = 0
  const reconcile = async () => {
-    await Promise.all(props.directories.map(watcher.wait))
+    const id = ++reconciliationID
+    const started = Date.now()
+    log.info("plugin reconciliation started", { id })
+    await trace("watch", { reconciliation: id, directories: props.directories }, () =>
+      Promise.all(props.directories.map(watcher.wait)).then(() => undefined),
+    )
    const entries = [
-      ...(await discoverPluginTargets(props.directories)).map((entry) => ({
+      ...(
+        await trace("discover", { reconciliation: id, directories: props.directories }, () =>
+          discoverPluginTargets(props.directories),
+        )
+      ).map((entry) => ({
        entry,
        install: true,
        optional: true,
@@ -295,12 +340,20 @@ export function PluginProvider(props: ParentProps<{ packages: PackageSource; dir
      const memo = local ? undefined : npmFailures.get(target)
      const resolved = memo
        ? { status: "failed" as const, error: memo }
-        : await resolvePlugin(target, local, options, previous, props.packages, source.install, sources.read).catch(
-            (error) => ({
-              status: "failed" as const,
-              error: errorMessage(error),
-            }),
-          )
+        : await resolvePlugin(
+            target,
+            local,
+            options,
+            previous,
+            props.packages,
+            source.install,
+            sources.read,
+            trace,
+            id,
+          ).catch((error) => ({
+            status: "failed" as const,
+            error: errorMessage(error),
+          }))
      if (resolved.status === "unsupported") {
        if (source.optional) continue
        failures.push({ target, status: "unsupported" })
@@ -426,6 +479,7 @@ export function PluginProvider(props: ParentProps<{ packages: PackageSource; dir
          action: { label: "Open plugins", run: () => host.keymap.dispatch("plugins.list") },
        })
    setStore("states", reconcileStore(states))
+    log.info("plugin reconciliation completed", { id, durationMs: Date.now() - started, plugins: desired.size })
  }
  const slotItems = new WeakMap<SlotRender, Claim<SlotRender>>()
  // The mounted slot tree: path -> live <Slot> instance count. Reference
@@ -598,17 +652,26 @@ async function resolvePlugin(
  packages: PackageSource,
  install: boolean,
  readSource: ReturnType<typeof createPluginSources>["read"],
+  trace: Trace,
+  reconciliation: number,
 ) {
  // Package entrypoints never change within a session, so a loaded previous
  // version needs no re-resolution (which could otherwise hit npm).
  if (!local && previous && sameOptions(previous.options, options))
    return { status: "unchanged" as const, plugin: previous.plugin, version: previous.version }
-  const target = local ? { directory: fileURLToPath(local) } : await packages.prepare(spec, install)
+  const target = local
+    ? { directory: fileURLToPath(local) }
+    : await trace("prepare", { reconciliation, target: spec, install }, () => packages.prepare(spec, install))
  const entrypoint = Host.resolve(target).tui
  if (!entrypoint) return { status: "unsupported" as const }
  // Content remains stable across the several mtimes one save may expose to
  // filesystem watchers, while the generation keeps reverted modules fresh.
-  let source = local ? await readSource(entrypoint) : { version: entrypoint, module: await Host.load(entrypoint) }
+  let source = local
+    ? await trace("read", { reconciliation, target: spec, entrypoint }, () => readSource(entrypoint))
+    : {
+        version: entrypoint,
+        module: await trace("load", { reconciliation, target: spec, entrypoint }, () => Host.load(entrypoint)),
+      }
  while (true) {
    const version = source.version
    if (previous && previous.version === version && sameOptions(previous.options, options))
@@ -289,6 +289,7 @@ export function reduceSessionRows(messages: SessionMessageInfo[], inputs = new S
    ...messages.filter(isInput),
  ].reduce<ProjectionEntry[]>((rows, message) => {
    if (message.type !== "assistant") {
+      if (message.type === "idle") return rows
      if (message.type === "synthetic" && !message.description?.trim()) return rows
      if (message.type === "compaction" && message.status === "completed" && usage) usage.previousTurnCache = undefined
      rows.push({ entry: { type: "message", messageID: message.id }, closesPrevious: !pending.has(message.id) })
@@ -20,6 +20,10 @@ export interface ScrollViewProps extends ComponentProps<"div"> {
  thumbContainer?: HTMLElement
  /** Element whose hover reveals the thumb. Defaults to the ScrollView root when unset. */
  thumbHoverTarget?: HTMLElement
+  /** Reconcile native scroll geometry before keyboard or scrollbar navigation reads it. */
+  onBeforeScroll?: () => void
+  /** Offset/extent correction for a virtualized vertical scrollbar. */
+  verticalScrollAdjustment?: number
 }

 export const scrollKey = (event: Pick<KeyboardEvent, "key" | "altKey" | "ctrlKey" | "metaKey" | "shiftKey">) => {
@@ -124,6 +128,8 @@ export function ScrollView(props: ScrollViewProps) {
      "thumbVisibility",
      "thumbContainer",
      "thumbHoverTarget",
+      "onBeforeScroll",
+      "verticalScrollAdjustment",
      "style",
    ],
    [
@@ -189,17 +195,19 @@ export function ScrollView(props: ScrollViewProps) {
    const minThumbSize = 32

    if (vertical()) {
+      const adjustment = local.verticalScrollAdjustment ?? 0
+      const scrollHeight = viewportRef.scrollHeight + adjustment
      const trackSize = Math.max(0, (thumbMount()?.clientHeight || viewportRef.clientHeight) - trackPadding * 2)
      const size = trackSize
-        ? Math.min(trackSize, Math.max((viewportRef.clientHeight / viewportRef.scrollHeight) * trackSize, minThumbSize))
+        ? Math.min(trackSize, Math.max((viewportRef.clientHeight / scrollHeight) * trackSize, minThumbSize))
        : 0
-      const maxScroll = viewportRef.scrollHeight - viewportRef.clientHeight
+      const maxScroll = scrollHeight - viewportRef.clientHeight
      const maxStart = trackSize - size
      setState("showVerticalThumb", maxScroll > 0)
      setState("verticalThumbSize", size)
      setState(
        "verticalThumbStart",
-        trackPadding + (maxScroll > 0 ? (viewportRef.scrollTop / maxScroll) * maxStart : 0),
+        trackPadding + (maxScroll > 0 ? ((viewportRef.scrollTop + adjustment) / maxScroll) * maxStart : 0),
      )
    } else {
      setState("showVerticalThumb", false)
@@ -263,9 +271,17 @@ export function ScrollView(props: ScrollViewProps) {
    })
  })

+  const prepareScroll = () => {
+    if (local.onBeforeScroll) {
+      local.onBeforeScroll()
+      updateThumb()
+    }
+  }
+
  const onThumbPointerDown = (axis: "vertical" | "horizontal", e: PointerEvent) => {
    e.preventDefault()
    e.stopPropagation()
+    prepareScroll()
    setState("dragging", axis)
    const thumb = axis === "vertical" ? verticalThumbRef : horizontalThumbRef
    const grabOffset =
@@ -277,6 +293,7 @@ export function ScrollView(props: ScrollViewProps) {
    thumb.setPointerCapture(e.pointerId)

    const onPointerMove = (e: PointerEvent) => {
+      prepareScroll()
      const vertical = axis === "vertical"
      const rtl = !vertical && getComputedStyle(viewportRef).direction === "rtl"
      const offset = scrollOffsetFromThumbPointer({
@@ -355,10 +372,23 @@ export function ScrollView(props: ScrollViewProps) {
      return
    }
    const next = scrollKey(e)
-    if (!next) return
-    if (!isScrollKeyTarget(e.target, next)) return
-    if (scrollKeyOwner(viewportRef, e.target, next) !== viewportRef) return
+    // Modified navigation (for example Ctrl+Home) stays native, but must read
+    // the same reconciled geometry as the keys handled by this component.
+    const intent =
+      next ??
+      scrollKey({
+        key: e.key,
+        shiftKey: e.key === " " && e.shiftKey,
+        altKey: false,
+        ctrlKey: false,
+        metaKey: false,
+      })
+    if (!intent) return
+    if (!isScrollKeyTarget(e.target, intent)) return
+    if (scrollKeyOwner(viewportRef, e.target, intent) !== viewportRef) return

+    prepareScroll()
+    if (!next) return
    const scrollAmount = viewportRef.clientHeight * 0.8
    const lineAmount = 40

@@ -1,5 +1,5 @@
 diff --git a/dist/cjs/index.cjs b/dist/cjs/index.cjs
-index e470032a9572b3ced764ca02238a8c6be435a9d4..84a7bfca638f70e32a9567bc732a84b83578af4e 100644
+index e470032a9572b3ced764ca02238a8c6be435a9d4..4c25e03b5db221a78793083d97970b2d90e28efa 100644
 --- a/dist/cjs/index.cjs
 +++ b/dist/cjs/index.cjs
@@ -289,7 +289,7 @@ class Virtualizer {
@@ -82,7 +82,50 @@ index e470032a9572b3ced764ca02238a8c6be435a9d4..84a7bfca638f70e32a9567bc732a84b8
           followOnAppend,
           anchorDelta
         ];
-@@ -725,17 +735,20 @@ class Virtualizer {
+@@ -440,7 +450,17 @@ class Virtualizer {
+         );
+         if ("addEventListener" in this.scrollElement) {
+           const scrollEl = this.scrollElement;
+-          const onTouchStart = () => {
+          let touchTarget = null;
+          const clearTouchTarget = () => {
+            touchTarget?.removeEventListener("touchend", onTouchEnd);
+            touchTarget?.removeEventListener("touchcancel", onTouchEnd);
+            touchTarget = null;
+          };
+          const onTouchStart = (event) => {
+            clearTouchTarget();
+            touchTarget = event.target ?? scrollEl;
+            touchTarget.addEventListener("touchend", onTouchEnd, addEventListenerOptions);
+            touchTarget.addEventListener("touchcancel", onTouchEnd, addEventListenerOptions);
+             this._iosTouching = true;
+             this._iosJustTouchEnded = false;
+             if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+@@ -449,6 +469,7 @@ class Virtualizer {
+             }
+           };
+           const onTouchEnd = () => {
+            clearTouchTarget();
+             this._iosTouching = false;
+             if (!isIOSWebKit() || this.targetWindow == null) {
+               return;
+@@ -465,14 +486,9 @@ class Virtualizer {
+             onTouchStart,
+             addEventListenerOptions
+           );
+-          scrollEl.addEventListener(
+-            "touchend",
+-            onTouchEnd,
+-            addEventListenerOptions
+-          );
+           this.unsubs.push(() => {
+             scrollEl.removeEventListener("touchstart", onTouchStart);
+-            scrollEl.removeEventListener("touchend", onTouchEnd);
+            clearTouchTarget();
+             if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+               this.targetWindow.clearTimeout(this._iosTouchEndTimerId);
+               this._iosTouchEndTimerId = null;
+@@ -725,17 +741,20 @@ class Virtualizer {
         this.getMeasurements(),
         this.getSize(),
         this.getScrollOffset(),
@@ -106,7 +149,7 @@ index e470032a9572b3ced764ca02238a8c6be435a9d4..84a7bfca638f70e32a9567bc732a84b8
           lanes,
           // Pass the typed array so binary search + forward-walk can read
           // start/end directly from Float64Array, skipping the Proxy traps.
-@@ -1095,8 +1108,10 @@ class Virtualizer {
+@@ -1095,8 +1114,10 @@ class Virtualizer {
       const snapshot = [];
       if (this.itemSizeCache.size === 0) return snapshot;
       const m = this.getMeasurements();
@@ -146,7 +189,7 @@ index 6b43c0aea7ed9eeef75cbfb1351fcbd243913bdd..7be2680967934ddfbc4583a210a3d11e
     getVirtualIndexes: {
         (): number[];
 diff --git a/dist/esm/index.js b/dist/esm/index.js
-index 2495b26cf2c3589213546b3958eaadf2eb6b751d..accd38a89bee766fd568aa8cec9bb90c6789277a 100644
+index 2495b26cf2c3589213546b3958eaadf2eb6b751d..1398bc7dd33690a8fe3280343b6aabdeaea6435a 100644
 --- a/dist/esm/index.js
 +++ b/dist/esm/index.js
@@ -287,7 +287,7 @@ class Virtualizer {
@@ -229,7 +272,50 @@ index 2495b26cf2c3589213546b3958eaadf2eb6b751d..accd38a89bee766fd568aa8cec9bb90c
           followOnAppend,
           anchorDelta
         ];
-@@ -723,17 +733,20 @@ class Virtualizer {
+@@ -438,7 +448,17 @@ class Virtualizer {
+         );
+         if ("addEventListener" in this.scrollElement) {
+           const scrollEl = this.scrollElement;
+-          const onTouchStart = () => {
+          let touchTarget = null;
+          const clearTouchTarget = () => {
+            touchTarget?.removeEventListener("touchend", onTouchEnd);
+            touchTarget?.removeEventListener("touchcancel", onTouchEnd);
+            touchTarget = null;
+          };
+          const onTouchStart = (event) => {
+            clearTouchTarget();
+            touchTarget = event.target ?? scrollEl;
+            touchTarget.addEventListener("touchend", onTouchEnd, addEventListenerOptions);
+            touchTarget.addEventListener("touchcancel", onTouchEnd, addEventListenerOptions);
+             this._iosTouching = true;
+             this._iosJustTouchEnded = false;
+             if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+@@ -447,6 +467,7 @@ class Virtualizer {
+             }
+           };
+           const onTouchEnd = () => {
+            clearTouchTarget();
+             this._iosTouching = false;
+             if (!isIOSWebKit() || this.targetWindow == null) {
+               return;
+@@ -463,14 +484,9 @@ class Virtualizer {
+             onTouchStart,
+             addEventListenerOptions
+           );
+-          scrollEl.addEventListener(
+-            "touchend",
+-            onTouchEnd,
+-            addEventListenerOptions
+-          );
+           this.unsubs.push(() => {
+             scrollEl.removeEventListener("touchstart", onTouchStart);
+-            scrollEl.removeEventListener("touchend", onTouchEnd);
+            clearTouchTarget();
+             if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+               this.targetWindow.clearTimeout(this._iosTouchEndTimerId);
+               this._iosTouchEndTimerId = null;
+@@ -723,17 +739,20 @@ class Virtualizer {
         this.getMeasurements(),
         this.getSize(),
         this.getScrollOffset(),
@@ -253,7 +339,7 @@ index 2495b26cf2c3589213546b3958eaadf2eb6b751d..accd38a89bee766fd568aa8cec9bb90c
           lanes,
           // Pass the typed array so binary search + forward-walk can read
           // start/end directly from Float64Array, skipping the Proxy traps.
-@@ -1093,8 +1106,10 @@ class Virtualizer {
+@@ -1093,8 +1112,10 @@ class Virtualizer {
       const snapshot = [];
       if (this.itemSizeCache.size === 0) return snapshot;
       const m = this.getMeasurements();
@@ -267,7 +353,7 @@ index 2495b26cf2c3589213546b3958eaadf2eb6b751d..accd38a89bee766fd568aa8cec9bb90c
             index: item.index,
             key: item.key,
 diff --git a/src/index.ts b/src/index.ts
-index dc6f1010c4d4758de9c46fb8d69209e582e47171..2578338abb5d9237624dd6d96bb50546c6dc3e68 100644
+index dc6f1010c4d4758de9c46fb8d69209e582e47171..9299287d72ce79d5a597cdc3440339ee148e6385 100644
 --- a/src/index.ts
 +++ b/src/index.ts
@@ -567,7 +567,7 @@ export class Virtualizer<
@@ -380,7 +466,51 @@ index dc6f1010c4d4758de9c46fb8d69209e582e47171..2578338abb5d9237624dd6d96bb50546
         followOnAppend,
         anchorDelta,
       ]
-@@ -1410,16 +1421,25 @@ export class Virtualizer<
+@@ -895,7 +906,18 @@ export class Virtualizer<
+       // and _flushIosDeferredIfReady so we only burn the path on iOS.
+       if ('addEventListener' in this.scrollElement) {
+         const scrollEl = this.scrollElement as unknown as EventTarget
+-        const onTouchStart = () => {
+        let touchTarget: EventTarget | null = null
+        const clearTouchTarget = () => {
+          touchTarget?.removeEventListener('touchend', onTouchEnd)
+          touchTarget?.removeEventListener('touchcancel', onTouchEnd)
+          touchTarget = null
+        }
+        const onTouchStart = (event: Event) => {
+          clearTouchTarget()
+          // The original target still receives release after its DOM removal.
+          touchTarget = event.target ?? scrollEl
+          touchTarget.addEventListener('touchend', onTouchEnd, addEventListenerOptions)
+          touchTarget.addEventListener('touchcancel', onTouchEnd, addEventListenerOptions)
+           this._iosTouching = true
+           this._iosJustTouchEnded = false
+           if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+@@ -904,6 +926,7 @@ export class Virtualizer<
+           }
+         }
+         const onTouchEnd = () => {
+          clearTouchTarget()
+           this._iosTouching = false
+           if (!isIOSWebKit() || this.targetWindow == null) {
+             // Non-iOS: nothing more to track. Just clear the touching flag.
+@@ -924,14 +947,9 @@ export class Virtualizer<
+           onTouchStart,
+           addEventListenerOptions,
+         )
+-        scrollEl.addEventListener(
+-          'touchend',
+-          onTouchEnd,
+-          addEventListenerOptions,
+-        )
+         this.unsubs.push(() => {
+           scrollEl.removeEventListener('touchstart', onTouchStart)
+-          scrollEl.removeEventListener('touchend', onTouchEnd)
+          clearTouchTarget()
+           if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+             this.targetWindow.clearTimeout(this._iosTouchEndTimerId)
+             this._iosTouchEndTimerId = null
+@@ -1410,16 +1428,25 @@ export class Virtualizer<
       this.getSize(),
       this.getScrollOffset(),
       this.options.lanes,
@@ -408,7 +538,7 @@ index dc6f1010c4d4758de9c46fb8d69209e582e47171..2578338abb5d9237624dd6d96bb50546
         lanes,
         // Pass the typed array so binary search + forward-walk can read
         // start/end directly from Float64Array, skipping the Proxy traps.
-@@ -1937,12 +1957,13 @@ export class Virtualizer<
+@@ -1937,12 +1964,13 @@ export class Virtualizer<
   takeSnapshot = (): Array<VirtualItem> => {
     const snapshot: Array<VirtualItem> = []
     if (this.itemSizeCache.size === 0) return snapshot
@@ -3242,6 +3242,152 @@
        "summary": "Get session context"
      }
    },
+    "/api/session/{sessionID}/diff": {
+      "get": {
+        "tags": ["session"],
+        "operationId": "v2.session.diff",
+        "parameters": [
+          {
+            "name": "sessionID",
+            "in": "path",
+            "schema": {
+              "type": "string",
+              "pattern": "^ses"
+            },
+            "required": true
+          },
+          {
+            "name": "from",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "pattern": "^msg_"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "User message whose turn to diff. Defaults to the turn of the newest user message."
+            },
+            "required": false
+          },
+          {
+            "name": "to",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "pattern": "^msg_"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Later user message whose turn ends the range. Defaults to the turn of `from` alone."
+            },
+            "required": false
+          },
+          {
+            "name": "context",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Unchanged lines around each hunk. Omit for full-file patches."
+            },
+            "required": false
+          }
+        ],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/components/schemas/FileDiff.Info"
+                      }
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "MessageNotFoundError | SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/MessageNotFoundErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "UnknownError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnknownErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Structured per-file diffs of the files a turn changed. A turn runs from the first prompt after the session was last idle until its next idle marker, so prompts steered in while it was busy belong to the same turn; `to` extends the range through a later turn. Compares the range's first recorded snapshot with its last; a step still running in the active session compares against the working copy. Ranges that span a location change are rejected. In sessions without any idle marker, a prompt's turn spans until the next user message.",
+        "summary": "Diff session turns"
+      }
+    },
    "/api/session/{sessionID}/inbox": {
      "get": {
        "tags": ["session"],
@@ -18421,6 +18567,38 @@
        "required": ["type", "id", "time", "status", "reason", "summary", "recent"],
        "additionalProperties": false
      },
+      "Session.Message.Idle": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^msg_"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "time": {
+            "type": "object",
+            "properties": {
+              "created": {
+                "type": "number"
+              }
+            },
+            "required": ["created"],
+            "additionalProperties": false
+          },
+          "type": {
+            "type": "string",
+            "enum": ["idle"]
+          },
+          "outcome": {
+            "type": "string",
+            "enum": ["succeeded", "failed", "interrupted"]
+          }
+        },
+        "required": ["id", "time", "type", "outcome"],
+        "additionalProperties": false
+      },
      "Session.Message.Info": {
        "anyOf": [
          {
@@ -18452,6 +18630,9 @@
          },
          {
            "$ref": "#/components/schemas/Session.Message.Compaction"
+          },
+          {
+            "$ref": "#/components/schemas/Session.Message.Idle"
          }
        ]
      },
@@ -3242,6 +3242,152 @@
        "summary": "Get session context"
      }
    },
+    "/api/session/{sessionID}/diff": {
+      "get": {
+        "tags": ["session"],
+        "operationId": "v2.session.diff",
+        "parameters": [
+          {
+            "name": "sessionID",
+            "in": "path",
+            "schema": {
+              "type": "string",
+              "pattern": "^ses"
+            },
+            "required": true
+          },
+          {
+            "name": "from",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "pattern": "^msg_"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "User message whose turn to diff. Defaults to the turn of the newest user message."
+            },
+            "required": false
+          },
+          {
+            "name": "to",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "pattern": "^msg_"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Later user message whose turn ends the range. Defaults to the turn of `from` alone."
+            },
+            "required": false
+          },
+          {
+            "name": "context",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Unchanged lines around each hunk. Omit for full-file patches."
+            },
+            "required": false
+          }
+        ],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/components/schemas/FileDiff.Info"
+                      }
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "MessageNotFoundError | SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/MessageNotFoundErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "UnknownError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnknownErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Structured per-file diffs of the files a turn changed. A turn runs from the first prompt after the session was last idle until its next idle marker, so prompts steered in while it was busy belong to the same turn; `to` extends the range through a later turn. Compares the range's first recorded snapshot with its last; a step still running in the active session compares against the working copy. Ranges that span a location change are rejected. In sessions without any idle marker, a prompt's turn spans until the next user message.",
+        "summary": "Diff session turns"
+      }
+    },
    "/api/session/{sessionID}/inbox": {
      "get": {
        "tags": ["session"],
@@ -18421,6 +18567,38 @@
        "required": ["type", "id", "time", "status", "reason", "summary", "recent"],
        "additionalProperties": false
      },
+      "Session.Message.Idle": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^msg_"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "time": {
+            "type": "object",
+            "properties": {
+              "created": {
+                "type": "number"
+              }
+            },
+            "required": ["created"],
+            "additionalProperties": false
+          },
+          "type": {
+            "type": "string",
+            "enum": ["idle"]
+          },
+          "outcome": {
+            "type": "string",
+            "enum": ["succeeded", "failed", "interrupted"]
+          }
+        },
+        "required": ["id", "time", "type", "outcome"],
+        "additionalProperties": false
+      },
      "Session.Message.Info": {
        "anyOf": [
          {
@@ -18452,6 +18630,9 @@
          },
          {
            "$ref": "#/components/schemas/Session.Message.Compaction"
+          },
+          {
+            "$ref": "#/components/schemas/Session.Message.Idle"
          }
        ]
      },
Author	SHA1	Message	Date
Dax Raad	dbc63955b0	refactor(tui): simplify theme palette lifecycle	2026-09-12 17:50:32 -04:00
Shoubhit DashandDax Raad	2816d1c849	feat(session): add turn diff route (#47821 ) Co-authored-by: Dax Raad <d@ironbay.co>	2026-09-12 21:26:52 +00:00
Dax Raad	61d812fcd6	fix(tui): refresh system palette after paint	2026-09-12 17:25:44 -04:00
Dax Raad	e47b9b5453	fix(tui): cache system theme palette	2026-09-12 17:24:04 -04:00
Dax Raad	21dac524f3	fix(tui): defer palette probe until first frame	2026-09-12 17:20:09 -04:00
Dax Raad	3dde11c392	chore(tui): log stalled plugin startup	2026-09-12 16:43:59 -04:00
opencode-agent[bot]	0643a5638e	chore: update nix node_modules hashes	2026-09-12 19:41:39 +00:00
Luke Parker	81523d4a84	fix(app): stabilize mobile timeline touch scrolling (#48600 )	2026-09-13 05:24:23 +10:00