Session 1VkeGpRWPqPO

[
  {
    "content": "Verify immutable inputs, repository guidance, scripts, hashes, exact base, and clean 33-file patch application",
    "status": "in_progress",
    "priority": "high"
  },
  {
    "content": "Inspect all changed files and trace recovery lifecycle, fencing, replay, migration, concurrency, and generated artifacts",
    "status": "pending",
    "priority": "high"
  },
  {
    "content": "Reassess seven prior blockers and secondary recovery paths with exact frozen file:line evidence",
    "status": "pending",
    "priority": "high"
  },
  {
    "content": "Produce severity-ordered independent verdict ending in required merge decision",
    "status": "pending",
    "priority": "high"
  }
]

49183f9e082f71a26d07ce8bf7dd2b391214908f3d07637a3c02163fe20826c7  /tmp/opencode/session-recovery-final-v5.patch
f08e78a61ef53f72a9810cc09facbe2d181c63f6a14231a95d66d16de44a80ed  /home/byk/Code/opencode/packages/opencode/dist/server/opencode-server

...output truncated...

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

packages/ui/src/assets/icons/provider/modelscope.svg
packages/ui/src/assets/icons/provider/moonshotai-cn.svg
packages/ui/src/assets/icons/provider/moonshotai.svg
packages/ui/src/assets/icons/provider/morph.svg
packages/ui/src/assets/icons/provider/nano-gpt.svg
packages/ui/src/assets/icons/provider/nebius.svg
packages/ui/src/assets/icons/provider/nova.svg
packages/ui/src/assets/icons/provider/novita-ai.svg
packages/ui/src/assets/icons/provider/nvidia.svg
packages/ui/src/assets/icons/provider/ollama-cloud.svg
packages/ui/src/assets/icons/provider/openai.svg
packages/ui/src/assets/icons/provider/opencode-go.svg
packages/ui/src/assets/icons/provider/opencode.svg
packages/ui/src/assets/icons/provider/openrouter.svg
packages/ui/src/assets/icons/provider/ovhcloud.svg
packages/ui/src/assets/icons/provider/perplexity-agent.svg
packages/ui/src/assets/icons/provider/perplexit...

commit
ab9408c81cc9916177641ae8e9f08624fc27b5b9

Found 59 matches
/home/byk/.local/share/opencode/tool-output/tool_0a9e97427001Y83Ynuq5kZeMn8:
  Line 90: AGENTS.md

  Line 92: CONTRIBUTING.md

  Line 126: artifacts/glm52-rise-video/package.json

  Line 147: github/package.json

  Line 167: package.json

  Line 169: packages/app/AGENTS.md

  Line 174: packages/app/e2e/AGENTS.md

  Line 175: packages/app/e2e/performance/AGENTS.md

  Line 293: packages/app/package.json

  Line 817: packages/cli/package.json

  Line 841: packages/client/package.json

  Line 861: packages/codemode/AGENTS.md

  Line 864: packages/codemode/package.json

  Line 905: packages/console/app/package.json

  Line 1386: packages/console/core/package.json

  Line 1446: packages/console/function/package.json

  Line 1467: packages/console/mail/package.json

  Line 1470: packages/console/resource/package.json

  Line 1475: packages/console/support/package.json

  Line 1498: packages/core/package.json

  Line 1765: packages/core/src/tool/AGENTS.md

  Line 1988: ...

drwxr-xr-x 6 byk byk 4096 Sep 16 11:09 /tmp/opencode

/tmp/opencode/session-recovery-v5-review.r03hHL

(no output)

(no output)

526	47	packages/core/schema.json
1	0	packages/core/src/database/migration.gen.ts
55	0	packages/core/src/database/migration/20260914170650_session-recovery.ts
45	0	packages/core/src/database/schema.gen.ts
5	4	packages/core/src/session.ts
31	16	packages/core/src/session/compaction.ts
54	34	packages/core/src/session/context-epoch.ts
66	0	packages/core/src/session/execution/claim.ts
124	19	packages/core/src/session/execution/local.ts
342	31	packages/core/src/session/input.ts
69	0	packages/core/src/session/message-updater.ts
77	1	packages/core/src/session/projector.ts
6	0	packages/core/src/session/recovery-id.ts
315	0	packages/core/src/session/recovery.ts
30	5	packages/core/src/session/run-coordinator.ts
4	0	packages/core/src/session/runner/index.ts
208	91	packages/core/src/session/runner/llm.ts
74	28	packages/core/src/session/runner/publish-llm-event.ts
70	1	packages/core/src/session/sql.ts
63	1	packages/core/test/database-migration.test.ts
243	0	packages/core/test/session-execution-local....

(no output)

(no output)

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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-v5-review.r03hHL/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-v5-review.r03hHL/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-v5-review.r03hHL/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. ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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-v5-review.r03hHL/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": ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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-v5-review.r03hHL/packages/schema/package.json</path>
<type>file</type>
<content>
1: {
2:   "$schema": "https://json.schemastore.org/package.json",
3:   "name": "@opencode-ai/schema",
4:   "private": true,
5:   "type": "module",
6:   "license": "MIT",
7:   "exports": {
8:     ".": "./src/index.ts",
9:     "./*": "./src/*.ts"
10:   },
11:   "scripts": {
12:     "typecheck": "tsgo --noEmit"
13:   },
14:   "dependencies": {
15:     "effect": "catalog:"
16:   },
17:   "devDependencies": {
18:     "@tsconfig/bun": "catalog:",
19:     "@types/bun": "catalog:",
20:     "@typescript/native-preview": "catalog:"
21:   }
22: }

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

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/server/package.json</path>
<type>file</type>
<content>
1: {
2:   "$schema": "https://json.schemastore.org/package.json",
3:   "name": "@opencode-ai/server",
4:   "version": "1.18.30",
5:   "private": true,
6:   "type": "module",
7:   "license": "MIT",
8:   "exports": {
9:     "./*": "./src/*.ts"
10:   },
11:   "scripts": {
12:     "typecheck": "tsgo --noEmit"
13:   },
14:   "dependencies": {
15:     "@opencode-ai/core": "workspace:*",
16:     "@opencode-ai/protocol": "workspace:*",
17:     "drizzle-orm": "catalog:",
18:     "effect": "catalog:"
19:   },
20:   "devDependencies": {
21:     "@tsconfig/bun": "catalog:",
22:     "@types/bun": "catalog:",
23:     "@typescript/native-preview": "catalog:"
24:   }
25: }

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

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/opencode/package.json</path>
<type>file</type>
<content>
1: {
2:   "$schema": "https://json.schemastore.org/package.json",
3:   "version": "1.18.30",
4:   "name": "opencode",
5:   "type": "module",
6:   "license": "MIT",
7:   "private": true,
8:   "scripts": {
9:     "typecheck": "tsgo --noEmit",
10:     "test": "bun test --timeout 30000 --only-failures",
11:     "test:httpapi": "bun run script/httpapi-exercise.ts --mode coverage --fail-on-missing --fail-on-skip && bun run script/httpapi-exercise.ts --mode auth --fail-on-missing --fail-on-skip && bun run script/httpapi-exercise.ts --mode effect --fail-on-missing --fail-on-skip",
12:     "bench:test": "bun run script/bench-test-suite.ts",
13:     "profile:test": "bun run script/profile-test-files.ts",
14:     "build": "bun run script/build.ts",
15:     "build:server": "node script/build-server.mjs",
16:     "dev": "bun run ./src/index.ts",
17:     "dev:temporary": "bun run ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/sdk/js/package.json</path>
<type>file</type>
<content>
1: {
2:   "$schema": "https://json.schemastore.org/package.json",
3:   "name": "@opencode-ai/sdk",
4:   "version": "1.18.30",
5:   "type": "module",
6:   "license": "MIT",
7:   "scripts": {
8:     "test": "bun test",
9:     "typecheck": "tsgo --noEmit",
10:     "build": "bun ./script/build.ts"
11:   },
12:   "exports": {
13:     ".": "./src/index.ts",
14:     "./client": "./src/client.ts",
15:     "./server": "./src/server.ts",
16:     "./v2": "./src/v2/index.ts",
17:     "./v2/client": "./src/v2/client.ts",
18:     "./v2/gen/client": "./src/v2/gen/client/index.ts",
19:     "./v2/server": "./src/v2/server.ts",
20:     "./v2/types": "./src/v2/gen/types.gen.ts"
21:   },
22:   "files": [
23:     "dist"
24:   ],
25:   "devDependencies": {
26:     "@hey-api/openapi-ts": "0.90.10",
27:     "@tsconfig/node22": "catalog:",
28:     "@types/cross-spawn": "catalog:",
29:     ...

[
  {
    "content": "Verify immutable inputs, repository guidance, scripts, hashes, exact base, and clean 33-file patch application",
    "status": "completed",
    "priority": "high"
  },
  {
    "content": "Inspect all changed files and trace recovery lifecycle, fencing, replay, migration, concurrency, and generated artifacts",
    "status": "in_progress",
    "priority": "high"
  },
  {
    "content": "Reassess seven prior blockers and secondary recovery paths with exact frozen file:line evidence",
    "status": "pending",
    "priority": "high"
  },
  {
    "content": "Produce severity-ordered independent verdict ending in required merge decision",
    "status": "pending",
    "priority": "high"
  }
]

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/session/execution/claim.ts</path>
<type>file</type>
<content>
1: export * as SessionExecutionClaim from "./claim"
2: 
3: import { and, eq, gt } 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<Pick<typeof SessionExecutionTable.$inferInsert, "assistant_message_id" | "phase">>
18: 
19: export class Lost extends Error {
20:   constructor(readonly claim: Claim) {
21:     super(`Session execution claim lost: ${claim.executionID}`)
22:   }
23: }
24: 
25: const where = (claim: Claim, now: ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/session/execution/local.ts</path>
<type>file</type>
<content>
1: import { and, asc, eq, isNull } from "drizzle-orm"
2: import { Cause, Clock, Duration, Effect, Exit, Layer, 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 { SessionExecutionClaim } from "./claim"
13: import { SESSION_EXECUTION_LEASE_MS, SessionExecutionTable, SessionRecoveryTable } from "../sql"
14: 
15: /** Current-process routing for implicit-local Locations. ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/session/recovery.ts</path>
<type>file</type>
<content>
1: export * as SessionRecovery from "./recovery"
2: 
3: import { and, asc, desc, eq, 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 { SessionSchema } from "./schema"
14: import {
15:   SESSION_EXECUTION_LEASE_MS,
16:   SessionExecutionTable,
17:   SessionInputTable,
18:   SessionRecoveryTable,
19:   SessionMessageTable,
20: } from "./sql"
21: 
22: export const BATCH_SIZE = 100
23: ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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: ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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 } from "./sql"
14: 
15: type DatabaseService = Database.Interface["db"]
16: 
17: export { Admitted, Delivery }
18: 
19: const decodePrompt = Schema.decodeUnknownSync(Prompt)
20: const encodePrompt = Schema.encodeSync(Prompt)
21: ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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, FiberSet, 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-v5-review.r03hHL/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) => Effect.Effect<void>
15:   readonly terminalCommit: (assistantMessageID: SessionMessage.ID) => Effect.Effect<void>
16:   readonly interruptedCommit: (assistantMessageID: SessionMessage.ID) => Effect.Effect<void>
17:   readonly eventCommit: () ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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-v5-review.r03hHL/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: ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/session/message-updater.ts</path>
<type>file</type>
<content>
1: import { castDraft, produce, type WritableDraft } from "immer"
2: import { Effect } from "effect"
3: import { SessionEvent } from "./event"
4: import { SessionMessage } from "./message"
5: import { message } from "./recovery-id"
6: 
7: export type MemoryState = {
8:   messages: SessionMessage.Message[]
9: }
10: 
11: export interface Adapter {
12:   readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined>
13:   readonly getAssistant: (messageID: SessionMessage.ID) => Effect.Effect<SessionMessage.Assistant | undefined>
14:   readonly getCurrentShell: (callID: string) => Effect.Effect<SessionMessage.Shell | undefined>
15:   readonly updateAssistant: (assistant: SessionMessage.Assistant) => Effect.Effect<void>
16:   readonly updateShell: (shell: SessionMessage.Shell) => Effect.Effect<void>
17:   readonly appendMessage: ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/session/message-updater.ts</path>
<type>file</type>
<content>
451:             metadata: event.metadata,
452:             reason: event.data.reason,
453:             summary: event.data.text,
454:             recent: event.data.recent,
455:             time: { created: event.data.timestamp },
456:           }),
457:         )
458:       },
459:       "session.next.revert.staged": () => Effect.void,
460:       "session.next.revert.cleared": () => Effect.void,
461:       "session.next.revert.committed": () => Effect.void,
462:     })
463:   })
464: }
465: 
466: export * as SessionMessageUpdater from "./message-updater"

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

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/session/projector.ts</path>
<type>file</type>
<content>
1: export * as SessionProjector from "./projector"
2: 
3: import { and, desc, eq, gt, or, sql } from "drizzle-orm"
4: import { DateTime, Effect, Layer, Schema } from "effect"
5: import { Database } from "../database/database"
6: import { EventV2 } from "../event"
7: import { makeGlobalNode } from "../effect/app-node"
8: import { SessionEvent } from "./event"
9: import { SessionV1 } from "../v1/session"
10: import { WorkspaceTable } from "../control-plane/workspace.sql"
11: import { SessionMessage } from "./message"
12: import { SessionMessageUpdater } from "./message-updater"
13: import { SessionInput } from "./input"
14: import { Prompt } from "./prompt"
15: import { continuation } from "./recovery-id"
16: import { WorkspaceV2 } from "../workspace"
17: import {
18:   MessageTable,
19:   PartTable,
20:   SessionInputTable,
21:   SessionMessageTable,
22:   ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/session/sql.ts</path>
<type>file</type>
<content>
1: import { sql } from "drizzle-orm"
2: import { check, sqliteTable, text, integer, index, primaryKey, real, uniqueIndex } from "drizzle-orm/sqlite-core"
3: import * as DatabasePath from "../database/path"
4: import { ProjectTable } from "../project/sql"
5: import type { SessionMessage } from "./message"
6: import type { Prompt } from "./prompt"
7: import type { SessionInput } from "./input"
8: import type { Snapshot } from "../snapshot"
9: import { PermissionV1 } from "../v1/permission"
10: import { ProjectV2 } from "../project"
11: import type { SessionSchema } from "./schema"
12: import type { MessageID, PartID, SessionV1 } from "../v1/session"
13: import { WorkspaceV2 } from "../workspace"
14: import { Timestamps } from "../database/schema.sql"
15: import type { SystemContext } from "../system-context/index"
16: import { AgentV2 } from "../agent"
17: import ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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(`ALTER TABLE \`session_input\` ADD \`wake_attempts\` integer DEFAULT 0 NOT NULL;`)
10:       yield* tx.run(`
11:         CREATE TABLE \`session_execution\` (
12:           \`id\` text NOT NULL,
13:           \`session_id\` text NOT NULL,
14:           \`owner_id\` text NOT NULL,
15:           \`assistant_message_id\` text,
16:           \`phase\` text NOT NULL,
17:           \`time_created\` integer NOT NULL,
18:           \`expires_at\` integer NOT NULL,
19:           \`recovery_error\` ...

Found 2 matches
/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/schema.json:
  Line 5:   "prevIds": [

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

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/schema.json</path>
<type>file</type>
<content>
1: {
2:   "version": "7",
3:   "dialect": "sqlite",
4:   "id": "539b8b9f-47d0-4d6d-b29f-4282139c71eb",
5:   "prevIds": [
6:     "f14a9b18-8207-487e-a3d3-227e629ba9ad"
7:   ],
8:   "ddl": [
9:     {
10:       "name": "workspace",
11:       "entityType": "tables"
12:     },
13:     {
14:       "name": "data_migration",
15:       "entityType": "tables"
16:     },
17:     {
18:       "name": "account_state",
19:       "entityType": "tables"
20:     },
21:     {
22:       "name": "account",
23:       "entityType": "tables"
24:     },
25:     {
26:       "name": "control_account",
27:       "entityType": "tables"
28:     },
29:     {
30:       "name": "credential",
31:       "entityType": "tables"
32:     },
33:     {
34:       "name": "event_sequence",
35:       "entityType": "tables"
36:     },
37:     {
38:       "name": "event",
39:       "entityType": "tables"
40:     ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/session.ts</path>
<type>file</type>
<content>
1: export * as SessionV2 from "./session"
2: export * from "./session/schema"
3: 
4: import { DateTime, Effect, Layer, Schema, Context, Stream } from "effect"
5: import { ListAnchor } from "@opencode-ai/schema/session"
6: import { and, asc, desc, eq, gt, like, lt, or, type SQL } from "drizzle-orm"
7: import { ProjectV2 } from "./project"
8: import { WorkspaceV2 } from "./workspace"
9: import { ModelV2 } from "./model"
10: import { Location } from "./location"
11: import { SessionMessage } from "./session/message"
12: import { Prompt } from "./session/prompt"
13: import { PromptInput } from "@opencode-ai/schema/prompt-input"
14: import { EventV2 } from "./event"
15: import { Database } from "./database/database"
16: import { SessionProjector } from "./session/projector"
17: import { SessionMessageTable, SessionTable } from "./session/sql"
18: import { SessionSchema } ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/session.ts</path>
<type>file</type>
<content>
321:           ? order === "asc"
322:             ? gt(SessionMessageTable.seq, anchor.seq)
323:             : lt(SessionMessageTable.seq, anchor.seq)
324:           : undefined
325:         const where = boundary
326:           ? and(eq(SessionMessageTable.session_id, input.sessionID), boundary)
327:           : eq(SessionMessageTable.session_id, input.sessionID)
328:         const query = db
329:           .select()
330:           .from(SessionMessageTable)
331:           .where(where)
332:           .orderBy(order === "asc" ? asc(SessionMessageTable.seq) : desc(SessionMessageTable.seq))
333:         const rows = yield* (input.limit === undefined ? query.all() : query.limit(input.limit).all()).pipe(
334:           Effect.orDie,
335:         )
336:         return yield* Effect.forEach(direction === "previous" ? rows.toReversed() : rows, decode)
337:       }),
338:     ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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-v5-review.r03hHL/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-v5-review.r03hHL/packages/schema/src/session-event.ts</path>
<type>file</type>
<content>
1: export * as SessionEvent from "./session-event"
2: 
3: import { Schema } from "effect"
4: import { optional } from "./schema"
5: import { Event } from "./event"
6: import { ProviderMetadata, ToolContent } from "./llm"
7: import { Delivery } from "./session-delivery"
8: import { Model } from "./model"
9: import { DateTimeUtcFromMillis, NonNegativeInt, RelativePath } from "./schema"
10: import { FileAttachment, Prompt } from "./prompt"
11: import { SessionID } from "./session-id"
12: import { Location } from "./location"
13: import { SessionMessage } from "./session-message"
14: import { Revert } from "./revert"
15: 
16: export { FileAttachment }
17: 
18: export const Source = Schema.Struct({
19:   start: NonNegativeInt,
20:   end: NonNegativeInt,
21:   text: Schema.String,
22: }).annotate({
23:   identifier: "session.next.event.source",
24: })
25: export ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/schema/src/session-event.ts</path>
<type>file</type>
<content>
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:   Reasoning.Ended,
540:   Tool.Input.Started,
541:   Tool.Input.Delta,
542:   Tool.Input.Ended,
543:   Tool.Called,
544:   Tool.Progress,
545:   Tool.Success,
546:   Tool.Failed,
547:   Retried,
548:   Compaction.Started,
549:   Compaction.Delta,
550:   Compaction.Ended,
551:   RevertEvent.Staged,
552:   RevertEvent.Cleared,
553:   RevertEvent.Committed,
554: )
555: 
556: export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" })
557:   ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/server/src/routes.ts</path>
<type>file</type>
<content>
1: import { Database } from "@opencode-ai/core/database/database"
2: import { LayerNode } from "@opencode-ai/core/effect/layer-node"
3: import { httpClient } from "@opencode-ai/core/effect/app-node-platform"
4: import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
5: import { EventV2 } from "@opencode-ai/core/event"
6: import { Credential } from "@opencode-ai/core/credential"
7: import { PermissionSaved } from "@opencode-ai/core/permission/saved"
8: import { PtyTicket } from "@opencode-ai/core/pty/ticket"
9: import { SessionV2 } from "@opencode-ai/core/session"
10: import { SessionExecution } from "@opencode-ai/core/session/execution"
11: import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
12: import { SessionExecutionLocal } from "@opencode-ai/core/session/execution/local"
13: import { SessionRecovery } from ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/opencode/src/server/routes/instance/httpapi/server.ts</path>
<type>file</type>
<content>
1: import { Config as EffectConfig, Context, Effect, Layer } from "effect"
2: import { HttpApiBuilder, OpenApi } from "effect/unstable/httpapi"
3: import { HttpClient, HttpMiddleware, HttpRouter, HttpServer, HttpServerResponse } from "effect/unstable/http"
4: import * as Socket from "effect/unstable/socket/Socket"
5: import { FSUtil } from "@opencode-ai/core/fs-util"
6: import * as Observability from "@opencode-ai/core/observability"
7: import { Account } from "@/account/account"
8: import { Agent } from "@/agent/agent"
9: import { Auth } from "@/auth"
10: import { BackgroundJob } from "@/background/job"
11: import { Command } from "@/command"
12: import { Config } from "@/config/config"
13: import { Workspace } from "@/control-plane/workspace"
14: import { Env } from "@/env"
15: import { EventV2Bridge } from "@/event-v2-bridge"
16: ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/opencode/src/server/routes/instance/httpapi/server.ts</path>
<type>file</type>
<content>
241:   EventV2Bridge.node,
242:   SessionRunState.node,
243:   SessionProcessor.node,
244:   SessionCompaction.node,
245:   SessionRevert.node,
246:   SessionSummary.node,
247:   SessionPrompt.node,
248:   Instruction.node,
249:   LLM.node,
250:   LSP.node,
251:   MCP.node,
252:   McpAuth.node,
253:   Command.node,
254:   Truncate.node,
255:   ToolRegistry.node,
256:   Format.node,
257:   Project.node,
258:   Vcs.node,
259:   Workspace.node,
260:   Worktree.node,
261:   Installation.node,
262:   ShareNext.node,
263:   SessionShare.node,
264:   InstanceStore.node,
265:   httpClient,
266:   EventV2.node,
267:   ProjectV2.node,
268:   ProjectCopy.node,
269:   PtyTicket.node,
270: ])
271: 
272: export function createRoutes(
273:   corsOptions?: CorsOptions,
274: ): Layer.Layer<never, EffectConfig.ConfigError, RouteRequirements> {
275:   ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/database/migration.gen.ts</path>
<type>file</type>
<content>
1: import type { DatabaseMigration } from "./migration"
2: 
3: export const migrations = (
4:   await Promise.all([
5:     import("./migration/20260127222353_familiar_lady_ursula"),
6:     import("./migration/20260211171708_add_project_commands"),
7:     import("./migration/20260213144116_wakeful_the_professor"),
8:     import("./migration/20260225215848_workspace"),
9:     import("./migration/20260227213759_add_session_workspace_id"),
10:     import("./migration/20260228203230_blue_harpoon"),
11:     import("./migration/20260303231226_add_workspace_fields"),
12:     import("./migration/20260309230000_move_org_to_state"),
13:     import("./migration/20260312043431_session_message_cursor"),
14:     import("./migration/20260323234822_events"),
15:     import("./migration/20260410174513_workspace-name"),
16:     ...

Found 18 matches
/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/database/schema.gen.ts:
  Line 158:         CREATE TABLE \`session_execution\` (

  Line 167:           CONSTRAINT \`session_execution_pk\` PRIMARY KEY(\`id\`),

  Line 168:           CONSTRAINT \`fk_session_execution_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE,

  Line 169:           CONSTRAINT "session_execution_phase_check" CHECK("phase" IN ('ready', 'safe', 'unknown', 'continue'))

  Line 180:           \`wake_pending\` integer DEFAULT false NOT NULL,

  Line 181:           \`wake_attempts\` integer DEFAULT 0 NOT NULL,

  Line 199:         CREATE TABLE \`session_recovery\` (

  Line 205:           \`wake_pending\` integer DEFAULT true NOT NULL,

  Line 206:           \`wake_attempts\` integer DEFAULT 0 NOT NULL,

  Line 209:           CONSTRAINT \`session_recovery_pk\` PRIMARY KEY(\`execution_id\`),

  Line 210:           CONSTRAINT ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/src/database/schema.gen.ts</path>
<type>file</type>
<content>
135:         );
136:       `)
137:       yield* tx.run(`
138:         CREATE TABLE \`part\` (
139:           \`id\` text PRIMARY KEY,
140:           \`message_id\` text NOT NULL,
141:           \`session_id\` text NOT NULL,
142:           \`time_created\` integer NOT NULL,
143:           \`time_updated\` integer NOT NULL,
144:           \`data\` text NOT NULL,
145:           CONSTRAINT \`fk_part_message_id_message_id_fk\` FOREIGN KEY (\`message_id\`) REFERENCES \`message\`(\`id\`) ON DELETE CASCADE
146:         );
147:       `)
148:       yield* tx.run(`
149:         CREATE TABLE \`session_context_epoch\` (
150:           \`session_id\` text PRIMARY KEY,
151:           \`baseline\` text NOT NULL,
152:           \`snapshot\` text NOT NULL,
153:           \`baseline_seq\` integer NOT NULL,
154:           CONSTRAINT ...

Found 11 matches
/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-execution-local.test.ts:
  Line 42: describe("SessionExecutionLocal", () => {

  Line 61:       yield* Deferred.await(started)

  Line 76:       yield* Deferred.await(started)

  Line 96:       yield* Deferred.await(firstStarted)

  Line 120:       yield* Deferred.await(firstStarted)

  Line 167:       yield* Deferred.await(started)

  Line 191:       yield* Deferred.await(started)

  Line 219:                   ? Deferred.succeed(finalizerStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFinalizer)))

  Line 226:       yield* Deferred.await(firstStarted)

  Line 228:       yield* Deferred.await(finalizerStarted)

  Line 235:       yield* Deferred.await(successorStarted)

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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 } 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 { SessionSchema } from "@opencode-ai/core/session/schema"
11: import { SessionExecutionTable, SessionTable } from "@opencode-ai/core/session/sql"
12: import { testEffect } from "./lib/effect"
13: 
14: const sessionID = SessionSchema.ID.make("ses_execution_local")
15: const it = ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-run-coordinator.test.ts</path>
<type>file</type>
<content>
1: import { describe, expect } from "bun:test"
2: import { Cause, Deferred, Effect, Exit, Fiber, Layer } from "effect"
3: import { SessionRunCoordinator } from "@opencode-ai/core/session/run-coordinator"
4: import { testEffect } from "./lib/effect"
5: 
6: const it = testEffect(Layer.empty)
7: 
8: describe("SessionRunCoordinator", () => {
9:   it.effect("joins concurrent resumes for one key", () =>
10:     Effect.scoped(
11:       Effect.gen(function* () {
12:         const gate = yield* Deferred.make<void>()
13:         let runs = 0
14:         const coordinator = yield* SessionRunCoordinator.make({
15:           drain: () => Effect.sync(() => runs++).pipe(Effect.andThen(Deferred.await(gate))),
16:         })
17: 
18:         const first = yield* coordinator.run("session").pipe(Effect.forkChild)
19:         yield* Effect.yieldNow
20:         const ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-run-coordinator.test.ts</path>
<type>file</type>
<content>
331:     Effect.scoped(
332:       Effect.gen(function* () {
333:         const firstStarted = yield* Deferred.make<void>()
334:         const cleanupStarted = yield* Deferred.make<void>()
335:         const cleanupGate = yield* Deferred.make<void>()
336:         const secondStarted = yield* Deferred.make<void>()
337:         const forces: boolean[] = []
338:         const coordinator = yield* SessionRunCoordinator.make<string, never>({
339:           drain: (_key, force) => {
340:             forces.push(force)
341:             return forces.length === 1
342:               ? Deferred.succeed(firstStarted, undefined).pipe(
343:                   Effect.andThen(Effect.never),
344:                   Effect.onInterrupt(() =>
345:                     Deferred.succeed(cleanupStarted, undefined).pipe(Effect.andThen(Deferred.await(cleanupGate))),
346:    ...

Found 100 matches (more matches available)
/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-runner.test.ts:
  Line 35: import { SessionRecovery } from "@opencode-ai/core/session/recovery"

  Line 43: import { ConfigCompaction } from "@opencode-ai/core/config/compaction"

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

  Line 110: const recoveryModel = Model.make({

  Line 111:   id: "recovery",

  Line 223:             compaction: new ConfigCompaction.Info({

  Line 248:       run: (claim, force, recoveryInputID) => sessionRunner.run({ ...claim, force, recoveryInputID }),

  Line 381:     resume: false,

  Line 383:   yield* session.resume(sessionID)

  Line 384:   currentModel = recoveryModel

  Line 396: const replaySessionProjection = (id: SessionV2.ID) =>

  Line 411:     yield* events.replayAll(

  Line 428:   readonly expectedAssistant: unknown

  Line 429:   readonly expectedContent: unknown

  Line 505:     yield* session.prompt({ ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-runner.test.ts</path>
<type>file</type>
<content>
1: import { describe, expect } from "bun:test"
2: import {
3:   LLMClient,
4:   LLMError,
5:   LLMEvent,
6:   Model,
7:   TransportReason,
8:   InvalidRequestReason,
9:   type LLMClientShape,
10:   type LLMRequest,
11: } from "@opencode-ai/llm"
12: import * as OpenAIChat from "@opencode-ai/llm/protocols/openai-chat"
13: import { Database } from "@opencode-ai/core/database/database"
14: import { makeLocationNode } from "@opencode-ai/core/effect/app-node"
15: import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
16: import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
17: import { LayerNode } from "@opencode-ai/core/effect/layer-node"
18: import { EventV2 } from "@opencode-ai/core/event"
19: import { PermissionV2 } from "@opencode-ai/core/permission"
20: import { EventTable } from ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-runner.test.ts</path>
<type>file</type>
<content>
481:         LLMEvent.stepStart({ index: 0 }),
482:         LLMEvent.toolInputStart({ id, name: "echo" }),
483:         ...chunks.map((text) => LLMEvent.toolInputDelta({ id, name: "echo", text })),
484:       ]
485:       const expectedContent = { type: "tool", id, state: { status: "pending", input: text } }
486:       return {
487:         delta: SessionEvent.Tool.Input.Delta,
488:         partialEvents,
489:         completeEvents: [...partialEvents, LLMEvent.toolInputEnd({ id, name: "echo" })],
490:         expectedAssistant: { type: "assistant", content: [expectedContent] },
491:         expectedContent,
492:       }
493:     }
494:   }
495: }
496: 
497: const verifyEphemeralDeltas = (kind: FragmentKind) =>
498:   Effect.gen(function* () {
499:     yield* setup
500:     const session = yield* SessionV2.Service
501:     const prompt = `Stream ...

Found 70 matches
/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-create.test.ts:
  Line 211:   it.effect("replays one prompt lifecycle into a fresh target database", () =>


/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-runner.test.ts:
  Line 598:   it.effect("redrives only the synthetic recovery continuation", () =>

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

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

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

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

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

  Line 1362:   it.effect("rebuilds the baseline directly after completed compaction", () =>

  Line 1474:   it.effect("keeps automatic compaction unknown until Compaction.Ended ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/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-v5-review.r03hHL/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
440:   it.effect("quarantines a malformed recovery row without blocking a valid wake", () =>
441:     Effect.gen(function* () {
442:       const { db } = yield* Database.Service
443:       const events = yield* EventV2.Service
444:       const valid = SessionV2.ID.make("ses_recovery_row_valid")
445:       yield* db
446:         .insert(ProjectTable)
447:         .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
448:         .run()
449:       yield* db
450:         .insert(SessionTable)
451:         .values(
452:           [sessionID, valid].map((id) => ({
453:             id,
454:             project_id: Project.ID.global,
455:             slug: id,
456:             directory: "/project",
457:             title: "test",
458:             version: "test",
459:           })),
460:         )
461:         .run()
462:  ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
957:   it.effect("quarantines a recovery wake behind a newer assistant", () =>
958:     Effect.gen(function* () {
959:       const { db } = yield* Database.Service
960:       const events = yield* EventV2.Service
961:       const recoveredID = SessionMessage.ID.make("msg_recovery_stale")
962:       yield* db
963:         .insert(ProjectTable)
964:         .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
965:         .run()
966:       yield* db
967:         .insert(SessionTable)
968:         .values({
969:           id: sessionID,
970:           project_id: Project.ID.global,
971:           slug: "test",
972:           directory: "/project",
973:           title: "test",
974:           version: "test",
975:         })
976:         .run()
977:       yield* events.publish(SessionEvent.Step.Started, {
978:         ...

<path>/tmp/opencode/session-recovery-v5-review.r03hHL/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
1557:         END
1558:       `)
1559:       const detachedEvents: EventV2.Interface = {
1560:         ...events,
1561:         publish: (definition, data, options) =>
1562:           events.publish(definition, data).pipe(Effect.tap(() => options?.commit?.(0) ?? Effect.void)),
1563:       }
1564: 
1565:       const advanced = yield* SessionContextEpoch.prepare(
1566:         db,
1567:         detachedEvents,
1568:         Effect.succeed(context("after")),
1569:         sessionID,
1570:         claim,
1571:       ).pipe(Effect.exit)
1572: 
1573:       expect(Exit.isFailure(advanced)).toBe(true)
1574:       expect(
1575:         yield* db
1576:           .select({ snapshot: SessionContextEpochTable.snapshot })
1577:           .from(SessionContextEpochTable)
1578:           .where(eq(SessionContextEpochTable.session_id, sessionID))
1579:           ...