refactor(core): decouple session version

Merge remote-tracking branch 'origin/v2' into client-service
# Conflicts: # packages/core/src/session/generate-node.ts # packages/core/src/session/title.ts # packages/util/src/observability.ts
2026-10-20 20:27:02 +08:00 · 2026-07-21 14:07:25 -04:00 · 2026-07-21 13:10:07 -04:00 · 2026-07-21 12:58:16 -04:00
33 changed files with 107 additions and 1092 deletions
@@ -32,9 +32,6 @@ export default Runtime.handler(Commands.commands.mini, (input) =>
        replayLimit: Option.getOrUndefined(input.replayLimit),
        demo: input.demo,
        tuiConfig: resolved,
-        config: {
-          update: (update) => runServicePromise(config.update(update)),
-        },
      }),
    )
  }),
@@ -22,7 +22,6 @@ export type MiniCommandInput = {
  replayLimit?: number
  demo?: boolean
  tuiConfig?: MiniFrontendInput["tuiConfig"]
-  config?: MiniFrontendInput["config"]
 }

 type Model = MiniFrontendInput["model"]
@@ -120,7 +119,6 @@ export async function runMini(input: MiniCommandInput) {
        replayLimit: input.replayLimit,
        demo: input.demo,
        tuiConfig: input.tuiConfig,
-        config: input.config,
      })
    })
    if (result.exitCode !== 0) process.exit(result.exitCode)
@@ -131,16 +131,11 @@ test("updates a config draft while preserving JSONC comments", async () => {
        const service = yield* Config.Service
        return yield* service.update((draft) => {
          draft.prompt = { paste: "compact" }
-          draft.mini = { thinking: "hide", shell_output: "hide" }
        })
      }),
    )

-    expect(config).toEqual({
-      animations: true,
-      prompt: { paste: "compact" },
-      mini: { thinking: "hide", shell_output: "hide" },
-    })
+    expect(config).toEqual({ animations: true, prompt: { paste: "compact" } })
    expect(await Bun.file(path.join(directory, "cli.json")).text()).toContain("// Keep this comment")
  } finally {
    await Bun.$`rm -rf ${directory}`
@@ -36,8 +36,7 @@ ultimate source of truth.
 - [x] Regular-expression literals.
 - [x] `NaN` and `Infinity` globals.
 - [ ] BigInt literals and in-interpreter BigInt arithmetic; BigInt remains invalid at JSON-like host boundaries.
- [ ] Arbitrary Symbol primitive values and symbol-keyed properties. The confined `Symbol.iterator` and
-      `Symbol.asyncIterator` keys are available only for custom iterator protocols.
+- [ ] Symbol primitive values and symbol-keyed properties.
 - [ ] Tagged-template calls.
 - [ ] Getter and setter definitions in object literals.

@@ -71,11 +70,9 @@ ultimate source of truth.
 - [x] `try`, `catch`, optional catch bindings, and `finally`.
 - [x] `throw` with arbitrary values.
 - [x] Labeled statements, labeled `break`, and labeled `continue`.
- [x] `for await...of` over the supported synchronous collections and custom iterator objects using
-      `Symbol.asyncIterator` or the `Symbol.iterator` fallback. Each iterator step is sequential, yielded promises and
-      plain values from synchronous collections and sync iterators are awaited before binding, and abrupt loop
-      completion invokes the iterator's optional `return()`. Custom async iterators control their yielded values, as in
-      JavaScript; only their `next()` results are awaited. Async generators remain outside the supported subset.
+- [x] `for await...of` over the supported synchronous collections, awaiting each yielded CodeMode promise or plain
+      value before binding it. Custom sync/async iterator objects, `Symbol.asyncIterator`, and async generators remain
+      outside the supported subset.

 ## Functions and callbacks

@@ -36,7 +36,7 @@ export type StatementResult =

 export type MemberReference = {
  target: SafeObject | Array<unknown> | CodeModeRegExp | CodeModeURL
-  key: PropertyKey
+  key: string | number
 }

 export class CodeModeFunction {
@@ -61,12 +61,6 @@ export class ComputedValue {

 export class PromiseNamespace {}

-export class SymbolNamespace {}
-
-export const AsyncIteratorSymbol: unique symbol = Symbol("codemode.async-iterator")
-export const IteratorSymbol: unique symbol = Symbol("codemode.iterator")
-export const IteratorSymbols = [AsyncIteratorSymbol, IteratorSymbol] as const
-
 export type PromiseMethodName = "all" | "allSettled" | "race" | "any" | "resolve" | "reject"

 export class PromiseMethodReference {
@@ -13,7 +13,6 @@ import {
  PromiseMethodReference,
  PromiseNamespace,
  SearchFunction,
-  SymbolNamespace,
  UriFunction,
 } from "./model.js"
 import { ToolReference } from "../tool-runtime.js"
@@ -35,7 +34,6 @@ export const isRuntimeReference = (value: unknown): boolean =>
  value instanceof SearchFunction ||
  value instanceof PromiseCapabilityFunction ||
  value instanceof ErrorConstructorReference ||
-  value instanceof SymbolNamespace ||
  isCodeModeValue(value)

 function* childValues(value: object): Generator<unknown> {
@@ -115,8 +113,7 @@ export const typeofValue = (value: unknown): string => {
    value instanceof PromiseInstanceMethodReference ||
    value instanceof PromiseNamespace ||
    value instanceof PromiseCapabilityFunction ||
-    value instanceof ErrorConstructorReference ||
-    value instanceof SymbolNamespace
+    value instanceof ErrorConstructorReference
  )
    return "function"
  if (value instanceof UriFunction || value instanceof SearchFunction) return "function"
@@ -1,8 +1,7 @@
-import { Cause, Effect, Exit } from "effect"
+import { Cause, Effect } from "effect"
 import { isBlockedMember, ToolReference, ToolRuntimeError, type SafeObject } from "../tool-runtime.js"
 import {
  type AstNode,
-  AsyncIteratorSymbol,
  asNode,
  type Binding,
  CodeModeFunction,
@@ -20,8 +19,6 @@ import {
  IntrinsicReference,
  InterpreterRuntimeError,
  isRecord,
-  IteratorSymbol,
-  IteratorSymbols,
  JsonMethodReference,
  type MemberReference,
  OptionalShortCircuit,
@@ -33,7 +30,6 @@ import {
  ProgramThrow,
  type ProgramNode,
  SearchFunction,
-  SymbolNamespace,
  type StatementResult,
  supportedSyntaxMessage,
  unsupportedSyntax,
@@ -215,12 +211,6 @@ const loopDeclaration = (left: AstNode, statement: "for...of" | "for...in") => {
  }
 }

-type CustomIterator = {
-  iterator: SafeObject
-  next: unknown
-  asynchronous: boolean
-}
-
 export class Interpreter<R> {
  private scopes: ScopeStack
  private readonly invokeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>
@@ -251,7 +241,6 @@ export class Interpreter<R> {
    globalScope.set("tools", { mutable: false, value: new ToolReference([]) })
    globalScope.set("search", { mutable: false, value: new SearchFunction() })
    globalScope.set("Promise", { mutable: false, value: new PromiseNamespace() })
-    globalScope.set("Symbol", { mutable: false, value: new SymbolNamespace() })
    globalScope.set("undefined", { mutable: false, value: undefined })
    globalScope.set("Object", { mutable: false, value: new GlobalNamespace("Object") })
    globalScope.set("Math", { mutable: false, value: new GlobalNamespace("Math") })
@@ -647,10 +636,9 @@ export class Interpreter<R> {
      const body = getNode(node, "body")

      const iterable = spreadItems(right)
-      const iterator = iterable === undefined && awaiting ? yield* self.customIterator(right, node) : undefined
-      if (iterable === undefined && iterator === undefined) {
+      if (iterable === undefined) {
        throw new InterpreterRuntimeError(
-          `${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, or URLSearchParams${awaiting ? ", or custom iterator" : ""} value.`,
+          `${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, or URLSearchParams value.`,
          node,
        )
      }
@@ -669,14 +657,19 @@ export class Interpreter<R> {
        throw new InterpreterRuntimeError("Unsupported for...of binding.", left)
      }

-      const evaluateBody = (value: unknown) =>
-        Effect.gen(function* () {
+      for (const value of iterable) {
+        const resolved = awaiting
+          ? value instanceof CodeModePromise
+            ? yield* self.settlePromise(value)
+            : yield* Effect.as(Effect.yieldNow, value)
+          : value
+        const result = yield* Effect.gen(function* () {
          if (declared) {
            self.scopes.push()
            if (declared.lexical) self.predeclarePattern(declared.pattern, declared.mutable, left)
-            yield* self.declarePattern(declared.pattern, value, declared.mutable, left, declared.lexical)
+            yield* self.declarePattern(declared.pattern, resolved, declared.mutable, left, declared.lexical)
          } else if (assignment) {
-            yield* self.assignPattern(assignment, value, left)
+            yield* self.assignPattern(assignment, resolved, left)
          }
          return yield* self.evaluateStatement(body)
        }).pipe(
@@ -687,48 +680,22 @@ export class Interpreter<R> {
          ),
        )

-      if (iterable !== undefined) {
-        for (const value of iterable) {
-          const result = yield* evaluateBody(awaiting ? yield* self.awaitValue(value) : value)
-
-          if (result.kind === "return") return result
-          if (result.kind === "break") {
-            if (result.label !== undefined && !labels?.has(result.label)) return result
-            return { kind: "none" } satisfies StatementResult
-          }
-          if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label)) return result
-        }
-        return { kind: "none" } satisfies StatementResult
-      }
-      if (iterator === undefined) throw new InterpreterRuntimeError("Custom iterator is unavailable.", node)
-
-      while (true) {
-        const step = yield* self.nextIteratorResult(iterator, node)
-        if (step.done) return { kind: "none" } satisfies StatementResult
-        const bodyExit = yield* Effect.exit(evaluateBody(step.value))
-        if (!Exit.isSuccess(bodyExit)) {
-          // Process interruption must remain prompt; user cleanup cannot extend a timeout.
-          if (!Cause.hasInterruptsOnly(bodyExit.cause)) yield* Effect.exit(self.closeIterator(iterator, node))
-          return yield* Effect.failCause(bodyExit.cause)
-        }
-        const result = bodyExit.value
-
        if (result.kind === "return") {
-          yield* self.closeIterator(iterator, node)
          return result
        }

        if (result.kind === "break") {
-          yield* self.closeIterator(iterator, node)
          if (result.label !== undefined && !labels?.has(result.label)) return result
          return { kind: "none" } satisfies StatementResult
        }

-        if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label)) {
-          yield* self.closeIterator(iterator, node)
-          return result
+        if (result.kind === "continue") {
+          if (result.label !== undefined && !labels?.has(result.label)) return result
+          continue
        }
      }
+
+      return { kind: "none" } satisfies StatementResult
    }).pipe(
      Effect.ensuring(
        Effect.sync(() => {
@@ -738,101 +705,6 @@ export class Interpreter<R> {
    )
  }

-  private awaitValue(value: unknown): Effect.Effect<unknown, unknown, R> {
-    return value instanceof CodeModePromise ? this.settlePromise(value) : Effect.as(Effect.yieldNow, value)
-  }
-
-  private customIterator(value: unknown, node: AstNode) {
-    if (!isRecord(value) || isRuntimeReference(value)) return Effect.succeed(undefined)
-    const asyncMethod = Reflect.get(value, AsyncIteratorSymbol)
-    const method = asyncMethod ?? Reflect.get(value, IteratorSymbol)
-    if (method === undefined || method === null) return Effect.succeed(undefined)
-    const self = this
-    return Effect.map(
-      this.invokeCallable(this.requireIteratorMethod(method, "Iterator method", node), [], node),
-      (iterator) => {
-        const object = self.requireIteratorObject(iterator, "Iterator method result", node)
-        return {
-          iterator: object,
-          next: self.requireIteratorMethod(object.next, "Iterator next", node),
-          asynchronous: asyncMethod !== undefined && asyncMethod !== null,
-        }
-      },
-    )
-  }
-
-  private nextIteratorResult(iterator: CustomIterator, node: AstNode) {
-    const self = this
-    return Effect.gen(function* () {
-      if (iterator.asynchronous) {
-        const object = self.requireIteratorObject(
-          yield* self.awaitValue(yield* self.invokeCallable(iterator.next, [], node)),
-          "Iterator next() result",
-          node,
-        )
-        return { done: Boolean(object.done), value: object.value }
-      }
-
-      const called = yield* Effect.exit(self.invokeCallable(iterator.next, [], node))
-      if (!Exit.isSuccess(called)) {
-        yield* Effect.yieldNow
-        return yield* Effect.failCause(called.cause)
-      }
-      const captured = yield* Effect.exit(
-        Effect.sync(() => {
-          const object = self.requireIteratorObject(called.value, "Iterator next() result", node)
-          return { done: Boolean(object.done), value: object.value }
-        }),
-      )
-      if (!Exit.isSuccess(captured)) {
-        yield* Effect.yieldNow
-        return yield* Effect.failCause(captured.cause)
-      }
-      return { done: captured.value.done, value: yield* self.awaitValue(captured.value.value) }
-    })
-  }
-
-  private closeIterator(iterator: CustomIterator, node: AstNode): Effect.Effect<void, unknown, R> {
-    const close = iterator.iterator.return
-    if (close === undefined || close === null) return iterator.asynchronous ? Effect.void : Effect.yieldNow
-    const self = this
-    return Effect.gen(function* () {
-      const method = self.requireIteratorMethod(close, "Iterator return", node)
-      if (iterator.asynchronous) {
-        self.requireIteratorObject(
-          yield* self.awaitValue(yield* self.invokeCallable(method, [], node)),
-          "Iterator return() result",
-          node,
-        )
-        return
-      }
-
-      const called = yield* Effect.exit(self.invokeCallable(method, [], node))
-      if (!Exit.isSuccess(called)) {
-        yield* Effect.yieldNow
-        return yield* Effect.failCause(called.cause)
-      }
-      const captured = yield* Effect.exit(
-        Effect.sync(() => self.requireIteratorObject(called.value, "Iterator return() result", node).value),
-      )
-      if (!Exit.isSuccess(captured)) {
-        yield* Effect.yieldNow
-        return yield* Effect.failCause(captured.cause)
-      }
-      yield* self.awaitValue(captured.value)
-    })
-  }
-
-  private requireIteratorObject(value: unknown, context: string, node: AstNode): SafeObject {
-    if (isRecord(value) && !isRuntimeReference(value)) return value
-    throw new InterpreterRuntimeError(`${context} must be an object.`, node).as("TypeError")
-  }
-
-  private requireIteratorMethod(value: unknown, context: string, node: AstNode): unknown {
-    if (typeofValue(value) === "function") return value
-    throw new InterpreterRuntimeError(`${context} must be a function.`, node).as("TypeError")
-  }
-
  private enumerableKeys(value: unknown): Array<string> | undefined {
    if (value instanceof ToolReference) {
      return [...this.toolKeys(value.path)]
@@ -1050,7 +922,7 @@ export class Interpreter<R> {
          )
        }

-        const consumed = new Set<PropertyKey>()
+        const consumed = new Set<string>()
        for (const propertyValue of getArray(pattern, "properties")) {
          const property = asNode(propertyValue, "properties")

@@ -1059,10 +931,6 @@ export class Interpreter<R> {
            for (const [key, item] of Object.entries(value as SafeObject)) {
              if (!consumed.has(key) && !isBlockedMember(key)) rest[key] = item
            }
-            for (const symbol of IteratorSymbols) {
-              if (!consumed.has(symbol) && Object.hasOwn(value, symbol))
-                Reflect.set(rest, symbol, Reflect.get(value, symbol))
-            }
            yield* self.declarePattern(getNode(property, "argument"), rest, mutable, property, initialize)
            continue
          }
@@ -1071,7 +939,7 @@ export class Interpreter<R> {
          if (isBlockedMember(String(key))) {
            throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, property)
          }
-          consumed.add(typeof key === "symbol" ? key : String(key))
+          consumed.add(String(key))
          yield* self.declarePattern(
            getNode(property, "value"),
            self.destructuringPropertyValue(value as SafeObject | Array<unknown>, key),
@@ -1134,7 +1002,7 @@ export class Interpreter<R> {
        }

        const source = value as SafeObject | Array<unknown>
-        const consumed = new Set<PropertyKey>()
+        const consumed = new Set<string>()
        for (const propertyValue of getArray(pattern, "properties")) {
          const property = asNode(propertyValue, "properties")
          if (property.type === "RestElement") {
@@ -1142,10 +1010,6 @@ export class Interpreter<R> {
            for (const [key, item] of Object.entries(source)) {
              if (!consumed.has(key) && !isBlockedMember(key)) rest[key] = item
            }
-            for (const symbol of IteratorSymbols) {
-              if (!consumed.has(symbol) && Object.hasOwn(source, symbol))
-                Reflect.set(rest, symbol, Reflect.get(source, symbol))
-            }
            yield* self.assignPattern(getNode(property, "argument"), rest, property)
            continue
          }
@@ -1153,7 +1017,7 @@ export class Interpreter<R> {
          if (isBlockedMember(String(key))) {
            throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, property)
          }
-          consumed.add(typeof key === "symbol" ? key : String(key))
+          consumed.add(String(key))
          yield* self.assignPattern(getNode(property, "value"), self.destructuringPropertyValue(source, key), property)
        }
        return
@@ -1180,7 +1044,7 @@ export class Interpreter<R> {
    })
  }

-  private destructuringPropertyKey(property: AstNode): Effect.Effect<PropertyKey, unknown, R> {
+  private destructuringPropertyKey(property: AstNode): Effect.Effect<string | number, unknown, R> {
    if (property.type !== "Property" || getString(property, "kind") !== "init") {
      throw new InterpreterRuntimeError("Unsupported object destructuring property.", property)
    }
@@ -1191,12 +1055,12 @@ export class Interpreter<R> {
    return Effect.succeed(keyNode.type === "Identifier" ? getString(keyNode, "name") : String(keyNode.value))
  }

-  private destructuringPropertyValue(source: SafeObject | Array<unknown>, key: PropertyKey): unknown {
-    if (!Array.isArray(source)) return Reflect.get(source, key)
+  private destructuringPropertyValue(source: SafeObject | Array<unknown>, key: string | number): unknown {
+    if (!Array.isArray(source)) return source[String(key)]
    if (key === "length") return source.length
    if (typeof key === "number") return source[key]
-    if (Object.hasOwn(source, key)) return Reflect.get(source, key)
-    if (typeof key === "string" && arrayMethods.has(key)) return new IntrinsicReference(source, key)
+    if (Object.hasOwn(source, key)) return (source as Record<string, unknown> & Array<unknown>)[key]
+    if (arrayMethods.has(key)) return new IntrinsicReference(source, key)
    return undefined
  }

@@ -1826,12 +1690,6 @@ export class Interpreter<R> {
      if (callable instanceof PromiseNamespace) {
        throw new InterpreterRuntimeError("Constructor Promise requires 'new'.", node).as("TypeError")
      }
-      if (callable instanceof SymbolNamespace) {
-        throw new InterpreterRuntimeError(
-          "Symbol is not callable; only Symbol.asyncIterator and Symbol.iterator are available.",
-          node,
-        ).as("TypeError")
-      }
      if (callable instanceof PromiseCapabilityFunction) {
        callable.settle(args[0])
        return undefined
@@ -1942,9 +1800,6 @@ export class Interpreter<R> {
            if (isBlockedMember(key)) throw new InterpreterRuntimeError(`Property '${key}' is not available.`, property)
            objectValue[key] = value
          }
-          for (const symbol of IteratorSymbols) {
-            if (Object.hasOwn(spread, symbol)) Reflect.set(objectValue, symbol, Reflect.get(spread, symbol))
-          }
          continue
        }

@@ -1975,7 +1830,7 @@ export class Interpreter<R> {
        if (isBlockedMember(String(key))) {
          throw new InterpreterRuntimeError(`Property '${String(key)}' is not available.`, keyNode)
        }
-        Reflect.set(objectValue, key, yield* self.evaluateExpression(valueNode))
+        objectValue[String(key)] = yield* self.evaluateExpression(valueNode)
      }

      return objectValue
@@ -2100,12 +1955,6 @@ export class Interpreter<R> {
        )
      }

-      if (objectValue instanceof SymbolNamespace) {
-        if (key === "asyncIterator") return new ComputedValue(AsyncIteratorSymbol)
-        if (key === "iterator") return new ComputedValue(IteratorSymbol)
-        return new ComputedValue(undefined)
-      }
-
      if (objectValue instanceof GlobalNamespace) {
        if (typeof key === "string" && isBlockedMember(key)) {
          throw new InterpreterRuntimeError(`${objectValue.name}.${key} is not available.`, propertyNode)
@@ -2127,7 +1976,7 @@ export class Interpreter<R> {

      if (typeof objectValue === "string") {
        if (key === "length") return new ComputedValue(objectValue.length)
-        const index = typeof key === "symbol" ? undefined : parseArrayIndex(key)
+        const index = parseArrayIndex(key)
        if (index !== undefined) return new ComputedValue(objectValue[index])
        if (typeof key === "string" && stringMethods.has(key)) return new IntrinsicReference(objectValue, key)
        return new ComputedValue(undefined)
@@ -2223,7 +2072,7 @@ export class Interpreter<R> {

      if (Array.isArray(objectValue)) {
        if (operation === "delete") return { target: objectValue, key }
-        const index = typeof key === "symbol" ? undefined : parseArrayIndex(key)
+        const index = parseArrayIndex(key)
        if (key !== "length" && !(typeof key === "string" && arrayMethods.has(key)) && index === undefined) {
          if (typeof key === "string" && Object.hasOwn(objectValue, key)) {
            return new ComputedValue((objectValue as Record<string, unknown> & Array<unknown>)[key])
@@ -2254,13 +2103,13 @@ export class Interpreter<R> {
      if (Array.isArray(reference.target)) {
        if (reference.key === "length") return reference.target.length
        if (typeof reference.key === "string") return new IntrinsicReference(reference.target, reference.key)
-        return Reflect.get(reference.target, reference.key)
+        return reference.target[reference.key]
      }
      if (reference.target instanceof CodeModeRegExp) return reference.target.lastIndex
      if (reference.target instanceof CodeModeURL) {
-        return Reflect.get(reference.target.url, reference.key)
+        return (reference.target.url as unknown as Record<string, unknown>)[String(reference.key)]
      }
-      return Reflect.get(reference.target, reference.key)
+      return reference.target[String(reference.key)]
    })
  }

@@ -2322,22 +2171,22 @@ export class Interpreter<R> {
          throw new InterpreterRuntimeError("Array methods cannot be assigned.", node)
        }
      }
-      const key = reference.key
+      const key = Array.isArray(reference.target) ? reference.key : String(reference.key)
      const { write, next, result } = yield* compute(self.readReferenceValue(reference, key))
      if (write) self.assignToReference(reference, key, next, node)
      return result
    })
  }

-  private readReferenceValue(reference: MemberReference, key: PropertyKey): unknown {
+  private readReferenceValue(reference: MemberReference, key: number | string): unknown {
    if (reference.target instanceof CodeModeURL) {
-      return Reflect.get(reference.target.url, key)
+      return (reference.target.url as unknown as Record<string, unknown>)[key]
    }
    if (reference.target instanceof CodeModeRegExp) return reference.target.lastIndex
-    return Reflect.get(reference.target, key)
+    return (reference.target as Record<PropertyKey, unknown>)[key]
  }

-  private assignToReference(reference: MemberReference, key: PropertyKey, next: unknown, node: AstNode): void {
+  private assignToReference(reference: MemberReference, key: number | string, next: unknown, node: AstNode): void {
    if (Array.isArray(reference.target)) {
      const target = reference.target
      if (typeof key !== "number" || parseArrayIndex(key) === undefined) {
@@ -2370,19 +2219,16 @@ export class Interpreter<R> {
      return
    }
    const target = reference.target as SafeObject
+    const objectKey = key as string
    rejectCircularInsertion(target, next, "Object assignment result", node)
-    Reflect.set(target, key, next)
+    target[objectKey] = next
  }

-  private toPropertyKey(value: unknown, node: AstNode): PropertyKey {
+  private toPropertyKey(value: unknown, node: AstNode): string | number {
    if (typeof value === "string" || typeof value === "number") {
      return value
    }
-    if (value === AsyncIteratorSymbol || value === IteratorSymbol) return value

-    throw new InterpreterRuntimeError(
-      "Property key must be a string or number, or Symbol.asyncIterator/Symbol.iterator.",
-      node,
-    )
+    throw new InterpreterRuntimeError("Property key must be a string or number.", node)
  }
 }
@@ -1,10 +1,4 @@
-import {
-  type AstNode,
-  AsyncIteratorSymbol,
-  InterpreterRuntimeError,
-  IteratorSymbol,
-  IteratorSymbols,
-} from "../interpreter/model.js"
+import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
 import { containsOpaqueReference } from "../interpreter/references.js"
 import { isBlockedMember } from "../tool-runtime.js"
 import { isCodeModeValue, CodeModeMap, CodeModePromise, CodeModeSet, CodeModeURLSearchParams } from "../values.js"
@@ -52,10 +46,7 @@ export const invokeObjectMethod = (name: string, args: Array<unknown>, node: Ast
    case "entries":
      return Object.entries(requireObject()).map(([key, item]) => [key, item])
    case "hasOwn":
-      return Object.hasOwn(
-        requireObject(),
-        args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]),
-      )
+      return Object.hasOwn(requireObject(), String(args[1]))
    case "is":
      if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
        throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue")
@@ -73,9 +64,6 @@ export const invokeObjectMethod = (name: string, args: Array<unknown>, node: Ast
          throw new InterpreterRuntimeError("Object.assign expects data objects.", node)
        }
        for (const [key, item] of Object.entries(source)) guardedSet(out, key, item)
-        for (const symbol of IteratorSymbols) {
-          if (Object.hasOwn(source, symbol)) Reflect.set(out, symbol, Reflect.get(source, symbol))
-        }
      }
      return out
    }
@@ -1,15 +1,10 @@
 /*
 * Portions adapted from Test262 at revision 250f204f23a9249ff204be2baec29600faae7b75:
 * - test/language/statements/for-await-of/ticks-with-sync-iter-resolved-promise-and-constructor-lookup.js
- * - test/language/statements/for-await-of/ticks-with-async-iter-resolved-promise-and-constructor-lookup.js
 * - test/language/statements/for-await-of/async-func-dstr-let-ary-ptrn-elem-id-iter-val.js
 * - test/language/statements/for-await-of/async-func-decl-dstr-array-rest-after-element.js
- * - test/language/statements/for-await-of/iterator-close-non-throw-get-method-is-null.js
- * - test/language/statements/for-await-of/iterator-close-non-throw-get-method-non-callable.js
- * - test/language/statements/for-await-of/iterator-close-throw-get-method-non-callable.js
 *
 * Copyright (C) 2019 André Bargull. All rights reserved.
- * Copyright (C) 2020 Alexey Shvayka. All rights reserved.
 * Test262 portions are governed by the BSD license in LICENSE.test262.
 */
 import { describe, expect, test } from "bun:test"
@@ -135,400 +130,10 @@ describe("Test262 for-await-of adaptations", () => {
    ).toEqual([1, 3])
  })

-  test("drives a custom async iterator sequentially", async () => {
-    expect(
-      await value(`
-        let index = 0
-        const iterator = {
-          [Symbol.asyncIterator]: () => iterator,
-          async next() {
-            index += 1
-            if (index > 3) return { done: true }
-            return { done: false, value: index }
-          },
-        }
-        const values = []
-        for await (const item of iterator) values.push(item)
-        return values
-      `),
-    ).toEqual([1, 2, 3])
-  })
-
-  test("leaves async iterator values under the iterator's control", async () => {
-    expect(
-      await value(`
-        let done = false
-        const iterator = {
-          [Symbol.asyncIterator]: () => iterator,
-          next: async () => done ? { done: true } : (done = true, { done: false, value: Promise.resolve(1) }),
-        }
-        for await (const item of iterator) return [item instanceof Promise, await item]
-      `),
-    ).toEqual([true, 1])
-  })
-
-  test("awaits synchronous results from an async iterator before the body", async () => {
-    expect(
-      await value(`
-        const events = ["pre"]
-        const ticks = Promise.resolve()
-          .then(() => events.push("tick 1"))
-          .then(() => events.push("tick 2"))
-        let done = false
-        const iterator = {
-          [Symbol.asyncIterator]: () => iterator,
-          next: () => done ? { done: true } : (done = true, { done: false, value: Promise.resolve(1) }),
-        }
-        for await (const item of iterator) events.push(item instanceof Promise ? "loop" : "adopted")
-        events.push("post")
-        await ticks
-        return events
-      `),
-    ).toEqual(["pre", "tick 1", "loop", "tick 2", "post"])
-  })
-
-  test("falls back to a custom synchronous iterator", async () => {
-    expect(
-      await value(`
-        let index = 0
-        const iterator = {
-          [Symbol.iterator]: () => iterator,
-          next() {
-            index += 1
-            return index > 2 ? { done: true } : { done: false, value: Promise.resolve(index) }
-          },
-        }
-        const values = []
-        for await (const item of iterator) values.push(item)
-        return values
-      `),
-    ).toEqual([1, 2])
-  })
-
-  test("adopts terminal and close values from synchronous iterators", async () => {
-    expect(
-      await value(`
-        const terminal = {
-          [Symbol.iterator]: () => terminal,
-          next: () => ({ done: true, value: Promise.reject("terminal") }),
-        }
-        let terminalError
-        try {
-          for await (const item of terminal) {}
-        } catch (error) {
-          terminalError = error
-        }
-
-        const closing = {
-          [Symbol.iterator]: () => closing,
-          next: () => ({ done: false, value: 1 }),
-          return: () => ({ done: true, value: Promise.reject("close") }),
-        }
-        let closeError
-        try {
-          for await (const item of closing) break
-        } catch (error) {
-          closeError = error
-        }
-        return [terminalError, closeError]
-      `),
-    ).toEqual(["terminal", "close"])
-  })
-
-  test("captures the next method when acquiring the iterator", async () => {
-    expect(
-      await value(`
-        let count = 0
-        const next = () => {
-          count += 1
-          if (count === 1) iterator.next = () => ({ done: true })
-          return count > 2 ? { done: true } : { done: false, value: count }
-        }
-        const iterator = { [Symbol.iterator]: () => iterator, next }
-        const values = []
-        for await (const item of iterator) values.push(item)
-        return values
-      `),
-    ).toEqual([1, 2])
-  })
-
-  test("captures synchronous iterator result fields before suspending", async () => {
-    expect(
-      await value(`
-        let count = 0
-        const result = { done: false, value: 1 }
-        const iterator = {
-          [Symbol.iterator]: () => iterator,
-          next() {
-            count += 1
-            if (count > 1) return { done: true }
-            Promise.resolve().then(() => {
-              result.done = true
-              result.value = 2
-            })
-            return result
-          },
-        }
-        const values = []
-        for await (const item of iterator) values.push(item)
-        return values
-      `),
-    ).toEqual([1])
-  })
-
-  test("preserves the async close turn for a sync iterator without return", async () => {
-    expect(
-      await value(`
-        const events = []
-        const iterator = {
-          [Symbol.iterator]: () => iterator,
-          next: () => ({ done: false, value: 1 }),
-        }
-        for await (const item of iterator) {
-          Promise.resolve().then(() => events.push("reaction"))
-          break
-        }
-        events.push("after")
-        return events
-      `),
-    ).toEqual(["reaction", "after"])
-  })
-
-  test("defers synchronous iterator protocol errors", async () => {
-    expect(
-      await value(`
-        const events = []
-        const throwing = {
-          [Symbol.iterator]: () => throwing,
-          next() {
-            Promise.resolve().then(() => events.push("next reaction"))
-            throw "next"
-          },
-        }
-        try {
-          for await (const item of throwing) {}
-        } catch (error) {
-          events.push("next catch")
-        }
-
-        const malformed = {
-          [Symbol.iterator]: () => malformed,
-          next() {
-            Promise.resolve().then(() => events.push("result reaction"))
-            return 1
-          },
-        }
-        try {
-          for await (const item of malformed) {}
-        } catch (error) {
-          events.push("result catch")
-        }
-
-        const closing = {
-          [Symbol.iterator]: () => closing,
-          next: () => ({ done: false, value: 1 }),
-          return() {
-            Promise.resolve().then(() => events.push("return reaction"))
-            throw "return"
-          },
-        }
-        try {
-          for await (const item of closing) break
-        } catch (error) {
-          events.push("return catch")
-        }
-        return events
-      `),
-    ).toEqual(["next reaction", "next catch", "result reaction", "result catch", "return reaction", "return catch"])
-  })
-
-  test("prefers Symbol.asyncIterator over Symbol.iterator", async () => {
-    expect(
-      await value(`
-        let done = false
-        const asyncIterator = {
-          next: async () => done ? { done: true } : (done = true, { done: false, value: "async" }),
-        }
-        const syncIterator = { next: () => ({ done: true }) }
-        const iterable = {
-          [Symbol.asyncIterator]: () => asyncIterator,
-          [Symbol.iterator]: () => syncIterator,
-        }
-        const values = []
-        for await (const item of iterable) values.push(item)
-        return values
-      `),
-    ).toEqual(["async"])
-  })
-
-  test("closes a custom iterator on abrupt loop completion", async () => {
-    expect(
-      await value(`
-        let closed = 0
-        const iterator = {
-          [Symbol.asyncIterator]: () => iterator,
-          next: async () => ({ done: false, value: 1 }),
-          return: async () => (closed += 1, { done: true }),
-        }
-        for await (const item of iterator) break
-        try {
-          for await (const item of iterator) throw "stop"
-        } catch (error) {}
-        return closed
-      `),
-    ).toBe(2)
-  })
-
-  test("treats a null iterator return method as absent", async () => {
-    expect(
-      await value(`
-        let count = 0
-        const iterator = {
-          [Symbol.asyncIterator]: () => iterator,
-          next: async () => ({ done: false, value: 1 }),
-          return: null,
-        }
-        for await (const item of iterator) {
-          count += 1
-          break
-        }
-        return count
-      `),
-    ).toBe(1)
-  })
-
-  test("a non-callable return method replaces break with TypeError", async () => {
-    expect(
-      await value(`
-        const iterator = {
-          [Symbol.asyncIterator]: () => iterator,
-          next: async () => ({ done: false, value: 1 }),
-          return: true,
-        }
-        try {
-          for await (const item of iterator) break
-        } catch (error) {
-          return error.name
-        }
-        return "missed"
-      `),
-    ).toBe("TypeError")
-  })
-
-  test("a body throw wins over a non-callable return method", async () => {
-    expect(
-      await value(`
-        const iterator = {
-          [Symbol.asyncIterator]: () => iterator,
-          next: async () => ({ done: false, value: 1 }),
-          return: true,
-        }
-        try {
-          for await (const item of iterator) throw "body"
-        } catch (error) {
-          return error
-        }
-        return "missed"
-      `),
-    ).toBe("body")
-  })
-
-  test("rejects a primitive iterator return result", async () => {
-    expect(
-      await value(`
-        const iterator = {
-          [Symbol.asyncIterator]: () => iterator,
-          next: async () => ({ done: false, value: 1 }),
-          return: async () => null,
-        }
-        try {
-          for await (const item of iterator) break
-        } catch (error) {
-          return error.name
-        }
-        return "missed"
-      `),
-    ).toBe("TypeError")
-  })
-
-  test("propagates iterator acquisition failures", async () => {
-    expect(
-      await value(`
-        const iterator = {
-          [Symbol.asyncIterator]: () => { throw "acquire" },
-        }
-        try {
-          for await (const item of iterator) {}
-        } catch (error) {
-          return error
-        }
-        return "missed"
-      `),
-    ).toBe("acquire")
-  })
-
-  test("rejects malformed iterator acquisition methods and results", async () => {
-    expect(
-      await value(`
-        const names = []
-        const invalid = [
-          { [Symbol.asyncIterator]: true },
-          { [Symbol.asyncIterator]: () => 1 },
-          { [Symbol.asyncIterator]: () => ({ next: true }) },
-        ]
-        for (const iterator of invalid) {
-          try {
-            for await (const item of iterator) {}
-          } catch (error) {
-            names.push(error.name)
-          }
-        }
-        return names
-      `),
-    ).toEqual(["TypeError", "TypeError", "TypeError"])
-  })
-
-  test("preserves iterator protocol keys through object copies", async () => {
-    expect(
-      await value(`
-        let done = false
-        const iterable = {
-          plain: true,
-          [Symbol.asyncIterator]: () => iterable,
-          next: async () => done ? { done: true } : (done = true, { done: false, value: 1 }),
-        }
-        const spread = { ...iterable }
-        const { plain, ...rest } = iterable
-        const assigned = Object.assign({}, iterable)
-        const values = []
-        for await (const item of spread) values.push(item)
-        return [
-          values,
-          Object.hasOwn(spread, Symbol.asyncIterator),
-          Object.hasOwn(rest, Symbol.asyncIterator),
-          Object.hasOwn(assigned, Symbol.asyncIterator),
-        ]
-      `),
-    ).toEqual([[1], true, true, true])
-  })
-
-  test("rejects malformed iterator protocol results", async () => {
-    const result = await execute(`
-      const iterator = {
-        [Symbol.asyncIterator]: () => iterator,
-        next: async () => 1,
-      }
-      for await (const item of iterator) {}
-    `)
-    expect(result.ok).toBe(false)
-    if (result.ok) return
-    expect(result.error.message).toContain("Iterator next() result must be an object")
-  })
-
-  test("rejects objects without an iterator protocol method", async () => {
+  test("keeps custom iterator objects outside the supported subset", async () => {
    const result = await execute(`for await (const item of { values: [1, 2] }) {}`)
    expect(result.ok).toBe(false)
    if (result.ok) return
-    expect(result.error.message).toContain("or custom iterator value")
+    expect(result.error.message).toContain("for await...of requires an array, string, Map, Set, or URLSearchParams")
  })
 })
@@ -717,18 +717,6 @@ describe("destructuring assignment", () => {
    ).toEqual({ first: 1, rest: [2, 3], entry: "a4" })
  })

-  test("excludes computed numeric keys from object rest", async () => {
-    expect(
-      await value(`
-        const { [0]: declared, ...declarationRest } = { 0: "a", 1: "b" }
-        let assigned
-        let assignmentRest
-        ;({ [0]: assigned, ...assignmentRest } = { 0: "c", 1: "d" })
-        return { declared, declarationRest, assigned, assignmentRest }
-      `),
-    ).toEqual({ declared: "a", declarationRest: { 1: "b" }, assigned: "c", assignmentRest: { 1: "d" } })
-  })
-
  test("rejects computed keys that are not confined property keys", async () => {
    const err = await error(`const key = {}; const { [key]: value } = {}`)
    expect(err.message).toContain("Property key must be a string or number")
@@ -189,7 +189,6 @@ export const Plugin = {
                        catch: (error) => new ToolFailure({ message: `patch verification failed: ${String(error)}` }),
                      })
                      const moveTarget = hunk.movePath ? resolveTarget(location, hunk.movePath) : undefined
-                      if (moveTarget) targets.push(moveTarget)
                      if (moveTarget?.externalDirectory) {
                        yield* permission.assert({
                          action: "external_directory",
@@ -40,18 +40,6 @@ describe("Patch", () => {
    expect(() => parse("*** Begin Patch\n*** Add File: add.txt\n+added")).toThrow(
      "The last line of the patch must be '*** End Patch'",
    )
-    expect(() => parse("extra\n*** Begin Patch\n*** End Patch")).toThrow(
-      "The first line of the patch must be '*** Begin Patch'",
-    )
-    expect(() => parse("*** Begin Patch\n*** Add File: add.txt\n+added\n*** End Patch\nextra")).toThrow(
-      "The last line of the patch must be '*** End Patch'",
-    )
-  })
-
-  test("allows whitespace after the end marker", () => {
-    expect(parse("*** Begin Patch\n*** Add File: add.txt\n+added\n*** End Patch\n \t\n")).toEqual([
-      { type: "add", path: "add.txt", contents: "added" },
-    ])
  })

  test("strips a heredoc wrapper", () => {
@@ -181,25 +169,6 @@ describe("Patch", () => {
    ).toBe('He said "hi"\n')
  })

-  test("matches Unicode minus signs and spaces", () => {
-    expect(
-      Patch.derive("minus.txt", [{ oldLines: ["value - 1"], newLines: ["value - 2"] }], "value − 1\n")
-        .content,
-    ).toBe("value - 2\n")
-    const spaces = ["\u00A0", "\u2002", "\u2003", "\u2004", "\u2005", "\u2006", "\u2007", "\u2008", "\u2009", "\u200A", "\u202F", "\u205F", "\u3000"]
-    spaces.forEach(
-      (space) => {
-        expect(
-          Patch.derive(
-            "spaces.txt",
-            [{ oldLines: ["hello world"], newLines: ["hello there"] }],
-            `hello${space}world\n`,
-          ).content,
-        ).toBe("hello there\n")
-      },
-    )
-  })
-
  test("matches EOF-anchored chunks from the end", () => {
    expect(
      Patch.derive(
@@ -351,28 +351,6 @@ describe("PatchTool", () => {
    ),
  )

-  it.live("includes the move destination in edit permission resources", () =>
-    withTempTool((directory, registry) =>
-      Effect.gen(function* () {
-        const source = path.join(directory, "old", "name.txt")
-        yield* Effect.promise(() => fs.mkdir(path.dirname(source), { recursive: true }))
-        yield* Effect.promise(() => fs.writeFile(source, "old content\n"))
-        yield* executeTool(
-          registry,
-          call(
-            "*** Begin Patch\n*** Update File: old/name.txt\n*** Move to: renamed/dir/name.txt\n@@\n-old content\n+new content\n*** End Patch",
-          ),
-        )
-        expect(assertions).toMatchObject([
-          {
-            action: "edit",
-            resources: ["old/name.txt", "renamed/dir/name.txt"],
-          },
-        ])
-      }),
-    ),
-  )
-
  it.live("inserts lines with an insert-only hunk", () =>
    withTempTool((directory, registry) =>
      Effect.gen(function* () {
@@ -122,16 +122,6 @@ export const Info = Schema.Struct({
      }),
    }),
  ).annotate({ description: "Session transcript presentation settings" }),
-  mini: Schema.optional(
-    Schema.Struct({
-      thinking: Schema.optional(Schema.Literals(["show", "hide"])).annotate({
-        description: "Show or hide model reasoning in Mini",
-      }),
-      shell_output: Schema.optional(Schema.Literals(["show", "hide"])).annotate({
-        description: "Show or hide raw shell tool output in Mini",
-      }),
-    }),
-  ).annotate({ description: "Mini transcript presentation settings" }),
  hints: Schema.optional(
    Schema.Struct({
      onboarding: Schema.optional(Schema.Boolean).annotate({ description: "Show getting-started guidance" }),
@@ -1,5 +1,5 @@
 import { toolEntryBody } from "./tool"
-import type { RunEntryBody, ScrollbackOptions, StreamCommit } from "./types"
+import type { RunEntryBody, StreamCommit } from "./types"

 export type EntryFlags = {
  startOnNewLine: boolean
@@ -162,7 +162,7 @@ export function entryCanStream(commit: StreamCommit, body: RunEntryBody): boolea
  return commit.kind === "assistant" || commit.kind === "reasoning"
 }

-export function entryBody(commit: StreamCommit, options?: ScrollbackOptions): RunEntryBody {
+export function entryBody(commit: StreamCommit): RunEntryBody {
  if (commit.summary) {
    return RUN_ENTRY_NONE
  }
@@ -174,7 +174,7 @@ export function entryBody(commit: StreamCommit, options?: ScrollbackOptions): Ru
  }

  if (commit.kind === "tool") {
-    return toolEntryBody(commit, raw, options) ?? RUN_ENTRY_NONE
+    return toolEntryBody(commit, raw) ?? RUN_ENTRY_NONE
  }

  if (commit.kind === "assistant") {
@@ -5,15 +5,7 @@ import fuzzysort from "fuzzysort"
 import { createEffect, createMemo, createSignal, type Accessor } from "solid-js"
 import { RunFooterMenu, createFooterMenuState, type RunFooterMenuItem } from "./footer.menu"
 import type { RunFooterTheme } from "./theme"
-import type {
-  FooterQueuedPrompt,
-  FooterSubagentTab,
-  MiniSettingChange,
-  MiniSettings,
-  RunCommand,
-  RunInput,
-  RunProvider,
-} from "./types"
+import type { FooterQueuedPrompt, FooterSubagentTab, RunCommand, RunInput, RunProvider } from "./types"

 type PanelEntry = RunFooterMenuItem & {
  category: string
@@ -28,7 +20,6 @@ type CommandEntry =
  | (PanelEntry & { action: "subagent" })
  | (PanelEntry & { action: "variant.cycle" })
  | (PanelEntry & { action: "variant.list" })
-  | (PanelEntry & { action: "settings" })
  | (PanelEntry & { action: "slash"; name: string })
  | (PanelEntry & { action: "exit" })

@@ -57,10 +48,6 @@ type QueuedEntry = PanelEntry & {
  prompt: FooterQueuedPrompt
 }

-type SettingEntry = PanelEntry & {
-  key: keyof MiniSettings
-}
-
 const PANEL_PAD = 2
 const PANEL_LIST_ROWS = 10
 const PANEL_FRAME_ROWS = 6
@@ -279,7 +266,6 @@ function PanelShell(props: {
  inputRef: (input: InputRenderable) => void
  onQuery: (query: string) => void
  children: JSX.Element
-  hint?: string
  dark?: boolean
  chrome?: "default" | "minimal"
 }) {
@@ -308,7 +294,7 @@ function PanelShell(props: {
        ) : null}
        <box flexGrow={1} flexShrink={1} backgroundColor="transparent" />
        <text fg={props.theme().muted} wrapMode="none" truncate flexShrink={0}>
-          {props.hint ? `${props.hint} · ` : ""}esc
+          esc
        </text>
      </box>
      <box height={1} flexShrink={0} backgroundColor={background()} />
@@ -414,7 +400,6 @@ export function RunCommandMenuBody(props: {
  onQueued: () => void
  onVariant: () => void
  onVariantCycle: () => void
-  onSettings: () => void
  onCommand: (name: string) => void
  onNew: () => void
  onExit: () => void
@@ -422,7 +407,7 @@ export function RunCommandMenuBody(props: {
  const skills = createMemo(() => (props.commands() ?? []).filter((item) => item.source === "skill"))
  const activeSubagentCount = createMemo(() => props.subagents().filter((item) => item.status === "running").length)
  const entries = createMemo<CommandEntry[]>(() => {
-    const builtins = ["editor", "new", "settings"]
+    const builtins = ["editor", "new"]
    const session: CommandEntry[] = [
      {
        action: "editor",
@@ -530,13 +515,6 @@ export function RunCommandMenuBody(props: {
      ...prompt,
      ...agent,
      ...commands,
-      {
-        action: "settings",
-        category: "System",
-        display: "Open settings",
-        footer: "/settings",
-        keywords: "/settings settings preferences configuration",
-      },
      { action: "exit", category: "System", display: "Exit", footer: "/exit", keywords: "/exit exit" },
    ]
  })
@@ -576,11 +554,6 @@ export function RunCommandMenuBody(props: {
      return
    }

-    if (item.action === "settings") {
-      props.onSettings()
-      return
-    }
-
    if (item.action === "exit") {
      props.onExit()
      return
@@ -633,87 +606,6 @@ export function RunCommandMenuBody(props: {
  )
 }

-export function RunSettingsBody(props: {
-  theme: Accessor<RunFooterTheme>
-  settings: Accessor<MiniSettings>
-  onClose: () => void
-  onChange: (change: MiniSettingChange) => void | Promise<void>
-}) {
-  const [saving, setSaving] = createSignal<keyof MiniSettings>()
-  const entries = createMemo<SettingEntry[]>(() => [
-    {
-      category: "Transcript",
-      display: "Thinking",
-      description: "future sessions",
-      footer: saving() === "thinking" ? "saving" : props.settings().thinking,
-      keywords: `thinking reasoning ${props.settings().thinking}`,
-      key: "thinking",
-    },
-    {
-      category: "Transcript",
-      display: "Shell tool output",
-      description: "model-issued commands",
-      footer: saving() === "shell_output" ? "saving" : props.settings().shell_output,
-      keywords: `shell tool command output ${props.settings().shell_output}`,
-      key: "shell_output",
-    },
-  ])
-  const change = (item: SettingEntry) => {
-    if (saving()) return
-    const current = props.settings()[item.key]
-    setSaving(item.key)
-    void Promise.resolve(props.onChange({ key: item.key, value: current === "show" ? "hide" : "show" }))
-      .catch(() => {})
-      .finally(() => setSaving())
-  }
-  const controller = createSearchablePanelController({
-    entries,
-    limit: PANEL_LIST_ROWS,
-    onClose: props.onClose,
-    onSelect: change,
-    onKey(event, item) {
-      const name = event.name.toLowerCase()
-      if (name !== "left" && name !== "right") return false
-      event.preventDefault()
-      if (item) change(item)
-      return true
-    },
-  })
-
-  return (
-    <PanelShell
-      title="Settings"
-      countVisible={false}
-      query={controller.query()}
-      count={controller.items().length}
-      total={entries().length}
-      placeholder="Search"
-      theme={props.theme}
-      inputRef={controller.inputRef}
-      onQuery={controller.setQuery}
-      hint="left/right change"
-      dark
-      chrome="minimal"
-    >
-      <RunFooterMenu
-        theme={props.theme}
-        items={controller.items}
-        selected={controller.menu.selected}
-        offset={controller.menu.offset}
-        rows={() => PANEL_LIST_ROWS}
-        limit={PANEL_LIST_ROWS}
-        empty="No settings found"
-        border={false}
-        paddingLeft={PANEL_PAD}
-        paddingRight={PANEL_PAD}
-        grouped={!controller.query().trim()}
-        background
-        headerColor={props.theme().muted}
-      />
-    </PanelShell>
-  )
-}
-
 export function RunSubagentSelectBody(props: {
  theme: Accessor<RunFooterTheme>
  tabs: Accessor<FooterSubagentTab[]>
@@ -51,7 +51,7 @@ type Auto = RunFooterMenuItem & {
 type SlashOption = RunFooterMenuItem & {
  kind: "slash"
  name: string
-  action?: "skill-menu" | "editor" | "settings"
+  action?: "skill-menu" | "editor"
 }

 type PromptOption = Auto | SlashOption
@@ -79,7 +79,6 @@ type PromptInput = {
  onExitRequest?: () => boolean
  onExit: () => void
  onSkillMenu: () => void
-  onSettings: () => void
  onRows: (rows: number) => void
  onStatus: (text: string) => void
 }
@@ -381,13 +380,6 @@ export function createPromptState(input: PromptInput): PromptState {
        display: "/editor",
        description: "compose in your external editor",
      } satisfies SlashOption,
-      {
-        kind: "slash",
-        action: "settings" as const,
-        name: "settings",
-        display: "/settings",
-        description: "configure Mini transcript output",
-      } satisfies SlashOption,
      { kind: "slash", name: "new", display: "/new", description: "start a new session" } satisfies SlashOption,
      { kind: "slash", name: "exit", display: "/exit", description: "close OpenCode" } satisfies SlashOption,
    ]
@@ -823,12 +815,6 @@ export function createPromptState(input: PromptInput): PromptState {
        return
      }

-      if (next.action === "settings" && !shell()) {
-        cancelAutocomplete()
-        input.onSettings()
-        return
-      }
-
      const cursor = area.cursorOffset
      const head = parseSlashHead(area.plainText)
      const local = !shell() && (next.name === "new" || next.name === "exit")
@@ -936,7 +922,6 @@ export function createPromptState(input: PromptInput): PromptState {
    if (current === "skill") return false
    if (current === "model") return false
    if (current === "variant") return false
-    if (current === "settings") return false
    if (current === "queued-menu") return false
    if (current === "subagent-menu") return false
    return true
@@ -1134,12 +1119,6 @@ export function createPromptState(input: PromptInput): PromptState {
      return
    }

-    if (!command && next.mode !== "shell" && next.text.trim().toLowerCase() === "/settings") {
-      resetDraft()
-      input.onSettings()
-      return
-    }
-
    const parsed =
      command || next.mode === "shell" || isNewCommand(next.text)
        ? undefined
@@ -56,7 +56,6 @@ export function RunFooterSubagentBody(props: {
  // Formatted interrupt shortcut from the registered keymap binding; the
  // command itself is dispatched through the keymap in footer.view.
  interrupt?: () => string | undefined
-  shellOutput?: () => boolean
 }) {
  const theme = createMemo(() => props.theme())
  const footer = createMemo(() => theme().footer)
@@ -87,7 +86,7 @@ export function RunFooterSubagentBody(props: {
  const rows = indexArray(commits, (commit, index) => (
    <box flexDirection="column" gap={0} flexShrink={0}>
      {index > 0 && separatorRows(commits()[index - 1], commit()) > 0 ? <box height={1} flexShrink={0} /> : null}
-      <RunEntryContent commit={commit()} theme={theme()} opts={{ shellOutput: props.shellOutput?.() ?? true }} />
+      <RunEntryContent commit={commit()} theme={theme()} />
    </box>
  ))
  let scroll: ScrollBoxRenderable | undefined
@@ -48,8 +48,6 @@ import type {
  FooterView,
  FormCancel,
  FormReply,
-  MiniSettingChange,
-  MiniSettings,
  PermissionReply,
  RunAgent,
  RunCommand,
@@ -83,10 +81,6 @@ type RunFooterOptions = {
  history?: RunPrompt[]
  theme: RunTheme
  tuiConfig: RunTuiConfig
-  miniSettings: {
-    current: MiniSettings
-    update?: (change: MiniSettingChange) => Promise<MiniSettings>
-  }
  onPermissionReply: (input: PermissionReply) => void | Promise<void>
  onFormReply: (input: FormReply) => void | Promise<void>
  onFormCancel: (input: FormCancel) => void | Promise<void>
@@ -103,7 +97,11 @@ type RunFooterOptions = {

 const PERMISSION_ROWS = 12
 const FORM_ROWS = 14
+const COMMAND_ROWS = RUN_COMMAND_PANEL_ROWS
+const SKILL_ROWS = RUN_COMMAND_PANEL_ROWS
 const SUBAGENT_ROWS = RUN_SUBAGENT_PANEL_ROWS
+const MODEL_ROWS = RUN_COMMAND_PANEL_ROWS
+const VARIANT_ROWS = RUN_COMMAND_PANEL_ROWS
 const NOTICE_DURATION = 3000
 const THEME_REFRESH_DELAYS = [1000, 1000] as const

@@ -187,8 +185,6 @@ export class RunFooter implements FooterApi {
  private setQueuedPrompts: Setter<FooterQueuedPrompt[]>
  private history: Accessor<RunPrompt[]>
  private setHistory: Setter<RunPrompt[]>
-  private miniSettings: Accessor<MiniSettings>
-  private setMiniSettings: Setter<MiniSettings>
  private promptRoute: FooterPromptRoute = { type: "composer" }
  private subagentMenuRows = SUBAGENT_ROWS
  private interruptTimeout: NodeJS.Timeout | undefined
@@ -213,7 +209,6 @@ export class RunFooter implements FooterApi {
          .catch(() => {})
          .finally(() => this.destroyTheme(theme))
      },
-      shellOutput: () => this.miniSettings().shell_output === "show",
    })
  }

@@ -274,9 +269,6 @@ export class RunFooter implements FooterApi {
    const [history, setHistory] = createSignal(options.history ?? [])
    this.history = history
    this.setHistory = setHistory
-    const [miniSettings, setMiniSettings] = createSignal(options.miniSettings.current)
-    this.miniSettings = miniSettings
-    this.setMiniSettings = setMiniSettings
    this.base = Math.max(1, renderer.footerHeight - TEXTAREA_MIN_ROWS)
    this.scrollback = this.createScrollback(options.wrote ?? false)

@@ -308,7 +300,6 @@ export class RunFooter implements FooterApi {
              currentVariant: footer.currentVariant,
              theme: footer.theme,
              tuiConfig: options.tuiConfig,
-              miniSettings: footer.miniSettings,
              history: footer.history,
              onSubmit: footer.handlePrompt,
              onPermissionReply: footer.handlePermissionReply,
@@ -327,7 +318,6 @@ export class RunFooter implements FooterApi {
              onRows: footer.syncRows,
              onLayout: footer.syncLayout,
              onStatus: footer.setStatus,
-              onMiniSettingChange: footer.handleMiniSettingChange,
              onSubagentSelect: options.onSubagentSelect,
              onSubagentInterrupt: options.onSubagentInterrupt,
            })
@@ -672,19 +662,26 @@ export class RunFooter implements FooterApi {
  // get fixed extra rows; the prompt view scales with textarea line count.
  private applyHeight(): void {
    const type = this.view().type
-    const route = this.promptRoute.type
    const height =
      type === "permission"
        ? this.base + PERMISSION_ROWS
        : type === "form"
          ? this.base + FORM_ROWS
-          : ["command", "skill", "model", "variant", "settings"].includes(route)
-            ? 1 + RUN_COMMAND_PANEL_ROWS
-            : route === "queued-menu" || route === "subagent-menu"
-              ? 1 + this.subagentMenuRows
-              : route === "subagent"
-                ? this.base + SUBAGENT_INSPECTOR_ROWS
-                : this.base + Math.max(TEXTAREA_MIN_ROWS, Math.min(PROMPT_MAX_ROWS, this.rows))
+          : this.promptRoute.type === "command"
+            ? 1 + COMMAND_ROWS
+            : this.promptRoute.type === "skill"
+              ? 1 + SKILL_ROWS
+              : this.promptRoute.type === "model"
+                ? 1 + MODEL_ROWS
+                : this.promptRoute.type === "variant"
+                  ? 1 + VARIANT_ROWS
+                  : this.promptRoute.type === "queued-menu"
+                    ? 1 + this.subagentMenuRows
+                    : this.promptRoute.type === "subagent-menu"
+                      ? 1 + this.subagentMenuRows
+                      : this.promptRoute.type === "subagent"
+                        ? this.base + SUBAGENT_INSPECTOR_ROWS
+                        : this.base + Math.max(TEXTAREA_MIN_ROWS, Math.min(PROMPT_MAX_ROWS, this.rows))

    if (height !== this.renderer.footerHeight) {
      this.renderer.footerHeight = height
@@ -867,21 +864,6 @@ export class RunFooter implements FooterApi {
      .catch(() => {})
  }

-  private handleMiniSettingChange = async (change: MiniSettingChange): Promise<void> => {
-    if (!this.options.miniSettings.update) {
-      this.setNotice("settings are unavailable")
-      return
-    }
-
-    try {
-      this.setMiniSettings(await this.options.miniSettings.update(change))
-      this.setNotice("settings updated")
-    } catch (error) {
-      this.setNotice("failed to save settings")
-      throw error
-    }
-  }
-
  private clearInterruptTimer(): void {
    if (!this.interruptTimeout) {
      return
@@ -17,7 +17,6 @@ import {
  RunCommandMenuBody,
  RunModelSelectBody,
  RunQueuedPromptSelectBody,
-  RunSettingsBody,
  RunSkillSelectBody,
  RunSubagentSelectBody,
  RunVariantSelectBody,
@@ -40,8 +39,6 @@ import type {
  FooterView,
  FormCancel,
  FormReply,
-  MiniSettingChange,
-  MiniSettings,
  PermissionReply,
  RunAgent,
  RunCommand,
@@ -85,7 +82,6 @@ type RunFooterViewProps = {
  queuedPrompts?: () => FooterQueuedPrompt[]
  theme: () => RunTheme
  tuiConfig: RunTuiConfig
-  miniSettings: () => MiniSettings
  history?: () => RunPrompt[]
  onSubmit: (input: RunPrompt) => boolean
  onPermissionReply: (input: PermissionReply) => void | Promise<void>
@@ -104,7 +100,6 @@ type RunFooterViewProps = {
  onRows: (rows: number) => void
  onLayout: (input: { route: FooterPromptRoute; subagentRows: number }) => void
  onStatus: (text: string) => void
-  onMiniSettingChange: (change: MiniSettingChange) => void | Promise<void>
  onSubagentSelect?: (sessionID: string | undefined) => void
  onSubagentInterrupt?: (sessionID: string) => void
 }
@@ -136,7 +131,6 @@ export function RunFooterView(props: RunFooterViewProps) {
  const skilling = createMemo(() => active().type === "prompt" && route().type === "skill")
  const modeling = createMemo(() => active().type === "prompt" && route().type === "model")
  const varianting = createMemo(() => active().type === "prompt" && route().type === "variant")
-  const setting = createMemo(() => active().type === "prompt" && route().type === "settings")
  const panel = createMemo(
    () =>
      active().type === "permission" ||
@@ -146,8 +140,7 @@ export function RunFooterView(props: RunFooterViewProps) {
      commanding() ||
      skilling() ||
      modeling() ||
-      varianting() ||
-      setting(),
+      varianting(),
  )
  const selected = createMemo(() => {
    const current = route()
@@ -264,11 +257,6 @@ export function RunFooterView(props: RunFooterViewProps) {
    props.onSubagentSelect?.(undefined)
  }

-  const openSettings = () => {
-    setRoute({ type: "settings" })
-    props.onSubagentSelect?.(undefined)
-  }
-
  const openSubagentMenu = () => {
    if (tabs().length === 0) {
      return
@@ -335,7 +323,6 @@ export function RunFooterView(props: RunFooterViewProps) {
    onExitRequest: props.onExitRequest,
    onExit: props.onExit,
    onSkillMenu: openSkillMenu,
-    onSettings: openSettings,
    onRows: props.onRows,
    onStatus: props.onStatus,
  })
@@ -572,7 +559,6 @@ export function RunFooterView(props: RunFooterViewProps) {
      current.type !== "skill" &&
      current.type !== "model" &&
      current.type !== "variant" &&
-      current.type !== "settings" &&
      current.type !== "queued-menu" &&
      current.type !== "subagent-menu"
    ) {
@@ -682,7 +668,6 @@ export function RunFooterView(props: RunFooterViewProps) {
                            onSubagent={openSubagentMenu}
                            onQueued={openQueuedMenu}
                            onVariant={openVariant}
-                            onSettings={openSettings}
                            onVariantCycle={() => {
                              props.onCycle()
                              closePanel()
@@ -741,14 +726,6 @@ export function RunFooterView(props: RunFooterViewProps) {
                            }}
                          />
                        </Match>
-                        <Match when={setting()}>
-                          <RunSettingsBody
-                            theme={theme}
-                            settings={props.miniSettings}
-                            onClose={closePanel}
-                            onChange={props.onMiniSettingChange}
-                          />
-                        </Match>
                        <Match when={active().type === "permission"}>
                          <RunPermissionBody
                            request={permission()!.request}
@@ -927,7 +904,6 @@ export function RunFooterView(props: RunFooterViewProps) {
            onCycle={cycleTab}
            onClose={closeTab}
            interrupt={() => subagentInterruptShortcut() || undefined}
-            shellOutput={() => props.miniSettings().shell_output === "show"}
          />
        </box>
      </Show>
@@ -8,7 +8,7 @@ import type { LocationRef } from "@opencode-ai/client/promise"
 import { resolve } from "../config"
 import { loadRunProviders } from "./catalog.shared"
 import { resolveCurrentSession, sessionHistory } from "./session.shared"
-import type { MiniSettings, RunInput, RunPrompt, RunProvider, RunTuiConfig } from "./types"
+import type { RunInput, RunPrompt, RunProvider, RunTuiConfig } from "./types"
 import { pickVariant } from "./variant.shared"

 export type ModelInfo = {
@@ -83,10 +83,3 @@ export async function resolveRunTuiConfig(
    .then((value) => value ?? defaultRunTuiConfig(platform))
    .catch(() => defaultRunTuiConfig(platform))
 }
-
-export function resolveMiniSettings(config?: { mini?: Partial<MiniSettings> }): MiniSettings {
-  return {
-    thinking: config?.mini?.thinking ?? "hide",
-    shell_output: config?.mini?.shell_output ?? "hide",
-  }
-}
@@ -18,8 +18,6 @@ import type {
  FooterApi,
  FormCancel,
  FormReply,
-  MiniSettingChange,
-  MiniSettings,
  MiniHost,
  PermissionReply,
  RunAgent,
@@ -28,7 +26,6 @@ import type {
  RunReference,
  RunTuiConfig,
 } from "./types"
-import { resolveMiniSettings } from "./runtime.boot"
 import { formatModelLabel } from "./variant.shared"

 const FOOTER_HEIGHT = 4
@@ -65,7 +62,6 @@ export type LifecycleInput = {
  model: RunInput["model"]
  variant: string | undefined
  tuiConfig: RunTuiConfig | Promise<RunTuiConfig>
-  onMiniSettingChange?: (change: MiniSettingChange) => Promise<MiniSettings>
  onPermissionReply: (input: PermissionReply) => void | Promise<void>
  onFormReply: (input: FormReply) => void | Promise<void>
  onFormCancel: (input: FormCancel) => void | Promise<void>
@@ -228,10 +224,6 @@ export async function createRuntimeLifecycle(input: LifecycleInput): Promise<Lif
    theme,
    wrote,
    tuiConfig,
-    miniSettings: {
-      current: resolveMiniSettings(tuiConfig),
-      update: input.onMiniSettingChange,
-    },
    onPermissionReply: input.onPermissionReply,
    onFormReply: input.onFormReply,
    onFormCancel: input.onFormCancel,
@@ -10,27 +10,11 @@
 //   4. runs the prompt queue until the footer closes.
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import type { LocationRef } from "@opencode-ai/client/promise"
-import type { Config } from "../config"
 import { loadRunAgents, loadRunCommands, loadRunReferences, waitForDefaultModel } from "./catalog.shared"
-import {
-  resolveMiniSettings,
-  resolveModelInfo,
-  resolveModelInfoStrict,
-  resolveRunTuiConfig,
-  resolveSessionInfo,
-} from "./runtime.boot"
+import { resolveModelInfo, resolveModelInfoStrict, resolveRunTuiConfig, resolveSessionInfo } from "./runtime.boot"
 import { createRuntimeLifecycle } from "./runtime.lifecycle"
 import { cycleVariant, formatModelLabel, resolveVariant } from "./variant.shared"
-import type {
-  LocalReplayRow,
-  MiniHost,
-  MiniSettings,
-  RunInput,
-  RunPrompt,
-  RunProvider,
-  RunTuiConfig,
-  StreamCommit,
-} from "./types"
+import type { LocalReplayRow, MiniHost, RunInput, RunPrompt, RunProvider, RunTuiConfig, StreamCommit } from "./types"

 type BootContext = Pick<RunInput, "sdk" | "agent" | "model" | "variant"> & {
  location: LocationRef
@@ -59,7 +43,6 @@ type RunRuntimeInput = {
  replayLimit?: number
  demo?: RunInput["demo"]
  tuiConfig?: RunTuiConfig | Promise<RunTuiConfig>
-  config?: Pick<Config.Interface, "update">
 }

 export type RunDeferredInput = {
@@ -79,7 +62,6 @@ export type RunDeferredInput = {
  replayLimit?: number
  demo?: RunInput["demo"]
  tuiConfig?: RunTuiConfig | Promise<RunTuiConfig>
-  config?: Pick<Config.Interface, "update">
 }

 type StreamTransportModule = Pick<
@@ -192,12 +174,7 @@ function abortable<A>(task: Promise<A>, signal: AbortSignal): Promise<A | undefi
 async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDeps = {}): Promise<void> {
  const start = input.host.startup.now()
  const log = input.host.diagnostics.trace
-  const config = input.config
-  const configState: { current: MiniSettings } = { current: resolveMiniSettings() }
-  const tuiConfigTask = resolveRunTuiConfig(input.tuiConfig, input.host.platform).then((tuiConfig) => {
-    configState.current = resolveMiniSettings(tuiConfig)
-    return tuiConfig
-  })
+  const tuiConfigTask = resolveRunTuiConfig(input.tuiConfig, input.host.platform)
  const ctx = await input.boot()
  const runtimeController = new AbortController()
  const session = {
@@ -249,16 +226,6 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
    model: state.model,
    variant: state.activeVariant,
    tuiConfig: tuiConfigTask,
-    onMiniSettingChange: config
-      ? async (change) => {
-          const info = await config.update((draft) => {
-            if (!draft.mini || typeof draft.mini !== "object") draft.mini = {}
-            draft.mini[change.key] = change.value
-          })
-          configState.current = resolveMiniSettings(info)
-          return configState.current
-        }
-      : undefined,
    onPermissionReply: async (next) => {
      if (state.demo?.permission(next)) {
        return
@@ -392,8 +359,8 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
      })
    },
  })
-  await tuiConfigTask
-  const thinking = () => input.thinking ?? configState.current.thinking === "show"
+  const tuiConfig = await tuiConfigTask
+  const thinking = input.thinking ?? tuiConfig.session?.thinking !== "hide"
  const footer = shell.footer
  const firstPaint = footer.idle().catch(() => {})
  const offRuntimeClose = footer.onClose(() => runtimeController.abort())
@@ -712,7 +679,7 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
    return createRunDemo({
      footer,
      sessionID: state.sessionID,
-      thinking: thinking(),
+      thinking,
    })
  }

@@ -755,7 +722,7 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
        readTextFile: input.host.files.readText,
        location: state.location,
        sessionID: state.sessionID,
-        thinking: thinking(),
+        thinking,
        replay: input.replay,
        replayLimit: input.replayLimit,
        footer,
@@ -1051,7 +1018,6 @@ export async function runInteractiveDeferredMode(input: RunDeferredInput, deps?:
      replayLimit: input.replayLimit,
      demo: input.demo,
      tuiConfig: input.tuiConfig,
-      config: input.config,
      reconnect: input.reconnect,
      resolveSession: input.target,
      createSession: input.createSession,
@@ -88,7 +88,6 @@ export class RunScrollbackStream {
  private active: ActiveEntry | undefined
  private treeSitterClient: TreeSitterClient | undefined
  private wrote: boolean
-  private shellOutput: () => boolean
  private pendingThemes: RunTheme[] = []

  constructor(
@@ -98,12 +97,10 @@ export class RunScrollbackStream {
      wrote?: boolean
      treeSitterClient?: TreeSitterClient
      onThemeRelease?: (theme: RunTheme) => void
-      shellOutput?: () => boolean
    } = {},
  ) {
    this.treeSitterClient = options.treeSitterClient
    this.wrote = options.wrote ?? false
-    this.shellOutput = options.shellOutput ?? (() => true)
    this.onThemeRelease = options.onThemeRelease
  }

@@ -357,7 +354,7 @@ export class RunScrollbackStream {
      return
    }

-    const body = entryBody(commit, { shellOutput: this.shellOutput() })
+    const body = entryBody(commit)
    if (body.type === "none") {
      if (entryDone(commit)) {
        this.markRendered(await this.finishActive(false))
@@ -74,7 +74,7 @@ export function RunEntryContent(props: {
  opts?: ScrollbackOptions
 }) {
  const theme = createMemo(() => props.theme ?? RUN_THEME_FALLBACK)
-  const body = createMemo(() => props.body ?? entryBody(props.commit, props.opts))
+  const body = createMemo(() => props.body ?? entryBody(props.commit))
  const style = createMemo(() => entryLook(props.commit, theme().entry))
  const syntax = createMemo(() => entrySyntax(theme()))
  const color = createMemo(() => entryColor(props.commit, theme()))
@@ -758,12 +758,10 @@ export async function createSessionTransport(input: StreamInput): Promise<Sessio
      client.session.active(options),
    ])
    if (!current(attempt)) return
-    state.pending = new Map(
-      pending.flatMap((item) => {
-        const prompt = pendingPrompt(item)
-        return prompt ? [[prompt.messageID, prompt] as const] : []
-      }),
-    )
+    state.pending = new Map(pending.flatMap((item) => {
+      const prompt = pendingPrompt(item)
+      return prompt ? [[prompt.messageID, prompt] as const] : []
+    }))
    syncPending()
    state.permissions = permissions
    pruneToolSources()
@@ -1273,11 +1273,7 @@ function shellOutput(command: string, raw: string): string | undefined {
  return `\n${body}`
 }

-export function toolEntryBody(
-  commit: StreamCommit,
-  raw: string,
-  options?: { shellOutput?: boolean },
-): RunEntryBody | undefined {
+export function toolEntryBody(commit: StreamCommit, raw: string): RunEntryBody | undefined {
  if (commit.shell) {
    if (commit.phase === "start") {
      return textBody(`$ ${commit.shell.command}`)
@@ -1298,8 +1294,6 @@ export function toolEntryBody(
  const ctx = toolFrame(commit, raw)
  const view = toolView(ctx.name)

-  if (ctx.name === "shell" && commit.phase === "progress" && options?.shellOutput === false) return undefined
-
  if (ctx.name === "subagent") {
    if (commit.phase === "start") {
      return undefined
@@ -184,7 +184,6 @@ export type TurnSummary = {

 export type ScrollbackOptions = {
  suppressBackgrounds?: boolean
-  shellOutput?: boolean
 }

 export type ToolCodeSnapshot = {
@@ -294,7 +293,6 @@ export type FooterPromptRoute =
  | { type: "skill" }
  | { type: "model" }
  | { type: "variant" }
-  | { type: "settings" }

 export type FooterSubagentTab = {
  sessionID: string
@@ -391,17 +389,7 @@ export type FormCancel = {
  location?: LocationRef
 }

-export type RunTuiConfig = Pick<Config.Resolved, "keybinds" | "leader" | "theme" | "session" | "mini">
-
-export type MiniSettings = {
-  thinking: "show" | "hide"
-  shell_output: "show" | "hide"
-}
-
-export type MiniSettingChange = {
-  key: keyof MiniSettings
-  value: "show" | "hide"
-}
+export type RunTuiConfig = Pick<Config.Resolved, "keybinds" | "leader" | "theme" | "session">

 // Lifecycle phase of a scrollback entry. "start" opens the entry, "progress"
 // appends content (coalesced in the footer queue), "final" closes it.
@@ -389,6 +389,7 @@ describe("run entry body", () => {
      type: "text",
      content: "$ pwd",
    })
+
    expect(
      entryBody(
        commit({
@@ -410,15 +411,6 @@ describe("run entry body", () => {
    })
  })

-  test("hides shell tool output but not direct shell output", () => {
-    const output = commit({ kind: "tool", text: "output", phase: "progress", source: "tool", tool: "shell" })
-    expect(entryBody(output, { shellOutput: false })).toEqual({ type: "none" })
-    expect(entryBody({ ...output, shell: { command: "pwd" } }, { shellOutput: false })).toEqual({
-      type: "text",
-      content: "\noutput",
-    })
-  })
-
  test("falls back to patch summary when patch has no visible diff items", () => {
    expect(
      entryBody(
@@ -55,7 +55,6 @@ test("down opens subagents from an empty prompt", async () => {
          subagent={subagents}
          theme={() => RUN_THEME_FALLBACK}
          tuiConfig={config}
-          miniSettings={() => ({ thinking: "hide", shell_output: "hide" })}
          onSubmit={() => true}
          onPermissionReply={() => {}}
          onFormReply={() => {}}
@@ -70,7 +69,6 @@ test("down opens subagents from an empty prompt", async () => {
          onRows={() => {}}
          onLayout={() => {}}
          onStatus={() => {}}
-          onMiniSettingChange={() => {}}
        />
      </Keymap.Provider>
    )
@@ -11,7 +11,6 @@ import {
  RunCommandMenuBody,
  RunModelSelectBody,
  RunQueuedPromptSelectBody,
-  RunSettingsBody,
  RunSkillSelectBody,
  RunSubagentSelectBody,
  RunVariantSelectBody,
@@ -24,8 +23,6 @@ import type {
  FooterSubagentState,
  FooterSubagentTab,
  FooterView,
-  MiniSettingChange,
-  MiniSettings,
  RunCommand,
  RunInput,
  RunPrompt,
@@ -120,8 +117,6 @@ async function renderFooter(
    onSubmit?: (prompt: RunPrompt) => boolean
    view?: FooterView
    onFormReply?: (input: unknown) => void
-    miniSettings?: MiniSettings
-    onMiniSettingChange?: (change: MiniSettingChange) => void
  } = {},
 ) {
  const [view, setView] = createSignal<FooterView>(input.view ?? { type: "prompt" })
@@ -130,7 +125,6 @@ async function renderFooter(
  )
  const state = footerState(input.state)
  const config = input.tuiConfig ?? tuiConfig
-  const [miniSettings] = createSignal<MiniSettings>(input.miniSettings ?? { thinking: "hide", shell_output: "hide" })
  function Harness() {
    return (
      <Keymap.Provider config={config}>
@@ -149,7 +143,6 @@ async function renderFooter(
          subagent={subagents}
          theme={input.theme ?? (() => RUN_THEME_FALLBACK)}
          tuiConfig={config}
-          miniSettings={miniSettings}
          onSubmit={input.onSubmit ?? (() => true)}
          onPermissionReply={() => {}}
          onFormReply={(value) => input.onFormReply?.(value)}
@@ -164,7 +157,6 @@ async function renderFooter(
          onRows={() => {}}
          onLayout={() => {}}
          onStatus={() => {}}
-          onMiniSettingChange={(change) => input.onMiniSettingChange?.(change)}
        />
      </Keymap.Provider>
    )
@@ -377,7 +369,6 @@ test("direct command panel renders grouped command palette", async () => {
          onQueued={() => {}}
          onVariant={() => {}}
          onVariantCycle={() => {}}
-          onSettings={() => {}}
          onCommand={() => {}}
          onNew={() => {}}
          onExit={() => {}}
@@ -417,40 +408,6 @@ test("direct command panel renders grouped command palette", async () => {
  }
 })

-test("direct settings panel changes Mini transcript preferences", async () => {
-  const [settings, setSettings] = createSignal<MiniSettings>({ thinking: "hide", shell_output: "hide" })
-  const app = await testRender(
-    () => (
-      <box width={100} height={RUN_COMMAND_PANEL_ROWS}>
-        <RunSettingsBody
-          theme={() => RUN_THEME_FALLBACK.footer}
-          settings={settings}
-          onClose={() => {}}
-          onChange={(change) => {
-            setSettings((current) => ({ ...current, [change.key]: change.value }))
-          }}
-        />
-      </box>
-    ),
-    { width: 100, height: RUN_COMMAND_PANEL_ROWS },
-  )
-
-  try {
-    await app.renderOnce()
-    expect(app.captureCharFrame()).toContain("Settings")
-    expect(app.captureCharFrame()).toContain("Thinking")
-    expect(app.captureCharFrame()).toContain("Shell tool output")
-    expect(app.captureCharFrame()).toContain("left/right change")
-
-    app.mockInput.pressKey("ARROW_RIGHT")
-    await app.renderOnce()
-
-    expect(settings()).toEqual({ thinking: "show", shell_output: "hide" })
-  } finally {
-    app.renderer.destroy()
-  }
-})
-
 test("direct skill panel renders searchable skill list", async () => {
  const [commands] = createSignal<RunCommand[] | undefined>([
    command({ name: "review", description: "Review code" }),
@@ -561,7 +518,6 @@ test("direct command panel shows subagent entry when available", async () => {
          onQueued={() => {}}
          onVariant={() => {}}
          onVariantCycle={() => {}}
-          onSettings={() => {}}
          onCommand={() => {}}
          onNew={() => {}}
          onExit={() => {}}
@@ -610,7 +566,6 @@ test("direct command panel keeps completed subagents available", async () => {
          onQueued={() => {}}
          onVariant={() => {}}
          onVariantCycle={() => {}}
-          onSettings={() => {}}
          onCommand={() => {}}
          onNew={() => {}}
          onExit={() => {}}
@@ -867,7 +822,7 @@ test("direct footer submits slash autocomplete selections without dispatching sh
    await app.renderOnce()

    app.mockInput.pressKey("!")
-    "/settings".split("").forEach((key) => app.mockInput.pressKey(key))
+    "/rev".split("").forEach((key) => app.mockInput.pressKey(key))
    await app.renderOnce()
    app.mockInput.pressEnter()
    await app.renderOnce()
@@ -879,7 +834,7 @@ test("direct footer submits slash autocomplete selections without dispatching sh
      { text: "/new ", parts: [] },
      { text: "/new ", parts: [] },
    ])
-    expect(app.renderer.currentFocusedEditor?.plainText).toBe("/settings ")
+    expect(app.captureCharFrame()).toContain("/review")
  } finally {
    app.cleanup()
  }
@@ -912,26 +867,6 @@ test("direct footer slash autocomplete keeps a real skills command", async () =>
  }
 })

-test("direct footer closes settings with ctrl-c instead of arming exit", async () => {
-  const app = await renderFooter({ height: 20 })
-
-  try {
-    await app.renderOnce()
-    "/settings".split("").forEach((key) => app.mockInput.pressKey(key))
-    await app.renderOnce()
-    app.mockInput.pressEnter()
-    await app.renderOnce()
-    expect(app.captureCharFrame()).toContain("Shell tool output")
-
-    app.mockInput.pressKey("c", { ctrl: true })
-    await app.renderOnce()
-    expect(app.captureCharFrame()).not.toContain("Shell tool output")
-    expect(app.renderer.currentFocusedEditor?.plainText).toBe("")
-  } finally {
-    app.cleanup()
-  }
-})
-
 test("selectedCommand backfills the catalog source for bound drafts", () => {
  const catalog = [command({ name: "opencode-ts", description: "TS skill", source: "skill" })]

@@ -1099,7 +1034,6 @@ test("direct footer shows authoritative pending work while running", async () =>
          ]}
          theme={() => RUN_THEME_FALLBACK}
          tuiConfig={tuiConfig}
-          miniSettings={() => ({ thinking: "hide", shell_output: "hide" })}
          onSubmit={() => true}
          onPermissionReply={() => {}}
          onFormReply={() => {}}
@@ -1114,7 +1048,6 @@ test("direct footer shows authoritative pending work while running", async () =>
          onRows={() => {}}
          onLayout={() => {}}
          onStatus={() => {}}
-          onMiniSettingChange={() => {}}
        />
      </Keymap.Provider>
    )
@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
 import { OpenCode } from "@opencode-ai/client/promise"
 import type { Resolved } from "../../src/config"
-import { resolveMiniSettings, resolveModelInfo, resolveRunTuiConfig } from "../../src/mini/runtime.boot"
+import { resolveModelInfo, resolveRunTuiConfig } from "../../src/mini/runtime.boot"
 import { catalogModel, catalogProvider } from "./fixture/catalog"
 import { createTuiResolvedConfig } from "./fixture/tui-runtime"

@@ -91,23 +91,18 @@ describe("run runtime boot", () => {
    expect(result.keybinds.get("leader")).toEqual([])
  })

-  test("preserves shared config while resolving independent Mini defaults", async () => {
+  test("preserves current theme mode, leader, and thinking config", async () => {
    const result = await resolveRunTuiConfig(
      createTuiResolvedConfig({
        theme: { mode: "light" },
        leader_timeout: 450,
-        session: { thinking: "show" },
+        session: { thinking: "hide" },
      }),
    )

    expect(result.theme).toEqual({ mode: "light" })
    expect(result.leader.timeout).toBe(450)
-    expect(result.session?.thinking).toBe("show")
-    expect(resolveMiniSettings(result)).toEqual({ thinking: "hide", shell_output: "hide" })
-    expect(resolveMiniSettings({ mini: { thinking: "show", shell_output: "show" } })).toEqual({
-      thinking: "show",
-      shell_output: "show",
-    })
+    expect(result.session?.thinking).toBe("hide")
  })

  test("loads v2 providers and models for model selector data", async () => {
@@ -47,8 +47,8 @@ export function parse(patchText: string): Result.Result<ReadonlyArray<Hunk>, Par
  const lines = stripHeredoc(patchText.trim())
    .split("\n")
    .map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line))
-  const begin = lines[0]?.trim() === "*** Begin Patch" ? 0 : -1
-  const end = lines.at(-1)?.trim() === "*** End Patch" ? lines.length - 1 : -1
+  const begin = lines.findIndex((line) => line.trim() === "*** Begin Patch")
+  const end = lines.findIndex((line) => line.trim() === "*** End Patch")
  if (begin === -1) return Result.fail(new BoundaryError({ boundary: "first" }))
  if (end === -1 || begin >= end) return Result.fail(new BoundaryError({ boundary: "last" }))

@@ -227,9 +227,9 @@ const normalize = (value: string) =>
  value
    .replace(/[‘’‚‛]/g, "'")
    .replace(/[“”„‟]/g, '"')
-    .replace(/[‐‑‒–—―−]/g, "-")
+    .replace(/[‐‑‒–—―]/g, "-")
    .replace(/…/g, "...")
-    .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ")
+    .replace(/ /g, " ")
 const splitBom = (text: string) =>
  text.startsWith("\uFEFF") ? { bom: true, text: text.slice(1) } : { bom: false, text }
 const stripHeredoc = (input: string) =>
Author	SHA1	Message	Date
Dax Raad	dcc924386d	refactor(core): decouple session version	2026-07-21 14:07:25 -04:00
Dax Raad	689e17738c	Merge remote-tracking branch 'origin/v2' into client-service # Conflicts: # packages/core/src/session/generate-node.ts # packages/core/src/session/title.ts # packages/util/src/observability.ts	2026-07-21 13:10:07 -04:00
Dax Raad	e2f203a56e	refactor: centralize client identity	2026-07-21 12:58:16 -04:00