Session 0pakyzl3wsdq

/tmp/opencode/session-recovery-v21-review/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/ui/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/app/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/codemode/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/opencode/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/app/e2e/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/app/e2e/performance/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/schema/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/opencode/src/session/llm/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/desktop/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/opencode/test/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/opencode/src/server/routes/instance/httpapi/AGENTS.md
/tmp/opencode/session-recovery-v21-review/packages/opencode/test/server/AGENTS.md
/tmp/opencode/session-recovery-v21-review/pa...

/tmp/opencode/session-recovery-v21-review
## HEAD (no branch)
 M packages/client/src/generated/types.ts
 M packages/core/schema.json
 M packages/core/src/database/migration.gen.ts
 M packages/core/src/database/schema.gen.ts
 M packages/core/src/session.ts
 M packages/core/src/session/compaction.ts
 M packages/core/src/session/context-epoch.ts
 M packages/core/src/session/execution/local.ts
 M packages/core/src/session/input.ts
 M packages/core/src/session/message-updater.ts
 M packages/core/src/session/projector.ts
 M packages/core/src/session/run-coordinator.ts
 M packages/core/src/session/runner/index.ts
 M packages/core/src/session/runner/llm.ts
 M packages/core/src/session/runner/publish-llm-event.ts
 M packages/core/src/session/sql.ts
 M packages/core/test/database-migration.test.ts
 M packages/core/test/session-projector.test.ts
 M packages/core/test/session-prompt.test.ts
 M packages/core/test/session-run-coordinator.test.ts
 M ...

72	0	packages/client/src/generated/types.ts
566	47	packages/core/schema.json
1	0	packages/core/src/database/migration.gen.ts
62	0	packages/core/src/database/migration/20260914170650_session-recovery.ts
52	1	packages/core/src/database/schema.gen.ts
6	4	packages/core/src/session.ts
31	16	packages/core/src/session/compaction.ts
54	34	packages/core/src/session/context-epoch.ts
213	19	packages/core/src/session/execution/local.ts
391	31	packages/core/src/session/input.ts
69	0	packages/core/src/session/message-updater.ts
88	1	packages/core/src/session/projector.ts
560	0	packages/core/src/session/recovery.ts
35	5	packages/core/src/session/run-coordinator.ts
4	0	packages/core/src/session/runner/index.ts
289	104	packages/core/src/session/runner/llm.ts
108	48	packages/core/src/session/runner/publish-llm-event.ts
88	1	packages/core/src/session/sql.ts
66	1	packages/core/test/database-migration.test.ts
393	0	packages/core/test/session-execution-local.test.ts
2922	3	packages/core/test/session-project...

<path>/tmp/opencode/session-recovery-v21-review/AGENTS.md</path>
<type>file</type>
<content>
1: - To regenerate the legacy JavaScript SDK, run `./packages/sdk/js/script/build.ts`.
2: - After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit `src/generated` or `src/generated-effect` directly.
3: - Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk-next` composes Client, Core, and Server.
4: - The default branch in this repo is `dev`.
5: - Local `main` ref may not exist; use `dev` or `origin/dev` for diffs.
6: 
7: ## Branch Names
8: 
9: Use a short branch name of at most three words, separated by hyphens. Do not use slashes or type prefixes such as `feat/` or `fix/`.
10: 
11: Examples: `session-recovery`, `fix-scroll-state`, `regenerate-sdk`. ...

<path>/tmp/opencode/session-recovery-v21-review/packages/opencode/AGENTS.md</path>
<type>file</type>
<content>
1: # opencode database guide
2: 
3: ## Database
4: 
5: - **Schema**: Drizzle schema lives in `packages/core/src/**/*.sql.ts`.
6: - **Migrations**: database migrations live in `packages/core` and are applied by core.
7: 
8: ## Development server
9: 
10: - Running `bun dev` from `packages/opencode` starts the live interactive TUI. Do not run it as a blocking foreground command when you need to inspect the result.
11: - Start it in `tmux` instead: `tmux new-session -d -s opencode-dev 'bun dev'`.
12: - Capture the current TUI output with: `tmux capture-pane -pt opencode-dev`.
13: - Stop the session explicitly when done: `tmux kill-session -t opencode-dev`.
14: 
15: # Module shape
16: 
17: Do not use `export namespace Foo { ... }` for module organization. It is not
18: standard ESM, it prevents tree-shaking, and it breaks Node's native TypeScript
19: runner. ...

<path>/tmp/opencode/session-recovery-v21-review/packages/opencode/src/server/routes/instance/httpapi/AGENTS.md</path>
<type>file</type>
<content>
1: # HttpApi Route Patterns
2: 
3: Use `HttpApiBuilder.group(...)` for normal HTTP endpoints, including streaming HTTP responses such as server-sent events. Handlers should yield stable services once while building the handler layer, then close over those services in endpoint implementations.
4: 
5: ```ts
6: export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session", (handlers) =>
7:   Effect.gen(function* () {
8:     const session = yield* Session.Service
9: 
10:     return handlers.handle("list", () => session.list())
11:   }),
12: )
13: ```
14: 
15: For SSE endpoints, stay in `HttpApiBuilder.group(...)` and return `HttpServerResponse.stream(...)` from the handler. Annotate the endpoint success schema with `HttpApiSchema.asText({ contentType: "text/event-stream" })` so OpenAPI documents the stream content type. ...

<path>/tmp/opencode/session-recovery-v21-review/packages/schema/AGENTS.md</path>
<type>file</type>
<content>
1: # Schema Package Guide
2: 
3: `@opencode-ai/schema` owns browser-safe wire and storage contracts shared by protocol, server, core, and generated SDKs. Keep runtime behavior, service layers, side effects, and host-local implementation details in the domain package that owns them.
4: 
5: ## Package Boundary
6: 
7: - Preserve the dependency direction: `@opencode-ai/schema <- @opencode-ai/protocol <- @opencode-ai/server`.
8: - Schema values should be serializable contract definitions, not service implementations or runtime registries.
9: - A domain may keep a minimal public wire contract here when SDK generation needs it, but do not move the broader runtime model into Schema just because an event is public. `plugin.added` is the current example: Schema may own the minimum browser-safe event payload, while plugin runtime behavior stays outside Schema. ...

/tmp/opencode/session-recovery-v21-review/CONTRIBUTING.md

<path>/tmp/opencode/session-recovery-v21-review/CONTRIBUTING.md</path>
<type>file</type>
<content>
1: # Contributing to OpenCode
2: 
3: We want to make it easy for you to contribute to OpenCode. Here are the most common type of changes that get merged:
4: 
5: - Bug fixes
6: - Additional LSPs / Formatters
7: - Improvements to LLM performance
8: - Support for new providers
9: - Fixes for environment-specific quirks
10: - Missing standard behavior
11: - Documentation improvements
12: 
13: However, any UI or core product feature must go through a design review with the core team before implementation.
14: 
15: If you are unsure if a PR would be accepted, feel free to ask a maintainer or look for issues with any of the following labels:
16: 
17: - [`help wanted`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3Ahelp-wanted)
18: - [`good first ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/package.json</path>
<type>file</type>
<content>
1: {
2:   "$schema": "https://json.schemastore.org/package.json",
3:   "version": "1.18.30",
4:   "name": "@opencode-ai/core",
5:   "type": "module",
6:   "license": "MIT",
7:   "private": true,
8:   "scripts": {
9:     "db": "bun drizzle-kit",
10:     "migration": "bun run script/migration.ts",
11:     "fix-node-pty": "bun run script/fix-node-pty.ts",
12:     "test": "bun test --only-failures",
13:     "typecheck": "tsgo --noEmit"
14:   },
15:   "bin": {
16:     "opencode": "./bin/opencode"
17:   },
18:   "exports": {
19:     "./effect/layer-node": "./src/effect/layer-node.ts",
20:     "./effect/app-node": "./src/effect/app-node.ts",
21:     "./session/runner": "./src/session/runner/index.ts",
22:     "./system-context": "./src/system-context/index.ts",
23:     "./*": "./src/*.ts"
24:   },
25:   "imports": {
26:     "#sqlite": {
27:       "bun": ...

<path>/tmp/opencode/session-recovery-v21-review/package.json</path>
<type>file</type>
<content>
1: {
2:   "$schema": "https://json.schemastore.org/package.json",
3:   "name": "opencode",
4:   "description": "AI-powered development tool",
5:   "private": true,
6:   "type": "module",
7:   "packageManager": "bun@1.3.14",
8:   "scripts": {
9:     "dev": "bun run --cwd packages/opencode src/index.ts",
10:     "dev:desktop": "bun --cwd packages/desktop dev",
11:     "dev:web": "bun --cwd packages/app dev",
12:     "dev:console": "ulimit -n 10240 2>/dev/null; bun run --cwd packages/console/app dev",
13:     "dev:stats": "bun sst shell --stage=production -- bun run --cwd packages/stats/app dev",
14:     "dev:storybook": "bun --cwd packages/storybook storybook",
15:     "lint": "oxlint",
16:     "typecheck": "bun turbo typecheck",
17:     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
18:     "postinstall": "bun run --cwd packages/core fix-node-pty",
19:     "prepare": "husky",
20:    ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/execution/claim.ts</path>
<type>file</type>
<content>
1: export * as SessionExecutionClaim from "./claim"
2: 
3: import { and, eq, gt, notInArray } from "drizzle-orm"
4: import { Clock, Effect } from "effect"
5: import type { Database } from "../../database/database"
6: import type { SessionSchema } from "../schema"
7: import { SESSION_EXECUTION_LEASE_MS, SessionExecutionTable } from "../sql"
8: 
9: type DatabaseService = Database.Interface["db"]
10: 
11: export type Claim = {
12:   readonly sessionID: SessionSchema.ID
13:   readonly executionID: string
14:   readonly ownerID: string
15: }
16: 
17: export type Values = Partial<
18:   Pick<typeof SessionExecutionTable.$inferInsert, "assistant_message_id" | "assistant_seq" | "phase">
19: >
20: 
21: export class Lost extends Error {
22:   constructor(readonly claim: Claim) {
23:     super(`Session execution claim lost: ${claim.executionID}`)
24:   }
25: }
26: 
27: ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/recovery-id.ts</path>
<type>file</type>
<content>
1: import { SessionMessage } from "./message"
2: 
3: export const message = (executionID: string, assistantMessageID?: SessionMessage.ID) =>
4:   assistantMessageID ?? SessionMessage.ID.make(`msg_recovery_${executionID}`)
5: 
6: export const continuation = (executionID: string) => SessionMessage.ID.make(`msg_recovery_continue_${executionID}`)

(End of file - total 6 lines)
</content>

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/database/migration/20260914170650_session-recovery.ts</path>
<type>file</type>
<content>
1: import { Effect } from "effect"
2: import type { DatabaseMigration } from "../migration"
3: 
4: export default {
5:   id: "20260914170650_session-recovery",
6:   up(tx) {
7:     return Effect.gen(function* () {
8:       yield* tx.run(`ALTER TABLE \`session_input\` ADD \`wake_pending\` integer DEFAULT false NOT NULL;`)
9:       yield* tx.run(
10:         `ALTER TABLE \`session\` ADD \`wake_attempts\` integer DEFAULT 0 NOT NULL CONSTRAINT \`session_wake_attempts_check\` CHECK(\`wake_attempts\` >= 0 AND \`wake_attempts\` <= 9007199254740991);`,
11:       )
12:       yield* tx.run(`
13:         CREATE TABLE \`session_execution\` (
14:           \`id\` text NOT NULL,
15:           \`session_id\` text NOT NULL,
16:           \`owner_id\` text NOT NULL,
17:           \`assistant_message_id\` text,
18:            \`phase\` text NOT ...

diff --git a/packages/core/src/database/migration.gen.ts b/packages/core/src/database/migration.gen.ts
index e6ea4eaa14..77948f1529 100644
--- a/packages/core/src/database/migration.gen.ts
+++ b/packages/core/src/database/migration.gen.ts
@@ -1,44 +1,45 @@
 import type { DatabaseMigration } from "./migration"
 
 export const migrations = (
   await Promise.all([
     import("./migration/20260127222353_familiar_lady_ursula"),
     import("./migration/20260211171708_add_project_commands"),
     import("./migration/20260213144116_wakeful_the_professor"),
     import("./migration/20260225215848_workspace"),
     import("./migration/20260227213759_add_session_workspace_id"),
     import("./migration/20260228203230_blue_harpoon"),
     import("./migration/20260303231226_add_workspace_fields"),
     import("./migration/20260309230000_move_org_to_state"),
     import("./migration/20260312043431_session_message_cursor"),
     import("./migration/20260323234822_events"),
     ...

Found 100 matches (more matches available)
/tmp/opencode/session-recovery-v21-review/packages/core/schema.json:
  Line 4:   "id": "3bc49670-06d1-4eba-9a45-8c8128bdcf6f",

  Line 5:   "prevIds": [

  Line 6:     "f14a9b18-8207-487e-a3d3-227e629ba9ad"

  Line 99:       "name": "id",

  Line 159:       "name": "project_id",

  Line 199:       "name": "id",

  Line 209:       "name": "active_account_id",

  Line 219:       "name": "active_org_id",

  Line 229:       "name": "id",

  Line 389:       "name": "id",

  Line 399:       "name": "integration_id",

  Line 429:       "name": "connector_id",

  Line 439:       "name": "method_id",

  Line 479:       "name": "aggregate_id",

  Line 499:       "name": "owner_id",

  Line 509:       "name": "id",

  Line 519:       "name": "aggregate_id",

  Line 559:       "name": "id",

  Line 569:       "name": "project_id",

  Line 619:       "name": "project_id",

  Line 669:       "name": "id",

  Line 719:       "name": "icon_url_override",

  ...

/usr/bin/bash: line 1: python: command not found

base.id f14a9b18-8207-487e-a3d3-227e629ba9ad
current.prevIds ["f14a9b18-8207-487e-a3d3-227e629ba9ad"]
direct true

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/execution/local.ts</path>
<type>file</type>
<content>
1: import { and, asc, desc, eq, isNull } from "drizzle-orm"
2: import { Cause, Clock, DateTime, Deferred, Duration, Effect, Exit, Layer, Option, Schedule } from "effect"
3: import { Database } from "../../database/database"
4: import { LocationServiceMap } from "../../location-service-map"
5: import { makeGlobalNode } from "../../effect/app-node"
6: import { SessionRunCoordinator } from "../run-coordinator"
7: import { SessionRunner } from "../runner"
8: import { SessionMessage } from "../message"
9: import { SessionSchema } from "../schema"
10: import { SessionStore } from "../store"
11: import { SessionExecution } from "../execution"
12: import { EventV2 } from "../../event"
13: import { SessionEvent } from "../event"
14: import { SessionExecutionClaim } from "./claim"
15: import {
16:   SESSION_EXECUTION_LEASE_MS,
17:   SessionExecutionTable,
18:   ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/run-coordinator.ts</path>
<type>file</type>
<content>
1: export * as SessionRunCoordinator from "./run-coordinator"
2: 
3: import { Deferred, Effect, Exit, Fiber, FiberSet, Scope } from "effect"
4: 
5: /** Serializes execution for each key while allowing different keys to run concurrently. */
6: export interface Coordinator<Key, E> {
7:   /** Snapshots keys with an execution owned by this coordinator. */
8:   readonly active: Effect.Effect<ReadonlySet<Key>>
9:   /** Starts execution while idle or joins the active execution. */
10:   readonly run: (key: Key) => Effect.Effect<void, E>
11:   /** Registers one coalesced follow-up after newly recorded work. */
12:   readonly wake: (key: Key) => Effect.Effect<void>
13:   /** Stops active execution, runs cleanup, then starts work that arrived while stopping. */
14:   readonly interrupt: (key: Key, cleanup?: Effect.Effect<void>) => Effect.Effect<void>
15: }
16: 
17: ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/recovery.ts</path>
<type>file</type>
<content>
1: export * as SessionRecovery from "./recovery"
2: 
3: import { and, asc, desc, eq, exists, gt, isNull, lte, or, sql } from "drizzle-orm"
4: import { Clock, DateTime, Effect, Layer, Option, Schedule, Schema } from "effect"
5: import { Database } from "../database/database"
6: import { makeGlobalNode } from "../effect/app-node"
7: import { EventV2 } from "../event"
8: import { SessionEvent } from "./event"
9: import { SessionExecution } from "./execution"
10: import { SessionProjector } from "./projector"
11: import { SessionExecutionClaim } from "./execution/claim"
12: import { SessionInput } from "./input"
13: import { SessionMessage } from "./message"
14: import { continuation } from "./recovery-id"
15: import { SessionSchema } from "./schema"
16: import {
17:   MAX_WAKE_ATTEMPTS,
18:   SESSION_EXECUTION_LEASE_MS,
19:   SessionExecutionTable,
20:   ...

No files found

/tmp/opencode/session-recovery-v21-review/packages/core/src/event.ts
/tmp/opencode/session-recovery-v21-review/packages/core/src/session/event.ts

Found 34 matches
/tmp/opencode/session-recovery-v21-review/packages/core/src/event.ts:
  Line 122:   /** Local operational projection committed atomically with a new durable event. Not replayed or serialized. */

  Line 123:   readonly commit?: (seq: number) => Effect.Effect<void>

  Line 127:   readonly publish: <D extends Definition>(

  Line 140:     options?: { readonly publish?: boolean; readonly ownerID?: string; readonly strictOwner?: boolean },

  Line 144:     options?: { readonly publish?: boolean; readonly ownerID?: string; readonly strictOwner?: boolean },

  Line 205:       function commitDurableEvent(

  Line 214:         commit?: (seq: number) => Effect.Effect<void>,

  Line 239:                   const committed = yield* db

  Line 316:                           const committed = {

  Line 321:                             yield* projector(committed)

  Line 323:                           if (commit) yield* commit(seq)

  Line 354:                   if (committed) {

  ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/event.ts</path>
<type>file</type>
<content>
110: export class SubscriberOverflowError extends Schema.TaggedErrorClass<SubscriberOverflowError>()(
111:   "EventV2.SubscriberOverflow",
112:   { capacity: Schema.Int },
113: ) {}
114: 
115: export const define = Event.define
116: export const versionedType = Event.versionedType
117: 
118: export interface PublishOptions {
119:   readonly id?: ID
120:   readonly metadata?: Record<string, unknown>
121:   readonly location?: Location.Ref
122:   /** Local operational projection committed atomically with a new durable event. Not replayed or serialized. */
123:   readonly commit?: (seq: number) => Effect.Effect<void>
124: }
125: 
126: export interface Interface {
127:   readonly publish: <D extends Definition>(
128:     definition: D,
129:     data: Data<D>,
130:     options?: PublishOptions,
131:   ) => Effect.Effect<Payload<D>>
132:   readonly subscribe: <D extends ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/input.ts</path>
<type>file</type>
<content>
1: export * as SessionInput from "./input"
2: 
3: import { and, asc, desc, eq, isNull, lte } from "drizzle-orm"
4: import { DateTime, Effect, Option, Schema } from "effect"
5: import { Admitted, Delivery } from "@opencode-ai/schema/session-input"
6: import type { Database } from "../database/database"
7: import { EventV2 } from "../event"
8: import { SessionEvent } from "./event"
9: import { SessionMessage } from "./message"
10: import { Prompt } from "./prompt"
11: import { continuation, message } from "./recovery-id"
12: import { SessionSchema } from "./schema"
13: import { SessionInputTable, SessionMessageTable, SessionRecoveryTable, SessionTable } from "./sql"
14: 
15: type DatabaseService = Database.Interface["db"]
16: 
17: export { Admitted, Delivery }
18: 
19: const decodePrompt = Schema.decodeUnknownSync(Prompt)
20: const encodePrompt = ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/input.ts</path>
<type>file</type>
<content>
621:             commit(row).pipe(
622:               Effect.andThen(
623:                 db
624:                   .update(SessionRecoveryTable)
625:                   .set({ recovery_error: defect.reason })
626:                   .where(
627:                     and(
628:                       eq(SessionRecoveryTable.execution_id, defect.executionID),
629:                       eq(SessionRecoveryTable.wake_pending, true),
630:                       isNull(SessionRecoveryTable.recovery_error),
631:                     ),
632:                   )
633:                   .returning({ executionID: SessionRecoveryTable.execution_id })
634:                   .get()
635:                   .pipe(Effect.orDie),
636:               ),
637:             ),
638:           { behavior: "immediate" },
639:         )
640:         .pipe(
641:           Effect.orDie,
642:           ...

...output truncated...

Full output saved to: /home/byk/.local/share/opencode/tool-output/tool_0ae9f5a3a001gdGU5fZJ1n1seQ

-    const baselineSeq = yield* insert(db, sessionID, generation)
+    const baselineSeq = yield* insert(db, sessionID, generation, claim)
     return { baseline: generation.baseline, baselineSeq }
   }
 
   const snapshot = yield* Schema.decodeUnknownEffect(SystemContext.Snapshot)(stored.snapshot).pipe(
     Effect.mapError((error) => new ContextSnapshotDecodeError({ sessionID, details: String(error) })),
   )
   const replacementSeq = compaction !== undefined && compaction.seq > stored.baseline_seq ? compaction.seq : undefined
   const result = replacementSeq
     ? yield* SystemContext.replace(value, snapshot)
     : yield* SystemContext.reconcile(value, snapshot)
   if (result._tag === "Unchanged" || result._tag === "ReplacementBlocked") {
     return { baseline: stored.baseline, baselineSeq: stored.baseline_seq }
   }
   if (result._tag === ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/message-updater.ts</path>
<type>file</type>
<content>
180:               produce(currentShell, (draft) => {
181:                 draft.output = event.data.output
182:                 draft.time.completed = event.data.timestamp
183:               }),
184:             )
185:           }
186:         })
187:       },
188:       "session.next.step.started": (event) => {
189:         return Effect.gen(function* () {
190:           const currentAssistant = yield* adapter.getCurrentAssistant()
191:           if (currentAssistant) {
192:             yield* adapter.updateAssistant(
193:               produce(currentAssistant, (draft) => {
194:                 draft.time.completed = event.data.timestamp
195:               }),
196:             )
197:           }
198:           yield* adapter.appendMessage(
199:             SessionMessage.Assistant.make({
200:               id: event.data.assistantMessageID,
201:            ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/runner/index.ts</path>
<type>file</type>
<content>
1: export * as SessionRunner from "./index"
2: 
3: import type { LLMError } from "@opencode-ai/llm"
4: import { Context, Effect } from "effect"
5: import { SessionSchema } from "../schema"
6: import type { SessionMessage } from "../message"
7: import type { ContextSnapshotDecodeError, MessageDecodeError } from "../error"
8: import { SessionRunnerModel } from "./model"
9: import type { SystemContext } from "../../system-context/index"
10: import type { ToolOutputStore } from "../../tool-output-store"
11: 
12: export type RunError =
13:   | LLMError
14:   | SessionRunnerModel.Error
15:   | MessageDecodeError
16:   | ContextSnapshotDecodeError
17:   | SystemContext.InitializationBlocked
18:   | ToolOutputStore.Error
19: 
20: /** Runs one local continuation from already-recorded Session history. ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/runner/llm.ts</path>
<type>file</type>
<content>
1: import {
2:   LLM,
3:   LLMClient,
4:   LLMError,
5:   LLMEvent,
6:   Message,
7:   SystemPart,
8:   isContextOverflowFailure,
9:   type ProviderErrorEvent,
10: } from "@opencode-ai/llm"
11: import { Cause, DateTime, Effect, Exit, Fiber, Layer, Option, Semaphore, Stream } from "effect"
12: import { and, eq } from "drizzle-orm"
13: import { AgentV2 } from "../../agent"
14: import { Config } from "../../config"
15: import { Database } from "../../database/database"
16: import { EventV2 } from "../../event"
17: import { Location } from "../../location"
18: import { ModelV2 } from "../../model"
19: import { PermissionV2 } from "../../permission"
20: import { ProviderV2 } from "../../provider"
21: import { QuestionV2 } from "../../question"
22: import { SystemContext } from "../../system-context/index"
23: import { SystemContextRegistry } from ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/runner/publish-llm-event.ts</path>
<type>file</type>
<content>
1: import { ToolOutput, type LLMEvent, type ProviderMetadata, type ToolResultValue, type Usage } from "@opencode-ai/llm"
2: import { DateTime, Effect } from "effect"
3: import { EventV2 } from "../../event"
4: import { ModelV2 } from "../../model"
5: import { SessionEvent } from "../event"
6: import { SessionMessage } from "../message"
7: import { SessionSchema } from "../schema"
8: 
9: type Input = {
10:   readonly sessionID: SessionSchema.ID
11:   readonly agent: string
12:   readonly model: ModelV2.Ref
13:   readonly snapshot?: string
14:   readonly startCommit: (assistantMessageID: SessionMessage.ID, seq: number) => Effect.Effect<void>
15:   readonly eventCommit: () => Effect.Effect<void>
16: }
17: 
18: const safe = (value: number | undefined) => Math.max(0, Number.isFinite(value) ? (value ?? ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/compaction.ts</path>
<type>file</type>
<content>
1: export * as SessionCompaction from "./compaction"
2: 
3: import { LLM, LLMError, LLMEvent, Message, type LLMRequest, type Model } from "@opencode-ai/llm"
4: import { DateTime, Effect, Stream } from "effect"
5: import type { Config } from "../config"
6: import type { EventV2 } from "../event"
7: import { SessionEvent } from "./event"
8: import { SessionMessage } from "./message"
9: import { SessionSchema } from "./schema"
10: import { Token } from "../util/token"
11: 
12: const DEFAULT_BUFFER = 20_000
13: const DEFAULT_KEEP_TOKENS = 8_000
14: const TOOL_OUTPUT_MAX_CHARS = 2_000
15: const SUMMARY_OUTPUT_TOKENS = 4_096
16: const SUMMARY_TEMPLATE = `Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response. ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/context-epoch.ts</path>
<type>file</type>
<content>
1: export * as SessionContextEpoch from "./context-epoch"
2: 
3: import { eq } from "drizzle-orm"
4: import { DateTime, Effect, Schema } from "effect"
5: import type { Database } from "../database/database"
6: import { EventV2 } from "../event"
7: import { SystemContext } from "../system-context/index"
8: import { ContextSnapshotDecodeError } from "./error"
9: import { SessionEvent } from "./event"
10: import { SessionHistory } from "./history"
11: import { SessionInput } from "./input"
12: import { SessionMessage } from "./message"
13: import { SessionSchema } from "./schema"
14: import { SessionContextEpochTable } from "./sql"
15: import { SessionExecutionClaim } from "./execution/claim"
16: 
17: type DatabaseService = Database.Interface["db"]
18: 
19: interface Prepared {
20:   readonly baseline: string
21:   readonly baselineSeq: number
22: }
23: 
24: ...

No files found

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/event.ts</path>
<type>file</type>
<content>
1: export * from "@opencode-ai/schema/session-event"
2: export * as SessionEvent from "@opencode-ai/schema/session-event"

(End of file - total 2 lines)
</content>

<path>/tmp/opencode/session-recovery-v21-review/packages/schema/src/session-event.ts</path>
<type>file</type>
<content>
500:   Text.Started,
501:   Text.Ended,
502:   Tool.Input.Started,
503:   Tool.Input.Ended,
504:   Tool.Called,
505:   Tool.Progress,
506:   Tool.Success,
507:   Tool.Failed,
508:   Reasoning.Started,
509:   Reasoning.Ended,
510:   Retried,
511:   Compaction.Started,
512:   Compaction.Ended,
513:   RevertEvent.Staged,
514:   RevertEvent.Cleared,
515:   RevertEvent.Committed,
516: )
517: 
518: export const Definitions = Event.inventory(
519:   AgentSwitched,
520:   ModelSwitched,
521:   Moved,
522:   Prompted,
523:   PromptAdmitted,
524:   PromptExecutionRequested,
525:   ContextUpdated,
526:   Synthetic,
527:   Shell.Started,
528:   Shell.Ended,
529:   Step.Started,
530:   Step.Ended,
531:   Step.Failed,
532:   Step.Interrupted,
533:   Step.Recovered,
534:   Text.Started,
535:   Text.Delta,
536:   Text.Ended,
537:   Reasoning.Started,
538:   Reasoning.Delta,
539:   ...

<path>/tmp/opencode/session-recovery-v21-review/packages/schema/src/session-event.ts</path>
<type>file</type>
<content>
450:       messageID: SessionMessage.ID,
451:       text: Schema.String,
452:     },
453:   })
454:   export type Delta = typeof Delta.Type
455: 
456:   export const Ended = Event.define({
457:     type: "session.next.compaction.ended",
458:     ...options,
459:     schema: {
460:       ...Base,
461:       messageID: SessionMessage.ID,
462:       reason: Started.data.fields.reason,
463:       text: Schema.String,
464:       recent: Schema.String,
465:     },
466:   })
467:   export type Ended = typeof Ended.Type
468: }
469: 
470: export namespace RevertEvent {
471:   export const Staged = Event.define({
472:     type: "session.next.revert.staged",
473:     ...options,
474:     schema: { ...Base, revert: Revert.State },
475:   })
476:   export const Cleared = Event.define({ type: "session.next.revert.cleared", ...options, schema: Base })
477:   export const Committed ...

diff --git a/packages/opencode/src/server/routes/instance/httpapi/server.ts b/packages/opencode/src/server/routes/instance/httpapi/server.ts
index fb9d2db656..748e8aa43b 100644
--- a/packages/opencode/src/server/routes/instance/httpapi/server.ts
+++ b/packages/opencode/src/server/routes/instance/httpapi/server.ts
@@ -1,168 +1,169 @@
 import { Config as EffectConfig, Context, Effect, Layer } from "effect"
 import { HttpApiBuilder, OpenApi } from "effect/unstable/httpapi"
 import { HttpClient, HttpMiddleware, HttpRouter, HttpServer, HttpServerResponse } from "effect/unstable/http"
 import * as Socket from "effect/unstable/socket/Socket"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import * as Observability from "@opencode-ai/core/observability"
 import { Account } from "@/account/account"
 import { Agent } from "@/agent/agent"
 import { Auth } from "@/auth"
 import { BackgroundJob } from "@/background/job"
 import { Command } from "@/command"
 import { Config } from ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/test/session-execution-local.test.ts</path>
<type>file</type>
<content>
1: import { describe, expect } from "bun:test"
2: import { Deferred, Effect, Exit, Fiber, Scope } from "effect"
3: import { TestClock } from "effect/testing"
4: import { eq, sql } from "drizzle-orm"
5: import { Database } from "@opencode-ai/core/database/database"
6: import { Project } from "@opencode-ai/core/project"
7: import { ProjectTable } from "@opencode-ai/core/project/sql"
8: import { AbsolutePath } from "@opencode-ai/core/schema"
9: import { SessionExecutionLocal } from "@opencode-ai/core/session/execution/local"
10: import { SessionExecutionClaim } from "@opencode-ai/core/session/execution/claim"
11: import { SessionMessage } from "@opencode-ai/core/session/message"
12: import { SessionSchema } from "@opencode-ai/core/session/schema"
13: import { SessionExecutionTable, SessionTable } from "@opencode-ai/core/session/sql"
14: import { testEffect ...

diff --git a/packages/core/test/session-run-coordinator.test.ts b/packages/core/test/session-run-coordinator.test.ts
index dfbeda664c..fd19ee776c 100644
--- a/packages/core/test/session-run-coordinator.test.ts
+++ b/packages/core/test/session-run-coordinator.test.ts
@@ -205,196 +205,298 @@ describe("SessionRunCoordinator", () => {
       }),
     ),
   )
 
   it.effect("does nothing when interrupted while idle", () =>
     Effect.scoped(
       Effect.gen(function* () {
         const coordinator = yield* SessionRunCoordinator.make({ drain: () => Effect.void })
         yield* coordinator.interrupt("session")
       }),
     ),
   )
 
   it.effect("interrupts active execution and clears its pending wake", () =>
     Effect.scoped(
       Effect.gen(function* () {
         const started = yield* Deferred.make<void>()
         const interrupted = yield* Deferred.make<void>()
         let runs = 0
         const coordinator = yield* SessionRunCoordinator.make({
           drain: () =>
   ...

Found 100 matches (more matches available)
/tmp/opencode/session-recovery-v21-review/packages/core/test/session-runner.test.ts:
  Line 26: import { Snapshot } from "@opencode-ai/core/snapshot"

  Line 35: import { SessionRecovery } from "@opencode-ai/core/session/recovery"

  Line 39: import { ToolRegistry } from "@opencode-ai/core/tool/registry"

  Line 40: import { ApplicationTools } from "@opencode-ai/core/tool/application-tools"

  Line 44: import { Tool } from "@opencode-ai/core/tool/tool"

  Line 73: let toolExecutionGate: Deferred.Deferred<void> | undefined

  Line 74: let toolExecutionsStarted: Deferred.Deferred<void> | undefined

  Line 76: let toolExecutionsReady = 5

  Line 100:     }) as unknown as LLMClientShape["stream"],

  Line 111: const recoveryModel = Model.make({

  Line 112:   id: "recovery",

  Line 143:             if (activeToolExecutions === toolExecutionsReady && toolExecutionsStarted) {

  Line 144:               yield* ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/test/session-runner.test.ts</path>
<type>file</type>
<content>
380:   yield* setup
381:   const session = yield* SessionV2.Service
382:   response = fragmentFixture("text", "text-earlier", ["Earlier answer"]).completeEvents
383:   yield* session.prompt({
384:     sessionID,
385:     prompt: Prompt.make({ text: "Earlier question ".repeat(700) }),
386:     resume: false,
387:   })
388:   yield* session.resume(sessionID)
389:   currentModel = recoveryModel
390:   requests.length = 0
391:   return session
392: })
393: 
394: const messageTexts = (request: LLMRequest, role: "user" | "system") =>
395:   request.messages.flatMap((message) =>
396:     message.role === role ? message.content.flatMap((content) => (content.type === "text" ? [content.text] : [])) : [],
397:   )
398: const userTexts = (request: LLMRequest) => messageTexts(request, "user")
399: const systemTexts = (request: LLMRequest) => messageTexts(request, ...

Found 42 matches
/tmp/opencode/session-recovery-v21-review/packages/core/test/session-runner.test.ts:
  Line 619:   it.effect("redrives only the synthetic recovery continuation", () =>

  Line 715:   it.effect("redrives an ordinary prompt after its advisory wake is lost", () =>

  Line 752:   it.effect("never dispatches a provider after ownership changes", () =>

  Line 778:   it.effect("never publishes streamed output after ownership changes", () =>

  Line 805:   it.effect("never starts a local tool after ownership changes", () =>

  Line 845:   it.effect("never fails interrupted tools after ownership changes", () =>

  Line 1060:   it.effect("fails gracefully when a stored context snapshot cannot be decoded", () =>

  Line 1495:   it.effect("keeps automatic compaction unknown until Compaction.Ended commits", () =>

  Line 1542:   it.effect("recovers the continuation committed with Compaction.Ended", () =>

  Line 1686:   it.effect("persists a second context overflow after one ...

Found 38 matches
/tmp/opencode/session-recovery-v21-review/packages/core/test/session-projector.test.ts:
  Line 68:   it.effect("atomically reconciles one abandoned execution into one continuation", () =>

  Line 222:   it.effect("never continues a Step that durably failed before owner loss", () =>

  Line 325:   it.effect("records a recovery continuation without forging an assistant identity", () =>

  Line 361:   it.effect("recovers each abandoned execution once across repeated startup scans", () =>

  Line 407:   it.effect("never recovers a live execution lease", () =>

  Line 445:   it.effect("never recovers an execution superseded by a newer assistant", () =>

  Line 607:   it.effect("recovers assistant-less continuation at its current assistant boundary", () =>

  Line 658:   it.effect("redrives a durable recovery wake after admission", () =>

  Line 709:   it.effect("quarantines a malformed recovery row without blocking a valid wake", () =>

  Line 763:   it.effect("quarantines ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
1: import { describe, expect } from "bun:test"
2: import { DateTime, Deferred, Effect, Exit, Fiber, Schema } from "effect"
3: import { TestClock } from "effect/testing"
4: import { asc, eq, sql } from "drizzle-orm"
5: import { Database } from "@opencode-ai/core/database/database"
6: import { LayerNode } from "@opencode-ai/core/effect/layer-node"
7: import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
8: import { EventV2 } from "@opencode-ai/core/event"
9: import { EventTable } from "@opencode-ai/core/event/sql"
10: import { ModelV2 } from "@opencode-ai/core/model"
11: import { Project } from "@opencode-ai/core/project"
12: import { ProjectTable } from "@opencode-ai/core/project/sql"
13: import { ProviderV2 } from "@opencode-ai/core/provider"
14: import { AbsolutePath } from "@opencode-ai/core/schema"
15: import { SessionV2 } from ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
430:           owner_id: "live",
431:           phase: "unknown",
432:           time_created: Date.now(),
433:           expires_at: Date.now() + 60_000,
434:         })
435:         .run()
436: 
437:       yield* SessionRecovery.recover().pipe(Effect.provideService(SessionExecution.Service, recoveryExecution))
438: 
439:       expect(yield* db.select().from(SessionExecutionTable).all()).toHaveLength(1)
440:       expect(yield* db.select().from(SessionRecoveryTable).all()).toEqual([])
441:       expect(yield* db.select().from(SessionInputTable).all()).toEqual([])
442:     }),
443:   )
444: 
445:   it.effect("never recovers an execution superseded by a newer assistant", () =>
446:     Effect.gen(function* () {
447:       const { db } = yield* Database.Service
448:       const abandonedID = SessionMessage.ID.make("msg_recovery_abandoned")
449:       yield* ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
949:       const restartedWakes: string[] = []
950:       const restartedExecution = SessionExecution.Service.of({
951:         ...recoveryExecution,
952:         wake: (id) => Effect.sync(() => restartedWakes.push(id)).pipe(Effect.asVoid),
953:       })
954:       yield* SessionRecovery.recover().pipe(Effect.provideService(SessionExecution.Service, restartedExecution))
955: 
956:       expect(restartedWakes).toContain(recoverySessions[0])
957:       expect(restartedWakes).toContain(ordinarySessions[0])
958:       expect(restartedWakes).toContain(recoverySessions[failedCount])
959:       expect(restartedWakes).toContain(ordinarySessions[failedCount])
960:     }),
961:     15_000,
962:   )
963: 
964:   it.effect("resets ordinary wake retry debt after fresh prompt promotion", () =>
965:     Effect.gen(function* () {
966:       const { db } = yield* ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
1469:     }),
1470:   )
1471: 
1472:   it.effect("never recovers a pre-promotion claim when input commits at the recovery boundary", () =>
1473:     Effect.gen(function* () {
1474:       const { db } = yield* Database.Service
1475:       const events = yield* EventV2.Service
1476:       yield* db
1477:         .insert(ProjectTable)
1478:         .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
1479:         .run()
1480:       yield* db
1481:         .insert(SessionTable)
1482:         .values({
1483:           id: sessionID,
1484:           project_id: Project.ID.global,
1485:           slug: "test",
1486:           directory: "/project",
1487:           title: "test",
1488:           version: "test",
1489:         })
1490:         .run()
1491:       yield* db
1492:         .insert(SessionExecutionTable)
1493:         ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
2449:       )
2450: 
2451:       expect(yield* db.select().from(SessionExecutionTable).get()).toMatchObject({
2452:         owner_id: "successor-owner",
2453:         recovery_error: null,
2454:       })
2455:     }),
2456:   )
2457: 
2458:   it.effect("quarantines failed execution conversion before scanning later claims", () =>
2459:     Effect.gen(function* () {
2460:       const { db } = yield* Database.Service
2461:       const events = yield* EventV2.Service
2462:       const count = SessionRecovery.BATCH_SIZE + 1
2463:       const ids = Array.from({ length: count }, (_, index) =>
2464:         SessionV2.ID.make(`ses_recovery_conversion_${index.toString().padStart(3, "0")}`),
2465:       )
2466:       yield* db
2467:         .insert(ProjectTable)
2468:         .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] ...

Found 100 matches (more matches available)
/tmp/opencode/session-recovery-v21-review/packages/core/test/event.test.ts:
  Line 461:       const continueRead = yield* Deferred.make<void>()

  Line 466:             ? Deferred.succeed(readStarted, undefined).pipe(Effect.andThen(Deferred.await(continueRead)))

  Line 478:         yield* Deferred.succeed(continueRead, undefined)

  Line 992:         data: durableData(aggregateID, "original"),


/tmp/opencode/session-recovery-v21-review/packages/core/test/config/plugin.test.ts:
  Line 107:   it.live("ignores invalid plugins and continues loading", () =>


/tmp/opencode/session-recovery-v21-review/packages/core/test/instruction-context.test.ts:
  Line 84:           expect(yield* SystemContext.reconcile(yield* load, initialized.snapshot)).toMatchObject({

  Line 90:           const partial = yield* SystemContext.reconcile(yield* load, initialized.snapshot)

  Line 102:           expect(yield* SystemContext.reconcile(yield* load, ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/test/session-runner.test.ts</path>
<type>file</type>
<content>
1470:       requests.length = 0
1471:       executions.length = 0
1472:       responses = [
1473:         fragmentFixture("text", "text-summary-2", ["## Objective\n- Preserve the updated task"]).completeEvents,
1474:         fragmentFixture("text", "text-final-2", ["Continued again"]).completeEvents,
1475:       ]
1476:       yield* session.prompt({
1477:         sessionID,
1478:         prompt: Prompt.make({ text: "Newest exact request ".repeat(180) }),
1479:         resume: false,
1480:       })
1481:       yield* session.resume(sessionID)
1482: 
1483:       expect(requests).toHaveLength(2)
1484:       expect(userTexts(requests[0])[0]).toContain(
1485:         "<prior-summary>\n## Objective\n- Preserve the task\n</prior-summary>",
1486:       )
1487:       expect(userTexts(requests[0])[0]).toContain("Recent exact request")
1488:       expect((yield* (yield* ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/test/session-runner.test.ts</path>
<type>file</type>
<content>
3760:       toolExecutionGate = yield* Deferred.make<void>()
3761:       responseStream = Stream.concat(
3762:         Stream.fromIterable([
3763:           LLMEvent.stepStart({ index: 0 }),
3764:           LLMEvent.toolCall({ id: "call-before-failure", name: "echo", input: { text: "settle" } }),
3765:         ]),
3766:         Stream.fail(failure),
3767:       )
3768: 
3769:       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
3770:       while (executions.length === 0) yield* Effect.yieldNow
3771:       yield* Effect.yieldNow
3772:       yield* Deferred.succeed(toolExecutionGate, undefined)
3773:       expect(yield* Fiber.join(run).pipe(Effect.flip)).toBe(failure)
3774:       toolExecutionGate = undefined
3775: 
3776:       expect(yield* session.context(sessionID)).toMatchObject([
3777:         { type: "user", text: "Settle before failing" ...

diff --git a/packages/core/test/session-prompt.test.ts b/packages/core/test/session-prompt.test.ts
index c6bc9430b3..a0d6f26467 100644
--- a/packages/core/test/session-prompt.test.ts
+++ b/packages/core/test/session-prompt.test.ts
@@ -1,160 +1,198 @@
 import { describe, expect } from "bun:test"
 import { DateTime, Effect, Fiber, Layer, Stream } from "effect"
-import { eq } from "drizzle-orm"
+import { asc, eq } from "drizzle-orm"
 import { Database } from "@opencode-ai/core/database/database"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { EventV2 } from "@opencode-ai/core/event"
 import { EventTable } from "@opencode-ai/core/event/sql"
 import { SessionEvent } from "@opencode-ai/core/session/event"
 import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { ...

diff --git a/packages/core/test/database-migration.test.ts b/packages/core/test/database-migration.test.ts
index 464ce2695a..9814b75a11 100644
--- a/packages/core/test/database-migration.test.ts
+++ b/packages/core/test/database-migration.test.ts
@@ -1,264 +1,329 @@
 import { describe, expect, test } from "bun:test"
 import { $ } from "bun"
 import { fileURLToPath } from "url"
 import path from "path"
 import { SqliteClient } from "@effect/sql-sqlite-bun"
 import { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
-import { Effect, Layer } from "effect"
+import { Effect, Exit, Layer } from "effect"
 import { eq, inArray, sql } from "drizzle-orm"
 import { DatabaseMigration } from "@opencode-ai/core/database/migration"
 import { migrations } from "@opencode-ai/core/database/migration.gen"
 import workspaceNameMigration from "@opencode-ai/core/database/migration/20260410174513_workspace-name"
 import sessionUsageMigration from ...

diff --git a/packages/client/src/generated/types.ts b/packages/client/src/generated/types.ts
index 3b3188c874..5130fa9496 100644
--- a/packages/client/src/generated/types.ts
+++ b/packages/client/src/generated/types.ts
@@ -748,62 +748,71 @@ export type SessionsHistoryOutput = {
             }>
           }
           readonly delivery: "steer" | "queue"
         }
       }
     | {
         readonly id: string
         readonly metadata?: { readonly [x: string]: JsonValue }
         readonly type: "session.next.prompt.admitted"
         readonly durable?: { readonly aggregateID: string; readonly seq: number; readonly version: number }
         readonly location?: { readonly directory: string; readonly workspaceID?: string }
         readonly data: {
           readonly timestamp: number
           readonly sessionID: string
           readonly messageID: string
           readonly prompt: {
             readonly text: string
             readonly files?: ReadonlyArray<{
               ...

Found 30 matches
/tmp/opencode/session-recovery-v21-review/packages/sdk/openapi.json:
  Line 15336:             "$ref": "#/components/schemas/EventSessionNextStepInterrupted"

  Line 15339:             "$ref": "#/components/schemas/EventSessionNextStepRecovered"

  Line 17899:                       "requestExecution": {

  Line 17919:                     "enum": ["session.next.prompt.execution_requested"]

  Line 18253:                     "enum": ["session.next.step.interrupted"]

  Line 18289:                     "enum": ["session.next.step.recovered"]

  Line 20604:                 "$ref": "#/components/schemas/SyncEventSessionNextStepInterrupted"

  Line 20607:                 "$ref": "#/components/schemas/SyncEventSessionNextStepRecovered"

  Line 23838:             "$ref": "#/components/schemas/SessionNextStepInterrupted"

  Line 23841:             "$ref": "#/components/schemas/SessionNextStepRecovered"

  Line 24227:             "$ref": ...

No files found

diff --git a/packages/schema/test/event-manifest.test.ts b/packages/schema/test/event-manifest.test.ts
index 5694afdd30..0861792411 100644
--- a/packages/schema/test/event-manifest.test.ts
+++ b/packages/schema/test/event-manifest.test.ts
@@ -1,53 +1,56 @@
 import { describe, expect, test } from "bun:test"
 import { FileSystem, Integration, Permission, Project, Reference, Session, Workspace } from "../src"
 import { EventManifest } from "../src/event-manifest"
 import { IdeEvent } from "../src/ide-event"
 import { SessionEvent } from "../src/session-event"
 import { SessionTodo } from "../src/session-todo"
 import { SessionV1 } from "../src/session-v1"
 import { WorkspaceEvent } from "../src/workspace-event"
 
 describe("public event manifest", () => {
   test("owns the complete public event surface", () => {
-    expect(EventManifest.ServerDefinitions.length).toBe(55)
-    expect(EventManifest.Definitions.length).toBe(85)
+    expect(EventManifest.ServerDefinitions.length).toBe(61)
+ ...

diff --git a/packages/core/test/session-runner-recorded.test.ts b/packages/core/test/session-runner-recorded.test.ts
index d45cc8c734..ec91d1b4a4 100644
--- a/packages/core/test/session-runner-recorded.test.ts
+++ b/packages/core/test/session-runner-recorded.test.ts
@@ -1,193 +1,188 @@
 import { HttpRecorder } from "@opencode-ai/http-recorder"
 import { HttpRecorderInternal } from "@opencode-ai/http-recorder/internal"
 import * as OpenAIChat from "@opencode-ai/llm/protocols/openai-chat"
 import { Auth, LLMClient, RequestExecutor } from "@opencode-ai/llm/route"
 import { Database } from "@opencode-ai/core/database/database"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { EventV2 } from "@opencode-ai/core/event"
 import { EventTable } from "@opencode-ai/core/event/sql"
 import { PermissionV2 } from ...

packages/core/test/session-runner.test.ts
+  it.effect("redrives only the synthetic recovery continuation", () =>
+  it.effect("clears durable execution intent when ordinary input is promoted", () =>
+  it.effect("redrives an ordinary prompt after its advisory wake is lost", () =>
+  it.effect("never dispatches a provider after ownership changes", () =>
+  it.effect("never publishes streamed output after ownership changes", () =>
+  it.effect("never starts a local tool after ownership changes", () =>
+  it.effect("never fails interrupted tools after ownership changes", () =>
+  it.effect("keeps automatic compaction unknown until Compaction.Ended commits", () =>
+  it.effect("recovers the continuation committed with Compaction.Ended", () =>
+  it.effect("continues with reloaded history after durably settling one local tool call", () =>
+  it.effect("never commits continuation before unresolved hosted tools are reconciled", () =>
+  it.effect("never commits a Step end after the ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/schema.json</path>
<type>file</type>
<content>
900:       "entityType": "columns",
901:       "table": "session_context_epoch"
902:     },
903:     {
904:       "type": "text",
905:       "notNull": true,
906:       "autoincrement": false,
907:       "default": null,
908:       "generated": null,
909:       "name": "baseline",
910:       "entityType": "columns",
911:       "table": "session_context_epoch"
912:     },
913:     {
914:       "type": "text",
915:       "notNull": true,
916:       "autoincrement": false,
917:       "default": null,
918:       "generated": null,
919:       "name": "snapshot",
920:       "entityType": "columns",
921:       "table": "session_context_epoch"
922:     },
923:     {
924:       "type": "integer",
925:       "notNull": true,
926:       "autoincrement": false,
927:       "default": null,
928:       "generated": null,
929:       "name": "baseline_seq",
930:       "entityType": ...

<path>/tmp/opencode/session-recovery-v21-review/packages/core/src/session/projector.ts</path>
<type>file</type>
<content>
100:   sessionID: (typeof SessionV1.Event.MessageUpdated.Type)["data"]["sessionID"],
101:   value: Usage,
102:   sign = 1,
103: ) {
104:   return db
105:     .update(SessionTable)
106:     .set({
107:       cost: sql`${SessionTable.cost} + ${value.cost * sign}`,
108:       tokens_input: sql`${SessionTable.tokens_input} + ${value.tokens.input * sign}`,
109:       tokens_output: sql`${SessionTable.tokens_output} + ${value.tokens.output * sign}`,
110:       tokens_reasoning: sql`${SessionTable.tokens_reasoning} + ${value.tokens.reasoning * sign}`,
111:       tokens_cache_read: sql`${SessionTable.tokens_cache_read} + ${value.tokens.cache.read * sign}`,
112:       tokens_cache_write: sql`${SessionTable.tokens_cache_write} + ${value.tokens.cache.write * sign}`,
113:       time_updated: sql`${SessionTable.time_updated}`,
114:     })
115:     .where(eq(SessionTable.id, ...

diff --git a/packages/core/src/session/run-coordinator.ts b/packages/core/src/session/run-coordinator.ts
index 2f89aff9e3..81d875d894 100644
--- a/packages/core/src/session/run-coordinator.ts
+++ b/packages/core/src/session/run-coordinator.ts
@@ -1,104 +1,134 @@
 export * as SessionRunCoordinator from "./run-coordinator"
 
 import { Deferred, Effect, Exit, Fiber, FiberSet, Scope } from "effect"
 
 /** Serializes execution for each key while allowing different keys to run concurrently. */
 export interface Coordinator<Key, E> {
   /** Snapshots keys with an execution owned by this coordinator. */
   readonly active: Effect.Effect<ReadonlySet<Key>>
   /** Starts execution while idle or joins the active execution. */
   readonly run: (key: Key) => Effect.Effect<void, E>
   /** Registers one coalesced follow-up after newly recorded work. */
   readonly wake: (key: Key) => Effect.Effect<void>
-  /** Stops active execution and waits for its cleanup. ...

Found 9 matches
/tmp/opencode/session-recovery-v21-review/packages/core/schema.json:
  Line 2266:       "name": "session_execution_session_idx",

  Line 2280:       "name": "session_execution_owner_idx",

  Line 2306:       "name": "session_execution_recovery_scan_idx",

  Line 2390:       "name": "session_input_wake_pending_promoted_session_idx",

  Line 2480:       "name": "session_recovery_continuation_message_idx",

  Line 2510:       "name": "session_recovery_wake_pending_error_attempts_created_execution_idx",

  Line 2572:       "name": "session_execution_phase_check",

  Line 2578:       "name": "session_recovery_wake_attempts_check",

  Line 2584:       "name": "session_wake_attempts_check",

72	0	packages/client/src/generated/types.ts
566	47	packages/core/schema.json
1	0	packages/core/src/database/migration.gen.ts
52	1	packages/core/src/database/schema.gen.ts
6	4	packages/core/src/session.ts
31	16	packages/core/src/session/compaction.ts
54	34	packages/core/src/session/context-epoch.ts
213	19	packages/core/src/session/execution/local.ts
391	31	packages/core/src/session/input.ts
69	0	packages/core/src/session/message-updater.ts
88	1	packages/core/src/session/projector.ts
35	5	packages/core/src/session/run-coordinator.ts
4	0	packages/core/src/session/runner/index.ts
289	104	packages/core/src/session/runner/llm.ts
108	48	packages/core/src/session/runner/publish-llm-event.ts
88	1	packages/core/src/session/sql.ts
66	1	packages/core/test/database-migration.test.ts
2922	3	packages/core/test/session-projector.test.ts
247	25	packages/core/test/session-prompt.test.ts
102	0	packages/core/test/session-run-coordinator.test.ts
5	10	packages/core/test/session-runner-recorded.test.ts
46	7	...

Found 3 matches
/tmp/opencode/session-recovery-v21-review/github/tsconfig.json:
  Line 25:     "noUnusedLocals": false,

  Line 26:     "noUnusedParameters": false,


/tmp/opencode/session-recovery-v21-review/sdks/vscode/tsconfig.json:
  Line 14:     // "noUnusedParameters": true,  /* Report errors on unused parameters. */

Found 8 matches
/tmp/opencode/session-recovery-v21-review/packages/core/test/session-execution-local.test.ts:
  Line 240:       const firstDone = Deferred.makeUnsafe<void>()

  Line 241:       const secondDone = Deferred.makeUnsafe<void>()

  Line 286:       const firstDone = Deferred.makeUnsafe<void>()

  Line 287:       const secondDone = Deferred.makeUnsafe<void>()

  Line 301:         .pipe(Effect.ensuring(Deferred.succeed(firstDone, undefined)), Effect.forkChild)

  Line 305:         .pipe(Effect.ensuring(Deferred.succeed(secondDone, undefined)), Effect.forkChild)

  Line 308:       expect(yield* Deferred.isDone(firstDone)).toBe(false)

  Line 309:       expect(yield* Deferred.isDone(secondDone)).toBe(false)

<path>/tmp/opencode/session-recovery-v21-review/packages/core/tsconfig.json</path>
<type>file</type>
<content>
1: {
2:   "$schema": "https://json.schemastore.org/tsconfig",
3:   "extends": "@tsconfig/bun/tsconfig.json",
4:   "compilerOptions": {
5:     "noUncheckedIndexedAccess": false
6:   }
7: }

(End of file - total 7 lines)
</content>

inspected

ab9408c81cc9916177641ae8e9f08624fc27b5b9
ab9408c81cc9916177641ae8e9f08624fc27b5b9
2ae4eea72024cafe8b69c0461063ee25cbf54608856cd258866b7f3b86620b36  /tmp/opencode/session-recovery-final-v21.patch
10a3698a5e3b009f811a1b27eefab9e1083b560e24efee5f537f003d7edd7384  /home/byk/Code/opencode/packages/opencode/dist/server/opencode-server
patch_paths 34
status_paths 34
sets_equal true
base_schema_id f14a9b18-8207-487e-a3d3-227e629ba9ad
current_prevIds ["f14a9b18-8207-487e-a3d3-227e629ba9ad"]
direct_prev true
openapi_json valid
## HEAD (no branch)
 M packages/client/src/generated/types.ts
 M packages/core/schema.json
 M packages/core/src/database/migration.gen.ts
 M packages/core/src/database/schema.gen.ts
 M packages/core/src/session.ts
 M packages/core/src/session/compaction.ts
 M packages/core/src/session/context-epoch.ts
 M packages/core/src/session/execution/local.ts
 M packages/core/src/session/input.ts
 M packages/core/src/session/message-updater.ts
 M ...