fix(cli): sign macOS preview binaries

.github/workflows/publish.yml

@@ -124,12 +124,66 @@ jobs:
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
-          name: opencode-preview-cli
+          name: opencode-preview-cli-unsigned
           path: packages/cli/dist/cli-*
 
     outputs:
       version: ${{ needs.version.outputs.version }}
 
+  sign-cli-macos:
+    needs: build-cli
+    runs-on: macos-26
+    if: github.repository == 'anomalyco/opencode'
+    steps:
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+
+      - uses: apple-actions/import-codesign-certs@8f3fb608891dd2244cdab3d69cd68c0d37a7fe93 # v2.0.0
+        with:
+          keychain: build
+          p12-file-base64: ${{ secrets.APPLE_CERTIFICATE }}
+          p12-password: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          name: opencode-preview-cli-unsigned
+          path: packages/cli/dist
+
+      - name: Sign macOS CLI binaries
+        run: |
+          identity=$(security find-identity -v -p codesigning build.keychain | sed -n 's/.*"\(Developer ID Application:.*\)"/\1/p' | head -n 1)
+          if [ -z "$identity" ]; then
+            echo "Developer ID Application identity not found"
+            exit 1
+          fi
+
+          found=0
+          for file in packages/cli/dist/cli-darwin-*/bin/opencode2; do
+            if [ ! -f "$file" ]; then
+              continue
+            fi
+            found=1
+            codesign \
+              --force \
+              --timestamp \
+              --options runtime \
+              --entitlements packages/cli/script/entitlements.plist \
+              --sign "$identity" \
+              "$file"
+            codesign --verify --deep --strict --verbose=4 "$file"
+            codesign --display --requirements - "$file"
+          done
+
+          if [ "$found" -eq 0 ]; then
+            echo "No macOS CLI binaries found"
+            exit 1
+          fi
+
+      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: opencode-preview-cli
+          path: packages/cli/dist/cli-*
+          if-no-files-found: error
+
   build-node-cli:
     needs: version
     if: github.repository == 'anomalyco/opencode'
@@ -471,6 +525,7 @@ jobs:
     needs:
       - version
       - build-cli
+      - sign-cli-macos
       - build-node-cli
       - sign-cli-windows
       - build-electron

packages/cli/script/entitlements.plist

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.disable-executable-page-protection</key>
+    <true/>
+    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+    <true/>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
+</dict>
+</plist>

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

@@ -420,7 +420,6 @@ export type Endpoint5_26Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly delta: { readonly [x: string]: (string & Brand.Brand<"Instruction.Hash">) | "removed" }
-            readonly text?: string | undefined
           }
         }
       | {

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

@@ -676,7 +676,7 @@ export type SessionInstructionsUpdated = {
   type: "session.instructions.updated"
   durable: { aggregateID: string; seq: number; version: 2 }
   location?: LocationRef
-  data: { sessionID: string; delta: { [x: string]: string | "removed" }; text?: string }
+  data: { sessionID: string; delta: { [x: string]: string | "removed" } }
 }
 
 export type SessionSynthetic = {

packages/core/src/bus.ts

@@ -3,7 +3,7 @@ export * as Bus from "./bus"
 import { Cause, Context, DateTime, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
 import { Event } from "@opencode-ai/schema/event"
 import type { EventLog } from "@opencode-ai/schema/event-log"
-import { and, asc, eq, gt, lte, sql } from "drizzle-orm"
+import { and, asc, eq, gt, inArray, lte, sql } from "drizzle-orm"
 import { Database } from "./database/database"
 import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
@@ -134,6 +134,8 @@ export interface Interface {
     readonly after?: number
     readonly follow?: boolean
   }) => Stream.Stream<LogItem>
+  /** Latest committed seq per aggregate. Aggregates without events are absent. */
+  readonly sequences: (aggregateIDs: ReadonlyArray<string>) => Effect.Effect<ReadonlyMap<string, Event.Seq>>
   /** @deprecated Use `subscribe()` and consume the returned stream. */
   readonly listen: (listener: Subscriber) => Effect.Effect<Unsubscribe>
   readonly project: <D extends Event.Definition>(definition: D, projector: Subscriber<D>) => Effect.Effect<void>
@@ -655,6 +657,19 @@ export const layerWith = (options?: LayerOptions) =>
           }),
         )
 
+      const sequences = (aggregateIDs: ReadonlyArray<string>): Effect.Effect<ReadonlyMap<string, Event.Seq>> => {
+        if (aggregateIDs.length === 0) return Effect.succeed(new Map())
+        return db
+          .select({ aggregateID: EventSequenceTable.aggregate_id, seq: EventSequenceTable.seq })
+          .from(EventSequenceTable)
+          .where(inArray(EventSequenceTable.aggregate_id, Array.from(aggregateIDs)))
+          .all()
+          .pipe(
+            Effect.orDie,
+            Effect.map((rows) => new Map(rows.map((row) => [row.aggregateID, Event.Seq.make(row.seq)]))),
+          )
+      }
+
       const listen = (listener: Subscriber): Effect.Effect<Unsubscribe> =>
         Effect.sync(() => {
           listeners.push(listener)
@@ -676,6 +691,7 @@ export const layerWith = (options?: LayerOptions) =>
         publish,
         subscribe,
         log,
+        sequences,
         listen,
         project,
         replay,

packages/core/src/file-mutation.ts

@@ -1,7 +1,8 @@
 export * as FileMutation from "./file-mutation"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Context, Effect, Layer } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
+import { dirname } from "path"
 import { KeyedMutex } from "./effect/keyed-mutex"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Bom } from "@opencode-ai/util/bom"
@@ -21,6 +22,22 @@ export interface TextWriteInput {
   readonly content: string
 }
 
+export interface ConditionalWriteInput extends WriteInput {
+  readonly expected: Uint8Array
+}
+
+export interface RemoveInput {
+  readonly target: Target
+}
+
+export class StaleContentError extends Schema.TaggedErrorClass<StaleContentError>()("FileMutation.StaleContentError", {
+  path: Schema.String,
+}) {}
+
+export class TargetExistsError extends Schema.TaggedErrorClass<TargetExistsError>()("FileMutation.TargetExistsError", {
+  path: Schema.String,
+}) {}
+
 export interface WriteResult {
   readonly operation: "write"
   readonly target: string
@@ -28,10 +45,24 @@ export interface WriteResult {
   readonly existed: boolean
 }
 
+export interface RemoveResult {
+  readonly operation: "remove"
+  readonly target: string
+  readonly resource: string
+  readonly existed: boolean
+}
+
 export interface Interface {
+  /** Create without replacing an existing target. */
+  readonly create: (input: WriteInput) => Effect.Effect<WriteResult, TargetExistsError | FSUtil.Error>
   readonly write: (input: WriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
   /** Write text while retaining an existing UTF-8 BOM and emitting at most one BOM. */
   readonly writeTextPreservingBom: (input: TextWriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
+  /** Commit only if an existing target still has the expected bytes. */
+  readonly writeIfUnchanged: (
+    input: ConditionalWriteInput,
+  ) => Effect.Effect<WriteResult, StaleContentError | FSUtil.Error>
+  readonly remove: (input: RemoveInput) => Effect.Effect<RemoveResult, FSUtil.Error>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/FileMutation") {}
@@ -58,6 +89,13 @@ const layer = Layer.effect(
       existed,
     })
 
+    const removeResult = (target: Target, existed: boolean): RemoveResult => ({
+      operation: "remove",
+      target: target.canonical,
+      resource: target.resource,
+      existed,
+    })
+
     const write = Effect.fn("FileMutation.write")((input: WriteInput) =>
       withTargetLock(input.target)(
         Effect.gen(function* () {
@@ -84,10 +122,62 @@ const layer = Layer.effect(
       ),
     )
 
-    return Service.of({ write, writeTextPreservingBom })
+    const create = Effect.fn("FileMutation.create")((input: WriteInput) =>
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const write =
+            typeof input.content === "string"
+              ? fs.writeFileString(input.target.canonical, input.content, { flag: "wx" })
+              : fs.writeFile(input.target.canonical, input.content, { flag: "wx" })
+          yield* write.pipe(
+            Effect.catchReason("PlatformError", "NotFound", () =>
+              fs.ensureDir(dirname(input.target.canonical)).pipe(Effect.andThen(write)),
+            ),
+            Effect.catchReason("PlatformError", "AlreadyExists", () =>
+              Effect.fail(new TargetExistsError({ path: input.target.canonical })),
+            ),
+          )
+          return writeResult(input.target, false)
+        }),
+      ),
+    )
+
+    const writeIfUnchanged = Effect.fn("FileMutation.writeIfUnchanged")((input: ConditionalWriteInput) =>
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const current = yield* fs.readFile(input.target.canonical)
+          if (!sameBytes(current, input.expected)) {
+            return yield* new StaleContentError({ path: input.target.canonical })
+          }
+          yield* typeof input.content === "string"
+            ? fs.writeFileString(input.target.canonical, input.content)
+            : fs.writeFile(input.target.canonical, input.content)
+          return writeResult(input.target, true)
+        }),
+      ),
+    )
+
+    const remove = Effect.fn("FileMutation.remove")((input: RemoveInput) =>
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const existed = yield* fs.remove(input.target.canonical).pipe(
+            Effect.as(true),
+            Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(false)),
+          )
+          return removeResult(input.target, existed)
+        }),
+      ),
+    )
+
+    return Service.of({ create, write, writeTextPreservingBom, writeIfUnchanged, remove })
   }),
 )
 
+function sameBytes(left: Uint8Array, right: Uint8Array) {
+  if (left.length !== right.length) return false
+  return left.every((byte, index) => byte === right[index])
+}
+
 export const node = makeLocationNode({ service: Service, layer, deps: [FSUtil.node] })
 
 /**

packages/core/src/filesystem/search.ts

@@ -31,7 +31,10 @@ export const ripgrepLayer = Layer.effect(
     const location = yield* Location.Service
     const ripgrep = yield* Ripgrep.Service
     const scope = yield* Scope.Scope
-    const files: string[] = []
+    const state = {
+      files: [] as string[],
+      directories: [] as string[],
+    }
     const directories = new Set<string>()
     yield* ripgrep
       .find({
@@ -40,9 +43,10 @@ export const ripgrepLayer = Layer.effect(
         limit: location.vcs ? Number.MAX_SAFE_INTEGER : 100_000,
         onEntry: (entry) =>
           Effect.sync(() => {
-            files.push(entry.path)
+            state.files.push(entry.path)
             const parts = entry.path.split("/")
             parts.slice(0, -1).forEach((_, index) => directories.add(parts.slice(0, index + 1).join("/") + path.sep))
+            state.directories = Array.from(directories)
           }),
       })
       .pipe(Effect.orDie, Effect.asVoid, Effect.forkIn(scope))
@@ -102,10 +106,10 @@ export const ripgrepLayer = Layer.effect(
         Effect.gen(function* () {
           const items =
             input.type === "file"
-              ? files
+              ? state.files
               : input.type === "directory"
-                ? Array.from(directories)
-                : [...files, ...directories]
+                ? state.directories
+                : [...state.files, ...state.directories]
           return fuzzysort.go(input.query, items, { limit: input.limit ?? 50 }).map((item) => {
             const relative = item.target
             const type = relative.endsWith(path.sep) ? ("directory" as const) : ("file" as const)

packages/core/src/formatter.ts

@@ -1,6 +1,6 @@
 export * as Formatter from "./formatter"
 
-import { Context, Effect, Layer } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import path from "path"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
@@ -11,7 +11,16 @@ import { Config } from "./config"
 import { Location } from "./location"
 import { make, type Info } from "./formatter/builtins"
 
+export const Status = Schema.Struct({
+  name: Schema.String,
+  extensions: Schema.Array(Schema.String),
+  enabled: Schema.Boolean,
+}).annotate({ identifier: "FormatterStatus" })
+export type Status = typeof Status.Type
+
 export interface Interface {
+  readonly init: () => Effect.Effect<void>
+  readonly status: () => Effect.Effect<Status[]>
   readonly file: (filepath: string) => Effect.Effect<boolean>
 }
 
@@ -75,6 +84,23 @@ const layer = Layer.effect(
       return result
     })
 
+    const init = Effect.fn("Formatter.init")(function* () {
+      yield* load
+    })
+
+    const status = Effect.fn("Formatter.status")(function* () {
+      yield* load
+      return yield* Effect.forEach(formatters, (formatter) =>
+        command(formatter).pipe(
+          Effect.map((enabled) => ({
+            name: formatter.name,
+            extensions: [...formatter.extensions],
+            enabled: enabled !== false,
+          })),
+        ),
+      )
+    })
+
     const file = Effect.fn("Formatter.file")(function* (filepath: string) {
       yield* load
       const matching = formatters.filter((formatter) =>
@@ -117,7 +143,7 @@ const layer = Layer.effect(
       return false
     })
 
-    return Service.of({ file })
+    return Service.of({ init, status, file })
   }),
 )
 

packages/core/src/git.ts

@@ -1,7 +1,8 @@
 export * as Git from "./git"
 
 import path from "path"
-import { Context, Effect, Layer, Schema } from "effect"
+import { randomUUID } from "crypto"
+import { Context, Effect, Layer, Schema, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { AbsolutePath, RelativePath } from "./schema"
 import { FSUtil } from "@opencode-ai/util/fs-util"
@@ -35,6 +36,9 @@ const snapshotConfig = `[core]
 	threads = true
 `
 
+export const ChangeSet = Schema.String.pipe(Schema.brand("Git.ChangeSet"))
+export type ChangeSet = typeof ChangeSet.Type
+
 export const TreeID = Schema.String.pipe(Schema.brand("Git.TreeID"))
 export type TreeID = typeof TreeID.Type
 
@@ -69,6 +73,13 @@ export class WorktreeError extends Schema.TaggedErrorClass<WorktreeError>()("Git
   cause: Schema.optional(Schema.Defect()),
 }) {}
 
+export class PatchError extends Schema.TaggedErrorClass<PatchError>()("Git.PatchError", {
+  operation: Schema.Literals(["capture", "apply", "reset"]),
+  directory: AbsolutePath,
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect()),
+}) {}
+
 export interface Interface {
   readonly repo: {
     readonly discover: (input: AbsolutePath) => Effect.Effect<Repository | undefined>
@@ -105,6 +116,20 @@ export interface Interface {
     ) => Effect.Effect<void, OperationError>
     readonly resetHard: (repository: Repository, revision: string) => Effect.Effect<void, OperationError>
   }
+  readonly change: {
+    readonly capture: (input: { repository: Repository; path: AbsolutePath }) => Effect.Effect<ChangeSet, PatchError>
+    readonly apply: (input: {
+      repository: Repository
+      path: AbsolutePath
+      changes: ChangeSet
+    }) => Effect.Effect<void, PatchError>
+    readonly discard: (input: {
+      repository: Repository
+      path: AbsolutePath
+      index: "preserve" | "reset"
+      untracked: "preserve" | "remove"
+    }) => Effect.Effect<void, PatchError>
+  }
   readonly worktree: {
     readonly create: (input: {
       repository: Repository
@@ -150,10 +175,17 @@ export interface Interface {
       context?: number
       paths?: readonly RelativePath[]
     }) => Effect.Effect<readonly File.Diff[], OperationError>
+    readonly preview: (input: {
+      repository: Repository
+      current: TreeID
+      files: ReadonlyMap<RelativePath, TreeID>
+      context?: number
+    }) => Effect.Effect<readonly File.Diff[], OperationError>
     readonly restore: (input: {
       repository: Repository
       files: ReadonlyMap<RelativePath, TreeID>
     }) => Effect.Effect<void, OperationError>
+    readonly checkout: (input: { repository: Repository; tree: TreeID }) => Effect.Effect<void, OperationError>
   }
 }
 
@@ -625,6 +657,58 @@ const layer = Layer.effect(
       return { mode: match[1], object: match[2] }
     })
 
+    const preview = Effect.fn("Git.tree.preview")(
+      (input: {
+        repository: Repository
+        current: TreeID
+        files: ReadonlyMap<RelativePath, TreeID>
+        context?: number
+      }) =>
+        locked(
+          input.repository,
+          Effect.gen(function* () {
+            const index = path.join(input.repository.gitDirectory, `preview-${randomUUID()}.index`)
+            const env = { GIT_INDEX_FILE: index }
+            return yield* Effect.gen(function* () {
+              yield* repositoryOperation("diff", input.repository, ["read-tree", input.current], { env })
+              yield* Effect.forEach(
+                input.files,
+                ([file, tree]) =>
+                  Effect.gen(function* () {
+                    const source = yield* entry(input.repository, tree, file)
+                    if (!source) {
+                      yield* repositoryOperation(
+                        "diff",
+                        input.repository,
+                        ["update-index", "--force-remove", "--", file],
+                        { env },
+                      )
+                      return
+                    }
+                    yield* repositoryOperation(
+                      "diff",
+                      input.repository,
+                      ["update-index", "--add", "--cacheinfo", source.mode, source.object, file],
+                      { env },
+                    )
+                  }),
+                { discard: true },
+              )
+              const target = TreeID.make(
+                (yield* repositoryOperation("diff", input.repository, ["write-tree"], { env })).text.trim(),
+              )
+              return yield* treeDiff({
+                repository: input.repository,
+                from: input.current,
+                to: target,
+                context: input.context,
+                paths: Array.from(input.files.keys()),
+              })
+            }).pipe(Effect.ensuring(fs.remove(index).pipe(Effect.catch(() => Effect.void))))
+          }),
+        ),
+    )
+
     const restore = Effect.fn("Git.tree.restore")(
       (input: { repository: Repository; files: ReadonlyMap<RelativePath, TreeID> }) =>
         locked(
@@ -654,6 +738,142 @@ const layer = Layer.effect(
         ),
     )
 
+    const checkoutTree = Effect.fn("Git.tree.checkout")((input: { repository: Repository; tree: TreeID }) =>
+      locked(
+        input.repository,
+        Effect.gen(function* () {
+          yield* repositoryOperation("restore", input.repository, ["read-tree", input.tree])
+          yield* repositoryOperation("restore", input.repository, ["checkout-index", "--all", "--force"])
+        }),
+      ),
+    )
+
+    const capture = Effect.fn("Git.change.capture")(function* (input: { repository: Repository; path: AbsolutePath }) {
+      const scope = path.relative(input.repository.worktree, input.path).replaceAll("\\", "/") || "."
+      const tracked = yield* execute(
+        input.repository.worktree,
+        proc,
+      )(["diff", "--binary", "HEAD", "--", scope]).pipe(
+        Effect.mapError(
+          (cause) => new PatchError({ operation: "capture", directory: input.path, message: cause.message, cause }),
+        ),
+      )
+      if (tracked.exitCode !== 0) {
+        return yield* new PatchError({
+          operation: "capture",
+          directory: input.path,
+          message: tracked.stderr.trim() || tracked.text.trim() || "Failed to capture tracked changes",
+        })
+      }
+
+      const untracked = yield* execute(
+        input.repository.worktree,
+        proc,
+      )(["ls-files", "--others", "--exclude-standard", "-z", "--", scope]).pipe(
+        Effect.mapError(
+          (cause) => new PatchError({ operation: "capture", directory: input.path, message: cause.message, cause }),
+        ),
+      )
+      if (untracked.exitCode !== 0) {
+        return yield* new PatchError({
+          operation: "capture",
+          directory: input.path,
+          message: untracked.stderr.trim() || untracked.text.trim() || "Failed to list untracked changes",
+        })
+      }
+
+      const created = yield* Effect.forEach(untracked.text.split("\0").filter(Boolean), (file) =>
+        execute(
+          input.repository.worktree,
+          proc,
+        )(["diff", "--binary", "--no-index", "--", "/dev/null", file]).pipe(
+          Effect.mapError(
+            (cause) => new PatchError({ operation: "capture", directory: input.path, message: cause.message, cause }),
+          ),
+          Effect.flatMap((result) =>
+            // git diff --no-index returns 1 when differences were found.
+            result.exitCode === 0 || result.exitCode === 1
+              ? Effect.succeed(result.text)
+              : Effect.fail(
+                  new PatchError({
+                    operation: "capture",
+                    directory: input.path,
+                    message:
+                      result.stderr.trim() || result.text.trim() || `Failed to capture untracked change: ${file}`,
+                  }),
+                ),
+          ),
+        ),
+      )
+      return ChangeSet.make([tracked.text, ...created].filter(Boolean).join("\n"))
+    })
+
+    const apply = Effect.fn("Git.change.apply")(function* (input: {
+      repository: Repository
+      path: AbsolutePath
+      changes: ChangeSet
+    }) {
+      const result = yield* proc
+        .run(
+          ChildProcess.make("git", ["apply", "-"], {
+            cwd: input.path,
+            extendEnv: true,
+            stdin: Stream.make(new TextEncoder().encode(input.changes)),
+          }),
+        )
+        .pipe(
+          Effect.mapError(
+            (cause) => new PatchError({ operation: "apply", directory: input.path, message: cause.message, cause }),
+          ),
+        )
+      if (result.exitCode === 0) return
+      return yield* new PatchError({
+        operation: "apply",
+        directory: input.path,
+        message:
+          result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || "Failed to apply changes",
+      })
+    })
+
+    const discard = Effect.fn("Git.change.discard")(function* (input: {
+      repository: Repository
+      path: AbsolutePath
+      index: "preserve" | "reset"
+      untracked: "preserve" | "remove"
+    }) {
+      const scope = path.relative(input.repository.worktree, input.path).replaceAll("\\", "/") || "."
+      const restore = yield* execute(
+        input.repository.worktree,
+        proc,
+      )(input.index === "reset" ? ["checkout", "HEAD", "--", scope] : ["checkout", "--", scope]).pipe(
+        Effect.mapError(
+          (cause) => new PatchError({ operation: "reset", directory: input.path, message: cause.message, cause }),
+        ),
+      )
+      if (restore.exitCode !== 0) {
+        return yield* new PatchError({
+          operation: "reset",
+          directory: input.path,
+          message: restore.stderr.trim() || restore.text.trim() || "Failed to restore tracked changes",
+        })
+      }
+      if (input.untracked === "preserve") return
+      const clean = yield* execute(
+        input.repository.worktree,
+        proc,
+      )(["clean", "-fd", "--", scope]).pipe(
+        Effect.mapError(
+          (cause) => new PatchError({ operation: "reset", directory: input.path, message: cause.message, cause }),
+        ),
+      )
+      if (clean.exitCode === 0) return
+      return yield* new PatchError({
+        operation: "reset",
+        directory: input.path,
+        message: clean.stderr.trim() || clean.text.trim() || "Failed to clean untracked changes",
+      })
+    })
+
     const worktreeRun = Effect.fnUntraced(function* (
       operation: "create" | "remove" | "list",
       repository: Repository,
@@ -729,6 +949,7 @@ const layer = Layer.effect(
       remote: { get: remote },
       history: { head, branch, defaultRemoteBranch: remoteHead, rootCommits: roots },
       sync: { fetchRemotes: fetch, fetchBranch, checkoutRemoteBranch: checkout, resetHard: reset },
+      change: { capture, apply, discard },
       worktree: { create: worktreeCreate, remove: worktreeRemove, list: worktreeList },
       index: { refresh, ignored },
       tree: {
@@ -736,7 +957,9 @@ const layer = Layer.effect(
         write: writeTree,
         files: treeFiles,
         diff: treeDiff,
+        preview,
         restore,
+        checkout: checkoutTree,
       },
     })
   }),

packages/core/src/session.ts

@@ -410,7 +410,7 @@ const layer = Layer.effect(
       fork: Effect.fn("Session.fork")(function* (input) {
         const parent = yield* result.get(input.sessionID)
         const boundary = yield* db
-          .select({ id: SessionMessageTable.id })
+          .select({ id: SessionMessageTable.id, seq: SessionMessageTable.seq })
           .from(SessionMessageTable)
           .where(
             and(
@@ -429,14 +429,13 @@ const layer = Layer.effect(
           })
         if (!boundary) return yield* new ForkEmptyError({ sessionID: input.sessionID })
         const sessionID = SessionSchema.ID.create()
-        // The fork adopts the parent's newest instruction values rather than the
-        // values in effect at the boundary; copied history may contain frozen
-        // instruction-update text the initial baseline already reflects.
+        const instructionThrough =
+          input.boundary.type === "before" ? boundary.seq - 1 : yield* Bus.latestSequence(db, parent.id)
         yield* bus.publish(SessionEvent.Forked, {
           sessionID,
           parentID: parent.id,
           boundary: { ...input.boundary, messageID: boundary.id },
-          instructions: yield* InstructionState.current(db, parent.id),
+          instructions: yield* InstructionState.valuesAt(db, parent.id, instructionThrough),
         })
         return yield* result.get(sessionID).pipe(Effect.orDie)
       }),

packages/core/src/session/history.ts

@@ -80,9 +80,10 @@ export const entriesForRunner = Effect.fn("SessionHistory.entriesForRunner")(fun
     .transaction(() =>
       Effect.gen(function* () {
         const messages = yield* messageEntries(db, sessionID)
+        const assembled = yield* InstructionState.assemble(db, sessionID, instructions)
         return {
-          initial: yield* InstructionState.initial(db, sessionID, instructions),
-          entries: messages,
+          initial: assembled.initial,
+          entries: [...messages, ...assembled.updates].toSorted((a, b) => a.seq - b.seq),
         }
       }),
     )
@@ -105,9 +106,10 @@ export const preview = Effect.fn("SessionHistory.preview")(function* (
         )
         const settled = unsettled === -1 ? messages : messages.slice(0, unsettled)
         const assembled = yield* InstructionState.preview(db, sessionID, instructions, observed)
+        const entries = [...settled, ...assembled.updates].toSorted((a, b) => a.seq - b.seq)
         return {
           initial: assembled.initial,
-          messages: settled.map((entry) => entry.message),
+          messages: entries.map((entry) => entry.message),
           instructionUpdate: assembled.update,
         }
       }),

packages/core/src/session/instruction-state.ts

@@ -1,20 +1,25 @@
 export * as InstructionState from "./instruction-state"
 
-import { eq, inArray, sql } from "drizzle-orm"
-import { Effect, Option, Schema } from "effect"
+import { and, asc, desc, eq, gt, inArray, lte, sql } from "drizzle-orm"
+import { DateTime, Effect, Option, Schema } from "effect"
 import type { Database } from "../database/database"
-import type { Bus } from "../bus"
+import { Bus } from "../bus"
+import { EventTable } from "../event/sql"
 import { Instructions } from "../instructions/index"
 import { SessionEvent } from "./event"
+import { SessionMessage } from "./message"
+import { Event } from "@opencode-ai/schema/event"
 import { SessionSchema } from "./schema"
 import { InstructionBlobTable, InstructionStateTable } from "./sql"
 
 type DatabaseService = Database.Interface["db"]
 
+const decodeInstructionsUpdated = Schema.decodeUnknownSync(SessionEvent.InstructionsUpdated.data)
+const decodeForked = Schema.decodeUnknownSync(SessionEvent.Forked.data)
+
 export interface Observation extends Instructions.Admission {
   readonly sessionID: SessionSchema.ID
   readonly initial: boolean
-  readonly previous: Instructions.Values
   readonly current: Instructions.Values
 }
 
@@ -23,14 +28,13 @@ export const observe = Effect.fn("InstructionState.observe")(function* (
   instructions: Instructions.Instructions,
   sessionID: SessionSchema.ID,
 ): Effect.fn.Return<Observation, Instructions.InitializationBlocked> {
-  const [observed, stored] = yield* Effect.all([Instructions.read(instructions), find(db, sessionID)], {
+  const [observed, stored] = yield* Effect.all([Instructions.read(instructions), ensure(db, sessionID)], {
     concurrency: "unbounded",
   })
   const result = yield* observeAgainst(observed, stored?.current_values)
   return {
     sessionID,
     initial: !stored,
-    previous: stored?.current_values ?? {},
     ...result,
   }
 })
@@ -38,20 +42,12 @@ export const observe = Effect.fn("InstructionState.observe")(function* (
 export const commit = Effect.fn("InstructionState.commit")(function* (
   db: DatabaseService,
   bus: Bus.Interface,
-  instructions: Instructions.Instructions,
   observation: Observation,
 ) {
   if (!observation.initial && Object.keys(observation.delta).length === 0) return
-  // The rendered text is frozen into the durable event: replaying it later would
-  // require the Location-scoped registry that produced it.
-  const text = observation.initial ? "" : yield* renderUpdateText(db, instructions, observation)
   yield* bus.publish(
     SessionEvent.InstructionsUpdated,
-    {
-      sessionID: observation.sessionID,
-      delta: observation.delta,
-      ...(text.length > 0 ? { text } : {}),
-    },
+    { sessionID: observation.sessionID, delta: observation.delta },
     {
       // Initial sync establishes the baseline; unlike later deltas it is not chronological history.
       ...(observation.initial ? { metadata: { instructions: { initial: true } } } : {}),
@@ -60,27 +56,13 @@ export const commit = Effect.fn("InstructionState.commit")(function* (
   )
 })
 
-const renderUpdateText = Effect.fnUntraced(function* (
-  db: DatabaseService,
-  instructions: Instructions.Instructions,
-  observation: Observation,
-) {
-  const replaced = Object.entries(observation.previous).filter(([key]) => Object.hasOwn(observation.delta, key))
-  const blobs = yield* loadBlobs(db, replaced.map(([, hash]) => hash))
-  const previous = Object.fromEntries(replaced.map(([key, hash]) => [key, requireBlob(blobs, hash)]))
-  const admitted = new Map(
-    Object.entries(observation.blobs).map(([hash, value]) => [Instructions.Hash.make(hash), value]),
-  )
-  return Instructions.renderUpdate(instructions, previous, dereferenceDelta(observation.delta, admitted))
-})
-
 export const prepare = Effect.fn("InstructionState.prepare")(function* (
   db: DatabaseService,
   bus: Bus.Interface,
   instructions: Instructions.Instructions,
   sessionID: SessionSchema.ID,
 ) {
-  yield* commit(db, bus, instructions, yield* observe(db, instructions, sessionID))
+  yield* commit(db, bus, yield* observe(db, instructions, sessionID))
 })
 
 export const apply = Effect.fn("InstructionState.apply")(function* (
@@ -158,24 +140,79 @@ export const reset = Effect.fn("InstructionState.reset")(function* (db: Database
     .pipe(Effect.orDie)
 })
 
-/** Renders the epoch baseline shown at the start of every model request. */
-export const initial = Effect.fn("InstructionState.initial")(function* (
+export const rebuild = Effect.fn("InstructionState.rebuild")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+) {
+  const state = yield* stateFromEvents(db, sessionID)
+  if (!state) {
+    yield* reset(db, sessionID)
+    return undefined
+  }
+  yield* db
+    .insert(InstructionStateTable)
+    .values(state)
+    .onConflictDoUpdate({
+      target: InstructionStateTable.session_id,
+      set: {
+        epoch_start: state.epoch_start,
+        through_seq: state.through_seq,
+        initial_values: state.initial_values,
+        current_values: state.current_values,
+      },
+    })
+    .run()
+    .pipe(Effect.orDie)
+  return state
+})
+
+const assembleState = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  instructions: Instructions.Instructions,
+  state: typeof InstructionStateTable.$inferSelect,
+) {
+  const rows = yield* instructionUpdatesAfter(db, sessionID, state.epoch_start)
+  const updates = rows.map((row) => ({
+    row,
+    delta: decodeInstructionsUpdated(row.data).delta,
+  }))
+  const blobs = yield* loadBlobs(db, [
+    ...Object.values(state.initial_values),
+    ...updates.flatMap((update) =>
+      Object.values(update.delta).filter((hash): hash is Instructions.Hash => hash !== "removed"),
+    ),
+  ])
+  const valuesAtStart = dereference(state.initial_values, blobs)
+  let values = valuesAtStart
+  const result: Array<{ readonly seq: number; readonly message: SessionMessage.System }> = []
+  for (const update of updates) {
+    const delta = dereferenceDelta(update.delta, blobs)
+    const text = Instructions.renderUpdate(instructions, values, delta)
+    if (text.length > 0)
+      result.push({
+        seq: update.row.seq,
+        message: SessionMessage.System.make({
+          id: SessionMessage.ID.fromEvent(Event.ID.make(update.row.id)),
+          type: "system",
+          text,
+          time: { created: DateTime.makeUnsafe(update.row.created) },
+        }),
+      })
+    values = Instructions.applyDelta(values, delta)
+  }
+  return { initial: Instructions.renderInitial(instructions, valuesAtStart), updates: result, current: values }
+})
+
+export const assemble = Effect.fn("InstructionState.assemble")(function* (
   db: DatabaseService,
   sessionID: SessionSchema.ID,
   instructions: Instructions.Instructions,
 ) {
   const state = yield* find(db, sessionID)
   if (!state) return yield* Effect.die(new Error(`Instruction state not found during assembly: ${sessionID}`))
-  const blobs = yield* loadBlobs(db, Object.values(state.initial_values))
-  return Instructions.renderInitial(instructions, dereference(state.initial_values, blobs))
-})
-
-/** The current instruction values, used to seed a fork's baseline. */
-export const current = Effect.fn("InstructionState.current")(function* (
-  db: DatabaseService,
-  sessionID: SessionSchema.ID,
-) {
-  return (yield* find(db, sessionID))?.current_values
+  const assembled = yield* assembleState(db, sessionID, instructions, state)
+  return { initial: assembled.initial, updates: assembled.updates }
 })
 
 export const preview = Effect.fn("InstructionState.preview")(function* (
@@ -184,26 +221,20 @@ export const preview = Effect.fn("InstructionState.preview")(function* (
   instructions: Instructions.Instructions,
   observed: Instructions.ReadResult,
 ) {
-  const state = yield* find(db, sessionID)
+  const state = yield* readState(db, sessionID)
   const result = yield* observeAgainst(observed, state?.current_values)
-  const observedBlobs = new Map<Instructions.Hash, Schema.Json>(
+  const blobs = new Map<Instructions.Hash, Schema.Json>(
     Object.entries(result.blobs).map(([hash, value]) => [Instructions.Hash.make(hash), value]),
   )
   if (!state) {
-    const values = dereference(result.current, observedBlobs)
-    return { initial: Instructions.renderInitial(instructions, values), update: "" }
+    const values = dereference(result.current, blobs)
+    return { initial: Instructions.renderInitial(instructions, values), updates: [], update: "" }
   }
-  const stored = yield* loadBlobs(db, [
-    ...Object.values(state.initial_values),
-    ...Object.values(state.current_values),
-  ])
+  const assembled = yield* assembleState(db, sessionID, instructions, state)
   return {
-    initial: Instructions.renderInitial(instructions, dereference(state.initial_values, stored)),
-    update: Instructions.renderUpdate(
-      instructions,
-      dereference(state.current_values, stored),
-      dereferenceDelta(result.delta, new Map([...stored, ...observedBlobs])),
-    ),
+    initial: assembled.initial,
+    updates: assembled.updates,
+    update: Instructions.renderUpdate(instructions, assembled.current, dereferenceDelta(result.delta, blobs)),
   }
 })
 
@@ -224,6 +255,46 @@ const find = Effect.fnUntraced(function* (db: DatabaseService, sessionID: Sessio
     .pipe(Effect.orDie)
 })
 
+const ensure = Effect.fnUntraced(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
+  const stored = yield* find(db, sessionID)
+  if (!stored) return yield* rebuild(db, sessionID)
+  const latest = yield* latestRelevantSequence(db, sessionID)
+  if (!latest || latest.seq <= stored.through_seq) return stored
+  return yield* rebuild(db, sessionID)
+})
+
+const readState = Effect.fnUntraced(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
+  const stored = yield* find(db, sessionID)
+  if (!stored) return yield* stateFromEvents(db, sessionID)
+  const latest = yield* latestRelevantSequence(db, sessionID)
+  if (!latest || latest.seq <= stored.through_seq) return stored
+  return yield* stateFromEvents(db, sessionID)
+})
+
+const stateFromEvents = Effect.fnUntraced(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
+  const folded = fold(yield* instructionEvents(db, sessionID))
+  return folded ? foldedState(sessionID, folded) : undefined
+})
+
+export const valuesAt = Effect.fn("InstructionState.valuesAt")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  through: number,
+) {
+  return fold(yield* instructionEvents(db, sessionID, through))?.current
+})
+
+const latestRelevantSequence = Effect.fnUntraced(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
+  return yield* db
+    .select({ seq: EventTable.seq })
+    .from(EventTable)
+    .where(and(eq(EventTable.aggregate_id, sessionID), inArray(EventTable.type, relevantEventTypes)))
+    .orderBy(desc(EventTable.seq))
+    .limit(1)
+    .get()
+    .pipe(Effect.orDie)
+})
+
 const insertBlobs = Effect.fnUntraced(function* (db: DatabaseService, blobs: Readonly<Record<string, Schema.Json>>) {
   const rows = Object.entries(blobs).map(([hash, value]) => ({ hash: Instructions.Hash.make(hash), value }))
   if (rows.length === 0) return
@@ -268,3 +339,106 @@ function requireBlob(blobs: ReadonlyMap<Instructions.Hash, Schema.Json>, hash: I
   if (value === undefined) throw new Error(`Instruction blob not found: ${hash}`)
   return value
 }
+
+const instructionEventType = Bus.versionedType(
+  SessionEvent.InstructionsUpdated.type,
+  SessionEvent.InstructionsUpdated.durable.version,
+)
+const compactionEventType = Bus.versionedType(
+  SessionEvent.Compaction.Ended.type,
+  SessionEvent.Compaction.Ended.durable.version,
+)
+const movedEventType = Bus.versionedType(SessionEvent.Moved.type, SessionEvent.Moved.durable.version)
+const revertedEventType = Bus.versionedType(
+  SessionEvent.RevertEvent.Committed.type,
+  SessionEvent.RevertEvent.Committed.durable.version,
+)
+const forkedEventType = Bus.versionedType(SessionEvent.Forked.type, SessionEvent.Forked.durable.version)
+const relevantEventTypes = [
+  forkedEventType,
+  instructionEventType,
+  compactionEventType,
+  movedEventType,
+  revertedEventType,
+]
+
+type InstructionEventRow = typeof EventTable.$inferSelect
+
+const instructionEvents = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  through?: number,
+): Effect.fn.Return<ReadonlyArray<InstructionEventRow>> {
+  return yield* eventRows(db, sessionID, relevantEventTypes, undefined, through)
+})
+
+const instructionUpdatesAfter = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  after: number,
+) {
+  return yield* eventRows(db, sessionID, [instructionEventType], after)
+})
+
+const eventRows = Effect.fnUntraced(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  types: ReadonlyArray<string>,
+  after?: number,
+  through?: number,
+): Effect.fn.Return<ReadonlyArray<InstructionEventRow>> {
+  return yield* db
+    .select()
+    .from(EventTable)
+    .where(
+      and(
+        eq(EventTable.aggregate_id, sessionID),
+        inArray(EventTable.type, types),
+        after === undefined ? undefined : gt(EventTable.seq, after),
+        through === undefined ? undefined : lte(EventTable.seq, through),
+      ),
+    )
+    .orderBy(asc(EventTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+})
+
+function fold(rows: ReadonlyArray<InstructionEventRow>) {
+  return rows.reduce<
+    | {
+        readonly epochStart: number
+        readonly throughSeq: number
+        readonly initial: Instructions.Values
+        readonly current: Instructions.Values
+      }
+    | undefined
+  >((state, row) => {
+    if (row.type === forkedEventType) {
+      const instructions = decodeForked(row.data).instructions
+      return instructions
+        ? { epochStart: row.seq, throughSeq: row.seq, initial: instructions, current: instructions }
+        : undefined
+    }
+    if (row.type === movedEventType || row.type === revertedEventType) return undefined
+    if (row.type === compactionEventType)
+      return state
+        ? { epochStart: row.seq, throughSeq: row.seq, initial: state.current, current: state.current }
+        : undefined
+    if (row.type !== instructionEventType) return state
+    const delta = decodeInstructionsUpdated(row.data).delta
+    const current = Instructions.applyHashDelta(state?.current ?? {}, delta)
+    return state
+      ? { ...state, throughSeq: row.seq, current }
+      : { epochStart: row.seq, throughSeq: row.seq, initial: current, current }
+  }, undefined)
+}
+
+function foldedState(sessionID: SessionSchema.ID, folded: NonNullable<ReturnType<typeof fold>>) {
+  return {
+    session_id: sessionID,
+    epoch_start: folded.epochStart,
+    through_seq: folded.throughSeq,
+    initial_values: folded.initial,
+    current_values: folded.current,
+  }
+}

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

@@ -179,18 +179,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       "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(
-          SessionMessage.System.make({
-            id: SessionMessage.ID.fromEvent(event.id),
-            type: "system",
-            text: event.data.text,
-            metadata: event.metadata,
-            time: { created: event.created },
-          }),
-        )
-      },
+      "session.instructions.updated": () => Effect.void,
       "session.synthetic": (event) => {
         return adapter.appendMessage(
           SessionMessage.Synthetic.make({

packages/core/src/session/pending.ts

@@ -12,8 +12,10 @@ import {
   User,
   UserData,
 } from "@opencode-ai/schema/session-pending"
+import { Event } from "@opencode-ai/schema/event"
 import type { Database } from "../database/database"
 import { Bus } from "../bus"
+import { EventTable } from "../event/sql"
 import { KeyedMutex } from "../effect/keyed-mutex"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
@@ -35,7 +37,11 @@ const decodeUser = Schema.decodeUnknownSync(UserData)
 const encodeUser = Schema.encodeSync(UserData)
 const decodeSynthetic = Schema.decodeUnknownSync(SyntheticData)
 const encodeSynthetic = Schema.encodeSync(SyntheticData)
-const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info)
+const decodeAdmittedEvent = Schema.decodeUnknownOption(SessionEvent.InputAdmitted.data)
+const admittedEventType = Bus.versionedType(
+  SessionEvent.InputAdmitted.type,
+  SessionEvent.InputAdmitted.durable.version,
+)
 const inboxLocks = KeyedMutex.makeUnsafe<SessionSchema.ID>()
 
 export class LifecycleConflict extends Schema.TaggedErrorClass<LifecycleConflict>()(
@@ -97,35 +103,46 @@ export const compaction = Effect.fn("SessionPending.compaction")(function* (
   return entry.type === "compaction" ? entry : undefined
 })
 
-const promotedFromMessage = Effect.fn("SessionPending.promotedFromMessage")(function* (
+/**
+ * Reconstruct the admitted record for a pending row that was already consumed
+ * by promotion. The projected `session_message` row proves promotion happened;
+ * the durable `session.input.admitted` event retains the exact admitted
+ * message, including delivery.
+ */
+const promotedFromHistory = Effect.fn("SessionPending.promotedFromHistory")(function* (
   db: DatabaseService,
   sessionID: SessionSchema.ID,
   id: SessionMessage.ID,
-  delivery: Delivery,
 ) {
-  const row = yield* db
+  const message = yield* db
     .select()
     .from(SessionMessageTable)
     .where(eq(SessionMessageTable.id, id))
     .get()
     .pipe(Effect.orDie)
-  if (row === undefined) return undefined
-  if (row.session_id !== sessionID || (row.type !== "user" && row.type !== "synthetic"))
+  if (message === undefined) return undefined
+  if (message.session_id !== sessionID || (message.type !== "user" && message.type !== "synthetic"))
     return yield* Effect.die(new LifecycleConflict({ id }))
-  const message = decodeMessage({ ...row.data, id: row.id, type: row.type })
-  const base = { id, sessionID, timeCreated: message.time.created, delivery }
-  if (message.type === "user")
-    return User.make({
-      ...base,
-      type: "user",
-      data: decodeUser(message),
-    })
-  if (message.type === "synthetic")
-    return Synthetic.make({
-      ...base,
-      type: "synthetic",
-      data: decodeSynthetic(message),
-    })
+  const rows = yield* db
+    .select()
+    .from(EventTable)
+    .where(and(eq(EventTable.aggregate_id, sessionID), eq(EventTable.type, admittedEventType)))
+    .all()
+    .pipe(Effect.orDie)
+  for (const row of rows) {
+    const decoded = decodeAdmittedEvent(row.data)
+    if (decoded._tag !== "Some" || decoded.value.inputID !== id) continue
+    const base = {
+      id,
+      sessionID,
+      timeCreated: DateTime.makeUnsafe(row.created),
+    }
+    return decoded.value.input.type === "user"
+      ? User.make({ ...base, ...decoded.value.input })
+      : Synthetic.make({ ...base, ...decoded.value.input })
+  }
+  // A projected message without an admitted event in this aggregate (for
+  // example fork-copied history) is not a retryable admission.
   return yield* Effect.die(new LifecycleConflict({ id }))
 })
 
@@ -143,7 +160,7 @@ export const admit = Effect.fn("SessionPending.admit")(function* (
     if (existing.type === "compaction") return yield* Effect.die(new LifecycleConflict({ id: request.id }))
     return existing
   }
-  const promoted = yield* promotedFromMessage(db, request.sessionID, request.id, request.input.delivery)
+  const promoted = yield* promotedFromHistory(db, request.sessionID, request.id)
   if (promoted !== undefined) return promoted
   return yield* bus
     .publish(SessionEvent.InputAdmitted, {
@@ -409,7 +426,7 @@ const publish = Effect.fn("SessionPending.publish")(function* (
         .pipe(
           Effect.catchDefect((defect) =>
             defect instanceof LifecycleConflict
-              ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(
+              ? promotedFromHistory(db, sessionID, entry.id).pipe(
                   Effect.flatMap((stored) => (stored !== undefined ? Effect.void : Effect.die(defect))),
                 )
               : Effect.die(defect),

packages/core/src/session/projector.ts

@@ -1,6 +1,6 @@
 export * as SessionProjector from "./projector"
 
-import { and, asc, desc, eq, gt, gte, lt, lte, sql } from "drizzle-orm"
+import { and, asc, desc, eq, gt, gte, inArray, lt, lte, sql } from "drizzle-orm"
 import { DateTime, Effect, Layer, Schema, Stream } from "effect"
 import { Database } from "../database/database"
 import { Bus } from "../bus"
@@ -21,7 +21,10 @@ import { Money } from "@opencode-ai/schema/money"
 
 type DatabaseService = Database.Interface["db"]
 type CurrentDurableEvent = Extract<SessionEvent.Event, { readonly durable: object }>
-type MessageEvent = Exclude<CurrentDurableEvent, typeof SessionEvent.Forked.Type | typeof SessionEvent.Deleted.Type>
+type MessageEvent = Exclude<
+  CurrentDurableEvent,
+  typeof SessionEvent.Forked.Type | typeof SessionEvent.Deleted.Type | typeof SessionEvent.InstructionsUpdated.Type
+>
 
 const decodeMessage = Schema.decodeUnknownSync(SessionMessage.Info)
 const encodeMessage = Schema.encodeSync(SessionMessage.Info)
@@ -252,22 +255,66 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
       .pipe(Effect.orDie)
     if (rows.length === 0) break
 
+    const idMap = new Map(rows.map((row) => [row.id, SessionMessage.ID.create()]))
     yield* db
       .insert(SessionMessageTable)
       .values(
-        rows.map((row) => ({
-          id: SessionMessage.ID.create(),
-          session_id: event.data.sessionID,
-          type: row.type,
-          seq: row.seq,
-          time_created: row.time_created,
-          time_updated: row.time_updated,
-          data: row.data,
-        })),
+        rows.map((row) => {
+          const id = idMap.get(row.id)
+          if (!id) throw new Error(`Fork message ID mapping missing: ${row.id}`)
+          return {
+            id,
+            session_id: event.data.sessionID,
+            type: row.type,
+            seq: row.seq,
+            time_created: row.time_created,
+            time_updated: row.time_updated,
+            data: row.data,
+          }
+        }),
       )
       .run()
       .pipe(Effect.orDie)
 
+    const pendingRows = yield* db
+      .select()
+      .from(SessionPendingTable)
+      .where(
+        and(
+          eq(SessionPendingTable.session_id, event.data.parentID),
+          inArray(
+            SessionPendingTable.id,
+            rows.map((row) => row.id),
+          ),
+        ),
+      )
+      .all()
+      .pipe(Effect.orDie)
+    if (pendingRows.length > 0) {
+      yield* db
+        .insert(SessionPendingTable)
+        .values(
+          pendingRows.flatMap((row) => {
+            const id = idMap.get(row.id)
+            return id && row.type !== "compaction"
+              ? [
+                  {
+                    id,
+                    session_id: event.data.sessionID,
+                    type: row.type,
+                    data: row.data,
+                    delivery: row.delivery,
+                    admitted_seq: row.admitted_seq,
+                    time_created: row.time_created,
+                  },
+                ]
+              : []
+          }),
+        )
+        .run()
+        .pipe(Effect.orDie)
+    }
+
     cursor = rows.at(-1)!.seq
   }
   if (copiedSeq !== undefined) yield* Bus.reserveSequence(db, event.data.sessionID, copiedSeq)
@@ -635,10 +682,7 @@ const layer = Layer.effectDiscard(
     yield* bus.project(SessionEvent.Execution.Failed, (event) => run(db, event))
     yield* bus.project(SessionEvent.Execution.Interrupted, (event) => run(db, event))
     yield* bus.project(SessionEvent.InstructionsUpdated, (event) =>
-      Effect.gen(function* () {
-        yield* run(db, event)
-        yield* InstructionState.apply(db, event.data.sessionID, event.durable.seq, event.data.delta)
-      }),
+      InstructionState.apply(db, event.data.sessionID, event.durable.seq, event.data.delta),
     )
     yield* bus.project(SessionEvent.Synthetic, (event) => run(db, event))
     yield* bus.project(SessionEvent.Skill.Activated, (event) => run(db, event))

packages/core/src/shell/select.ts

@@ -1,12 +1,15 @@
 export * as ShellSelect from "./select"
 
 import path from "path"
+import { spawn, type ChildProcess } from "child_process"
 import { readFile } from "fs/promises"
 import { statSync } from "fs"
+import { setTimeout } from "node:timers/promises"
 import { Schema } from "effect"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { which } from "../util/which"
 
+const SIGKILL_TIMEOUT_MS = 200
 const META: Record<string, { deny?: boolean; login?: boolean; posix?: boolean; ps?: boolean }> = {
   bash: { login: true, posix: true },
   dash: { login: true, posix: true },
@@ -30,6 +33,37 @@ export const Options = Schema.Struct({
 })
 export type Options = typeof Options.Type
 
+export async function killTree(proc: ChildProcess, opts?: { exited?: () => boolean }): Promise<void> {
+  const pid = proc.pid
+  if (!pid || opts?.exited?.()) return
+
+  if (process.platform === "win32") {
+    await new Promise<void>((resolve) => {
+      const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], {
+        stdio: "ignore",
+        windowsHide: true,
+      })
+      killer.once("exit", () => resolve())
+      killer.once("error", () => resolve())
+    })
+    return
+  }
+
+  try {
+    process.kill(-pid, "SIGTERM")
+    await setTimeout(SIGKILL_TIMEOUT_MS)
+    if (!opts?.exited?.()) {
+      process.kill(-pid, "SIGKILL")
+    }
+  } catch {
+    proc.kill("SIGTERM")
+    await setTimeout(SIGKILL_TIMEOUT_MS)
+    if (!opts?.exited?.()) {
+      proc.kill("SIGKILL")
+    }
+  }
+}
+
 function stat(file: string) {
   return statSync(file, { throwIfNoEntry: false }) ?? undefined
 }

packages/core/src/snapshot.ts

@@ -16,7 +16,7 @@ import { Hash } from "@opencode-ai/util/hash"
 export { ID }
 
 export class Error extends Schema.TaggedErrorClass<Error>()("Snapshot.Error", {
-  operation: Schema.Literals(["capture", "files", "diff", "restore"]),
+  operation: Schema.Literals(["capture", "files", "diff", "preview", "restore"]),
   message: Schema.String,
   cause: Schema.optional(Schema.Defect()),
 }) {}
@@ -36,6 +36,10 @@ export interface RestoreInput {
   readonly files: ReadonlyMap<RelativePath, ID>
 }
 
+export interface PreviewInput extends RestoreInput {
+  readonly context?: number
+}
+
 export interface Interface {
   /**
    * Capture the current Location-scoped filesystem state as a content-addressed
@@ -56,11 +60,25 @@ export interface Interface {
    */
   readonly diff: (input: DiffInput) => Effect.Effect<readonly File.Diff[], Error>
 
+  /**
+   * Preview the filesystem result of a selective restore without modifying the
+   * worktree. Each project-relative path maps to the tree it would be restored
+   * from.
+   */
+  readonly preview: (input: PreviewInput) => Effect.Effect<readonly File.Diff[], Error>
+
   /**
    * Restore selected project-relative paths from their associated trees. A path
    * absent from its selected tree is removed; paths outside the map are untouched.
-  */
+   */
   readonly restore: (input: RestoreInput) => Effect.Effect<void, Error>
+
+  /**
+   * Replace the snapshot index with a captured tree and check out all its entries.
+   * Files absent from the tree remain untouched. Prefer selective `restore` when
+   * only known paths should change.
+   */
+  readonly checkout: (snapshot: ID) => Effect.Effect<void, Error>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Snapshot") {}
@@ -158,26 +176,59 @@ const layer = Layer.effect(
         .pipe(Effect.mapError((cause) => failure("diff", cause)))
     })
 
-    const plan = Effect.fnUntraced(function* (worktree: AbsolutePath, input: RestoreInput) {
+    const plan = Effect.fnUntraced(function* (
+      operation: "preview" | "restore",
+      worktree: AbsolutePath,
+      input: RestoreInput,
+    ) {
       const files = new Map<RelativePath, Git.TreeID>()
       for (const [file, snapshot] of input.files) {
         const absolute = path.resolve(worktree, file)
         if (!FSUtil.contains(worktree, absolute))
-          return yield* new Error({ operation: "restore", message: `Path escapes the project: ${file}` })
+          return yield* new Error({ operation, message: `Path escapes the project: ${file}` })
         files.set(file, Git.TreeID.make(snapshot))
       }
       return files
     })
 
+    const preview = Effect.fn("Snapshot.preview")(function* (input: PreviewInput) {
+      if (!(yield* enabled())) return yield* new Error({ operation: "preview", message: "Snapshots are disabled" })
+      const repo = yield* repository.pipe(Effect.mapError((cause) => failure("preview", cause)))
+      const files = yield* plan("preview", repo.worktree, input)
+      const current = yield* git.tree
+        .capture({
+          repository: repo.snapshotRepository,
+          scopes: Array.from(files.keys()),
+          ignores: repo.source,
+          maximumUntrackedFileBytes: 2 * 1024 * 1024,
+        })
+        .pipe(Effect.mapError((cause) => failure("preview", cause)))
+      return yield* git.tree
+        .preview({
+          repository: repo.snapshotRepository,
+          current,
+          files,
+          context: input.context,
+        })
+        .pipe(Effect.mapError((cause) => failure("preview", cause)))
+    })
+
     const restore = Effect.fn("Snapshot.restore")(function* (input: RestoreInput) {
       if (!(yield* enabled())) return yield* new Error({ operation: "restore", message: "Snapshots are disabled" })
       const repo = yield* repository.pipe(Effect.mapError((cause) => failure("restore", cause)))
       yield* git.tree
-        .restore({ repository: repo.snapshotRepository, files: yield* plan(repo.worktree, input) })
+        .restore({ repository: repo.snapshotRepository, files: yield* plan("restore", repo.worktree, input) })
         .pipe(Effect.mapError((cause) => failure("restore", cause)))
     })
 
-    return Service.of({ capture, files, diff, restore })
+    const checkout = Effect.fn("Snapshot.checkout")(function* (snapshot: ID) {
+      const repo = yield* repository.pipe(Effect.mapError((cause) => failure("restore", cause)))
+      yield* git.tree
+        .checkout({ repository: repo.snapshotRepository, tree: Git.TreeID.make(snapshot) })
+        .pipe(Effect.mapError((cause) => failure("restore", cause)))
+    })
+
+    return Service.of({ capture, files, diff, preview, restore, checkout })
   }).pipe(Effect.withSpan("Snapshot.boot")),
 )
 
@@ -193,7 +244,9 @@ export const noopLayer = Layer.succeed(
     capture: () => Effect.succeed(undefined),
     files: () => Effect.succeed([]),
     diff: () => Effect.succeed([]),
+    preview: () => Effect.succeed([]),
     restore: () => Effect.void,
+    checkout: () => Effect.void,
   }),
 )
 

packages/core/test/bus.test.ts

@@ -1298,4 +1298,24 @@ describe("Bus", () => {
     }),
   )
 
+  it.effect("sequences returns the latest committed seq per aggregate and omits unknown aggregates", () =>
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service
+      const first = Session.ID.create()
+      const second = Session.ID.create()
+      yield* bus.publish(DurableMessage, durableData(first, "zero"))
+      yield* bus.publish(DurableMessage, durableData(first, "one"))
+      yield* bus.publish(DurableMessage, durableData(second, "zero"))
+
+      const sequences = yield* bus.sequences([first, second, Session.ID.create()])
+
+      expect(sequences).toEqual(
+        new Map([
+          [first, Event.Seq.make(1)],
+          [second, Event.Seq.make(0)],
+        ]),
+      )
+      expect(yield* bus.sequences([])).toEqual(new Map())
+    }),
+  )
 })

packages/core/test/file-mutation.test.ts

@@ -89,6 +89,68 @@ describe("FileMutation", () => {
     ),
   )
 
+  it.live("rejects create when a prospective target appears after resolution", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const targetPath = path.join(directory, "appeared.txt")
+        const target = yield* (yield* LocationMutation.Service).resolve({ path: "appeared.txt" })
+        yield* Effect.promise(() => fs.writeFile(targetPath, "winner"))
+
+        expect(
+          yield* (yield* FileMutation.Service).create({ target, content: "replacement" }).pipe(Effect.flip),
+        ).toMatchObject({
+          _tag: "FileMutation.TargetExistsError",
+        })
+        expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("winner")
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("creates when an existing target disappears after resolution", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const targetPath = path.join(directory, "removed.txt")
+        yield* Effect.promise(() => fs.writeFile(targetPath, "before"))
+        const target = yield* (yield* LocationMutation.Service).resolve({ path: "removed.txt" })
+        yield* Effect.promise(() => fs.rm(targetPath))
+
+        expect(yield* (yield* FileMutation.Service).create({ target, content: "after" })).toEqual({
+          operation: "write",
+          target: target.canonical,
+          resource: "removed.txt",
+          existed: false,
+        })
+        expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("after")
+      }).pipe(provide(directory)),
+    ),
+  )
+
+  it.live("removes an existing internal file", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const targetPath = path.join(directory, "remove.txt")
+        yield* Effect.promise(() => fs.writeFile(targetPath, "remove"))
+        const target = yield* (yield* LocationMutation.Service).resolve({ path: "remove.txt" })
+        const result = yield* (yield* FileMutation.Service).remove({ target })
+
+        expect(result).toEqual({
+          operation: "remove",
+          target: target.canonical,
+          resource: "remove.txt",
+          existed: true,
+        })
+        expect(
+          yield* Effect.promise(() =>
+            fs.stat(targetPath).then(
+              () => true,
+              () => false,
+            ),
+          ),
+        ).toBe(false)
+      }).pipe(provide(directory)),
+    ),
+  )
+
   it.live("writes an explicitly resolved external target", () =>
     withTmp((directory) =>
       withTmp((outside) =>
@@ -109,6 +171,49 @@ describe("FileMutation", () => {
     ),
   )
 
+  it.live("removes an explicitly resolved external target", () =>
+    withTmp((directory) =>
+      withTmp((outside) =>
+        Effect.gen(function* () {
+          const targetPath = path.join(outside, "external.txt")
+          yield* Effect.promise(() => fs.writeFile(targetPath, "external"))
+          const target = yield* (yield* LocationMutation.Service).resolve({ path: targetPath })
+          const result = yield* (yield* FileMutation.Service).remove({ target })
+
+          expect(result).toEqual({
+            operation: "remove",
+            target: target.canonical,
+            resource: target.resource,
+            existed: true,
+          })
+          expect(
+            yield* Effect.promise(() =>
+              fs.stat(targetPath).then(
+                () => true,
+                () => false,
+              ),
+            ),
+          ).toBe(false)
+        }).pipe(provide(directory)),
+      ),
+    ),
+  )
+
+  it.live("reports a missing target as not removed without checking existence first", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const target = yield* (yield* LocationMutation.Service).resolve({ path: "missing.txt" })
+
+        expect(yield* (yield* FileMutation.Service).remove({ target })).toEqual({
+          operation: "remove",
+          target: target.canonical,
+          resource: "missing.txt",
+          existed: false,
+        })
+      }).pipe(provide(directory)),
+    ),
+  )
+
   it.live("serializes concurrent writes to the same canonical target", () =>
     withTmp((directory) =>
       Effect.gen(function* () {
@@ -152,6 +257,63 @@ describe("FileMutation", () => {
     ),
   )
 
+  it.live("allows only one concurrent conditional write based on the same bytes", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const targetPath = path.join(directory, "shared.txt")
+        yield* Effect.promise(() => fs.writeFile(targetPath, "initial"))
+        const firstStarted = yield* Deferred.make<void>()
+        const releaseFirst = yield* Deferred.make<void>()
+        let writes = 0
+        const filesystem = instrumentWrites((write) =>
+          Effect.gen(function* () {
+            writes++
+            if (writes === 1) {
+              yield* Deferred.succeed(firstStarted, undefined)
+              yield* Deferred.await(releaseFirst)
+            }
+            yield* write
+          }),
+        )
+
+        yield* Effect.gen(function* () {
+          const mutation = yield* LocationMutation.Service
+          const files = yield* FileMutation.Service
+          const target = yield* mutation.resolve({ path: "shared.txt" })
+          const expected = new TextEncoder().encode("initial")
+          const first = yield* files.writeIfUnchanged({ target, expected, content: "first" }).pipe(Effect.forkChild)
+          yield* Deferred.await(firstStarted)
+          const second = yield* files
+            .writeIfUnchanged({ target, expected, content: "second" })
+            .pipe(Effect.flip, Effect.forkChild)
+
+          yield* Deferred.succeed(releaseFirst, undefined)
+          yield* Fiber.join(first)
+          expect(yield* Fiber.join(second)).toMatchObject({ _tag: "FileMutation.StaleContentError" })
+          expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("first")
+          expect(writes).toBe(1)
+        }).pipe(provide(directory, filesystem))
+      }),
+    ),
+  )
+
+  it.live("rejects a conditional write when target content is already stale", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const targetPath = path.join(directory, "stale.txt")
+        yield* Effect.promise(() => fs.writeFile(targetPath, "current"))
+        const target = yield* (yield* LocationMutation.Service).resolve({ path: "stale.txt" })
+
+        expect(
+          yield* (yield* FileMutation.Service)
+            .writeIfUnchanged({ target, expected: new TextEncoder().encode("older"), content: "replacement" })
+            .pipe(Effect.flip),
+        ).toMatchObject({ _tag: "FileMutation.StaleContentError", path: target.canonical })
+        expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("current")
+      }).pipe(provide(directory)),
+    ),
+  )
+
   it.live("allows distinct canonical targets to proceed independently", () =>
     withTmp((directory) =>
       Effect.gen(function* () {

packages/core/test/formatter.test.ts

@@ -56,22 +56,52 @@ function withTemp<A, E, R>(body: (directory: string) => Effect.Effect<A, E, R>)
 }
 
 describe("Formatter", () => {
-  it.live("does not run formatters marked as disabled in config", () =>
+  it.live("status() returns empty list when no formatters are configured", () =>
     withTemp((directory) =>
-      Effect.gen(function* () {
-        const file = path.join(directory, "test.disabled")
-        expect(yield* Formatter.Service.use((formatter) => formatter.file(file))).toBe(false)
-      }).pipe(
-        Effect.provide(
-          formatterLayer(directory, {
-            disabled: {
-              disabled: true,
-              command: [process.execPath, "-e", "process.exit(0)", "$FILE"],
-              extensions: [".disabled"],
-            },
-          }),
-        ),
-      ),
+      Formatter.Service.use((formatter) => formatter.status()).pipe(Effect.provide(formatterLayer(directory))),
+    ),
+  )
+
+  it.live("status() returns built-in formatters when formatter is true", () =>
+    withTemp((directory) =>
+      Formatter.Service.use((formatter) =>
+        Effect.gen(function* () {
+          const statuses = yield* formatter.status()
+          const gofmt = statuses.find((item) => item.name === "gofmt")
+          expect(gofmt).toBeDefined()
+          expect(gofmt?.extensions).toContain(".go")
+        }),
+      ).pipe(Effect.provide(formatterLayer(directory, true))),
+    ),
+  )
+
+  it.live("status() keeps built-in formatters when config object is provided", () =>
+    withTemp((directory) =>
+      Formatter.Service.use((formatter) =>
+        Effect.gen(function* () {
+          const statuses = yield* formatter.status()
+          expect(statuses.find((item) => item.name === "gofmt")?.extensions).toContain(".go")
+          expect(statuses.find((item) => item.name === "mix")).toBeDefined()
+        }),
+      ).pipe(Effect.provide(formatterLayer(directory, { gofmt: {} }))),
+    ),
+  )
+
+  it.live("status() excludes formatters marked as disabled in config", () =>
+    withTemp((directory) =>
+      Formatter.Service.use((formatter) =>
+        Effect.gen(function* () {
+          const statuses = yield* formatter.status()
+          expect(statuses.find((item) => item.name === "gofmt")).toBeUndefined()
+          expect(statuses.find((item) => item.name === "mix")).toBeDefined()
+        }),
+      ).pipe(Effect.provide(formatterLayer(directory, { gofmt: { disabled: true } }))),
+    ),
+  )
+
+  it.live("service initializes without error", () =>
+    withTemp((directory) =>
+      Formatter.Service.use((formatter) => formatter.init()).pipe(Effect.provide(formatterLayer(directory))),
     ),
   )
 
@@ -85,29 +115,22 @@ describe("Formatter", () => {
     ),
   )
 
-  it.live("loads formatter state per directory", () =>
-    withTemp((off) =>
-      withTemp((on) =>
+  it.live("status() initializes formatter state per directory", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
+      ([off, on]) =>
         Effect.gen(function* () {
-          const offFile = path.join(off, "test.isolated")
-          const onFile = path.join(on, "test.isolated")
-          const disabled = yield* Formatter.Service.use((formatter) => formatter.file(offFile)).pipe(
-            Effect.provide(formatterLayer(off, false)),
+          const disabled = yield* Formatter.Service.use((formatter) => formatter.status()).pipe(
+            Effect.provide(formatterLayer(off.path, false)),
           )
-          const enabled = yield* Formatter.Service.use((formatter) => formatter.file(onFile)).pipe(
-            Effect.provide(
-              formatterLayer(on, {
-                isolated: {
-                  command: [process.execPath, "-e", "process.exit(0)", "$FILE"],
-                  extensions: [".isolated"],
-                },
-              }),
-            ),
+          const enabled = yield* Formatter.Service.use((formatter) => formatter.status()).pipe(
+            Effect.provide(formatterLayer(on.path, true)),
           )
-          expect(disabled).toBe(false)
-          expect(enabled).toBe(true)
+          expect(disabled).toEqual([])
+          expect(enabled.find((item) => item.name === "gofmt")).toBeDefined()
         }),
-      ),
+      (directories) =>
+        Effect.promise(() => Promise.all(directories.map((tmp) => tmp[Symbol.asyncDispose]())).then(() => undefined)),
     ),
   )
 

packages/core/test/git.test.ts

@@ -185,6 +185,9 @@ describe("Git trees", () => {
       ])
 
       const files = new Map([[RelativePath.make("scope/tracked.txt"), before]])
+      const preview = yield* git.tree.preview({ repository, current: after, files, context: 1 })
+      expect(preview).toHaveLength(1)
+      expect(preview[0]?.file).toBe(RelativePath.make("scope/tracked.txt"))
       yield* git.tree.restore({ repository, files })
       expect(yield* read(path.join(root.path, "scope", "tracked.txt"))).toBe("one\n")
       expect(yield* read(path.join(root.path, "scope", "added.txt"))).toBe("added\n")

packages/core/test/instruction-state.test.ts

@@ -14,7 +14,7 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { InstructionState } from "@opencode-ai/core/session/instruction-state"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionSchema } from "@opencode-ai/core/session/schema"
-import { InstructionBlobTable, InstructionStateTable, SessionMessageTable, SessionTable } from "@opencode-ai/core/session/sql"
+import { InstructionBlobTable, InstructionStateTable, SessionTable } from "@opencode-ai/core/session/sql"
 import { testEffect } from "./lib/effect"
 
 const it = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SessionProjector.node])))
@@ -105,7 +105,6 @@ describe("InstructionState", () => {
       expect(observation).toEqual({
         sessionID,
         initial: true,
-        previous: {},
         current: {
           "test/first": Instructions.hash("first"),
           "test/second": Instructions.hash("second"),
@@ -157,7 +156,7 @@ describe("InstructionState", () => {
 
       const initial = yield* InstructionState.observe(db, instructions, sessionID)
       expect(reads).toBe(2)
-      yield* InstructionState.commit(db, events, instructions, initial)
+      yield* InstructionState.commit(db, events, initial)
       expect(reads).toBe(2)
 
       current = "changed"
@@ -167,10 +166,6 @@ describe("InstructionState", () => {
       expect(changed).toMatchObject({
         sessionID,
         initial: false,
-        previous: {
-          "test/current": Instructions.hash("initial"),
-          "test/retired": Instructions.hash("retired"),
-        },
         current: { "test/current": Instructions.hash("changed") },
         delta: {
           "test/current": Instructions.hash("changed"),
@@ -178,7 +173,7 @@ describe("InstructionState", () => {
         },
         blobs: { [Instructions.hash("changed")]: "changed" },
       })
-      yield* InstructionState.commit(db, events, instructions, changed)
+      yield* InstructionState.commit(db, events, changed)
       expect(reads).toBe(4)
       yield* unsubscribe
 
@@ -195,11 +190,6 @@ describe("InstructionState", () => {
           "test/retired": "removed",
         },
       ])
-      // The chronological update text is frozen into the event; the baseline has none.
-      expect((yield* instructionEvents(db, sessionID)).map((event) => event.data.text)).toEqual([
-        undefined,
-        "changed\n\nRemoved retired",
-      ])
       expect(yield* db.select().from(InstructionStateTable).get().pipe(Effect.orDie)).toMatchObject({
         initial_values: {
           "test/current": Instructions.hash("initial"),
@@ -232,19 +222,18 @@ describe("InstructionState", () => {
       expect(observation).toEqual({
         sessionID,
         initial: false,
-        previous: { "test/context": Instructions.hash("unchanged") },
         current: { "test/context": Instructions.hash("unchanged") },
         delta: {},
         blobs: {},
       })
-      yield* InstructionState.commit(db, events, instructions, observation)
+      yield* InstructionState.commit(db, events, observation)
 
       expect(yield* instructionEvents(db, sessionID)).toEqual(beforeEvents)
       expect(yield* db.select().from(InstructionBlobTable).all().pipe(Effect.orDie)).toEqual(beforeBlobs)
     }),
   )
 
-  it.effect("treats a missing state row as a fresh baseline without repairing it", () =>
+  it.effect("assembles a fresh private update without repairing a missing cache", () =>
     Effect.gen(function* () {
       const sessionID = SessionSchema.ID.make("ses_instruction_generate")
       const { db, events } = yield* setup(sessionID)
@@ -265,7 +254,7 @@ describe("InstructionState", () => {
 
       const assembled = yield* preview(db, sessionID, instructions)
 
-      expect(assembled).toEqual({ initial: "Changed context", update: "" })
+      expect(assembled).toEqual({ initial: "Initial context", updates: [], update: "Changed context" })
       expect(yield* instructionEvents(db, sessionID)).toEqual(beforeEvents)
       expect(yield* db.select().from(InstructionBlobTable).all().pipe(Effect.orDie)).toEqual(beforeBlobs)
       expect(
@@ -279,7 +268,7 @@ describe("InstructionState", () => {
     }),
   )
 
-  it.effect("trusts the projected state without consulting durable events", () =>
+  it.effect("reads through a stale cache without repairing it", () =>
     Effect.gen(function* () {
       const sessionID = SessionSchema.ID.make("ses_instruction_generate_stale")
       const { db, events } = yield* setup(sessionID)
@@ -291,7 +280,6 @@ describe("InstructionState", () => {
       yield* InstructionState.prepare(db, events, instructions, sessionID)
       value = "Committed update"
       yield* InstructionState.prepare(db, events, instructions, sessionID)
-      // Tamper with the projected state; the authoritative row wins over event history.
       yield* db
         .update(InstructionStateTable)
         .set({ through_seq: 0, current_values: { "test/context": Instructions.hash("Initial context") } })
@@ -306,6 +294,7 @@ describe("InstructionState", () => {
       const assembled = yield* preview(db, sessionID, instructions)
 
       expect(assembled.initial).toBe("Initial context")
+      expect(assembled.updates.map((entry) => entry.message.text)).toEqual(["Committed update"])
       expect(assembled.update).toBe("Private update")
       expect(yield* instructionEvents(db, sessionID)).toEqual(beforeEvents)
       expect(yield* db.select().from(InstructionBlobTable).all().pipe(Effect.orDie)).toEqual(beforeBlobs)
@@ -313,41 +302,6 @@ describe("InstructionState", () => {
     }),
   )
 
-  it.effect("persists chronological updates as system messages", () =>
-    Effect.gen(function* () {
-      const sessionID = SessionSchema.ID.make("ses_instruction_messages")
-      const { db, events } = yield* setup(sessionID)
-      let value = "Initial context"
-      const instructions = source(
-        "test/context",
-        Effect.sync(() => value),
-      )
-      const messages = () =>
-        db
-          .select()
-          .from(SessionMessageTable)
-          .where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "system")))
-          .orderBy(asc(SessionMessageTable.seq))
-          .all()
-          .pipe(Effect.orDie)
-
-      // The initial baseline is not chronological history and produces no message.
-      yield* InstructionState.prepare(db, events, instructions, sessionID)
-      expect(yield* messages()).toEqual([])
-
-      value = "Changed context"
-      yield* InstructionState.prepare(db, events, instructions, sessionID)
-      const rows = yield* messages()
-      expect(rows).toHaveLength(1)
-      expect(rows[0]?.data).toMatchObject({ text: "Changed context" })
-      expect(rows.map((row) => row.seq)).toEqual([(yield* instructionEvents(db, sessionID)).at(-1)!.seq])
-
-      // A no-op observation adds nothing.
-      yield* InstructionState.prepare(db, events, instructions, sessionID)
-      expect(yield* messages()).toHaveLength(1)
-    }),
-  )
-
   it.effect("assembles initial instructions without persisting a baseline", () =>
     Effect.gen(function* () {
       const sessionID = SessionSchema.ID.make("ses_instruction_generate_initial")
@@ -356,6 +310,7 @@ describe("InstructionState", () => {
 
       expect(yield* preview(db, sessionID, instructions)).toEqual({
         initial: "Initial context",
+        updates: [],
         update: "",
       })
       expect(yield* instructionEvents(db, sessionID)).toEqual([])
@@ -381,6 +336,7 @@ describe("InstructionState", () => {
 
       expect(yield* preview(db, sessionID, instructions)).toEqual({
         initial: "Committed context",
+        updates: [],
         update: "",
       })
       expect(yield* instructionEvents(db, sessionID)).toEqual(beforeEvents)
@@ -432,7 +388,7 @@ describe("InstructionState", () => {
       for (const next of ["initial", "changed", "changed", Instructions.removed] as const) {
         value = next
         yield* InstructionState.observe(db, observedInstructions, observedSessionID).pipe(
-          Effect.flatMap((observation) => InstructionState.commit(db, events, observedInstructions, observation)),
+          Effect.flatMap((observation) => InstructionState.commit(db, events, observation)),
         )
         yield* InstructionState.prepare(db, events, preparedInstructions, preparedSessionID)
       }

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

@@ -284,9 +284,13 @@ describe("Session.create", () => {
       })
       expect(yield* SessionPending.find(db, forkContext[0].id)).toBeUndefined()
       expect(yield* SessionPending.find(db, forkContext[1].id)).toBeUndefined()
+      // Fork-copied messages have no admitted event in the fork aggregate, so
+      // reusing their IDs as prompt IDs is conflicting reuse, not a retry.
       expect(
-        yield* session.prompt({ id: forkContext[0].id, sessionID: forked.id, text: "First", resume: false }),
-      ).toMatchObject({ id: forkContext[0].id, type: "user", data: { text: "First" } })
+        yield* session
+          .prompt({ id: forkContext[0].id, sessionID: forked.id, text: "First", resume: false })
+          .pipe(Effect.flip),
+      ).toMatchObject({ _tag: "Session.PromptConflictError", messageID: forkContext[0].id })
 
       yield* session.prompt({
         sessionID: parent.id,

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

@@ -41,15 +41,17 @@ describe("Session.log", () => {
   it.effect("replays public session events and marks synced at the aggregate watermark", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
+      const bus = yield* Bus.Service
       const created = yield* session.create({ location })
       yield* session.rename({ sessionID: created.id, title: "session.renamed" })
 
       const items = Array.from(yield* Stream.runCollect(session.log({ sessionID: created.id })))
+      const watermark = (yield* bus.sequences([created.id])).get(created.id)
 
       // Session creation commits a non-public durable event, so the marker's
       // seq covers more of the aggregate than the public events emitted.
       expect(items.map((item) => item.type)).toEqual(["session.renamed", "log.synced"])
-      expect(items.at(-1)).toEqual({ type: "log.synced", aggregateID: created.id, seq: Event.Seq.make(1) })
+      expect(items.at(-1)).toEqual({ type: "log.synced", aggregateID: created.id, seq: watermark })
     }),
   )
 

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

@@ -553,47 +553,6 @@ describe("Session.prompt", () => {
     }),
   )
 
-  it.effect("reconciles an exact retry from the promoted message without admission history", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* Session.Service
-      const bus = yield* Bus.Service
-      const { db } = yield* Database.Service
-      const input = { sessionID, id: messageID, text: "Fix the failing tests", resume: false }
-      const first = yield* session.prompt(input)
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
-      yield* db
-        .delete(EventTable)
-        .where(eq(EventTable.aggregate_id, sessionID))
-        .run()
-        .pipe(Effect.orDie)
-
-      const retried = yield* session.prompt(input)
-
-      expect(retried).toMatchObject({ id: first.id, type: "user", data: { text: first.data.text } })
-      expect(yield* session.messages({ sessionID })).toMatchObject([
-        { id: messageID, type: "user", text: "Fix the failing tests" },
-      ])
-    }),
-  )
-
-  it.effect("ignores delivery when retrying a promoted message", () =>
-    Effect.gen(function* () {
-      yield* setup
-      const session = yield* Session.Service
-      const bus = yield* Bus.Service
-      const { db } = yield* Database.Service
-      const input = { sessionID, id: messageID, text: "Fix the failing tests", resume: false }
-      yield* session.prompt(input)
-      yield* SessionPending.promote(db, bus, sessionID, "steer")
-
-      const retried = yield* session.prompt({ ...input, delivery: "queue" })
-
-      expect(retried).toMatchObject({ id: messageID, type: "user", data: { text: input.text } })
-      expect(yield* admitted(messageID)).toBeUndefined()
-    }),
-  )
-
   it.effect("wakes execution when an exact prompt retry recovers a committed message", () =>
     Effect.gen(function* () {
       yield* setup

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

@@ -1180,7 +1180,7 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
-  it.effect("seeds a fork with the parent's newest instruction values", () =>
+  it.effect("forks instruction values at the selected message instead of the parent's latest state", () =>
     Effect.gen(function* () {
       const session = yield* setup
       yield* runPrompt(session, "First")
@@ -1197,16 +1197,14 @@ describe("SessionRunnerLLM", () => {
           .where(eq(InstructionStateTable.session_id, forked.id))
           .get(),
       ).toMatchObject({
-        initial_values: { "test/context": Instructions.hash("Latest context") },
-        current_values: { "test/context": Instructions.hash("Latest context") },
+        initial_values: { "test/context": Instructions.hash("Changed context") },
+        current_values: { "test/context": Instructions.hash("Changed context") },
       })
       yield* session.prompt({ sessionID: forked.id, text: "Forked", resume: false })
       yield* session.resume(forked.id)
 
-      expect(requests.at(-1)?.system.map((part) => part.text)).toEqual([defaultSystem, "Latest context"])
-      // Copied history keeps the frozen chronological update; no new update is emitted.
-      expect(systemTexts(requests.at(-1)!)).toContain("Changed context")
-      expect(systemTexts(requests.at(-1)!)).not.toContain("Latest context")
+      expect(requests.at(-1)?.system.map((part) => part.text)).toEqual([defaultSystem, "Changed context"])
+      expect(systemTexts(requests.at(-1)!)).toContain("Latest context")
 
       const { db } = yield* Database.Service
       const bus = yield* Bus.Service
@@ -1265,7 +1263,7 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
-  it.effect("re-establishes a fresh baseline when instruction state is missing", () =>
+  it.effect("rebuilds a missing instruction cache without admitting another delta", () =>
     Effect.gen(function* () {
       const session = yield* setup
       const { db } = yield* Database.Service
@@ -1279,15 +1277,13 @@ describe("SessionRunnerLLM", () => {
       expect(requests).toHaveLength(1)
       expect(requests[0]?.system.map((part) => part.text)).toEqual([defaultSystem, "Initial context"])
       expect(messageRoles(requests[0])).toEqual(["user", "user"])
-      // The projected row is authoritative: a missing row admits a fresh baseline
-      // instead of rebuilding from durable events.
       expect(
         yield* db
-          .select({ data: EventTable.data })
+          .select({ id: EventTable.id })
           .from(EventTable)
           .where(eq(EventTable.type, "session.instructions.updated.2"))
           .all(),
-      ).toHaveLength(2)
+      ).toHaveLength(1)
       expect(yield* db.select().from(InstructionStateTable).get()).toMatchObject({
         initial_values: { "test/context": Instructions.hash("Initial context") },
         current_values: { "test/context": Instructions.hash("Initial context") },
@@ -1314,10 +1310,7 @@ describe("SessionRunnerLLM", () => {
       ])
       expect(messageRoles(requests[1])).toEqual(["user", "system", "user"])
       expect(requests[1]?.messages.at(1)?.content).toEqual([{ type: "text", text: "Changed context" }])
-      // The chronological update is a durable client-visible system message.
-      const messages = yield* session.messages({ sessionID })
-      expect(messages).toHaveLength(3)
-      expect(messages[1]).toMatchObject({ type: "system", text: "Changed context" })
+      expect(yield* session.messages({ sessionID })).toHaveLength(2)
       const { db } = yield* Database.Service
       const updates = yield* db
         .select({ data: EventTable.data })
@@ -1334,10 +1327,9 @@ describe("SessionRunnerLLM", () => {
       expect(updates[1]?.data).toEqual({
         sessionID,
         delta: { "test/context": Instructions.hash("Changed context") },
-        text: "Changed context",
       })
       yield* replaySessionProjection(sessionID)
-      expect(yield* session.messages({ sessionID })).toHaveLength(3)
+      expect(yield* session.messages({ sessionID })).toHaveLength(2)
     }),
   )
 
@@ -1604,7 +1596,7 @@ describe("SessionRunnerLLM", () => {
       expect(requests[1]?.messages.at(1)?.content).toEqual([
         { type: "text", text: "System context source removed: test/context" },
       ])
-      expect(yield* session.messages({ sessionID })).toHaveLength(3)
+      expect(yield* session.messages({ sessionID })).toHaveLength(2)
     }),
   )
 
@@ -1716,14 +1708,12 @@ describe("SessionRunnerLLM", () => {
       expect(requests[2]?.messages.filter((message) => message.role === "system")).toHaveLength(2)
       expect((yield* session.context(sessionID)).map((message) => message.type)).toEqual([
         "user",
-        "system",
         "user",
         "model-switched",
-        "system",
         "user",
       ])
       yield* replaySessionProjection(sessionID)
-      expect(yield* session.messages({ sessionID })).toHaveLength(6)
+      expect(yield* session.messages({ sessionID })).toHaveLength(4)
       yield* runPrompt(session, "Fourth")
     }),
   )

packages/core/test/snapshot.test.ts

@@ -117,6 +117,9 @@ describe("Snapshot", () => {
               RelativePath.make("scope/tracked.txt"),
             ])
             const plan = new Map([[RelativePath.make("scope/tracked.txt"), before]])
+            const preview = yield* snapshot.preview({ files: plan, context: 1 })
+            expect(preview).toHaveLength(1)
+            expect(preview[0]?.file).toBe(RelativePath.make("scope/tracked.txt"))
             yield* snapshot.restore({ files: plan })
             expect(yield* read(path.join(location, "tracked.txt"))).toBe("one\n")
             expect(yield* read(path.join(location, "added.txt"))).toBe("added\n")
@@ -182,6 +185,36 @@ describe("Snapshot", () => {
       (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
     ),
   )
+
+  testEffect(Layer.empty).live("checks out a legacy revert snapshot without removing unrelated files", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) =>
+        Effect.gen(function* () {
+          const project = path.join(tmp.path, "project")
+          yield* Effect.promise(async () => {
+            await fs.mkdir(project)
+            await fs.writeFile(path.join(project, "tracked.txt"), "one\n")
+            await initGit(project)
+          })
+
+          yield* Effect.gen(function* () {
+            const snapshot = yield* Snapshot.Service
+            const before = yield* snapshot.capture()
+            expect(before).toBeDefined()
+            if (!before) return
+            yield* Effect.promise(async () => {
+              await fs.writeFile(path.join(project, "tracked.txt"), "two\n")
+              await fs.writeFile(path.join(project, "unrelated.txt"), "keep\n")
+            })
+            yield* snapshot.checkout(before)
+            expect(yield* read(path.join(project, "tracked.txt"))).toBe("one\n")
+            expect(yield* read(path.join(project, "unrelated.txt"))).toBe("keep\n")
+          }).pipe(Effect.provide(snapshotLayer(tmp.path, project)))
+        }),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ),
+  )
 })
 
 function snapshotLayer(data: string, directory: string) {

packages/schema/src/session-event.ts

@@ -186,11 +186,6 @@ export const InstructionsUpdated = Event.durable({
   schema: {
     ...Base,
     delta: Instruction.Delta,
-    /**
-     * The rendered chronological update shown to the model, frozen at emit time.
-     * Absent for the initial baseline observation and for deltas that render empty.
-     */
-    text: Schema.String.pipe(optional),
   },
 })
 export type InstructionsUpdated = typeof InstructionsUpdated.Type

packages/server/src/auth.ts

@@ -2,6 +2,10 @@ export * as ServerAuth from "./auth"
 
 import { Context, Layer, Option, Redacted } from "effect"
 
+export type Credentials = {
+  password?: string
+}
+
 export type DecodedCredentials = {
   readonly username: string
   readonly password: Redacted.Redacted
@@ -33,3 +37,16 @@ export function authorized(credentials: DecodedCredentials, config: Info) {
     Redacted.value(credentials.password) === config.password.value
   )
 }
+
+export function header(credentials?: Credentials) {
+  const password = credentials?.password
+  if (!password) return undefined
+
+  return `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`
+}
+
+export function headers(credentials?: Credentials) {
+  const authorization = header(credentials)
+  if (!authorization) return undefined
+  return { Authorization: authorization }
+}

packages/server/test/auth.test.ts

@@ -7,3 +7,7 @@ test("accepts only the fixed opencode username", () => {
   expect(ServerAuth.authorized({ username: "opencode", password: Redacted.make("secret") }, config)).toBe(true)
   expect(ServerAuth.authorized({ username: "custom", password: Redacted.make("secret") }, config)).toBe(false)
 })
+
+test("encodes the fixed opencode username", () => {
+  expect(ServerAuth.header({ password: "secret" })).toBe(`Basic ${Buffer.from("opencode:secret").toString("base64")}`)
+})

packages/tui/src/routes/session/index.tsx

@@ -96,7 +96,6 @@ import { findMessageBoundary, messageNavigationSlack } from "./message-navigatio
 import { stringWidth } from "../../util/string-width"
 import { useArgs } from "../../context/args"
 import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
-import { installSyntaxHighlightCache } from "../../util/syntax-highlight-cache"
 
 addDefaultParsers(parsers.parsers)
 
@@ -129,7 +128,6 @@ function use() {
 }
 
 export function Session() {
-  installSyntaxHighlightCache()
   const setEpilogue = useEpilogue()
   const clipboard = useClipboard()
   const writeExport = async (file: string, content: string) => {

packages/tui/src/util/syntax-highlight-cache.ts

@@ -1,38 +0,0 @@
-import { getTreeSitterClient, type TreeSitterClient } from "@opentui/core"
-
-const CACHE_SIZE = 500
-const installed = new WeakSet<TreeSitterClient>()
-
-export function installSyntaxHighlightCache() {
-  const client = getTreeSitterClient()
-  if (installed.has(client)) return
-  installed.add(client)
-  client.highlightOnce = cacheHighlights(client.highlightOnce.bind(client))
-}
-
-export function cacheHighlights(highlight: TreeSitterClient["highlightOnce"], capacity = CACHE_SIZE) {
-  const cache = new Map<string, ReturnType<TreeSitterClient["highlightOnce"]>>()
-
-  return (content: string, filetype: string) => {
-    const key = `${filetype}\0${content}`
-    const cached = cache.get(key)
-    if (cached) {
-      cache.delete(key)
-      cache.set(key, cached)
-      return cached
-    }
-
-    const result = highlight(content, filetype)
-    cache.set(key, result)
-    if (cache.size > capacity) cache.delete(cache.keys().next().value!)
-
-    void result
-      .then((value) => {
-        if (value.error && cache.get(key) === result) cache.delete(key)
-      })
-      .catch(() => {
-        if (cache.get(key) === result) cache.delete(key)
-      })
-    return result
-  }
-}

packages/tui/test/cli/tui/diff-viewer.test.tsx

@@ -147,12 +147,12 @@ async function renderDiffViewer(vcsDiff: unknown[], height = 20, initialRoute?:
   const config = createTuiResolvedConfig()
   const transport = createFetch((url) => {
     if (url.pathname !== "/api/vcs/diff") return
+    if (fail) return json({ message: "boom" }, { status: 500 })
     vcsDiffInput = {
       location: { directory: url.searchParams.get("location[directory]") },
       mode: url.searchParams.get("mode"),
       context: url.searchParams.get("context"),
     }
-    if (fail) return json({ message: "boom" }, { status: 500 })
     return json({
       location: { directory: "/repo/session", project: { id: "project-1", directory: "/repo/session" } },
       data: vcsDiff,
@@ -238,7 +238,6 @@ async function renderDiffViewer(vcsDiff: unknown[], height = 20, initialRoute?:
 
   const app = await testRender(() => <Harness />, { width: 80, height })
   await waitForCommand(app, commands, "diff.close")
-  await app.waitFor(() => vcsDiffInput !== undefined)
   return {
     app,
     commands,

packages/tui/test/util/syntax-highlight-cache.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { cacheHighlights } from "../../src/util/syntax-highlight-cache"
-
-describe("syntax highlight cache", () => {
-  test("reuses completed and in-flight highlights", async () => {
-    let calls = 0
-    const highlight = cacheHighlights(async () => {
-      calls++
-      return { highlights: [[0, 5, "keyword"]] }
-    })
-
-    const first = highlight("const", "typescript")
-    const second = highlight("const", "typescript")
-
-    expect(second).toBe(first)
-    expect(await second).toEqual({ highlights: [[0, 5, "keyword"]] })
-    expect(await highlight("const", "typescript")).toEqual({ highlights: [[0, 5, "keyword"]] })
-    expect(calls).toBe(1)
-  })
-
-  test("evicts least recently used highlights", async () => {
-    let calls = 0
-    const highlight = cacheHighlights(async () => {
-      calls++
-      return { highlights: [] }
-    }, 2)
-
-    await highlight("one", "text")
-    await highlight("two", "text")
-    await highlight("one", "text")
-    await highlight("three", "text")
-    await highlight("two", "text")
-
-    expect(calls).toBe(4)
-  })
-
-  test("retries failed highlights", async () => {
-    let calls = 0
-    const highlight = cacheHighlights(async () => {
-      calls++
-      if (calls === 1) return { error: "parser unavailable" }
-      return { highlights: [] }
-    })
-
-    await highlight("const", "typescript")
-    await highlight("const", "typescript")
-
-    expect(calls).toBe(2)
-  })
-
-  test("an evicted failure does not delete its replacement", async () => {
-    const pending = Promise.withResolvers<{ highlights: [] }>()
-    let calls = 0
-    const highlight = cacheHighlights(() => {
-      calls++
-      if (calls === 1) return pending.promise
-      return Promise.resolve({ highlights: [] })
-    }, 1)
-
-    const stale = highlight("one", "text")
-    await highlight("two", "text")
-    const current = highlight("one", "text")
-    pending.reject(new Error("parser unavailable"))
-
-    await expect(stale).rejects.toThrow("parser unavailable")
-    expect(highlight("one", "text")).toBe(current)
-    expect(calls).toBe(3)
-  })
-})