feat(codemode): add structuredClone

packages/app/e2e/regression/session-prompt-spacing.spec.ts

@@ -1,74 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { sessionID, setupTimeline, userMessage } from "../performance/timeline-stability/fixture"
-
-test("keeps a submitted prompt in place while its optimistic rows are measured", async ({ page }) => {
-  await setupTimeline(page, { messages: [userMessage()], seedHistory: true })
-  const release = Promise.withResolvers<void>()
-  await page.route(`**/api/session/${sessionID}/prompt`, async (route) => {
-    if (route.request().method() !== "POST") return route.fallback()
-    await release.promise
-    return route.fallback()
-  })
-
-  const editor = page.locator('[data-component="composer"]').getByRole("textbox")
-  await expect(editor).toBeEditable()
-  await editor.fill("Observe optimistic prompt spacing.")
-  await expect
-    .poll(() =>
-      page.locator("[data-timeline-virtual-content]").evaluate((element) => {
-        const root = element.parentElement!
-        return root.scrollHeight - root.clientHeight - root.scrollTop
-      }),
-    )
-    .toBe(0)
-
-  const observation = await page.evaluateHandle(() => {
-    const frames: { prompt?: number; working: boolean }[] = []
-    let frame = 0
-    const sample = () => {
-      const prompt = [...document.querySelectorAll<HTMLElement>('[data-timeline-row="UserMessage"]')].find((row) =>
-        row.textContent?.includes("Observe optimistic prompt spacing."),
-      )
-      frames.push({
-        ...(prompt ? { prompt: prompt.getBoundingClientRect().y } : {}),
-        working: !!document.querySelector('[data-component="session-working"]'),
-      })
-      frame = requestAnimationFrame(sample)
-    }
-    frame = requestAnimationFrame(sample)
-    return {
-      stop: () => {
-        cancelAnimationFrame(frame)
-        return frames
-      },
-    }
-  })
-  const requested = page.waitForRequest(
-    (request) => request.method() === "POST" && new URL(request.url()).pathname === `/api/session/${sessionID}/prompt`,
-  )
-  try {
-    await editor.press("Enter")
-    await requested
-    const prompt = page
-      .locator('[data-timeline-row="UserMessage"]')
-      .filter({ hasText: "Observe optimistic prompt spacing." })
-    await expect(prompt).toBeInViewport()
-    await expect(page.locator('[data-component="session-working"]')).toBeVisible()
-    await expect
-      .poll(() =>
-        page.locator("[data-timeline-virtual-content]").evaluate((element) => {
-          const root = element.parentElement!
-          return root.scrollHeight - root.clientHeight - root.scrollTop
-        }),
-      )
-      .toBe(0)
-    const frames = await observation.evaluate((value) => value.stop())
-    expect(frames.some((frame) => frame.working && frame.prompt === undefined)).toBe(false)
-    const positions = frames.flatMap((frame) => (frame.prompt === undefined ? [] : [frame.prompt]))
-    expect(positions.length).toBeGreaterThan(0)
-    expect(new Set(positions).size).toBe(1)
-  } finally {
-    release.resolve()
-    await observation.dispose()
-  }
-})

packages/app/e2e/regression/session-timeline-notices.spec.ts

@@ -122,15 +122,7 @@ test("renders compaction progress, summary, and outcome in order", async ({ page
   )
   await expect(compaction.getByRole("heading", { name: "Checkpoint" })).toBeVisible()
   await expect(compaction).toContainText("Streamed implementation details.")
-  const running = compaction.getByRole("status").getByLabel("Compacting", { exact: true })
-  await expect(running).toBeVisible()
-  await expect
-    .poll(async () => {
-      const summary = await compaction.locator('[data-component="text-part"]').boundingBox()
-      const status = await running.boundingBox()
-      return !!summary && !!status && status.y >= summary.y + summary.height
-    })
-    .toBe(true)
+  await expect(compaction.getByRole("status").getByLabel("Compacting", { exact: true })).toBeVisible()
   await expect(compaction.getByText("Session compacted", { exact: true })).toHaveCount(0)
 
   await timeline.send(

packages/app/src/composer/submit.ts

@@ -88,12 +88,8 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
       if (value.mode === "normal" && !command) {
         session.handoff?.set(handoffMessage(value))
         const optimisticBusy = !input.adapter.working()
-        if (optimisticBusy && input.adapter.kind === "new-session")
-          session.data.session.setStatus(session.id, "running")
-        const sending = sendPrompt(session, value, input.adapter.controls().model.selection.trackSessionCommit, () => {
-          if (optimisticBusy && input.adapter.kind === "active-session")
-            session.data.session.setStatus(session.id, "running")
-        }).then(
+        if (optimisticBusy) session.data.session.setStatus(session.id, "running")
+        const sending = sendPrompt(session, value, input.adapter.controls().model.selection.trackSessionCommit).then(
           () => ({ ok: true as const }),
           (error) => ({ ok: false as const, error }),
         )
@@ -363,8 +359,7 @@ async function applySelection(
 async function sendPrompt(
   session: ComposerSession,
   value: ComposerSubmission,
-  track: ModelSelection["trackSessionCommit"] | undefined,
-  onAdmit: () => void,
+  track?: ModelSelection["trackSessionCommit"],
 ) {
   const request = await buildSubmissionRequest(session, value)
   // Switching agent or model reconfigures the session immediately, and with it
@@ -394,9 +389,7 @@ async function sendPrompt(
       },
     },
   }
-  const sending = session.data.session.prompt(admission).catch(() => session.data.session.prompt(admission))
-  onAdmit()
-  await sending
+  await session.data.session.prompt(admission).catch(() => session.data.session.prompt(admission))
 }
 
 async function buildSubmissionRequest(session: ComposerSession, value: ComposerSubmission) {

packages/app/src/session/timeline/virtualizer.tsx

@@ -515,19 +515,6 @@ export function createTimelineVirtualizer(input: Input) {
           <div
             ref={(value) => {
               element = value
-              if (row()._tag !== "UserMessage" || !addedKeys.has(rowProps.rowKey) || !input.pinned() || coldPending)
-                return
-              // The optimistic row can paint before ResizeObserver corrects the tail estimates.
-              // Measure the mounted tail and pin it in this render's microtask instead.
-              queueMicrotask(() => {
-                if (!input.pinned() || !virtualContent?.isConnected) return
-                virtualizer.elementsCache.forEach((item) => {
-                  if (item.isConnected) virtualizer.resizeItem(virtualizer.indexFromElement(item), item.offsetHeight)
-                })
-                virtualizer.resizeItem(item().index, element.offsetHeight)
-                virtualContent.style.height = `${virtualizer.getTotalSize()}px`
-                virtualizer.scrollToEnd()
-              })
             }}
             data-index={item().index}
             style={{ "min-height": ready() ? undefined : `${initialItem.size}px` }}

packages/client/src/effect/api/api.ts

@@ -17,7 +17,6 @@ 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"
@@ -37,6 +36,7 @@ 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"
 
@@ -360,15 +360,6 @@ 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 messageID?: 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> = (
@@ -1148,7 +1139,6 @@ 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>

packages/client/src/effect/generated/client.ts

@@ -68,8 +68,6 @@ import type {
   SessionRevertCommitOutput,
   SessionContextInput,
   SessionContextOutput,
-  SessionDiffInput,
-  SessionDiffOutput,
   SessionInboxListInput,
   SessionInboxListOutput,
   SessionInboxCancelInput,
@@ -594,17 +592,6 @@ 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: { messageID: input["messageID"], 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(
@@ -744,7 +731,6 @@ const adaptGroupSession = (raw: RawClient["server.session"]) => ({
     commit: EndpointSessionRevertCommit(raw),
   },
   context: EndpointSessionContext(raw),
-  diff: EndpointSessionDiff(raw),
   inbox: {
     list: EndpointSessionInboxList(raw),
     cancel: EndpointSessionInboxCancel(raw),

packages/client/src/promise/generated/client.ts

@@ -62,8 +62,6 @@ import type {
   SessionRevertCommitOutput,
   SessionContextInput,
   SessionContextOutput,
-  SessionDiffInput,
-  SessionDiffOutput,
   SessionInboxListInput,
   SessionInboxListOutput,
   SessionInboxCancelInput,
@@ -844,18 +842,6 @@ 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: { messageID: input["messageID"], 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 }>(

packages/client/src/promise/generated/types.ts

@@ -147,14 +147,6 @@ 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"
@@ -2202,7 +2194,6 @@ export type SessionMessageInfo =
   | SessionMessageShell
   | SessionMessageAssistant
   | SessionMessageCompaction
-  | SessionMessageIdle
 
 export type SessionMessageContentUpdated = {
   id: string
@@ -3161,13 +3152,6 @@ 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"]
@@ -3473,13 +3457,6 @@ 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"]
@@ -3785,13 +3762,6 @@ 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"]
@@ -4281,27 +4251,6 @@ 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 messageID?: {
-    readonly messageID?: string | undefined
-    readonly to?: string | undefined
-    readonly context?: number | undefined
-  }["messageID"]
-  readonly to?: {
-    readonly messageID?: string | undefined
-    readonly to?: string | undefined
-    readonly context?: number | undefined
-  }["to"]
-  readonly context?: {
-    readonly messageID?: 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"]

packages/client/src/solid/data.ts

@@ -1024,18 +1024,6 @@ 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)

packages/codemode/interpreter-support.md

@@ -369,6 +369,9 @@ ultimate source of truth.
 - [x] `atob` and `btoa` with forgiving-base64 decoding and WebIDL string conversion; invalid input throws an Error
       named `InvalidCharacterError`, since there is no `DOMException`.
 - [x] `crypto.randomUUID()`.
+- [x] `structuredClone` over the data model: objects, arrays with holes, Date, RegExp (`lastIndex` reset), Map, Set,
+      URL, URLSearchParams, and Errors (name, message, and cause only); shared references stay shared within one
+      clone; functions, promises, and tool references throw an Error named `DataCloneError`.
 - [ ] `crypto.getRandomValues` and `crypto.subtle`, `TextEncoder`/`TextDecoder`, and `Blob`: these need a binary
       value type, which the JSON-like data model does not have yet.
 

packages/codemode/src/data.ts

@@ -138,6 +138,6 @@ const copy = (value: unknown, label: string, mode: Mode, depth: number, seen: Se
 
 // Own data property regardless of the target's prototype, so a "__proto__" key on a host object or
 // array never reaches the Object.prototype setter.
-const define = (target: object, key: string, value: unknown): void => {
+export const define = (target: object, key: string, value: unknown): void => {
   Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true })
 }

packages/codemode/src/interpreter/globals.ts

@@ -11,7 +11,7 @@ import { regexpGlobal } from "../stdlib/regexp.js"
 import { stringGlobal } from "../stdlib/string.js"
 import { uriGlobal, urlGlobal, urlSearchParamsGlobal } from "../stdlib/url.js"
 import { coercion, errorConstructors } from "../stdlib/value.js"
-import { atobGlobal, btoaGlobal, cryptoGlobal } from "../stdlib/web.js"
+import { atobGlobal, btoaGlobal, cryptoGlobal, structuredCloneGlobal } from "../stdlib/web.js"
 import { ToolReference } from "../tool-runtime.js"
 import { errorGlobal } from "./errors.js"
 import { HostFunction } from "./host.js"
@@ -75,5 +75,6 @@ export const globals = <R>(host: Host<R>): ReadonlyArray<readonly [string, unkno
   ["atob", atobGlobal],
   ["btoa", btoaGlobal],
   ["crypto", cryptoGlobal],
+  ["structuredClone", structuredCloneGlobal],
   ...[...errorConstructors].map((name) => [name, errorGlobal(name, host.runner)] as const),
 ]

packages/codemode/src/stdlib/web.ts

@@ -1,6 +1,9 @@
+import { define, type SafeObject } from "../data.js"
 import { HostNamespace, sync } from "../interpreter/host.js"
-import { InterpreterRuntimeError } from "../interpreter/model.js"
-import { coerceToString } from "./value.js"
+import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
+import { describeValue, isRuntimeReference } from "../interpreter/references.js"
+import { Values } from "../values.js"
+import { coerceToString, createErrorValue, errorBrandName } from "./value.js"
 
 // WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies.
 const base64 = (name: "atob" | "btoa") =>
@@ -22,3 +25,56 @@ export const btoaGlobal = base64("btoa")
 export const cryptoGlobal = new HostNamespace("crypto", {
   randomUUID: sync("crypto.randomUUID", () => crypto.randomUUID()),
 })
+
+// HTML structured clone over the data model: wrappers are copied, shared references stay shared within
+// one clone, Errors keep only name, message, and cause, and RegExp lastIndex resets like the spec.
+const cloneValue = (value: unknown, seen: Map<object, unknown>, node: AstNode): unknown => {
+  if (value === null || typeof value !== "object") return value
+  if (value instanceof Values.Promise || (isRuntimeReference(value) && !Values.isValue(value))) {
+    throw new InterpreterRuntimeError(`${describeValue(value)} could not be cloned.`, node).as("DataCloneError")
+  }
+  const existing = seen.get(value)
+  if (existing !== undefined) return existing
+  const remember = <T extends object>(copied: T): T => {
+    seen.set(value, copied)
+    return copied
+  }
+  if (value instanceof Values.Date) return remember(new Values.Date(value.time))
+  if (value instanceof Values.RegExp) return remember(new Values.RegExp(value.regex.source, value.regex.flags))
+  if (value instanceof Values.URL) return remember(new Values.URL(new URL(value.url.href)))
+  if (value instanceof Values.URLSearchParams) {
+    return remember(new Values.URLSearchParams(new URLSearchParams(value.params)))
+  }
+  if (value instanceof Values.Map) {
+    const copied = remember(new Values.Map())
+    for (const [key, item] of value.map) copied.map.set(cloneValue(key, seen, node), cloneValue(item, seen, node))
+    return copied
+  }
+  if (value instanceof Values.Set) {
+    const copied = remember(new Values.Set())
+    for (const item of value.set) copied.set.add(cloneValue(item, seen, node))
+    return copied
+  }
+  if (Array.isArray(value)) {
+    const copied = remember(new Array<unknown>(value.length))
+    for (const [key, item] of Object.entries(value)) define(copied, key, cloneValue(item, seen, node))
+    return copied
+  }
+  const brand = errorBrandName(value)
+  if (brand !== undefined) {
+    const error = value as { name?: unknown; message?: unknown; cause?: unknown }
+    const copied = remember(createErrorValue(brand, coerceToString(error.message)))
+    if (Object.hasOwn(value, "cause")) copied.cause = cloneValue(error.cause, seen, node)
+    return copied
+  }
+  const copied = remember(Object.create(null) as SafeObject)
+  for (const [key, item] of Object.entries(value)) define(copied, key, cloneValue(item, seen, node))
+  return copied
+}
+
+export const structuredCloneGlobal = sync("structuredClone", (args, node) => {
+  if (args.length === 0) {
+    throw new InterpreterRuntimeError("structuredClone requires a value to clone.", node).as("TypeError")
+  }
+  return cloneValue(args[0], new Map(), node)
+})

packages/codemode/test/structured-clone-wpt.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Portions adapted from web-platform-tests at revision 863077959ca8c1a7ceecfbe2534b75d2527b9013:
+ * - html/webappapis/structured-clone/structured-clone-battery-of-tests.js
+ *
+ * Copyright © web-platform-tests contributors. Governed by the 3-Clause BSD license in LICENSE.wpt.
+ *
+ * The battery's `check(description, input, compare)` shape and its `compare_*` helpers are kept, run
+ * inside the interpreter. Ported: primitives, Array/Object of primitives, Date, RegExp, Error, sparse
+ * arrays, identical (shared) property values, and the index-property-plus-length object. Not portable:
+ * boxed primitives, BigInt, Blob/File/ImageData/ArrayBuffer/typed arrays (no binary values), circular
+ * references (rejected at insertion here), property descriptors and prototype properties (no
+ * defineProperty or prototypes), and the throwing-getter case (no getters). `assert_throws_dom` for
+ * `DataCloneError` becomes an `error.name` check.
+ */
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { CodeMode } from "../src/index.js"
+
+const value = async (code: string) => {
+  const result = await Effect.runPromise(CodeMode.execute({ code, tools: {} }))
+  if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
+  return result.value
+}
+
+// The WPT harness, minus async: assertions push a failure description instead of throwing so one run
+// reports every failing check.
+const harness = `
+  const failures = []
+  const assert_equals = (a, b, m) => { if (!Object.is(a, b) && !(a !== a && b !== b)) failures.push((m ?? "") + ": " + String(a) + " !== " + String(b)) }
+  const assert_not_equals = (a, b, m) => { if (a === b) failures.push((m ?? "") + ": unexpectedly identical") }
+  const assert_true = (a, m) => { if (a !== true) failures.push((m ?? "") + ": not true") }
+  const assert_false = (a, m) => { if (a !== false) failures.push((m ?? "") + ": not false") }
+  let current = ""
+  function check(description, input, callback) {
+    current = description
+    const newInput = typeof input === "function" ? input() : input
+    const copy = structuredClone(newInput)
+    const before = failures.length
+    callback(copy, newInput)
+    for (let i = before; i < failures.length; i++) failures[i] = description + " — " + failures[i]
+  }
+  function compare_primitive(actual, input) { assert_equals(actual, input) }
+  function compare_Array(callback) {
+    return function (actual, input) {
+      assert_true(Array.isArray(actual), "instanceof Array")
+      assert_not_equals(actual, input)
+      assert_equals(actual.length, input.length, "length")
+      callback(actual, input)
+    }
+  }
+  function compare_Object(callback) {
+    return function (actual, input) {
+      assert_true(actual instanceof Object, "instanceof Object")
+      assert_false(Array.isArray(actual), "instanceof Array")
+      assert_not_equals(actual, input)
+      callback(actual, input)
+    }
+  }
+  function enumerate_props(compare_func) {
+    return function (actual, input) { for (const x in input) compare_func(actual[x], input[x]) }
+  }
+`
+
+describe("structuredClone WPT battery", () => {
+  test("primitives, and arrays and objects of primitives", async () => {
+    expect(
+      await value(`
+        ${harness}
+        check('primitive undefined', undefined, compare_primitive)
+        check('primitive null', null, compare_primitive)
+        check('primitive true', true, compare_primitive)
+        check('primitive false', false, compare_primitive)
+        check('primitive string, empty string', '', compare_primitive)
+        check('primitive string, lone high surrogate', '\\uD800', compare_primitive)
+        check('primitive string, lone low surrogate', '\\uDC00', compare_primitive)
+        check('primitive string, NUL', '\\u0000', compare_primitive)
+        check('primitive string, astral character', '\\uDBFF\\uDFFD', compare_primitive)
+        check('primitive number, 0.2', 0.2, compare_primitive)
+        check('primitive number, 0', 0, compare_primitive)
+        check('primitive number, -0', -0, compare_primitive)
+        check('primitive number, NaN', NaN, compare_primitive)
+        check('primitive number, Infinity', Infinity, compare_primitive)
+        check('primitive number, -Infinity', -Infinity, compare_primitive)
+        check('primitive number, 9007199254740992', 9007199254740992, compare_primitive)
+        check('primitive number, -9007199254740992', -9007199254740992, compare_primitive)
+        check('primitive number, 9007199254740994', 9007199254740994, compare_primitive)
+        check('primitive number, -9007199254740994', -9007199254740994, compare_primitive)
+        check('Array primitives', [undefined, null, true, false, '', '\\uD800', '\\uDC00', '\\u0000', '\\uDBFF\\uDFFD',
+          0.2, 0, -0, NaN, Infinity, -Infinity, 9007199254740992, -9007199254740992, 9007199254740994, -9007199254740994],
+          compare_Array(enumerate_props(compare_primitive)))
+        check('Object primitives', { 'undefined': undefined, 'null': null, 'true': true, 'false': false, 'empty': '',
+          'high surrogate': '\\uD800', 'low surrogate': '\\uDC00', 'nul': '\\u0000', 'astral': '\\uDBFF\\uDFFD',
+          '0.2': 0.2, '0': 0, '-0': -0, 'NaN': NaN, 'Infinity': Infinity, '-Infinity': -Infinity,
+          '9007199254740992': 9007199254740992, '-9007199254740992': -9007199254740992,
+          '9007199254740994': 9007199254740994, '-9007199254740994': -9007199254740994 },
+          compare_Object(enumerate_props(compare_primitive)))
+        return failures
+      `),
+    ).toEqual([])
+  })
+
+  test("Date", async () => {
+    expect(
+      await value(`
+        ${harness}
+        function compare_Date(actual, input) {
+          assert_true(actual instanceof Date, 'instanceof Date')
+          assert_equals(Number(actual), Number(input), 'converted to primitive')
+          assert_not_equals(actual, input)
+        }
+        check('Date 0', new Date(0), compare_Date)
+        check('Date -0', new Date(-0), compare_Date)
+        check('Date -8.64e15', new Date(-8.64e15), compare_Date)
+        check('Date 8.64e15', new Date(8.64e15), compare_Date)
+        check('Array Date objects', [new Date(0), new Date(-0), new Date(-8.64e15), new Date(8.64e15)],
+          compare_Array(enumerate_props(compare_Date)))
+        check('Object Date objects', { '0': new Date(0), '-0': new Date(-0), '-8.64e15': new Date(-8.64e15), '8.64e15': new Date(8.64e15) },
+          compare_Object(enumerate_props(compare_Date)))
+        return failures
+      `),
+    ).toEqual([])
+  })
+
+  test("RegExp: flags copied, lastIndex reset, source escaped", async () => {
+    expect(
+      await value(`
+        ${harness}
+        function compare_RegExp(expected_source) {
+          return function (actual, input) {
+            assert_true(actual instanceof RegExp, 'instanceof RegExp')
+            assert_equals(actual.global, input.global, 'global')
+            assert_equals(actual.ignoreCase, input.ignoreCase, 'ignoreCase')
+            assert_equals(actual.multiline, input.multiline, 'multiline')
+            assert_equals(actual.source, expected_source, 'source')
+            assert_equals(actual.sticky, input.sticky, 'sticky')
+            assert_equals(actual.unicode, input.unicode, 'unicode')
+            assert_equals(actual.lastIndex, 0, 'lastIndex')
+            assert_not_equals(actual, input)
+          }
+        }
+        function func_RegExp_flags_lastIndex() {
+          const r = /foo/gim
+          r.lastIndex = 2
+          return r
+        }
+        function func_RegExp_sticky() { return new RegExp('foo', 'y') }
+        function func_RegExp_unicode() { return new RegExp('foo', 'u') }
+        check('RegExp flags and lastIndex', func_RegExp_flags_lastIndex, compare_RegExp('foo'))
+        check('RegExp sticky flag', func_RegExp_sticky, compare_RegExp('foo'))
+        check('RegExp unicode flag', func_RegExp_unicode, compare_RegExp('foo'))
+        check('RegExp empty', new RegExp(''), compare_RegExp('(?:)'))
+        check('RegExp slash', new RegExp('/'), compare_RegExp('\\\\/'))
+        check('RegExp new line', new RegExp('\\n'), compare_RegExp('\\\\n'))
+        check('Array RegExp object, RegExp flags and lastIndex', [func_RegExp_flags_lastIndex()], compare_Array(enumerate_props(compare_RegExp('foo'))))
+        check('Array RegExp object, RegExp sticky flag', function () { return [func_RegExp_sticky()] }, compare_Array(enumerate_props(compare_RegExp('foo'))))
+        check('Array RegExp object, RegExp unicode flag', function () { return [func_RegExp_unicode()] }, compare_Array(enumerate_props(compare_RegExp('foo'))))
+        check('Array RegExp object, RegExp empty', [new RegExp('')], compare_Array(enumerate_props(compare_RegExp('(?:)'))))
+        check('Array RegExp object, RegExp slash', [new RegExp('/')], compare_Array(enumerate_props(compare_RegExp('\\\\/'))))
+        check('Array RegExp object, RegExp new line', [new RegExp('\\n')], compare_Array(enumerate_props(compare_RegExp('\\\\n'))))
+        check('Object RegExp object, RegExp flags and lastIndex', { 'x': func_RegExp_flags_lastIndex() }, compare_Object(enumerate_props(compare_RegExp('foo'))))
+        check('Object RegExp object, RegExp sticky flag', function () { return { 'x': func_RegExp_sticky() } }, compare_Object(enumerate_props(compare_RegExp('foo'))))
+        check('Object RegExp object, RegExp unicode flag', function () { return { 'x': func_RegExp_unicode() } }, compare_Object(enumerate_props(compare_RegExp('foo'))))
+        check('Object RegExp object, RegExp empty', { 'x': new RegExp('') }, compare_Object(enumerate_props(compare_RegExp('(?:)'))))
+        check('Object RegExp object, RegExp slash', { 'x': new RegExp('/') }, compare_Object(enumerate_props(compare_RegExp('\\\\/'))))
+        check('Object RegExp object, RegExp new line', { 'x': new RegExp('\\n') }, compare_Object(enumerate_props(compare_RegExp('\\\\n'))))
+        return failures
+      `),
+    ).toEqual([])
+  })
+
+  test("Error: name and message kept, custom properties dropped", async () => {
+    expect(
+      await value(`
+        ${harness}
+        function compare_Error(actual, input) {
+          assert_true(actual instanceof Error, "Checking instanceof")
+          assert_equals(actual.name, input.name, "Checking name")
+          assert_equals(Object.hasOwn(actual, "message"), Object.hasOwn(input, "message"), "Checking message existence")
+          assert_equals(actual.message, input.message, "Checking message")
+          assert_equals(actual.foo, undefined, "Checking for absence of custom property")
+        }
+        check('Empty Error object', new Error(), compare_Error)
+        for (const constructor of [Error, RangeError, ReferenceError, SyntaxError, TypeError, URIError]) {
+          check(constructor.name, () => {
+            const error = new constructor("Error message here")
+            error.foo = "testing"
+            return error
+          }, compare_Error)
+        }
+        return failures
+      `),
+    ).toEqual([])
+  })
+
+  test("sparse arrays, index-property objects, and identical property values", async () => {
+    expect(
+      await value(`
+        ${harness}
+        check('Array sparse', new Array(10), compare_Array(enumerate_props(compare_primitive)))
+        check('Object with index property and length', { '0': 'foo', 'length': 1 }, compare_Object(enumerate_props(compare_primitive)))
+        function check_identical_property_values(prop1, prop2) {
+          return function (actual) { assert_equals(actual[prop1], actual[prop2]) }
+        }
+        check('Array with identical property values', function () {
+          const obj = {}
+          return [obj, obj]
+        }, compare_Array(check_identical_property_values('0', '1')))
+        check('Object with identical property values', function () {
+          const obj = {}
+          return { 'x': obj, 'y': obj }
+        }, compare_Object(check_identical_property_values('x', 'y')))
+        return failures
+      `),
+    ).toEqual([])
+  })
+})
+
+describe("structuredClone beyond the WPT battery", () => {
+  test("Map, Set, URL, and URLSearchParams are copied, with shared references preserved across containers", async () => {
+    expect(
+      await value(`
+        const shared = { n: 1 }
+        const input = { m: new Map([[shared, shared]]), s: new Set([shared]), u: new URL("https://a.b/c?d=1") }
+        const copy = structuredClone(input)
+        const [[key, item]] = [...copy.m]
+        copy.u.searchParams.set("d", "2")
+        return [
+          copy.m !== input.m, key !== shared, key === item, key === [...copy.s][0],
+          copy.u !== input.u, input.u.href, copy.u.href,
+        ]
+      `),
+    ).toEqual([true, true, true, true, true, "https://a.b/c?d=1", "https://a.b/c?d=2"])
+  })
+
+  test("functions, promises, and tool references throw DataCloneError", async () => {
+    expect(
+      await value(`
+        return [() => 1, Promise.resolve(1), tools, Math, { nested: [() => 1] }].map((input) => {
+          try { structuredClone(input); return "cloned" } catch (error) { return error.name }
+        })
+      `),
+    ).toEqual(Array(5).fill("DataCloneError"))
+    expect(await value(`try { structuredClone() } catch (error) { return error.name }`)).toBe("TypeError")
+  })
+})

packages/core/src/git.ts

@@ -9,7 +9,6 @@ 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,
@@ -309,7 +308,7 @@ const layer = Layer.effect(
       operationName: OperationError["operation"],
       repository: Repository,
       args: string[],
-      options?: { stdin?: string; env?: Record<string, string>; maxOutputBytes?: number },
+      options?: { stdin?: string; env?: Record<string, string> },
     ) {
       const result = yield* proc
         .run(
@@ -318,7 +317,7 @@ const layer = Layer.effect(
             env: options?.env,
             extendEnv: true,
           }),
-          { stdin: options?.stdin, maxOutputBytes: options?.maxOutputBytes },
+          { stdin: options?.stdin },
         )
         .pipe(
           Effect.mapError(
@@ -332,8 +331,7 @@ const layer = Layer.effect(
           ),
         )
       const text = result.stdout.toString("utf8")
-      if (result.exitCode === 0)
-        return { text, stderr: result.stderr.toString("utf8"), truncated: result.stdoutTruncated }
+      if (result.exitCode === 0) return { text, stderr: result.stderr.toString("utf8") }
       return yield* new OperationError({
         operation: operationName,
         directory: repository.worktree,
@@ -387,7 +385,9 @@ const layer = Layer.effect(
       maximumUntrackedFileBytes?: number
     }) {
       const list = (args: string[]) =>
-        repositoryOperation("refresh", input.repository, args).pipe(Effect.map((result) => nuls(result.text)))
+        repositoryOperation("refresh", input.repository, args).pipe(
+          Effect.map((result) => result.text.split("\0").filter(Boolean)),
+        )
       const [tracked, untracked] = yield* Effect.all(
         [
           list(["diff-files", "--name-only", "-z", "--", input.scope]),
@@ -464,7 +464,13 @@ const layer = Layer.effect(
           directory: input.repository.worktree,
           message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths",
         })
-      return new Set(nuls(result.stdout.toString("utf8")).map((file) => RelativePath.make(file)))
+      return new Set(
+        result.stdout
+          .toString("utf8")
+          .split("\0")
+          .filter(Boolean)
+          .map((file) => RelativePath.make(file)),
+      )
     })
 
     const writeTree = Effect.fn("Git.tree.write")(function* (repository: Repository) {
@@ -493,23 +499,19 @@ const layer = Layer.effect(
       to: TreeID
     }) {
       // Undo needs both paths of a rename, not only its destination.
-      return nuls(
-        (yield* repositoryOperation("list_files", input.repository, [
-          "diff",
-          "--name-only",
-          "--no-renames",
-          "-z",
-          input.from,
-          input.to,
-        ])).text,
-      ).map((file) => RelativePath.make(file))
+      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))
     })
 
-    /**
-     * 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
@@ -517,57 +519,49 @@ const layer = Layer.effect(
       context?: number
       paths?: readonly RelativePath[]
     }) {
-      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(
+      const paths = input.paths ?? (yield* treeFiles(input))
+      return yield* Effect.forEach(paths, (file) =>
+        Effect.gen(function* () {
+          const statusText = (yield* repositoryOperation("diff", input.repository, [
             "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,
-          ]
+            "--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
         }),
       )
-      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) {
@@ -739,11 +733,6 @@ 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

packages/core/src/session.ts

@@ -54,11 +54,8 @@ 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"
@@ -110,7 +107,6 @@ 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<{
@@ -137,13 +133,6 @@ 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 messageID?: 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
@@ -232,7 +221,6 @@ 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)
 
@@ -364,17 +352,6 @@ 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,
-          messageID: input.messageID,
-          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),
@@ -463,7 +440,6 @@ export const node: LayerNode.Provider<Service, never, typeof Node.tags.values.gl
     SessionInbox.node,
     SessionMove.node,
     SessionProjector.node,
-    LocationServiceMap.node,
     FSUtil.node,
     App.node,
   ],

packages/core/src/session/diff.ts

@@ -1,138 +0,0 @@
-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(["messageID", "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 messageID?: 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.messageID ? eq(SessionMessageTable.id, input.messageID) : 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: "messageID" | "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.messageID ? yield* resolve("messageID", input.messageID) : 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)))
-})

packages/core/src/session/message-updater.ts

@@ -60,21 +60,6 @@ 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")({
@@ -138,11 +123,9 @@ 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": () => 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.execution.succeeded": () => clearCurrentRetry,
+      "session.execution.failed": () => clearCurrentRetry,
+      "session.execution.interrupted": () => clearCurrentRetry,
       "session.instructions.updated": (event) => {
         if (event.data.text === undefined) return Effect.void
         return adapter.appendMessage(

packages/core/src/session/runner/to-llm-message.ts

@@ -226,7 +226,6 @@ 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 [

packages/core/src/snapshot.ts

@@ -131,55 +131,38 @@ const layer = Layer.effect(
       )
     })
 
-    const comparison = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
+    const compare = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
       const repo = yield* repository.pipe(Effect.mapError((cause) => failure(operation, cause)))
-      return {
-        source: repo.source,
+      const comparison = {
         repository: repo.snapshotRepository,
         from: Git.TreeID.make(input.from),
         to: Git.TreeID.make(input.to),
       }
-    })
-
-    // 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 })
+      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 })
         .pipe(Effect.mapError((cause) => failure(operation, cause)))
+      return {
+        input: comparison,
+        files,
+        ignored,
+      }
     })
 
     const files = Effect.fn("Snapshot.files")(function* (input: CompareInput) {
-      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 comparison = yield* compare("files", input)
+      return comparison.files.filter((file) => !comparison.ignored.has(file))
     })
 
     const diff = Effect.fn("Snapshot.diff")(function* (input: DiffInput) {
-      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
+      const comparison = yield* compare("diff", input)
+      return yield* git.tree
         .diff({
-          repository: compared.repository,
-          from: compared.from,
-          to: compared.to,
+          ...comparison.input,
           context: input.context,
-          paths: input.paths,
+          paths: (input.paths ?? comparison.files).filter((file) => !comparison.ignored.has(file)),
         })
         .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) {

packages/core/test/git.test.ts

@@ -6,7 +6,6 @@ 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"
@@ -197,42 +196,6 @@ 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(

packages/core/test/session-diff.test.ts

@@ -1,198 +0,0 @@
-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?: { messageID?: 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({ messageID: 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({ messageID: steer })).toEqual(busy)
-          expect(yield* diff({ messageID: second })).toEqual([
-            ["first.txt", "modified", 1, 1],
-            ["manual.txt", "modified", 1, 1],
-            ["second.txt", "modified", 1, 1],
-          ])
-          expect(yield* diff({ messageID: 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, messageID: first })
-          expect(full[0]?.patch).toContain("-first\n+first edited\n")
-          expect(yield* diff({ messageID: steer, to: second }).pipe(Effect.flip)).toMatchObject({
-            _tag: "Session.TurnRangeError",
-            field: "to",
-          })
-          expect(yield* diff({ messageID: firstStep }).pipe(Effect.flip)).toMatchObject({
-            _tag: "Session.TurnRangeError",
-            field: "messageID",
-          })
-          expect(yield* diff({ messageID: 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({ messageID: 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 },
-  )
-})

packages/core/test/session-execution.test.ts

@@ -561,9 +561,7 @@ 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")
-        // 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([
+        expect(yield* sessions.messages({ sessionID })).toMatchObject([
           {
             id: background.notificationID,
             type: "synthetic",
@@ -571,6 +569,7 @@ describe("SessionRestart background recovery", () => {
             metadata: { state: "completed" },
           },
         ])
+        expect(yield* sessions.messages({ sessionID })).toHaveLength(1)
       }),
     )
   }

packages/protocol/openapi.json

@@ -3242,152 +3242,6 @@
         "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": "messageID",
-            "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 `messageID` 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"],
@@ -18540,38 +18394,6 @@
         "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": [
           {
@@ -18603,9 +18425,6 @@
           },
           {
             "$ref": "#/components/schemas/Session.Message.Compaction"
-          },
-          {
-            "$ref": "#/components/schemas/Session.Message.Idle"
           }
         ]
       },

packages/protocol/src/groups/session.ts

@@ -30,7 +30,6 @@ import { Model } from "@opencode/schema/model"
 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,
@@ -522,31 +521,6 @@ 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({
-          messageID: 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 `messageID` 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 },

packages/schema/src/session-message.ts

@@ -280,18 +280,6 @@ 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,
@@ -303,7 +291,6 @@ export const Info = Schema.Union([
   Shell,
   Assistant,
   Compaction,
-  Idle,
 ]).annotate({ identifier: "Session.Message.Info" })
 export type Info =
   | AgentSelected
@@ -316,5 +303,4 @@ export type Info =
   | Shell
   | Assistant
   | Compaction
-  | Idle
 export type Type = Info["type"]

packages/server/src/handlers/session-error.ts

@@ -1,6 +1,5 @@
 import { Session } from "@opencode/core/session"
-import type { Snapshot } from "@opencode/core/snapshot"
-import { MessageNotFoundError, SessionNotFoundError, UnknownError } from "@opencode/protocol/errors"
+import { SessionNotFoundError, UnknownError } from "@opencode/protocol/errors"
 import { Effect } from "effect"
 
 export function missingSession(error: Session.NotFoundError) {
@@ -10,14 +9,6 @@ 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(
@@ -27,16 +18,3 @@ 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 })),
-      ),
-    )
-  }
-}

packages/server/src/handlers/session.ts

@@ -17,9 +17,10 @@ import {
   ServiceUnavailableError,
   SessionBusyError,
   SkillNotFoundError,
+  UnknownError,
 } from "@opencode/protocol/errors"
 import { AbsolutePath } from "@opencode/core/schema"
-import { failedMessageDecode, failedSnapshot, missingMessage, missingSession } from "./session-error"
+import { failedMessageDecode, missingSession } from "./session-error"
 
 const DefaultSessionsLimit = 50
 
@@ -211,7 +212,15 @@ 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", missingMessage),
+              Effect.catchTag(
+                "Session.MessageNotFoundError",
+                (error) =>
+                  new MessageNotFoundError({
+                    sessionID: error.sessionID,
+                    messageID: error.messageID,
+                    message: `Message not found: ${error.messageID}`,
+                  }),
+              ),
               Effect.catchTag(
                 "Session.ForkEmptyError",
                 (error) => new InvalidRequestError({ message: error.message, kind: "empty_session" }),
@@ -439,14 +448,32 @@ 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", missingMessage),
-                Effect.catchTag("Session.BusyError", busySession),
-                Effect.catchTag("Snapshot.Error", failedSnapshot("stage session revert", ctx.params.sessionID)),
+            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}`,
+                  }),
               ),
+              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,
+                      }),
+                    ),
+                  ),
+                )
+              }),
+            ),
           }
         }),
       )
@@ -454,13 +481,23 @@ 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", failedSnapshot("clear session revert", 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,
+                    }),
+                  ),
+                ),
+              )
+            }),
+          )
           return HttpApiSchema.NoContent.make()
         }),
       )
@@ -490,22 +527,6 @@ 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) {

packages/server/test/session-diff.test.ts

@@ -1,98 +0,0 @@
-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(`?messageID=${ids.user}&context=3`)).toEqual({ status: 200, body: { data: [] } })
-    expect(yield* diff(`?messageID=${ids.assistant}`)).toMatchObject({
-      status: 400,
-      body: { _tag: "InvalidRequestError", field: "messageID" },
-    })
-    expect(yield* diff(`?messageID=${SessionMessage.ID.create()}`)).toMatchObject({
-      status: 404,
-      body: { _tag: "MessageNotFoundError" },
-    })
-    expect((yield* request(`/api/session/${Session.ID.create()}/diff`)).status).toBe(404)
-  }),
-)

packages/session-ui/src/message/message-content.tsx

@@ -427,17 +427,6 @@ export function SessionCompactionMessage(props: { message: SessionMessageCompact
       <div class="py-2">
         <TimelineSeparator label={i18n.t("ui.messagePart.compaction.started")} />
       </div>
-      <Show when={summary().trim()}>
-        <div data-component="text-part" data-timeline-part-id={props.message.id}>
-          <div data-slot="text-part-body">
-            <PacedMarkdown
-              text={summary()}
-              cacheKey={props.message.id}
-              streaming={props.message.status === "running"}
-            />
-          </div>
-        </div>
-      </Show>
       <Show when={props.message.status === "running"}>
         <div role="status" class="py-2">
           <BasicTool
@@ -449,6 +438,17 @@ export function SessionCompactionMessage(props: { message: SessionMessageCompact
           />
         </div>
       </Show>
+      <Show when={summary().trim()}>
+        <div data-component="text-part" data-timeline-part-id={props.message.id}>
+          <div data-slot="text-part-body">
+            <PacedMarkdown
+              text={summary()}
+              cacheKey={props.message.id}
+              streaming={props.message.status === "running"}
+            />
+          </div>
+        </div>
+      </Show>
       <Show when={props.message.status !== "running"}>
         <div class="py-2">
           <TimelineSeparator label={label()} />

packages/session-ui/src/timeline/projection.ts

@@ -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" | "idle" }>
+type Notice = Exclude<SessionMessageInfo, { type: "user" | "assistant" | "shell" }>
 type Entry = { type: "assistant"; message: SessionMessageAssistant } | { type: "notice"; message: Notice }
 type Content = SessionMessageAssistant["content"][number]
 type GroupRow = Extract<TimelineRow.TimelineRow, { _tag: "AssistantPart" }>
@@ -765,8 +765,7 @@ 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" || message.type === "idle")
-    return false
+  if (message.type === "user" || message.type === "assistant" || message.type === "shell") return false
   if (message.type !== "synthetic") return true
   return !!message.description?.trim() || timelineNoticeRequired(message)
 }

packages/tui/src/routes/session/rows.ts

@@ -305,7 +305,6 @@ export function reduceSessionRows(messages: SessionMessageInfo[], inputs = new S
     ...messages.filter(isInput),
   ].reduce<SessionRow[]>((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
       if (!pending.has(message.id)) completePrevious(rows)

services/www/openapi.json

@@ -3242,152 +3242,6 @@
         "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": "messageID",
-            "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 `messageID` 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"],
@@ -18540,38 +18394,6 @@
         "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": [
           {
@@ -18603,9 +18425,6 @@
           },
           {
             "$ref": "#/components/schemas/Session.Message.Compaction"
-          },
-          {
-            "$ref": "#/components/schemas/Session.Message.Idle"
           }
         ]
       },

services/www/public/openapi.json

@@ -3242,152 +3242,6 @@
         "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": "messageID",
-            "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 `messageID` 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"],
@@ -18540,38 +18394,6 @@
         "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": [
           {
@@ -18603,9 +18425,6 @@
           },
           {
             "$ref": "#/components/schemas/Session.Message.Compaction"
-          },
-          {
-            "$ref": "#/components/schemas/Session.Message.Idle"
           }
         ]
       },