refactor(core): separate configured command invocation

Merge session status changes received during activity hydration and ignore superseded reconnect responses. Cover terminal events, starts, deletion, and overlapping connections so idle sessions do not regain stale TUI spinners.

packages/client/src/solid/data.ts

@@ -215,8 +215,10 @@ export function createData(config: CreateDataInput) {
   )
   const messageIndex = new Map<string, Map<string, number>>()
   const sync = createSync()
+  let activeUpdates: Map<string, DataSessionStatus | undefined> | undefined
 
   function setSessionActive(sessionID: string, status: DataSessionStatus) {
+    activeUpdates?.set(sessionID, status)
     setStore("session", "active", sessionID, status)
   }
 
@@ -473,6 +475,7 @@ export function createData(config: CreateDataInput) {
   }
 
   function removeSession(sessionID: string) {
+    activeUpdates?.set(sessionID, undefined)
     store.session.pending[sessionID]?.forEach((item) => outbox.delete(item.id))
     messageIndex.delete(sessionID)
     sync.invalidate(`session:${sessionID}`)
@@ -504,17 +507,25 @@ export function createData(config: CreateDataInput) {
 
   function handleEvent(event: OpenCodeEvent) {
     switch (event.type) {
-      case "server.connected":
+      case "server.connected": {
+        const updates = new Map<string, DataSessionStatus | undefined>()
+        activeUpdates = updates
         void api()
           .session.active()
           .then((active) => {
-            setStore(
-              "session",
-              "active",
-              reconcile(Object.fromEntries(Object.keys(active).map((sessionID) => [sessionID, "running" as const]))),
-            )
+            if (activeUpdates !== updates) return
+            // Lifecycle events received during hydration supersede the snapshot.
+            const snapshot = new Map<string, DataSessionStatus>(Object.keys(active).map((id) => [id, "running"]))
+            updates.forEach((status, id) => {
+              if (status === undefined) return snapshot.delete(id)
+              snapshot.set(id, status)
+            })
+            activeUpdates = undefined
+            setStore("session", "active", reconcile(Object.fromEntries(snapshot)))
+          })
+          .catch(() => {
+            if (activeUpdates === updates) activeUpdates = undefined
           })
-          .catch(() => undefined)
         void api()
           .location.get({ location: locationQuery(defaultLocation()) })
           .then((location) => {
@@ -525,6 +536,7 @@ export function createData(config: CreateDataInput) {
         void result.location.vcs.sync().catch((error) => console.error("Failed to preload VCS info", error))
         void result.project.sync().catch((error) => console.error("Failed to preload projects", error))
         return
+      }
       case "project.updated":
         setStore("project", "info", event.data.id, reconcile(event.data))
         return

packages/client/test/solid-data.test.ts

@@ -485,6 +485,102 @@ test("preserves assistant content replacement events across an active message re
   }
 })
 
+test.each([
+  "session.execution.succeeded",
+  "session.execution.failed",
+  "session.execution.interrupted",
+  "session.execution.started",
+  "session.deleted",
+] as const)("preserves %s activity when an older snapshot arrives", async (type) => {
+  const release = Promise.withResolvers<void>()
+  const requested = Promise.withResolvers<void>()
+  const setup = activityFixture(async () => {
+    requested.resolve()
+    await release.promise
+    return Response.json({
+      data: {
+        ...(type === "session.execution.started" ? {} : { ses_refresh: { type: "running" } }),
+        ses_hydrated: { type: "running" },
+      },
+    })
+  })
+
+  try {
+    if (type !== "session.execution.started") setup.data.session.setStatus("ses_refresh", "running")
+    setup.emit({ type: "server.connected", data: {} })
+    await requested.promise
+    setup.emit({
+      id: "evt_activity",
+      created: 2,
+      type,
+      durable: { aggregateID: "ses_refresh", seq: 2, version: 1 },
+      data: { sessionID: "ses_refresh", reason: "user" },
+    })
+    expect(setup.data.session.status("ses_refresh")).toBe(type === "session.execution.started" ? "running" : "idle")
+    release.resolve()
+    await wait(() => setup.data.session.status("ses_hydrated") === "running")
+    expect(setup.data.session.status("ses_refresh")).toBe(type === "session.execution.started" ? "running" : "idle")
+  } finally {
+    release.resolve()
+    setup.dispose()
+  }
+})
+
+test("ignores activity snapshots from an older connection", async () => {
+  const reads: ReturnType<typeof Promise.withResolvers<Response>>[] = []
+  const setup = activityFixture(() => {
+    const read = Promise.withResolvers<Response>()
+    reads.push(read)
+    return read.promise
+  })
+
+  try {
+    setup.emit({ type: "server.connected", data: {} })
+    await wait(() => reads.length === 1)
+    setup.emit({ type: "server.connected", data: {} })
+    await wait(() => reads.length === 2)
+    reads[1]?.resolve(Response.json({ data: { ses_new: { type: "running" } } }))
+    await wait(() => setup.data.session.status("ses_new") === "running")
+    reads[0]?.resolve(Response.json({ data: { ses_old: { type: "running" } } }))
+    await Bun.sleep(20)
+    expect(setup.data.session.status("ses_new")).toBe("running")
+    expect(setup.data.session.status("ses_old")).toBe("idle")
+  } finally {
+    reads.forEach((read) => read.resolve(Response.json({ data: {} })))
+    setup.dispose()
+  }
+})
+
+function activityFixture(read: () => Response | Promise<Response>) {
+  const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
+  const api = OpenCode.make({
+    baseUrl: "http://opencode.local",
+    fetch: async (input, init) => {
+      const request = input instanceof Request ? input : new Request(input, init)
+      const path = new URL(request.url).pathname
+      if (path === "/api/session/active") return read()
+      if (path === "/api/project") return Response.json([])
+      if (path === "/api/location") return Response.json({ directory: "/project" })
+      return Response.json({ location: { directory: "/project" }, data: { branch: "main" } })
+    },
+  })
+  return createRoot((dispose) => ({
+    data: createData({
+      api: () => api,
+      directory: "/project",
+      event: {
+        on: () => () => {},
+        listen(handler) {
+          listeners.add(handler)
+          return () => listeners.delete(handler)
+        },
+      },
+    }),
+    emit: (details: OpenCodeEvent) => listeners.forEach((listener) => listener({ name: details.type, details })),
+    dispose,
+  }))
+}
+
 async function wait(check: () => boolean) {
   const started = Date.now()
   while (!check()) {

packages/core/src/command/invocation.ts

@@ -0,0 +1,107 @@
+export * as CommandInvocation from "./invocation.js"
+
+import type { Plugin } from "@opencode-ai/plugin/effect"
+import { Agent } from "@opencode-ai/schema/agent"
+import type { ConfigCommand } from "@opencode-ai/schema/config/command"
+import { Model } from "@opencode-ai/schema/model"
+import { Provider } from "@opencode-ai/schema/provider"
+import { AppProcess } from "@opencode-ai/util/process"
+import { Effect } from "effect"
+import { ChildProcess } from "effect/unstable/process"
+import type { Command } from "../command.js"
+import { Location } from "../location.js"
+import { ShellSelect } from "../shell/select.js"
+
+// Invocation for configured template commands; source loading and registration stay with the caller.
+export const make = Effect.fnUntraced(function* (ctx: Pick<Plugin.Context, "agent" | "session">) {
+  const location = yield* Location.Service
+  const processes = yield* AppProcess.Service
+  const shell = yield* ShellSelect.Service
+  return Effect.fn("CommandInvocation.invoke")(function* (command: ConfigCommand.Info, input: Command.Invocation) {
+    const agent = command.agent === undefined ? undefined : Agent.ID.make(command.agent)
+    const commandAgent = yield* Effect.gen(function* () {
+      if (agent === undefined) return
+      const session = yield* ctx.session.get({ sessionID: input.sessionID })
+      if (session.agent !== agent) yield* ctx.session.switchAgent({ sessionID: input.sessionID, agent })
+      return (yield* ctx.agent.get({ agentID: agent })).data
+    })
+    const model =
+      command.model === undefined
+        ? commandAgent?.model
+        : {
+            id: Model.ID.make(command.model.model),
+            providerID: Provider.ID.make(command.model.providerID),
+            ...(command.model.variant === undefined ? {} : { variant: Model.VariantID.make(command.model.variant) }),
+          }
+    if (model !== undefined) yield* ctx.session.switchModel({ sessionID: input.sessionID, model })
+    yield* ctx.session.prompt({
+      ...input.prompt,
+      sessionID: input.sessionID,
+      text: yield* evaluateTemplate(command.template, input.prompt.text, { location, processes, shell }),
+      delivery: input.delivery,
+    })
+  })
+})
+
+function evaluateTemplate(
+  template: string,
+  input: string,
+  services: {
+    readonly location: Location.Info
+    readonly processes: AppProcess.Interface
+    readonly shell: ShellSelect.Interface
+  },
+) {
+  return Effect.gen(function* () {
+    const args = parseArguments(input)
+    const placeholders = template.match(placeholderRegex) ?? []
+    const last = Math.max(0, ...placeholders.map((item) => Number(item.slice(1))))
+    const expanded = template.replaceAll(placeholderRegex, (_, index) => {
+      const position = Number(index)
+      const argIndex = position - 1
+      if (argIndex >= args.length) return ""
+      if (position === last) return args.slice(argIndex).join(" ")
+      return args[argIndex]
+    })
+    const withArguments = expanded.replaceAll("$ARGUMENTS", input)
+    const text =
+      placeholders.length === 0 && !template.includes("$ARGUMENTS") && input.trim()
+        ? `${withArguments}\n\n${input}`.trim()
+        : withArguments.trim()
+    const matches = Array.from(text.matchAll(shellRegex))
+    if (matches.length === 0) return text
+    const shell = yield* services.shell.resolve({ priority: "config" })
+    const outputs = yield* Effect.forEach(
+      matches,
+      (match) => {
+        const source = match[1] ?? ""
+        return services.processes
+          .run(
+            ChildProcess.make(shell, ShellSelect.args(shell, source), {
+              cwd: services.location.directory,
+              stdin: "ignore",
+            }),
+            { combineOutput: true },
+          )
+          .pipe(
+            Effect.map((result) => (result.output ?? Buffer.concat([result.stdout, result.stderr])).toString("utf8")),
+            Effect.mapError(
+              (error) => new Error(`Shell interpolation failed for ${JSON.stringify(source)}: ${error.message}`),
+            ),
+          )
+      },
+      { concurrency: 2 },
+    )
+    const iterator = outputs[Symbol.iterator]()
+    return text.replace(shellRegex, () => iterator.next().value ?? "")
+  })
+}
+
+function parseArguments(input: string) {
+  return (input.match(argsRegex) ?? []).map((arg) => arg.replace(quoteTrimRegex, ""))
+}
+
+const argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi
+const placeholderRegex = /\$(\d+)/g
+const quoteTrimRegex = /^["']|["']$/g
+const shellRegex = /!`([^`]+)`/g

packages/core/src/config/plugin/command.ts

@@ -1,18 +1,12 @@
 export * as ConfigCommandPlugin from "./command.js"
 
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Agent } from "@opencode-ai/schema/agent"
 import { Info, type Entry } from "@opencode-ai/schema/config"
 import { ConfigCommand } from "@opencode-ai/schema/config/command"
-import { Model } from "@opencode-ai/schema/model"
-import { Provider } from "@opencode-ai/schema/provider"
-import { AppProcess } from "@opencode-ai/util/process"
 import path from "path"
 import { Effect, Option, Schema, Stream } from "effect"
-import { ChildProcess } from "effect/unstable/process"
+import { CommandInvocation } from "../../command/invocation.js"
 import { Config } from "../../config.js"
-import { Location } from "../../location.js"
-import { ShellSelect } from "../../shell/select.js"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { ConfigMarkdown } from "../markdown.js"
 
@@ -29,9 +23,7 @@ export const Plugin = define({
       const commands = yield* loadDirectory(fs, entry.path)
       return [{ commands: Object.fromEntries(commands.map((command) => [command.name, command.info])) }]
     })
-    const location = yield* Location.Service
-    const processes = yield* AppProcess.Service
-    const shell = yield* ShellSelect.Service
+    const invoke = yield* CommandInvocation.make(ctx)
     const load = Effect.fn("ConfigCommandPlugin.load")(function* () {
       return yield* Effect.forEach(yield* config.entries(), loadEntry).pipe(Effect.map((documents) => documents.flat()))
     })
@@ -63,38 +55,7 @@ export const Plugin = define({
           draft.add({
             name,
             description: command.description,
-            execute: (input) =>
-              Effect.gen(function* () {
-                const agent = command.agent === undefined ? undefined : Agent.ID.make(command.agent)
-                const commandAgent = yield* Effect.gen(function* () {
-                  if (agent === undefined) return
-                  const session = yield* ctx.session.get({ sessionID: input.sessionID })
-                  if (session.agent !== agent) yield* ctx.session.switchAgent({ sessionID: input.sessionID, agent })
-                  return (yield* ctx.agent.get({ agentID: agent })).data
-                })
-                const model =
-                  command.model === undefined
-                    ? commandAgent?.model
-                    : {
-                        id: Model.ID.make(command.model.model),
-                        providerID: Provider.ID.make(command.model.providerID),
-                        ...(command.model.variant === undefined
-                          ? {}
-                          : { variant: Model.VariantID.make(command.model.variant) }),
-                      }
-                if (model !== undefined) yield* ctx.session.switchModel({ sessionID: input.sessionID, model })
-                yield* ctx.session.prompt({
-                  ...input.prompt,
-                  sessionID: input.sessionID,
-                  text: yield* evaluateTemplate(command.template, input.prompt.text, {
-                    config,
-                    location,
-                    processes,
-                    shell,
-                  }),
-                  delivery: input.delivery,
-                })
-              }).pipe(Effect.asVoid),
+            execute: (input) => invoke(command, input),
           })
         }
       }
@@ -147,67 +108,3 @@ function decode(directory: string, filepath: string, content: string) {
     info,
   }
 }
-
-function evaluateTemplate(
-  template: string,
-  input: string,
-  services: {
-    readonly config: Config.Interface
-    readonly location: Location.Info
-    readonly processes: AppProcess.Interface
-    readonly shell: ShellSelect.Interface
-  },
-) {
-  return Effect.gen(function* () {
-    const args = parseArguments(input)
-    const placeholders = template.match(placeholderRegex) ?? []
-    const last = Math.max(0, ...placeholders.map((item) => Number(item.slice(1))))
-    const expanded = template.replaceAll(placeholderRegex, (_, index) => {
-      const position = Number(index)
-      const argIndex = position - 1
-      if (argIndex >= args.length) return ""
-      if (position === last) return args.slice(argIndex).join(" ")
-      return args[argIndex]
-    })
-    const withArguments = expanded.replaceAll("$ARGUMENTS", input)
-    const text =
-      placeholders.length === 0 && !template.includes("$ARGUMENTS") && input.trim()
-        ? `${withArguments}\n\n${input}`.trim()
-        : withArguments.trim()
-    const matches = Array.from(text.matchAll(shellRegex))
-    if (matches.length === 0) return text
-    const shell = yield* services.shell.resolve({ priority: "config" })
-    const outputs = yield* Effect.forEach(
-      matches,
-      (match) => {
-        const source = match[1] ?? ""
-        return services.processes
-          .run(
-            ChildProcess.make(shell, ShellSelect.args(shell, source), {
-              cwd: services.location.directory,
-              stdin: "ignore",
-            }),
-            { combineOutput: true },
-          )
-          .pipe(
-            Effect.map((result) => (result.output ?? Buffer.concat([result.stdout, result.stderr])).toString("utf8")),
-            Effect.mapError((error) =>
-              new Error(`Shell interpolation failed for ${JSON.stringify(source)}: ${error.message}`),
-            ),
-          )
-      },
-      { concurrency: 2 },
-    )
-    const iterator = outputs[Symbol.iterator]()
-    return text.replace(shellRegex, () => iterator.next().value ?? "")
-  })
-}
-
-function parseArguments(input: string) {
-  return (input.match(argsRegex) ?? []).map((arg) => arg.replace(quoteTrimRegex, ""))
-}
-
-const argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi
-const placeholderRegex = /\$(\d+)/g
-const quoteTrimRegex = /^["']|["']$/g
-const shellRegex = /!`([^`]+)`/g

packages/core/src/session/compaction.ts

@@ -1,7 +1,6 @@
 export * as SessionCompaction from "./compaction.js"
 
-import { LLMClient, AIError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
-import type { StreamOptions } from "@opencode-ai/ai/route"
+import { LLMClient, LLMEvent, Message } from "@opencode-ai/ai"
 import { SessionError } from "@opencode-ai/schema/session-error"
 import { Context, Effect, Layer, Stream } from "effect"
 import { Bus } from "../bus.js"
@@ -65,13 +64,6 @@ export type Draft = {
   configure: (settings: Partial<Settings>) => void
 }
 
-type Dependencies = {
-  readonly bus: Bus.Interface
-  readonly llm: {
-    readonly stream: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<LLMEvent, AIError>
-  }
-}
-
 export type AutoInput = {
   readonly session: SessionSchema.Info
   readonly messages: readonly SessionMessage.Info[]
@@ -240,195 +232,196 @@ const planContent = (messages: readonly SessionMessage.Info[], tokens: number) =
   }
 }
 
-const make = (dependencies: Dependencies) => {
-  const state = State.create<Settings, Draft>({
-    name: "session-compaction",
-    initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS }),
-    draft: (draft) => ({
-      configure: (settings) => {
-        if (settings.auto !== undefined) draft.auto = settings.auto
-        if (settings.buffer !== undefined) draft.buffer = settings.buffer
-        if (settings.tokens !== undefined) draft.tokens = settings.tokens
-      },
-    }),
-  })
-  const failed = Effect.fnUntraced(function* (input: {
-    readonly sessionID: SessionSchema.ID
-    readonly reason: SessionMessage.Compaction["reason"]
-    readonly error: SessionError.Error
-    readonly inputID?: SessionMessage.ID
-  }) {
-    yield* dependencies.bus.publish(SessionEvent.Compaction.Failed, input)
-    return { status: "failed" as const, error: input.error }
-  })
-  const execute = Effect.fn("SessionCompaction.execute")(function* (plan: Plan) {
-    if (!plan.started)
-      yield* dependencies.bus.publish(SessionEvent.Compaction.Started, {
-        sessionID: plan.session.id,
-        reason: plan.reason,
-        recent: plan.recent,
-        inputID: plan.inputID,
-      })
-
-    const chunks: string[] = []
-    let failure: SessionError.Error | undefined
-    let usage: SessionUsage.Recorded | undefined
-    const recordUsage = Effect.suspend(() =>
-      usage
-        ? dependencies.bus.publish(SessionEvent.UsageRecorded, {
-            sessionID: plan.session.id,
-            source: "compaction",
-            ...usage,
-          })
-        : Effect.void,
-    )
-    const prepared = yield* plan.prepare({
-      scope: { session: plan.session, agentID: Agent.ID.make("compaction"), model: plan.resolved },
-      transcript: { system: [], messages: [Message.user(plan.prompt)] },
-      contextHooks: false,
-    })
-    yield* dependencies.llm.stream(prepared.request, prepared.options).pipe(
-      Stream.runForEach((event) => {
-        if (LLMEvent.is.providerError(event))
-          failure = {
-            type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
-            message: event.message,
-          }
-        if (LLMEvent.is.textDelta(event)) {
-          chunks.push(event.text)
-          return dependencies.bus.publish(SessionEvent.Compaction.Delta, {
-            sessionID: plan.session.id,
-            text: event.text,
-          })
-        }
-        if (LLMEvent.is.stepFinish(event)) {
-          const step = SessionUsage.record(event.usage, plan.resolved.cost)
-          usage = usage ? SessionUsage.add(usage, step) : step
-        }
-        return Effect.void
-      }),
-      Effect.catchTag("AI.Error", (error) =>
-        Effect.sync(() => {
-          failure = toSessionError(error)
-        }),
-      ),
-      Effect.onInterrupt(() =>
-        recordUsage.pipe(
-          Effect.andThen(
-            plan.reason === "auto"
-              ? failed({
-                  sessionID: plan.session.id,
-                  reason: plan.reason,
-                  error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
-                  inputID: plan.inputID,
-                }).pipe(Effect.asVoid)
-              : Effect.void,
-          ),
-        ),
-      ),
-    )
-    yield* recordUsage
-    const summary = chunks.join("")
-    if (failure || !summary.trim()) {
-      const error = failure ?? { type: "compaction.failed" as const, message: "Compaction produced no summary" }
-      return yield* failed({
-        sessionID: plan.session.id,
-        reason: plan.reason,
-        error,
-        inputID: plan.inputID,
-      })
-    }
-    yield* dependencies.bus.publish(SessionEvent.Compaction.Ended, {
-      sessionID: plan.session.id,
-      reason: plan.reason,
-      text: summary,
-      recent: plan.recent,
-    })
-    return { status: "completed" as const }
-  })
-  const compact = Effect.fn("SessionCompaction.compact")(function* (input: AutoInput) {
-    const content = planContent(input.messages, state.get().tokens)
-    if (content)
-      return yield* execute({
-        session: input.session,
-        resolved: input.resolved,
-        prepare: input.prepare,
-        reason: "auto",
-        ...content,
-      })
-    return yield* failed({
-      sessionID: input.session.id,
-      reason: "auto",
-      error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-    })
-  })
-  const required = (input: RequiredInput) => {
-    const config = state.get()
-    if (!config.auto) return false
-    const limit = input.resolved.limit
-    const context = limit.context
-    if (context <= 0) return false
-    const last = input.messages.findLast(
-      (message): message is SessionMessage.Assistant & { tokens: NonNullable<SessionMessage.Assistant["tokens"]> } =>
-        message.type === "assistant" && message.tokens !== undefined,
-    )
-    if (!last) return false
-    const output = Math.min(limit.output, OUTPUT_TOKEN_MAX)
-    const promptCeiling = Math.min(
-      limit.input === undefined ? Number.POSITIVE_INFINITY : limit.input - config.buffer,
-      context - Math.max(output, config.buffer),
-    )
-    const used =
-      last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write
-    if (used <= 0) return false
-    return used >= promptCeiling
-  }
-  const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: ManualInput) {
-    const content = planContent(input.messages, state.get().tokens)
-    if (!content)
-      return yield* failed({
-        sessionID: input.session.id,
-        reason: "manual",
-        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-        inputID: input.inputID,
-      })
-    const resolved = yield* input.resolveModel(input.session).pipe(
-      Effect.catch((cause) =>
-        failed({
-          sessionID: input.session.id,
-          reason: "manual",
-          error: toSessionError(cause),
-          inputID: input.inputID,
-        }),
-      ),
-    )
-    if ("status" in resolved) return resolved
-    return yield* execute({
-      session: input.session,
-      resolved,
-      prepare: input.prepare,
-      reason: "manual",
-      inputID: input.inputID,
-      started: input.started,
-      ...content,
-    })
-  })
-  return Service.of({
-    transform: state.transform,
-    reload: state.reload,
-    enabled: () => state.get().auto,
-    required,
-    compact,
-    compactManual,
-  })
-}
-
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const bus = yield* Bus.Service
     const llm = yield* LLMClient.Service
-    return make({ bus, llm })
+
+    const state = State.create<Settings, Draft>({
+      name: "session-compaction",
+      initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS }),
+      draft: (draft) => ({
+        configure: (settings) => {
+          if (settings.auto !== undefined) draft.auto = settings.auto
+          if (settings.buffer !== undefined) draft.buffer = settings.buffer
+          if (settings.tokens !== undefined) draft.tokens = settings.tokens
+        },
+      }),
+    })
+    const failed = Effect.fnUntraced(function* (input: {
+      readonly sessionID: SessionSchema.ID
+      readonly reason: SessionMessage.Compaction["reason"]
+      readonly error: SessionError.Error
+      readonly inputID?: SessionMessage.ID
+    }) {
+      yield* bus.publish(SessionEvent.Compaction.Failed, input)
+      return { status: "failed" as const, error: input.error }
+    })
+    const execute = Effect.fn("SessionCompaction.execute")(function* (plan: Plan) {
+      if (!plan.started)
+        yield* bus.publish(SessionEvent.Compaction.Started, {
+          sessionID: plan.session.id,
+          reason: plan.reason,
+          recent: plan.recent,
+          inputID: plan.inputID,
+        })
+
+      const chunks: string[] = []
+      let failure: SessionError.Error | undefined
+      let usage: SessionUsage.Recorded | undefined
+      const recordUsage = Effect.suspend(() =>
+        usage
+          ? bus.publish(SessionEvent.UsageRecorded, {
+              sessionID: plan.session.id,
+              source: "compaction",
+              ...usage,
+            })
+          : Effect.void,
+      )
+      const prepared = yield* plan.prepare({
+        scope: { session: plan.session, agentID: Agent.ID.make("compaction"), model: plan.resolved },
+        transcript: { system: [], messages: [Message.user(plan.prompt)] },
+        contextHooks: false,
+      })
+      yield* llm.stream(prepared.request, prepared.options).pipe(
+        Stream.runForEach((event) => {
+          if (LLMEvent.is.providerError(event))
+            failure = {
+              type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
+              message: event.message,
+            }
+          if (LLMEvent.is.textDelta(event)) {
+            chunks.push(event.text)
+            return bus.publish(SessionEvent.Compaction.Delta, {
+              sessionID: plan.session.id,
+              text: event.text,
+            })
+          }
+          if (LLMEvent.is.stepFinish(event)) {
+            const step = SessionUsage.record(event.usage, plan.resolved.cost)
+            usage = usage ? SessionUsage.add(usage, step) : step
+          }
+          return Effect.void
+        }),
+        Effect.catchTag("AI.Error", (error) =>
+          Effect.sync(() => {
+            failure = toSessionError(error)
+          }),
+        ),
+        Effect.onInterrupt(() =>
+          recordUsage.pipe(
+            Effect.andThen(
+              plan.reason === "auto"
+                ? failed({
+                    sessionID: plan.session.id,
+                    reason: plan.reason,
+                    error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
+                    inputID: plan.inputID,
+                  }).pipe(Effect.asVoid)
+                : Effect.void,
+            ),
+          ),
+        ),
+      )
+      yield* recordUsage
+      const summary = chunks.join("")
+      if (failure || !summary.trim()) {
+        const error = failure ?? { type: "compaction.failed" as const, message: "Compaction produced no summary" }
+        return yield* failed({
+          sessionID: plan.session.id,
+          reason: plan.reason,
+          error,
+          inputID: plan.inputID,
+        })
+      }
+      yield* bus.publish(SessionEvent.Compaction.Ended, {
+        sessionID: plan.session.id,
+        reason: plan.reason,
+        text: summary,
+        recent: plan.recent,
+      })
+      return { status: "completed" as const }
+    })
+    const compact = Effect.fn("SessionCompaction.compact")(function* (input: AutoInput) {
+      const content = planContent(input.messages, state.get().tokens)
+      if (content)
+        return yield* execute({
+          session: input.session,
+          resolved: input.resolved,
+          prepare: input.prepare,
+          reason: "auto",
+          ...content,
+        })
+      return yield* failed({
+        sessionID: input.session.id,
+        reason: "auto",
+        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
+      })
+    })
+    const required = (input: RequiredInput) => {
+      const config = state.get()
+      if (!config.auto) return false
+      const limit = input.resolved.limit
+      const context = limit.context
+      if (context <= 0) return false
+      const last = input.messages.findLast(
+        (message): message is SessionMessage.Assistant & { tokens: NonNullable<SessionMessage.Assistant["tokens"]> } =>
+          message.type === "assistant" && message.tokens !== undefined,
+      )
+      if (!last) return false
+      const output = Math.min(limit.output, OUTPUT_TOKEN_MAX)
+      const promptCeiling = Math.min(
+        limit.input === undefined ? Number.POSITIVE_INFINITY : limit.input - config.buffer,
+        context - Math.max(output, config.buffer),
+      )
+      const used =
+        last.tokens.input +
+        last.tokens.output +
+        last.tokens.reasoning +
+        last.tokens.cache.read +
+        last.tokens.cache.write
+      if (used <= 0) return false
+      return used >= promptCeiling
+    }
+    const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: ManualInput) {
+      const content = planContent(input.messages, state.get().tokens)
+      if (!content)
+        return yield* failed({
+          sessionID: input.session.id,
+          reason: "manual",
+          error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
+          inputID: input.inputID,
+        })
+      const resolved = yield* input.resolveModel(input.session).pipe(
+        Effect.catch((cause) =>
+          failed({
+            sessionID: input.session.id,
+            reason: "manual",
+            error: toSessionError(cause),
+            inputID: input.inputID,
+          }),
+        ),
+      )
+      if ("status" in resolved) return resolved
+      return yield* execute({
+        session: input.session,
+        resolved,
+        prepare: input.prepare,
+        reason: "manual",
+        inputID: input.inputID,
+        started: input.started,
+        ...content,
+      })
+    })
+    return Service.of({
+      transform: state.transform,
+      reload: state.reload,
+      enabled: () => state.get().auto,
+      required,
+      compact,
+      compactManual,
+    })
   }),
 )
 

packages/core/src/session/context.ts

@@ -2,7 +2,6 @@ export * as SessionContext from "./context.js"
 
 import { Context, Effect, Layer } from "effect"
 import { Agent } from "../agent.js"
-import { Bus } from "../bus.js"
 import { Catalog } from "../catalog.js"
 import { CodeModeInstructions } from "../codemode/instructions.js"
 import { Database } from "../database/database.js"
@@ -21,7 +20,6 @@ import { Tool } from "../tool.js"
 import { AgentNotFoundError } from "./error.js"
 import { SessionHistory } from "./history.js"
 import { InstructionEntry } from "./instruction-entry.js"
-import { InstructionState } from "./instruction-state.js"
 import { SessionMessage } from "./message.js"
 import { SessionModelRequest } from "./model-request.js"
 import { SessionRunnerModel } from "./runner/model.js"
@@ -53,10 +51,6 @@ export interface Loaded {
 export interface Interface {
   /** Selects the Session, agent, instructions, and tools used by subsequent work. */
   readonly select: (sessionID: SessionSchema.ID) => Effect.Effect<Selection, AgentNotFoundError>
-  /** Prepares the instruction baseline before delivery, or refreshes it without delivering input. */
-  readonly preflight: (
-    sessionID: SessionSchema.ID,
-  ) => Effect.Effect<Selection, AgentNotFoundError | Instructions.InitializationBlocked>
   /** Resolves the model and active history for that selection. */
   readonly load: (selection: Selection) => Effect.Effect<Loaded, SessionRunnerModel.Error>
   readonly resolveModel: (
@@ -81,7 +75,6 @@ const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const agents = yield* Agent.Service
-    const bus = yield* Bus.Service
     const builtins = yield* InstructionBuiltIns.Service
     const catalog = yield* Catalog.Service
     const db = (yield* Database.Service).db
@@ -164,13 +157,6 @@ const layer = Layer.effect(
       }
     })
 
-    const preflight = Effect.fn("SessionContext.preflight")(function* (sessionID: SessionSchema.ID) {
-      const selected = yield* select(sessionID)
-      // A blocked initial instruction baseline must leave admitted input pending.
-      yield* InstructionState.prepare(db, bus, selected.instructions, sessionID)
-      return selected
-    })
-
     const load = Effect.fn("SessionContext.load")(function* (selection: Selection) {
       const model = yield* resolveModel(selection.session)
       const history = yield* SessionHistory.entriesForRunner(db, selection.session.id, selection.instructions)
@@ -184,7 +170,7 @@ const layer = Layer.effect(
       }
     })
 
-    return Service.of({ select, preflight, load, resolveModel, selectTitle, prepare: modelRequests.prepare })
+    return Service.of({ select, load, resolveModel, selectTitle, prepare: modelRequests.prepare })
   }),
 )
 
@@ -196,7 +182,6 @@ export const node = makeLocationNode({
   layer,
   deps: [
     Agent.node,
-    Bus.node,
     Catalog.node,
     Database.node,
     InstructionBuiltIns.node,

packages/core/src/session/runner/attempt.ts

@@ -1,292 +0,0 @@
-export * as SessionAttempt from "./attempt.js"
-
-import {
-  AIError,
-  InvalidProviderOutputError,
-  LLMClient,
-  LLMEvent,
-  isContextOverflowFailure,
-  type ProviderErrorEvent,
-  type ToolCall,
-} from "@opencode-ai/ai"
-import { Cause, Data, Effect, Exit, Fiber, Option, Stream } from "effect"
-import { SessionError } from "@opencode-ai/schema/session-error"
-import { Agent } from "../../agent.js"
-import { Bus } from "../../bus.js"
-import { Permission } from "../../permission.js"
-import { Snapshot } from "../../snapshot.js"
-import { Tool } from "../../tool.js"
-import { ToolOutput } from "../../tool-output.js"
-import { QuestionTool } from "../../tool/plugin/question.js"
-import { StepFailedError } from "../error.js"
-import { SessionEvent } from "../event.js"
-import { SessionMessage } from "../message.js"
-import { SessionModelRequest } from "../model-request.js"
-import { SessionSchema } from "../schema.js"
-import { toSessionError } from "../to-session-error.js"
-import { SessionUsage } from "../usage.js"
-import { SessionRunnerModel } from "./model.js"
-import { createLLMEventPublisher } from "./publish-llm-event.js"
-
-export type Outcome = Data.TaggedEnum<{
-  Completed: { readonly needsContinuation: boolean }
-  Retry: { readonly cause: AIError; readonly error: SessionError.Error }
-  Continue: { readonly cause: AIError; readonly error: SessionError.Error }
-  RecoverFull: {}
-  Compacted: {}
-}>
-export const Outcome = Data.taggedEnum<Outcome>()
-
-/** Inspection only; the publisher and joined tool exits stay inside the attempt scope. */
-interface Result {
-  readonly outputStarted: boolean
-  readonly overflowBeforeOutput: boolean
-  /** Raw AI stream failure or synthesized unknown-finish failure; the full Exit stays private. */
-  readonly failure: AIError | undefined
-  /** Absent when a provider failure is already recorded or held, even if the stream also failed. */
-  readonly error: SessionError.Error | undefined
-}
-
-type Decision = Exclude<Outcome, { readonly _tag: "Completed" | "Continue" }>
-type Restore = <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-
-interface Input {
-  readonly sessionID: SessionSchema.ID
-  readonly assistantMessageID: SessionMessage.ID
-  readonly agent: Agent.ID
-  readonly model: SessionRunnerModel.Resolved
-  readonly prepared: SessionModelRequest.Prepared
-}
-
-const TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" } as const
-const STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" } as const
-const RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" } as const
-
-/** Owns one provider invocation, its tools, and publication until the Step chooses a disposition. */
-export const make = Effect.gen(function* () {
-  const bus = yield* Bus.Service
-  const llm = yield* LLMClient.Service
-  const snapshots = yield* Snapshot.Service
-  const toolOutput = yield* ToolOutput.Service
-
-  // Returning no decision accepts the attempt's existing settlement and Cause handling.
-  const use = Effect.fn("SessionAttempt.use")(function* (
-    input: Input,
-    decide: (result: Result, restore: Restore) => Effect.Effect<Decision | undefined>,
-  ) {
-    const startSnapshot = yield* snapshots.capture()
-    const publisher = createLLMEventPublisher(bus, {
-      sessionID: input.sessionID,
-      assistantMessageID: input.assistantMessageID,
-      agent: input.agent,
-      model: input.model.ref,
-      providerMetadataKey: input.model.model.route.providerMetadataKey ?? input.model.model.provider,
-      snapshot: startSnapshot,
-    })
-    const toolRuns: Array<{
-      readonly call: ToolCall
-      readonly fiber: Fiber.Fiber<void, Permission.DeclinedError | QuestionTool.CancelledError>
-    }> = []
-    const interruptTools = Effect.suspend(() => Fiber.interruptAll(toolRuns.map((run) => run.fiber)))
-    const executeTool = (call: ToolCall) => {
-      if (input.prepared.request.toolChoice?.type === "none")
-        return new Tool.Error({ message: "Tools are disabled after the maximum agent steps" })
-      return input.prepared.executeTool({
-        sessionID: input.sessionID,
-        agent: input.agent,
-        messageID: input.assistantMessageID,
-        call,
-        progress: (update) => publisher.progress(call.id, update),
-      })
-    }
-
-    // Provider and tool fibers retain per-source order without a shared writer queue.
-    // A local execution starts only after its Tool.Called publication completes.
-    let overflowFailure: ProviderErrorEvent | undefined
-    // Read to the end, not just the finish event, so the next request can reuse this response.
-    const providerStream = llm.stream(input.prepared.request, input.prepared.options).pipe(
-      Stream.runForEach((event) =>
-        Effect.gen(function* () {
-          if (overflowFailure || publisher.hasProviderError()) return
-          if (
-            LLMEvent.is.providerError(event) &&
-            isContextOverflowFailure(event) &&
-            !publisher.record().outputStarted
-          ) {
-            overflowFailure = event
-            return
-          }
-          yield* publisher.publish(event)
-          if (event.type !== "tool-call" || event.providerExecuted) return
-          toolRuns.push({
-            call: event,
-            fiber: yield* Effect.uninterruptibleMask((restore) =>
-              restore(executeTool(event)).pipe(
-                Effect.flatMap(toolOutput.truncate),
-                Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)),
-                Effect.catchTag("Tool.Error", (error) =>
-                  publisher.failTool(event.id, toSessionError(error), error.metadata).pipe(Effect.asVoid),
-                ),
-              ),
-            ).pipe(Effect.forkScoped),
-          })
-        }),
-      ),
-      Effect.ensuring(publisher.flush()),
-    )
-
-    // Keep the final tool and Step events uninterruptible, even when the work itself is cancelled.
-    return yield* Effect.uninterruptibleMask((restore) =>
-      Effect.gen(function* () {
-        const stream = yield* restore(providerStream).pipe(Effect.exit)
-        const streamFailure = Option.getOrUndefined(Exit.findErrorOption(stream))
-        const streamInterrupted = Exit.hasInterrupts(stream)
-        if (!overflowFailure && publisher.hasStarted()) yield* publisher.streamed()
-        if (streamInterrupted) yield* interruptTools
-        const joined = yield* restore(Fiber.awaitAll(toolRuns.map((run) => run.fiber))).pipe(Effect.exit)
-        if (Exit.isFailure(joined)) yield* interruptTools
-        const tools = classifyToolExits(joined, toolRuns)
-
-        const recorded = publisher.record()
-        const unknownFinish =
-          Exit.isSuccess(stream) && recorded.finish?.finish === "unknown"
-            ? new AIError({
-                reason: new InvalidProviderOutputError({
-                  message: "The provider response ended with an unknown finish reason.",
-                  classification: "incomplete-stream",
-                }),
-              })
-            : undefined
-        const llmFailure = streamFailure instanceof AIError ? streamFailure : unknownFinish
-        // A held overflow will record provider failure unless recovery replaces this attempt.
-        // Include that gate before publication so Step policy cannot transparently retry it.
-        const providerFailed = recorded.providerFailed || overflowFailure !== undefined
-        const llmError = llmFailure && !providerFailed ? toSessionError(llmFailure) : undefined
-        const decision = yield* decide(
-          {
-            outputStarted: recorded.outputStarted,
-            overflowBeforeOutput: !recorded.outputStarted && isContextOverflowFailure(overflowFailure ?? streamFailure),
-            failure: llmFailure,
-            error: llmError,
-          },
-          restore,
-        )
-        if (decision?._tag === "Compacted") return decision
-        if (overflowFailure) yield* publisher.publish(overflowFailure)
-        if (decision?._tag === "RecoverFull") return decision
-        if (decision?._tag === "Retry") {
-          // Retry state projects onto the existing assistant, even before it has produced output.
-          yield* publisher.startAssistant()
-          return decision
-        }
-        if (llmError) yield* publisher.failAssistant(llmError)
-
-        for (const decline of tools.declines)
-          yield* publisher.failTool(decline.call.id, {
-            type: "aborted",
-            message:
-              decline.reason._tag === "QuestionTool.CancelledError"
-                ? decline.reason.message
-                : "The user declined this tool call",
-          })
-        const interrupted = tools.declines.length > 0 || streamInterrupted || tools.interrupted
-        const toolFailure = interrupted
-          ? TOOLS_INTERRUPTED
-          : tools.failure !== undefined
-            ? toSessionError(Cause.squash(tools.failure))
-            : providerFailed
-              ? TOOLS_INTERRUPTED
-              : undefined
-        if (toolFailure) yield* publisher.failUnsettledTools(toolFailure)
-        if (interrupted) yield* publisher.failAssistant(STEP_INTERRUPTED)
-
-        // All local fibers have joined; only provider-hosted results can still be missing.
-        if (llmError || (Exit.isSuccess(stream) && !providerFailed)) {
-          const missing = yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted")
-          if (missing && !llmError && !recorded.finish) yield* publisher.failAssistant(RESULT_MISSING)
-        }
-
-        const record = publisher.record()
-        if (record.finish || record.failure) {
-          const snapshot = yield* snapshots.capture()
-          const files =
-            startSnapshot && snapshot
-              ? startSnapshot === snapshot
-                ? []
-                : yield* snapshots
-                    .files({ from: startSnapshot, to: snapshot })
-                    .pipe(Effect.orElseSucceed(() => undefined))
-              : undefined
-          const usage = record.finish
-            ? { cost: SessionUsage.calculateCost(input.model.cost, record.finish.tokens), tokens: record.finish.tokens }
-            : undefined
-          if (record.failure) yield* publisher.publishStepFailure({ ...usage, snapshot, files })
-          if (record.finish && usage && !record.failure)
-            yield* bus.publish(SessionEvent.Step.Ended, {
-              sessionID: input.sessionID,
-              assistantMessageID: yield* publisher.startAssistant(),
-              finish: record.finish.finish,
-              rawFinish: record.finish.rawFinish,
-              providerState: record.finish.providerState,
-              ...usage,
-              snapshot,
-              files,
-            })
-        }
-
-        if (
-          llmFailure &&
-          llmError &&
-          isInterruptedStream(llmFailure) &&
-          record.outputStarted &&
-          tools.declines.length === 0 &&
-          !tools.interrupted
-        )
-          return Outcome.Continue({ cause: llmFailure, error: llmError })
-
-        if (Exit.isFailure(stream)) return yield* Effect.failCause(stream.cause)
-        if (tools.declines.length > 0) return yield* Effect.interrupt
-        if (tools.interrupted && tools.failure) return yield* Effect.failCause(tools.failure)
-        if (tools.interrupted && Exit.isFailure(joined)) return yield* Effect.failCause(joined.cause)
-        if (record.failure) return yield* new StepFailedError({ error: record.failure })
-        return Outcome.Completed({
-          needsContinuation: input.prepared.request.toolChoice?.type !== "none" && record.needsContinuation,
-        })
-      }),
-    )
-  }, Effect.scoped)
-
-  return { use }
-})
-
-const isInterruptedStream = (failure: AIError) => {
-  if (failure.reason._tag === "InvalidProviderOutput") return failure.reason.classification === "incomplete-stream"
-  if (failure.reason._tag === "Transport") return failure.reason.operation === "read"
-  return false
-}
-
-/** Tool.Error settles in each fiber; only user declines remain in the typed error channel. */
-const classifyToolExits = (
-  settled: Exit.Exit<Array<Exit.Exit<void, Permission.DeclinedError | QuestionTool.CancelledError>>>,
-  runs: ReadonlyArray<{ readonly call: ToolCall }>,
-) => {
-  const exits = Exit.isSuccess(settled) ? settled.value : []
-  const declines = exits.flatMap((exit, index) =>
-    Exit.isFailure(exit)
-      ? exit.cause.reasons.flatMap((reason) =>
-          Cause.isFailReason(reason) ? [{ call: runs[index].call, reason: reason.error }] : [],
-        )
-      : [],
-  )
-  const causes = Exit.isFailure(settled)
-    ? [settled.cause]
-    : exits.flatMap((exit) => (Exit.isFailure(exit) ? [exit.cause] : []))
-  const failure = causes
-    .flatMap((cause) => {
-      if (Cause.hasInterrupts(cause)) return []
-      const reasons = cause.reasons.filter(Cause.isDieReason)
-      return reasons.length > 0 ? [Cause.fromReasons<never>(reasons)] : []
-    })
-    .at(0)
-  return { interrupted: causes.some(Cause.hasInterrupts), declines, failure }
-}

packages/core/src/session/runner/llm.ts

@@ -1,13 +1,17 @@
 export * as SessionRunnerLLM from "./llm.js"
 
-import { Cause, Effect, Exit, FiberMap, Layer } from "effect"
+import { Message } from "@opencode-ai/ai"
+import { Cause, Effect, Exit, FiberMap, Layer, Pull, Schedule } from "effect"
 import { Database } from "../../database/database.js"
 import { Bus } from "../../bus.js"
+import { InstructionState } from "../instruction-state.js"
 import { SessionCompaction } from "../compaction.js"
 import { SessionContext } from "../context.js"
 import { SessionEvent } from "../event.js"
 import { SessionInbox } from "../inbox.js"
+import { SessionModelRequest } from "../model-request.js"
 import { SessionModelTransport } from "../model-transport.js"
+import { SessionMessage } from "../message.js"
 import { SessionSchema } from "../schema.js"
 import { SessionStore } from "../store.js"
 import { SessionTitle } from "../title.js"
@@ -15,9 +19,15 @@ import { DrainResult, Service, type Continuation } from "./index.js"
 import { Snapshot } from "../../snapshot.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { llmClient } from "../../effect/app-node-platform.js"
+import { StepFailedError } from "../error.js"
+import { SessionRunnerRetry } from "./retry.js"
 import { SessionStep } from "./step.js"
 import { ToolOutput } from "../../tool-output.js"
 import { PluginSupervisor } from "../../plugin/supervisor.js"
+import { MAX_STEPS_PROMPT } from "./max-steps.js"
+
+const CONTINUE_AFTER_INCOMPLETE_STREAM =
+  "The previous response was interrupted. Continue from where you left off without repeating completed content."
 
 const layer = Layer.effect(
   Service,
@@ -125,7 +135,7 @@ const layer = Layer.effect(
                 return DrainResult.Complete()
               return yield* restore(
                 Effect.gen(function* () {
-                  const selected = yield* context.preflight(sessionID)
+                  const selected = yield* prepareContext(sessionID)
                   const promoted = yield* SessionInbox.promote(
                     db,
                     bus,
@@ -148,13 +158,107 @@ const layer = Layer.effect(
       while (true) {
         const next = yield* advanceToStep()
         if (next._tag !== "Ready") return next
-        continuing = yield* steps.run({ first: next.context, number: step })
+        continuing = yield* runStep(next.context, step)
         step++
         force = false
         entering = false
       }
     })
 
+    const prepareContext = Effect.fn("SessionRunner.prepareContext")(function* (sessionID: SessionSchema.ID) {
+      const selected = yield* context.select(sessionID)
+      // A blocked initial instruction baseline must leave admitted input pending.
+      yield* InstructionState.prepare(db, bus, selected.instructions, sessionID)
+      return selected
+    })
+
+    /** Owns logical Step policy; each attempt owns its streaming, tools, and durable settlement. */
+    const runStep = Effect.fn("SessionRunner.runStep")(function* (first: SessionContext.Loaded, step: number) {
+      const sessionID = first.session.id
+      let assistantMessageID = SessionMessage.ID.create()
+      const retry = yield* Schedule.toStepWithSleep(SessionRunnerRetry.schedule(bus, sessionID))
+      let initial: SessionContext.Loaded | undefined = first
+      let recoverOverflow = true
+      let recoverContinuation = true
+      while (true) {
+        // Reuse boundary preparation once; retries refresh context without delivering more input.
+        const loaded = initial ?? (yield* prepareContext(sessionID).pipe(Effect.flatMap(context.load)))
+        initial = undefined
+        const compactionInput = {
+          session: loaded.session,
+          messages: loaded.messages,
+          resolved: loaded.model,
+          prepare: context.prepare,
+        }
+        if (compaction.required(compactionInput)) {
+          const compacted = yield* compaction.compact(compactionInput)
+          if (compacted.status !== "completed") return yield* new StepFailedError({ error: compacted.error })
+          assistantMessageID = SessionMessage.ID.create()
+          continue
+        }
+        const stepLimitReached = loaded.agent.info.steps !== undefined && step >= loaded.agent.info.steps
+        const transcript = SessionModelRequest.baseTranscript({
+          agent: loaded.agent.info,
+          model: loaded.model,
+          tools: loaded.tools,
+          initial: loaded.initial,
+          messages: loaded.messages,
+        })
+        const prepared = yield* context.prepare({
+          scope: { session: loaded.session, agentID: loaded.agent.id, model: loaded.model, tools: loaded.tools },
+          transcript: {
+            system: transcript.system,
+            messages: stepLimitReached
+              ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)]
+              : transcript.messages,
+          },
+          // Keep tool definitions on the final Step to preserve the provider's cached prefix.
+          toolChoice: stepLimitReached ? "none" : undefined,
+          webSocket: "session",
+        })
+        const outcome = yield* steps.attempt({
+          sessionID,
+          assistantMessageID,
+          agent: loaded.agent.id,
+          model: loaded.model,
+          prepared,
+          recoverContinuation,
+          recoverOverflow: Effect.suspend(() =>
+            recoverOverflow && compaction.enabled()
+              ? compaction.compact(compactionInput).pipe(Effect.map((result) => result.status === "completed"))
+              : Effect.succeed(false),
+          ),
+        })
+        const completed = yield* SessionStep.Outcome.$match(outcome, {
+          Completed: (outcome) => Effect.succeed(outcome.needsContinuation),
+          Retry: (outcome) =>
+            retry({ cause: outcome.cause, error: outcome.error, assistantMessageID }).pipe(
+              Pull.catchDone(() =>
+                bus
+                  .publish(SessionEvent.Step.Failed, { sessionID, assistantMessageID, error: outcome.error })
+                  .pipe(Effect.andThen(outcome.cause)),
+              ),
+              Effect.asVoid,
+            ),
+          Continue: Effect.fnUntraced(function* (outcome) {
+            yield* retry({ cause: outcome.cause, error: outcome.error, assistantMessageID }).pipe(
+              Pull.catchDone(() => outcome.cause),
+            )
+            yield* bus.publish(SessionEvent.Synthetic, { sessionID, text: CONTINUE_AFTER_INCOMPLETE_STREAM })
+            assistantMessageID = SessionMessage.ID.create()
+          }),
+          Compacted: Effect.fnUntraced(function* () {
+            recoverOverflow = false
+            assistantMessageID = SessionMessage.ID.create()
+          }),
+          RecoverFull: Effect.fnUntraced(function* () {
+            recoverContinuation = false
+          }),
+        })
+        if (completed !== undefined) return completed
+      }
+    })
+
     const settleStaleToolCalls = Effect.fn("SessionRunner.settleStaleToolCalls")(function* (
       sessionID: SessionSchema.ID,
     ) {

packages/core/src/session/runner/step.ts

@@ -1,137 +1,279 @@
 export * as SessionStep from "./step.js"
 
-import { Message } from "@opencode-ai/ai"
-import { Effect, Pull, Schedule } from "effect"
+import {
+  AIError,
+  InvalidProviderOutputError,
+  LLMClient,
+  LLMEvent,
+  isContextOverflowFailure,
+  type ProviderErrorEvent,
+  type ToolCall,
+} from "@opencode-ai/ai"
+import { Cause, Data, Effect, Exit, Fiber, Option, Stream } from "effect"
+import { SessionError } from "@opencode-ai/schema/session-error"
+import { Agent } from "../../agent.js"
 import { Bus } from "../../bus.js"
-import { SessionCompaction } from "../compaction.js"
-import { SessionContext } from "../context.js"
+import { Permission } from "../../permission.js"
+import { Snapshot } from "../../snapshot.js"
+import { Tool } from "../../tool.js"
+import { ToolOutput } from "../../tool-output.js"
+import { QuestionTool } from "../../tool/plugin/question.js"
 import { StepFailedError } from "../error.js"
 import { SessionEvent } from "../event.js"
 import { SessionMessage } from "../message.js"
 import { SessionModelRequest } from "../model-request.js"
-import { SessionAttempt } from "./attempt.js"
-import { MAX_STEPS_PROMPT } from "./max-steps.js"
+import { SessionSchema } from "../schema.js"
+import { toSessionError } from "../to-session-error.js"
+import { SessionUsage } from "../usage.js"
+import { SessionRunnerModel } from "./model.js"
+import { createLLMEventPublisher } from "./publish-llm-event.js"
 import { SessionRunnerRetry } from "./retry.js"
 
-const CONTINUE_AFTER_INCOMPLETE_STREAM =
-  "The previous response was interrupted. Continue from where you left off without repeating completed content."
+export type Outcome = Data.TaggedEnum<{
+  Completed: { readonly needsContinuation: boolean }
+  Retry: { readonly cause: AIError; readonly error: SessionError.Error }
+  Continue: { readonly cause: AIError; readonly error: SessionError.Error }
+  RecoverFull: {}
+  Compacted: {}
+}>
+export const Outcome = Data.taggedEnum<Outcome>()
 
-/** A logical Step owns request preparation and recovery, without promoting inbox input. */
+interface Input {
+  readonly sessionID: SessionSchema.ID
+  readonly assistantMessageID: SessionMessage.ID
+  readonly agent: Agent.ID
+  readonly model: SessionRunnerModel.Resolved
+  readonly prepared: SessionModelRequest.Prepared
+  readonly recoverContinuation: boolean
+  /** The runner owns compaction policy; the attempt invokes it only before durable output. */
+  readonly recoverOverflow: Effect.Effect<boolean>
+}
+
+const TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" } as const
+const STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" } as const
+const RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" } as const
+
+/** Captures Location-scoped dependencies without introducing another service or execution loop. */
 export const make = Effect.gen(function* () {
   const bus = yield* Bus.Service
-  const context = yield* SessionContext.Service
-  const compaction = yield* SessionCompaction.Service
-  const attempts = yield* SessionAttempt.make
+  const llm = yield* LLMClient.Service
+  const snapshots = yield* Snapshot.Service
+  const toolOutput = yield* ToolOutput.Service
 
-  const run = Effect.fn("SessionStep.run")(function* (input: {
-    readonly first: SessionContext.Loaded
-    readonly number: number
-  }) {
-    const sessionID = input.first.session.id
-    let assistantMessageID = SessionMessage.ID.create()
-    const retry = yield* Schedule.toStepWithSleep(SessionRunnerRetry.schedule(bus, sessionID))
-    let initial: SessionContext.Loaded | undefined = input.first
-    let recoverOverflow = true
-    let recoverContinuation = true
-    while (true) {
-      // Reuse boundary preparation once; retries refresh context without delivering more input.
-      const loaded = initial ?? (yield* context.preflight(sessionID).pipe(Effect.flatMap(context.load)))
-      initial = undefined
-      const compactionInput = {
-        session: loaded.session,
-        messages: loaded.messages,
-        resolved: loaded.model,
-        prepare: context.prepare,
-      }
-      if (compaction.required(compactionInput)) {
-        const compacted = yield* compaction.compact(compactionInput)
-        if (compacted.status !== "completed") return yield* new StepFailedError({ error: compacted.error })
-        assistantMessageID = SessionMessage.ID.create()
-        continue
-      }
-      const stepLimitReached = loaded.agent.info.steps !== undefined && input.number >= loaded.agent.info.steps
-      const transcript = SessionModelRequest.baseTranscript({
-        agent: loaded.agent.info,
-        model: loaded.model,
-        tools: loaded.tools,
-        initial: loaded.initial,
-        messages: loaded.messages,
+  const attempt = Effect.fn("SessionStep.attempt")(function* (input: Input) {
+    const startSnapshot = yield* snapshots.capture()
+    const publisher = createLLMEventPublisher(bus, {
+      sessionID: input.sessionID,
+      assistantMessageID: input.assistantMessageID,
+      agent: input.agent,
+      model: input.model.ref,
+      providerMetadataKey: input.model.model.route.providerMetadataKey ?? input.model.model.provider,
+      snapshot: startSnapshot,
+    })
+    const toolRuns: Array<{
+      readonly call: ToolCall
+      readonly fiber: Fiber.Fiber<void, Permission.DeclinedError | QuestionTool.CancelledError>
+    }> = []
+    const interruptTools = Effect.suspend(() => Fiber.interruptAll(toolRuns.map((run) => run.fiber)))
+    const executeTool = (call: ToolCall) => {
+      if (input.prepared.request.toolChoice?.type === "none")
+        return new Tool.Error({ message: "Tools are disabled after the maximum agent steps" })
+      return input.prepared.executeTool({
+        sessionID: input.sessionID,
+        agent: input.agent,
+        messageID: input.assistantMessageID,
+        call,
+        progress: (update) => publisher.progress(call.id, update),
       })
-      const prepared = yield* context.prepare({
-        scope: { session: loaded.session, agentID: loaded.agent.id, model: loaded.model, tools: loaded.tools },
-        transcript: {
-          system: transcript.system,
-          messages: stepLimitReached
-            ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)]
-            : transcript.messages,
-        },
-        // Keep tool definitions on the final Step to preserve the provider's cached prefix.
-        toolChoice: stepLimitReached ? "none" : undefined,
-        webSocket: "session",
-      })
-      const outcome = yield* attempts.use(
-        {
-          sessionID,
-          assistantMessageID,
-          agent: loaded.agent.id,
-          model: loaded.model,
-          prepared,
-        },
-        (result, restore) =>
-          Effect.gen(function* () {
-            if (result.outputStarted) return undefined
-            // The attempt retains its pending terminal while interruptible summarization runs.
-            if (result.overflowBeforeOutput) {
-              // Even skipped recovery must observe pending interruption before publishing the held error.
-              const compacted = yield* restore(
-                recoverOverflow && compaction.enabled()
-                  ? compaction.compact(compactionInput).pipe(Effect.map((result) => result.status === "completed"))
-                  : Effect.succeed(false),
-              )
-              if (compacted) return SessionAttempt.Outcome.Compacted()
-            }
-            if (
-              recoverContinuation &&
-              result.failure?.reason._tag === "Transport" &&
-              (result.failure.reason.recovery === "retry-full" ||
-                result.failure.reason.recovery === "rotate-and-retry-full")
-            )
-              return SessionAttempt.Outcome.RecoverFull()
-            if (result.failure && result.error && SessionRunnerRetry.isRetryable(result.failure))
-              return SessionAttempt.Outcome.Retry({ cause: result.failure, error: result.error })
-            return undefined
-          }),
-      )
-      switch (outcome._tag) {
-        case "Completed":
-          return outcome.needsContinuation
-        case "Retry":
-          yield* retry({ cause: outcome.cause, error: outcome.error, assistantMessageID }).pipe(
-            Pull.catchDone(() =>
-              bus
-                .publish(SessionEvent.Step.Failed, { sessionID, assistantMessageID, error: outcome.error })
-                .pipe(Effect.andThen(outcome.cause)),
-            ),
-          )
-          continue
-        case "Continue":
-          // The partial span is already settled; share backoff before committing continuation.
-          yield* retry({ cause: outcome.cause, error: outcome.error, assistantMessageID }).pipe(
-            Pull.catchDone(() => outcome.cause),
-          )
-          yield* bus.publish(SessionEvent.Synthetic, { sessionID, text: CONTINUE_AFTER_INCOMPLETE_STREAM })
-          assistantMessageID = SessionMessage.ID.create()
-          continue
-        case "Compacted":
-          recoverOverflow = false
-          assistantMessageID = SessionMessage.ID.create()
-          continue
-        case "RecoverFull":
-          recoverContinuation = false
-          continue
-      }
     }
-  })
 
-  return { run }
+    // Provider and tool fibers retain per-source order without a shared writer queue.
+    // A local execution starts only after its Tool.Called publication completes.
+    let overflowFailure: ProviderErrorEvent | undefined
+    // Read to the end, not just the finish event, so the next request can reuse this response.
+    const providerStream = llm.stream(input.prepared.request, input.prepared.options).pipe(
+      Stream.runForEach((event) =>
+        Effect.gen(function* () {
+          if (overflowFailure || publisher.hasProviderError()) return
+          if (
+            LLMEvent.is.providerError(event) &&
+            isContextOverflowFailure(event) &&
+            !publisher.record().outputStarted
+          ) {
+            overflowFailure = event
+            return
+          }
+          yield* publisher.publish(event)
+          if (event.type !== "tool-call" || event.providerExecuted) return
+          toolRuns.push({
+            call: event,
+            fiber: yield* Effect.uninterruptibleMask((restore) =>
+              restore(executeTool(event)).pipe(
+                Effect.flatMap(toolOutput.truncate),
+                Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)),
+                Effect.catchTag("Tool.Error", (error) =>
+                  publisher.failTool(event.id, toSessionError(error), error.metadata).pipe(Effect.asVoid),
+                ),
+              ),
+            ).pipe(Effect.forkScoped),
+          })
+        }),
+      ),
+      Effect.ensuring(publisher.flush()),
+    )
+
+    // Keep the final tool and Step events uninterruptible, even when the work itself is cancelled.
+    return yield* Effect.uninterruptibleMask((restore) =>
+      Effect.gen(function* () {
+        const stream = yield* restore(providerStream).pipe(Effect.exit)
+        const streamFailure = Option.getOrUndefined(Exit.findErrorOption(stream))
+        const streamInterrupted = Exit.hasInterrupts(stream)
+        if (!overflowFailure && publisher.hasStarted()) yield* publisher.streamed()
+        if (streamInterrupted) yield* interruptTools
+        const joined = yield* restore(Fiber.awaitAll(toolRuns.map((run) => run.fiber))).pipe(Effect.exit)
+        if (Exit.isFailure(joined)) yield* interruptTools
+        const tools = classifyToolExits(joined, toolRuns)
+
+        if (
+          !publisher.record().outputStarted &&
+          isContextOverflowFailure(overflowFailure ?? streamFailure) &&
+          (yield* restore(input.recoverOverflow))
+        )
+          return Outcome.Compacted()
+
+        if (overflowFailure) yield* publisher.publish(overflowFailure)
+        const recorded = publisher.record()
+        const unknownFinish =
+          Exit.isSuccess(stream) && recorded.finish?.finish === "unknown"
+            ? new AIError({
+                reason: new InvalidProviderOutputError({
+                  message: "The provider response ended with an unknown finish reason.",
+                  classification: "incomplete-stream",
+                }),
+              })
+            : undefined
+        const llmFailure = streamFailure instanceof AIError ? streamFailure : unknownFinish
+        const llmError = llmFailure && !recorded.providerFailed ? toSessionError(llmFailure) : undefined
+        if (
+          input.recoverContinuation &&
+          llmFailure?.reason._tag === "Transport" &&
+          (llmFailure.reason.recovery === "retry-full" || llmFailure.reason.recovery === "rotate-and-retry-full") &&
+          !recorded.outputStarted
+        )
+          return Outcome.RecoverFull()
+        if (llmFailure && llmError && SessionRunnerRetry.isRetryable(llmFailure) && !recorded.outputStarted) {
+          // Retry state projects onto the existing assistant, even before it has produced output.
+          yield* publisher.startAssistant()
+          return Outcome.Retry({ cause: llmFailure, error: llmError })
+        }
+        if (llmError) yield* publisher.failAssistant(llmError)
+
+        for (const decline of tools.declines)
+          yield* publisher.failTool(decline.call.id, {
+            type: "aborted",
+            message:
+              decline.reason._tag === "QuestionTool.CancelledError"
+                ? decline.reason.message
+                : "The user declined this tool call",
+          })
+        const interrupted = tools.declines.length > 0 || streamInterrupted || tools.interrupted
+        const toolFailure = interrupted
+          ? TOOLS_INTERRUPTED
+          : tools.failure !== undefined
+            ? toSessionError(Cause.squash(tools.failure))
+            : recorded.providerFailed
+              ? TOOLS_INTERRUPTED
+              : undefined
+        if (toolFailure) yield* publisher.failUnsettledTools(toolFailure)
+        if (interrupted) yield* publisher.failAssistant(STEP_INTERRUPTED)
+
+        // All local fibers have joined; only provider-hosted results can still be missing.
+        if (llmError || (Exit.isSuccess(stream) && !recorded.providerFailed)) {
+          const missing = yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted")
+          if (missing && !llmError && !recorded.finish) yield* publisher.failAssistant(RESULT_MISSING)
+        }
+
+        const record = publisher.record()
+        if (record.finish || record.failure) {
+          const snapshot = yield* snapshots.capture()
+          const files =
+            startSnapshot && snapshot
+              ? startSnapshot === snapshot
+                ? []
+                : yield* snapshots
+                    .files({ from: startSnapshot, to: snapshot })
+                    .pipe(Effect.orElseSucceed(() => undefined))
+              : undefined
+          const usage = record.finish
+            ? { cost: SessionUsage.calculateCost(input.model.cost, record.finish.tokens), tokens: record.finish.tokens }
+            : undefined
+          if (record.failure) yield* publisher.publishStepFailure({ ...usage, snapshot, files })
+          if (record.finish && usage && !record.failure)
+            yield* bus.publish(SessionEvent.Step.Ended, {
+              sessionID: input.sessionID,
+              assistantMessageID: yield* publisher.startAssistant(),
+              finish: record.finish.finish,
+              rawFinish: record.finish.rawFinish,
+              providerState: record.finish.providerState,
+              ...usage,
+              snapshot,
+              files,
+            })
+        }
+
+        if (
+          llmFailure &&
+          llmError &&
+          isInterruptedStream(llmFailure) &&
+          record.outputStarted &&
+          tools.declines.length === 0 &&
+          !tools.interrupted
+        )
+          return Outcome.Continue({ cause: llmFailure, error: llmError })
+
+        if (Exit.isFailure(stream)) return yield* Effect.failCause(stream.cause)
+        if (tools.declines.length > 0) return yield* Effect.interrupt
+        if (tools.interrupted && tools.failure) return yield* Effect.failCause(tools.failure)
+        if (tools.interrupted && Exit.isFailure(joined)) return yield* Effect.failCause(joined.cause)
+        if (record.failure) return yield* new StepFailedError({ error: record.failure })
+        return Outcome.Completed({
+          needsContinuation: input.prepared.request.toolChoice?.type !== "none" && record.needsContinuation,
+        })
+      }),
+    )
+  }, Effect.scoped)
+
+  return { attempt }
 })
+
+const isInterruptedStream = (failure: AIError) => {
+  if (failure.reason._tag === "InvalidProviderOutput") return failure.reason.classification === "incomplete-stream"
+  if (failure.reason._tag === "Transport") return failure.reason.operation === "read"
+  return false
+}
+
+/** Tool.Error settles in each fiber; only user declines remain in the typed error channel. */
+const classifyToolExits = (
+  settled: Exit.Exit<Array<Exit.Exit<void, Permission.DeclinedError | QuestionTool.CancelledError>>>,
+  runs: ReadonlyArray<{ readonly call: ToolCall }>,
+) => {
+  const exits = Exit.isSuccess(settled) ? settled.value : []
+  const declines = exits.flatMap((exit, index) =>
+    Exit.isFailure(exit)
+      ? exit.cause.reasons.flatMap((reason) =>
+          Cause.isFailReason(reason) ? [{ call: runs[index].call, reason: reason.error }] : [],
+        )
+      : [],
+  )
+  const causes = Exit.isFailure(settled)
+    ? [settled.cause]
+    : exits.flatMap((exit) => (Exit.isFailure(exit) ? [exit.cause] : []))
+  const failure = causes
+    .flatMap((cause) => {
+      if (Cause.hasInterrupts(cause)) return []
+      const reasons = cause.reasons.filter(Cause.isDieReason)
+      return reasons.length > 0 ? [Cause.fromReasons<never>(reasons)] : []
+    })
+    .at(0)
+  return { interrupted: causes.some(Cause.hasInterrupts), declines, failure }
+}

packages/core/src/session/title.ts

@@ -1,8 +1,7 @@
 export * as SessionTitle from "./title.js"
 
 import { isDeepStrictEqual } from "node:util"
-import { LLMClient, AIError, LLMEvent, Message, SystemPart, type LLMRequest } from "@opencode-ai/ai"
-import type { StreamOptions } from "@opencode-ai/ai/route"
+import { LLMClient, LLMEvent, Message, SystemPart } from "@opencode-ai/ai"
 import { Context, DateTime, Effect, Layer, Stream } from "effect"
 import type { Agent } from "../agent.js"
 import { Database } from "../database/database.js"
@@ -23,15 +22,6 @@ const MAX_CONTEXT_LENGTH = 8_000
 const MAX_FIRST_MESSAGE_LENGTH = 2_000
 const titleChanged = Symbol("Session title changed")
 
-type Dependencies = {
-  readonly bus: Bus.Interface
-  readonly llm: {
-    readonly stream: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<LLMEvent, AIError>
-  }
-  readonly context: SessionContext.Interface
-  readonly store: SessionStore.Interface
-}
-
 export interface Interface {
   /** Generates an initial title or regenerates one from bounded conversation history. */
   readonly generate: (sessionID: SessionSchema.ID) => Effect.Effect<void>
@@ -46,117 +36,6 @@ export const isUntitled = (session: SessionSchema.Info) =>
     time: { created: DateTime.toEpochMillis(session.time.created) },
   })
 
-const attempt = Effect.fn("SessionTitle.attempt")(function* (
-  dependencies: Dependencies,
-  input: {
-    readonly session: SessionSchema.Info
-    readonly agent: Agent.Info
-    readonly text: string
-    readonly model: SessionRunnerModel.Resolved
-  },
-) {
-  const chunks: string[] = []
-  let failed = false
-  let usage: SessionUsage.Recorded | undefined
-  const recordUsage = Effect.suspend(() =>
-    usage
-      ? dependencies.bus.publish(SessionEvent.UsageRecorded, {
-          sessionID: input.session.id,
-          source: "title",
-          ...usage,
-        })
-      : Effect.void,
-  )
-  const prepared = yield* dependencies.context.prepare({
-    scope: { session: input.session, agentID: input.agent.id, model: input.model },
-    transcript: {
-      system: input.agent.system ? [SystemPart.make(input.agent.system)] : [],
-      messages: [Message.user(input.text)],
-    },
-    contextHooks: false,
-  })
-  yield* dependencies.llm.stream(prepared.request, prepared.options).pipe(
-    Stream.runForEach((event) => {
-      if (LLMEvent.is.providerError(event)) failed = true
-      if (LLMEvent.is.textDelta(event)) chunks.push(event.text)
-      if (LLMEvent.is.stepFinish(event)) {
-        const step = SessionUsage.record(event.usage, input.model.cost)
-        usage = usage ? SessionUsage.add(usage, step) : step
-      }
-      return Effect.void
-    }),
-    Effect.catchTag("AI.Error", () =>
-      Effect.sync(() => {
-        failed = true
-      }),
-    ),
-    Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)),
-  )
-  yield* recordUsage
-  if (failed) return
-  return chunks
-    .join("")
-    .split("\n")
-    .map((line) => line.trim())
-    .find((line) => line.length > 0)
-})
-
-const make = (dependencies: Dependencies) => {
-  const generate = Effect.fn("SessionTitle.generate")(function* (
-    db: Database.Interface["db"],
-    sessionID: SessionSchema.ID,
-  ) {
-    const session = yield* dependencies.store.get(sessionID)
-    if (!session) return
-    const firstUser = yield* SessionHistory.firstUserMessage(db, session.id)
-    if (!firstUser) return
-    const text = !isUntitled(session)
-      ? yield* dependencies.store.context(session.id).pipe(
-          Effect.map((messages) => {
-            const original = `Original request:\n${firstUser.text.slice(0, MAX_FIRST_MESSAGE_LENGTH)}`
-            const recent = messages
-              .flatMap((message) => {
-                if (message.type === "user" && message.id !== firstUser.id) return [`User: ${message.text.trim()}`]
-                if (message.type !== "assistant") return []
-                const text = message.content
-                  .flatMap((part) => (part.type === "text" ? [part.text.trim()] : []))
-                  .filter(Boolean)
-                  .join("\n")
-                return text ? [`Assistant: ${text}`] : []
-              })
-              .join("\n\n")
-            if (!recent) return original
-            const prefix = `${original}\n\nRecent conversation:\n`
-            return `${prefix}${recent.slice(-(MAX_CONTEXT_LENGTH - prefix.length))}`
-          }),
-          Effect.orElseSucceed(() => firstUser.text),
-        )
-      : firstUser.text
-    const selection = yield* dependencies.context.selectTitle(session)
-    if (!selection) return
-    const title =
-      (yield* attempt(dependencies, { session, agent: selection.agent, text, model: selection.selected })) ??
-      (selection.primary && !isDeepStrictEqual(selection.selected.ref, selection.primary.ref)
-        ? yield* attempt(dependencies, { session, agent: selection.agent, text, model: selection.primary })
-        : undefined)
-    if (!title) return
-    const expectedSequence = (yield* Bus.latestSequence(db, sessionID)) + 1
-    const current = yield* dependencies.store.get(sessionID)
-    if (!current || current.title !== session.title || current.title === truncate(title)) return
-    yield* dependencies.bus
-      .publish(
-        SessionEvent.Renamed,
-        {
-          sessionID: session.id,
-          title: truncate(title),
-        },
-        { commit: (sequence) => (sequence === expectedSequence ? Effect.void : Effect.die(titleChanged)) },
-      )
-      .pipe(Effect.catchDefect((defect) => (defect === titleChanged ? Effect.void : Effect.die(defect))))
-  })
-  return { generate }
-}
-
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -164,11 +43,110 @@ export const layer = Layer.effect(
     const llm = yield* LLMClient.Service
     const context = yield* SessionContext.Service
     const store = yield* SessionStore.Service
-    const database = yield* Database.Service
-    const title = make({ bus, llm, context, store })
-    return Service.of({
-      generate: (sessionID) => title.generate(database.db, sessionID),
+    const db = (yield* Database.Service).db
+
+    const attempt = Effect.fn("SessionTitle.attempt")(function* (input: {
+      readonly session: SessionSchema.Info
+      readonly agent: Agent.Info
+      readonly text: string
+      readonly model: SessionRunnerModel.Resolved
+    }) {
+      const chunks: string[] = []
+      let failed = false
+      let usage: SessionUsage.Recorded | undefined
+      const recordUsage = Effect.suspend(() =>
+        usage
+          ? bus.publish(SessionEvent.UsageRecorded, {
+              sessionID: input.session.id,
+              source: "title",
+              ...usage,
+            })
+          : Effect.void,
+      )
+      const prepared = yield* context.prepare({
+        scope: { session: input.session, agentID: input.agent.id, model: input.model },
+        transcript: {
+          system: input.agent.system ? [SystemPart.make(input.agent.system)] : [],
+          messages: [Message.user(input.text)],
+        },
+        contextHooks: false,
+      })
+      yield* llm.stream(prepared.request, prepared.options).pipe(
+        Stream.runForEach((event) => {
+          if (LLMEvent.is.providerError(event)) failed = true
+          if (LLMEvent.is.textDelta(event)) chunks.push(event.text)
+          if (LLMEvent.is.stepFinish(event)) {
+            const step = SessionUsage.record(event.usage, input.model.cost)
+            usage = usage ? SessionUsage.add(usage, step) : step
+          }
+          return Effect.void
+        }),
+        Effect.catchTag("AI.Error", () =>
+          Effect.sync(() => {
+            failed = true
+          }),
+        ),
+        Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)),
+      )
+      yield* recordUsage
+      if (failed) return
+      return chunks
+        .join("")
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.length > 0)
     })
+
+    const generate = Effect.fn("SessionTitle.generate")(function* (sessionID: SessionSchema.ID) {
+      const session = yield* store.get(sessionID)
+      if (!session) return
+      const firstUser = yield* SessionHistory.firstUserMessage(db, session.id)
+      if (!firstUser) return
+      const text = !isUntitled(session)
+        ? yield* store.context(session.id).pipe(
+            Effect.map((messages) => {
+              const original = `Original request:\n${firstUser.text.slice(0, MAX_FIRST_MESSAGE_LENGTH)}`
+              const recent = messages
+                .flatMap((message) => {
+                  if (message.type === "user" && message.id !== firstUser.id) return [`User: ${message.text.trim()}`]
+                  if (message.type !== "assistant") return []
+                  const text = message.content
+                    .flatMap((part) => (part.type === "text" ? [part.text.trim()] : []))
+                    .filter(Boolean)
+                    .join("\n")
+                  return text ? [`Assistant: ${text}`] : []
+                })
+                .join("\n\n")
+              if (!recent) return original
+              const prefix = `${original}\n\nRecent conversation:\n`
+              return `${prefix}${recent.slice(-(MAX_CONTEXT_LENGTH - prefix.length))}`
+            }),
+            Effect.orElseSucceed(() => firstUser.text),
+          )
+        : firstUser.text
+      const selection = yield* context.selectTitle(session)
+      if (!selection) return
+      const title =
+        (yield* attempt({ session, agent: selection.agent, text, model: selection.selected })) ??
+        (selection.primary && !isDeepStrictEqual(selection.selected.ref, selection.primary.ref)
+          ? yield* attempt({ session, agent: selection.agent, text, model: selection.primary })
+          : undefined)
+      if (!title) return
+      const expectedSequence = (yield* Bus.latestSequence(db, sessionID)) + 1
+      const current = yield* store.get(sessionID)
+      if (!current || current.title !== session.title || current.title === truncate(title)) return
+      yield* bus
+        .publish(
+          SessionEvent.Renamed,
+          {
+            sessionID: session.id,
+            title: truncate(title),
+          },
+          { commit: (sequence) => (sequence === expectedSequence ? Effect.void : Effect.die(titleChanged)) },
+        )
+        .pipe(Effect.catchDefect((defect) => (defect === titleChanged ? Effect.void : Effect.die(defect))))
+    })
+    return Service.of({ generate })
   }),
 )
 

packages/core/test/command/invocation.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect } from "bun:test"
+import path from "path"
+import { DateTime, Effect, Layer } from "effect"
+import { CommandInvocation } from "@opencode-ai/core/command/invocation"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { Location } from "@opencode-ai/core/location"
+import { ShellSelect } from "@opencode-ai/core/shell/select"
+import { Agent } from "@opencode-ai/schema/agent"
+import { ConfigCommand } from "@opencode-ai/schema/config/command"
+import { Model } from "@opencode-ai/schema/model"
+import { Money } from "@opencode-ai/schema/money"
+import { Provider } from "@opencode-ai/schema/provider"
+import { Session } from "@opencode-ai/schema/session"
+import { SessionInbox } from "@opencode-ai/schema/session-inbox"
+import { SessionMessage } from "@opencode-ai/schema/session-message"
+import { AppProcess } from "@opencode-ai/util/process"
+import { tempLocationLayer } from "../fixture/location"
+import { testEffect } from "../lib/effect"
+import { host } from "../plugin/host"
+
+const shell = ShellSelect.Service.of({
+  resolve: (input) =>
+    Effect.sync(() => {
+      expect(input).toEqual({ priority: "config" })
+      return "sh"
+    }),
+  transform: () => Effect.die("unused shell.transform"),
+  reload: () => Effect.die("unused shell.reload"),
+})
+const it = testEffect(
+  Layer.mergeAll(AppNodeBuilder.build(AppProcess.node), tempLocationLayer, Layer.succeed(ShellSelect.Service, shell)),
+)
+const sessionID = Session.ID.make("ses_command_invocation")
+
+describe("CommandInvocation", () => {
+  it.effect("expands arguments without changing unconfigured session defaults or prompt attachments", () =>
+    Effect.gen(function* () {
+      const prompts: unknown[] = []
+      const invoke = yield* CommandInvocation.make(promptHost(prompts))
+      const files = [{ uri: "file:///context.md", name: "context" }]
+      for (const [template, text, expected] of [
+        [
+          "$2 / $1 / $2",
+          `"alpha beta" 'gamma delta' [Image 3] tail`,
+          "gamma delta [Image 3] tail / alpha beta / gamma delta [Image 3] tail",
+        ],
+        ["[$1][$3]", "one two", "[one][]"],
+        ["raw [$ARGUMENTS]", `"alpha beta" 'gamma delta'`, `raw ["alpha beta" 'gamma delta']`],
+        ["  Review  ", " details ", "Review  \n\n details"],
+        ["  Review  ", "  ", "Review"],
+      ]) {
+        expect(
+          yield* invoke(new ConfigCommand.Info({ template }), {
+            sessionID,
+            prompt: { text, files },
+            delivery: "queue",
+          }),
+        ).toBeUndefined()
+        expect(prompts.at(-1)).toEqual({ sessionID, text: expected, files, delivery: "queue" })
+      }
+    }),
+  )
+
+  it.effect("switches agents before applying command or agent model defaults and admitting the prompt", () =>
+    Effect.gen(function* () {
+      const calls: unknown[] = []
+      const ctx = promptHost(calls)
+      const location = yield* Location.Service
+      const reviewer = Agent.ID.make("reviewer")
+      const agentModel = { id: Model.ID.make("agent-model"), providerID: Provider.ID.make("example") }
+      const commandModel = {
+        model: Model.ID.make("command-model"),
+        providerID: Provider.ID.make("example"),
+        variant: Model.VariantID.make("careful"),
+      }
+      const session = Session.Info.make({
+        id: sessionID,
+        projectID: location.project.id,
+        agent: Agent.ID.make("build"),
+        cost: Money.USD.zero,
+        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+        location: { directory: location.directory },
+      })
+      for (const testCase of [
+        {
+          currentAgent: session.agent,
+          agentModel,
+          command: new ConfigCommand.Info({ template: "Review", agent: reviewer, model: commandModel }),
+          expected: [
+            ["session.get", { sessionID }],
+            ["switchAgent", { sessionID, agent: reviewer }],
+            ["agent.get", { agentID: reviewer }],
+            ["switchModel", { sessionID, model: { id: "command-model", providerID: "example", variant: "careful" } }],
+          ],
+        },
+        {
+          currentAgent: reviewer,
+          agentModel,
+          command: new ConfigCommand.Info({ template: "Review", agent: reviewer }),
+          expected: [
+            ["session.get", { sessionID }],
+            ["agent.get", { agentID: reviewer }],
+            ["switchModel", { sessionID, model: agentModel }],
+          ],
+        },
+        {
+          currentAgent: session.agent,
+          agentModel: undefined,
+          command: new ConfigCommand.Info({ template: "Review", agent: reviewer }),
+          expected: [
+            ["session.get", { sessionID }],
+            ["switchAgent", { sessionID, agent: reviewer }],
+            ["agent.get", { agentID: reviewer }],
+          ],
+        },
+        {
+          currentAgent: session.agent,
+          agentModel,
+          command: new ConfigCommand.Info({
+            template: "Review",
+            model: { model: commandModel.model, providerID: commandModel.providerID },
+          }),
+          expected: [["switchModel", { sessionID, model: { id: "command-model", providerID: "example" } }]],
+        },
+      ]) {
+        calls.length = 0
+        const invoke = yield* CommandInvocation.make(
+          host({
+            agent: {
+              ...ctx.agent,
+              get: (input) =>
+                Effect.sync(() => {
+                  calls.push(["agent.get", input])
+                  return { location, data: { ...Agent.Info.default(reviewer), model: testCase.agentModel } }
+                }),
+            },
+            session: {
+              ...ctx.session,
+              get: (input) =>
+                Effect.sync(() => {
+                  calls.push(["session.get", input])
+                  return { ...session, agent: testCase.currentAgent }
+                }),
+              switchAgent: (input) => Effect.sync(() => calls.push(["switchAgent", input])),
+              switchModel: (input) => Effect.sync(() => calls.push(["switchModel", input])),
+            },
+          }),
+        )
+        yield* invoke(testCase.command, {
+          sessionID,
+          prompt: { text: "" },
+          delivery: "steer",
+        })
+        expect(calls).toEqual([...testCase.expected, { sessionID, text: "Review", delivery: "steer" }])
+      }
+    }),
+  )
+
+  it.live("interpolates in source order using the location, closed stdin and nonzero-exit output", () =>
+    Effect.gen(function* () {
+      const prompts: unknown[] = []
+      const location = yield* Location.Service
+      yield* Effect.promise(() => Bun.write(path.join(location.directory, "context.txt"), "context"))
+      const invoke = yield* CommandInvocation.make(promptHost(prompts))
+      yield* invoke(
+        new ConfigCommand.Info({
+          template:
+            'first=!`read value || printf closed-; cat context.txt; sleep 0.05; printf "%s" "-stderr" >&2; exit 7`; second=!`printf "%s" "$1"`',
+        }),
+        { sessionID, prompt: { text: "argument" }, delivery: "steer" },
+      )
+      expect(prompts).toEqual([{ sessionID, text: "first=closed-context-stderr; second=argument", delivery: "steer" }])
+    }),
+  )
+
+  it.live("wraps process failures with the shell source and does not admit a prompt", () =>
+    Effect.gen(function* () {
+      const prompts: unknown[] = []
+      const location = yield* Location.Service
+      const missing = path.join(location.directory, "missing-shell")
+      const invoke = yield* CommandInvocation.make(promptHost(prompts)).pipe(
+        Effect.provideService(ShellSelect.Service, { ...shell, resolve: () => Effect.succeed(missing) }),
+      )
+      const error = yield* invoke(new ConfigCommand.Info({ template: '!`printf "hello"`' }), {
+        sessionID,
+        prompt: { text: "" },
+        delivery: "steer",
+      }).pipe(Effect.flip)
+      expect(error).toBeInstanceOf(Error)
+      expect(String(error)).toContain('Shell interpolation failed for "printf \\"hello\\"": Command failed:')
+      expect(String(error)).toContain(missing)
+      expect(prompts).toEqual([])
+    }),
+  )
+})
+
+function promptHost(prompts: unknown[]) {
+  return host({
+    session: {
+      prompt: (input) =>
+        Effect.sync(() => {
+          prompts.push(input)
+          return SessionInbox.User.make({
+            id: SessionMessage.ID.make("msg_command_invocation"),
+            sessionID: input.sessionID,
+            timeCreated: DateTime.makeUnsafe(0),
+            type: "user",
+            payload: { text: input.text },
+            delivery: input.delivery ?? "steer",
+          })
+        }),
+    },
+  })
+}

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

@@ -205,7 +205,6 @@ const makeRunnerState = () => {
     systemLoadHook: Effect.void,
     skillBaselines: new Map<Agent.ID, string>(),
     pluginFlushHook: Effect.void,
-    compactionEndedHook: Effect.void,
     authorizations: new Array<Tool.Context>(),
     executions: new Array<string>(),
     closedTransports: new Array<Session.ID>(),
@@ -406,25 +405,6 @@ const layer = Layer.unwrap(
         small: () => Effect.undefined,
       },
     })
-    const compaction = makeLocationNode({
-      service: SessionCompaction.Service,
-      layer: SessionCompaction.layer.pipe(
-        Layer.updateService(Bus.Service, (bus) =>
-          Bus.Service.of({
-            ...bus,
-            publish: (definition, data, options) =>
-              bus
-                .publish(definition, data, options)
-                .pipe(
-                  Effect.tap(() =>
-                    definition.type === SessionEvent.Compaction.Ended.type ? state.compactionEndedHook : Effect.void,
-                  ),
-                ),
-          }),
-        ),
-      ),
-      deps: [Bus.node, LayerNodePlatform.llmClient],
-    })
     const replacements: LayerNode.Replacements = [
       [Snapshot.node, Snapshot.noopLayer],
       [LayerNodePlatform.llmClient, TestLLM.clientLayer],
@@ -438,7 +418,6 @@ const layer = Layer.unwrap(
       [Config.node, config],
       [PluginSupervisor.node, pluginSupervisor],
       [SessionModelTransport.node, modelTransport],
-      [SessionCompaction.node, compaction],
     ]
     const runnerLayer = AppNodeBuilder.build(SessionRunnerLLM.node, [
       ...replacements,
@@ -2522,29 +2501,6 @@ describe("SessionRunnerLLM", () => {
     )
   })
 
-  scenario("does not publish a held overflow when interrupted with automatic compaction disabled", function* (s) {
-    const compaction = yield* SessionCompaction.Service
-    yield* compaction.transform((draft) => draft.configure({ auto: false }))
-    const tail = yield* Deferred.make<void>()
-    yield* s.admit("Interrupt held overflow")
-    yield* s.llm.push(
-      Stream.concat(
-        Stream.make(LLMEvent.providerError({ message: "prompt too long", classification: "context-overflow" })),
-        Stream.fromEffect(Deferred.succeed(tail, undefined)).pipe(Stream.flatMap(() => Stream.never)),
-      ),
-    )
-    const run = yield* s.resume.pipe(Effect.forkChild)
-    yield* Deferred.await(tail)
-
-    yield* s.session.interrupt(sessionID)
-
-    const exit = yield* Fiber.await(run)
-    expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBeTrue()
-    expect(s.requests).toHaveLength(1)
-    expect(yield* s.context).toMatchObject([Expected.user("Interrupt held overflow")])
-    expect((yield* recordedEventTypes(sessionID)).filter((type) => type.startsWith("session.step."))).toEqual([])
-  })
-
   scenario("recovers from provider context overflow without a configured context limit", function* (s) {
     yield* setupOverflowRecovery(s)
     s.currentModel = model
@@ -2675,39 +2631,6 @@ describe("SessionRunnerLLM", () => {
     )
   })
 
-  scenario("interrupts after overflow compaction commits before recovery hands off", function* (s) {
-    yield* setupOverflowRecovery(s)
-    const committed = yield* Deferred.make<void>()
-    // The real Bus publication has returned, but the recovery outcome has not.
-    s.compactionEndedHook = Deferred.succeed(committed, undefined).pipe(Effect.andThen(Effect.never))
-    yield* s.llm.push(
-      [
-        LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.providerError({ message: "prompt too long", classification: "context-overflow" }),
-      ],
-      TestLLM.text("Committed overflow summary", "text-summary"),
-      TestLLM.text("Must not retry", "text-unexpected-retry"),
-    )
-    yield* s.admit("Continue")
-    const run = yield* s.resume.pipe(Effect.forkChild)
-    yield* Deferred.await(committed)
-    const assistant = requireAssistant(yield* s.messages)
-
-    yield* s.session.interrupt(sessionID)
-
-    const exit = yield* Fiber.await(run)
-    expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBeTrue()
-    expect(s.requests).toHaveLength(2)
-    expect(yield* s.context).toMatchObject([
-      { type: "compaction", status: "completed", reason: "auto", summary: "Committed overflow summary" },
-    ])
-    expect(yield* recordedStepSettlementTypes(sessionID, assistant.id)).toEqual(["session.step.started.1"])
-    expect((yield* recordedEventTypes(sessionID)).filter((type) => type.startsWith("session.compaction."))).toEqual([
-      "session.compaction.started.1",
-      "session.compaction.ended.1",
-    ])
-  })
-
   scenario("uses epoch values after compaction while a source is unavailable", function* (s) {
     yield* s.runPrompt("First")
     s.systemBaseline = "Changed context"
@@ -3703,32 +3626,6 @@ describe("SessionRunnerLLM", () => {
     expect(userTexts(s.requests[0])).toEqual(["Recover promoted input"])
   })
 
-  scenario("does not execute a local tool when durable call projection rolls back", function* (s) {
-    const defect = new Error("Tool.Called projection failed")
-    yield* s.bus.project(SessionEvent.Tool.Called, () =>
-      Effect.gen(function* () {
-        // The production projector has updated this transaction; the failure must roll it back.
-        expect(requireAssistant(yield* s.messages.pipe(Effect.orDie)).content).toMatchObject([
-          { type: "tool", id: "call-rollback", state: { status: "running", input: { text: "Must not execute" } } },
-        ])
-        return yield* Effect.die(defect)
-      }),
-    )
-    yield* s.admit("Call echo")
-    yield* s.llm.push(TestLLM.tool("call-rollback", "echo", { text: "Must not execute" }))
-
-    expect(yield* s.resume.pipe(Effect.catchDefect(Effect.succeed))).toBe(defect)
-
-    expect(s.requests).toHaveLength(1)
-    expect(s.executions).toEqual([])
-    expect(s.authorizations).toEqual([])
-    expect(requireAssistant(yield* s.messages).content).toMatchObject([
-      { type: "tool", id: "call-rollback", state: { status: "streaming" } },
-    ])
-    expect(yield* recordedEventTypes(sessionID)).not.toContain("session.tool.called.1")
-    expect(yield* recordedEventTypes(sessionID)).not.toContain("session.tool.success.2")
-  })
-
   scenario("does not strand a committed promotion when a post-commit listener defects", function* (s) {
     yield* s.bus.listen((event) =>
       event.type === SessionEvent.InboxDelivered.type ? Effect.die("fail after prompt promotion commits") : Effect.void,

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

@@ -14,7 +14,7 @@ import { Session } from "@opencode-ai/core/session"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionProjector } from "@opencode-ai/core/session/projector"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
-import { SessionAttempt } from "@opencode-ai/core/session/runner/attempt"
+import { SessionStep } from "@opencode-ai/core/session/runner/step"
 import { SessionMessageTable, SessionTable } from "@opencode-ai/core/session/sql"
 import { Snapshot } from "@opencode-ai/core/snapshot"
 import { ToolOutput } from "@opencode-ai/core/tool-output"
@@ -49,7 +49,7 @@ for (const fixture of [
       const files = [RelativePath.make("changed.ts")]
       let captures = 0
       let executions = 0
-      const attempts = yield* SessionAttempt.make.pipe(
+      const steps = yield* SessionStep.make.pipe(
         Effect.provide(
           Layer.mock(Snapshot.Service)({
             capture: () => Effect.sync(() => (captures++ === 0 ? start : end)),
@@ -98,31 +98,30 @@ for (const fixture of [
           LLMEvent.toolCall({ id: "call-test", name: "test", input: {} }),
         ),
       )
-      const result = yield* attempts
-        .use(
-          {
-            sessionID,
-            assistantMessageID,
-            agent: Agent.defaultID,
-            model,
-            prepared: {
-              request: LLM.request({ model: model.model, prompt: "Run one tool", toolChoice: fixture.toolChoice }),
-              options: {},
-              executeTool: () =>
-                Effect.sync(() => {
-                  executions++
-                  return { content: "Completed tool" }
-                }),
-            },
+      const result = yield* steps
+        .attempt({
+          sessionID,
+          assistantMessageID,
+          agent: Agent.defaultID,
+          model,
+          prepared: {
+            request: LLM.request({ model: model.model, prompt: "Run one tool", toolChoice: fixture.toolChoice }),
+            options: {},
+            executeTool: () =>
+              Effect.sync(() => {
+                executions++
+                return { content: "Completed tool" }
+              }),
           },
-          () => Effect.succeed(undefined),
-        )
+          recoverContinuation: true,
+          recoverOverflow: Effect.succeed(false),
+        })
         .pipe(Effect.exit)
       expect(Exit.isSuccess(result)).toBe(fixture.finish === "stop")
       expect(executions).toBe(fixture.toolChoice === "none" ? 0 : 1)
       if (Exit.isSuccess(result))
         expect(result.value).toEqual(
-          SessionAttempt.Outcome.Completed({ needsContinuation: fixture.toolChoice !== "none" }),
+          SessionStep.Outcome.Completed({ needsContinuation: fixture.toolChoice !== "none" }),
         )
       expect(yield* llm.requests()).toHaveLength(1)
       expect(captures).toBe(2)