Session 0WeSVEZBTPig

<skill_content name="jj-guide">
# Skill: jj-guide

# jj Guide for AI Agents

Jujutsu (jj) is a Git-compatible VCS with mutable commits, automatic snapshotting, no staging area, and first-class conflicts. This skill teaches you how to use it safely from a non-interactive agent environment.

If `.jj/` exists in the repo root, this is a jj repo. **Use `jj` commands, not `git`.** In a colocated repo (`.jj/` *and* `.git/`), git tools can read the state, but mutations should go through `jj` so the operation log stays consistent.

## Critical Rules

- **NEVER** use interactive flags (`-i`, `--interactive`). TUI prompts hang in agent environments. This applies to `jj split -i`, `jj squash -i`, `jj commit -i`, `jj resolve`, `jj diffedit`, etc.
- **ALWAYS** pass `-m "msg"` when describing/committing. Without `-m`, an editor opens and hangs.
- **VERIFY** mutations with `jj st` and `jj log` after `squash`, `abandon`, `rebase`, `restore`, `commit`. ...

446412b56ac31b2a60f98765b5f14955a771f6074ebeb9309f603a0ceefad1bc  /tmp/opencode/session-recovery-final-v8.patch
f4f0bd585d33bd47114b2d8d54082c2b061380771c808e909223350e62c8c72f  /home/byk/Code/opencode/packages/opencode/dist/server/opencode-server
ab9408c81cc9916177641ae8e9f08624fc27b5b9
commit
d3323b963b9ef2de41a7ff9884299c74b93886ba

531	48	packages/core/schema.json
1	0	packages/core/src/database/migration.gen.ts
58	0	packages/core/src/database/migration/20260914170650_session-recovery.ts
48	1	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
135	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
449	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
272	104	packages/core/src/session/runner/llm.ts
89	37	packages/core/src/session/runner/publish-llm-event.ts
78	1	packages/core/src/session/sql.ts
66	1	packages/core/test/database-migration.test.ts
283	0	packages/core/test/session-execution-local.test.ts
2007	3	packages/core/test/session-projector.test.ts
247	25	packages/core/test/session-...

<path>/tmp/opencode/session-recovery-final-v8.patch</path>
<type>file</type>
<content>
1: diff --git a/packages/core/schema.json b/packages/core/schema.json
2: index d0eeeebd5c..7e176bd78b 100644
3: --- a/packages/core/schema.json
4: +++ b/packages/core/schema.json
5: @@ -1,8 +1,10 @@
6:  {
7:    "version": "7",
8:    "dialect": "sqlite",
9: -  "id": "f14a9b18-8207-487e-a3d3-227e629ba9ad",
10: -  "prevIds": ["169a0f0f-d58f-479f-b024-fa1c7b9a09db"],
11: +  "id": "682548a8-b895-4f9b-a6af-fdd4b14a5fc9",
12: +  "prevIds": [
13: +    "d6936168-4f91-42dc-ad64-130da940b0f8"
14: +  ],
15:    "ddl": [
16:      {
17:        "name": "workspace",
18: @@ -60,6 +62,10 @@
19:        "name": "session_context_epoch",
20:        "entityType": "tables"
21:      },
22: +    {
23: +      "name": "session_execution",
24: +      "entityType": "tables"
25: +    },
26:      {
27:        "name": "session_input",
28:        "entityType": "tables"
29: @@ -68,6 +74,10 @@
30:        "name": "session_message",
31:  ...

OK packages/core/schema.json 7e176bd78b3a434a0be700e9579de40e5028ba92
OK packages/core/src/database/migration.gen.ts 77948f152910d908fa990652e38c8d756dca04e6
OK packages/core/src/database/migration/20260914170650_session-recovery.ts 31fd351cb1846ff2f5269a16310b719977276724
OK packages/core/src/database/schema.gen.ts a4b613c119b5bce8b15bf5f3310565122c66cf24
OK packages/core/src/session.ts fc5868837ad3e062e4bb13410217458f40d24db6
OK packages/core/src/session/compaction.ts 92a934c44f1f805afbc6e8f01f76cb55362ddc91
OK packages/core/src/session/context-epoch.ts 880d42bcf9450b074028c920cbcaa4107178543c
OK packages/core/src/session/execution/local.ts 37cfe481150b0e3818c7faa577e52eb31de42f0f
OK packages/core/src/session/input.ts 0b38eb2519691cfe2c57954513573f65a8deb386
OK packages/core/src/session/message-updater.ts e2d7e6b38eebdfcdbe9742a2d6c2f16258c19090
OK packages/core/src/session/projector.ts 43a9d26b12260de670b21c98222835ae30481c46
OK packages/core/src/session/recovery.ts ...

<path>/tmp/opencode/session-recovery-v7-check/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 ...

<path>/tmp/opencode/session-recovery-v7-check/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: number) ...

<path>/tmp/opencode/session-recovery-v7-check/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. Future remote placement belongs here. ...

<path>/tmp/opencode/session-recovery-v7-check/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 { SessionSchema } from "./schema"
14: import {
15:   MAX_WAKE_ATTEMPTS,
16:   SESSION_EXECUTION_LEASE_MS,
17:   SessionExecutionTable,
18:   SessionInputTable,
19:   SessionRecoveryTable,
20:   SessionMessageTable,
21:   SessionTable,
22: } from ...

<path>/tmp/opencode/session-recovery-v7-check/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: const ...

<path>/tmp/opencode/session-recovery-v7-check/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-v7-check/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-v7-check/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: (message: ...

<path>/tmp/opencode/session-recovery-v7-check/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 type { ...

Found 16 matches
/tmp/opencode/session-recovery-v7-check/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 198:         CREATE TABLE \`session_recovery\` (

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

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

  Line 210:           CONSTRAINT \`fk_session_recovery_assistant_message_id_session_message_id_fk\` FOREIGN KEY (\`assistant_message_id\`) REFERENCES ...

<path>/tmp/opencode/session-recovery-v7-check/packages/core/src/database/schema.gen.ts</path>
<type>file</type>
<content>
130:           \`session_id\` text NOT NULL,
131:           \`time_created\` integer NOT NULL,
132:           \`time_updated\` integer NOT NULL,
133:           \`data\` text NOT NULL,
134:           CONSTRAINT \`fk_message_session_id_session_id_fk\` FOREIGN KEY (\`session_id\`) REFERENCES \`session\`(\`id\`) ON DELETE CASCADE
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:       ...

<path>/tmp/opencode/session-recovery-v7-check/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-v7-check/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: export ...

<path>/tmp/opencode/session-recovery-v7-check/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-v7-check/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-v7-check/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 eventCommit: () => Effect.Effect<void>
16: }
17: 
18: const safe = (value: number | undefined) => Math.max(0, Number.isFinite(value) ? (value ?? ...

<path>/tmp/opencode/session-recovery-v7-check/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: type ...

<path>/tmp/opencode/session-recovery-v7-check/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 } from ...

<path>/tmp/opencode/session-recovery-v7-check/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 interface ...

<path>/tmp/opencode/session-recovery-v7-check/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-v7-check/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: import { ...

<path>/tmp/opencode/session-recovery-v7-check/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:   const ...

Found 42 matches
/tmp/opencode/session-recovery-v7-check/packages/core/src/database/migration/20260914170650_session-recovery.ts:
  Line 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);`,

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

  Line 39:           CONSTRAINT \`session_recovery_wake_attempts_check\` CHECK(\`wake_attempts\` >= 0 AND \`wake_attempts\` <= 9007199254740991),

  Line 54:         `CREATE INDEX \`session_recovery_wake_pending_error_attempts_created_execution_idx\` ON \`session_recovery\` (\`wake_pending\`, \`recovery_error\`, \`wake_attempts\`, \`time_created\`, \`execution_id\`);`,


/tmp/opencode/session-recovery-v7-check/packages/core/src/database/schema.gen.ts:
  Line 205:           \`wake_attempts\` integer DEFAULT 0 NOT NULL,

  Line 212:           CONSTRAINT ...

Found 100 matches (more matches available)
/tmp/opencode/session-recovery-v7-check/packages/core/test/tool-output-store.test.ts:
  Line 45: const it = testEffect(Layer.empty)

  Line 48:   it.live("bounds the provider-facing text channel with one managed file", () =>

  Line 73:   it.live("uses bounded text for oversized structured-only output", () =>

  Line 86:   it.live("preserves native media and structured metadata without applying a settlement media limit", () =>

  Line 111:   it.live("preserves structured metadata and native media when bounding text", () =>

  Line 134:   it.live("does not double-count structured data duplicated in projected text", () =>

  Line 147:   it.live("fails oversized settlement when complete retention cannot be written", () =>

  Line 165:   it.live("does not encode ignored structured metadata when projected content exists", () =>

  Line 177:   it.live("preserves interruption while retaining complete output", () =>

  Line 205:         return yield* ...

<path>/tmp/opencode/session-recovery-v7-check/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 = testEffect(Database.layerFromPath(":memory:"))
16: ...

Found 29 matches
/tmp/opencode/session-recovery-v7-check/packages/core/test/session-prompt.test.ts:
  Line 140:   it.effect("exposes the execution registry", () =>

  Line 147:   it.effect("delegates execution continuation through SessionExecution", () =>

  Line 159:   it.effect("delegates process-local interruption through SessionExecution", () =>

  Line 171:   it.effect("delegates interruption without requiring a recorded Session", () =>

  Line 181:   it.effect("durably admits one user message before transcript promotion", () =>

  Line 203:   it.effect("resolves attachment MIME before admission", () =>

  Line 224:   it.effect("streams durable Session events after an aggregate sequence", () =>

  Line 254:   it.effect("resumes through a recorded message without appending another prompt", () =>

  Line 275:   it.effect("records distinct messages when the ID is omitted", () =>

  Line 290:   it.effect("returns the original recorded message when the ID is retried", () =>

  Line ...

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

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

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

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

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

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

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

  Line 495:   it.effect("quarantines a full batch of poison recovery rows before redriving valid work", () =>

  Line 560:   it.effect("fairly redrives recovery and ordinary work beyond a full bounded batch", () =>

  Line 696:   ...

<path>/tmp/opencode/session-recovery-v7-check/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
1490:     }),
1491:   )
1492: 
1493:   it.effect("quarantines a malformed claim without blocking a valid claim", () =>
1494:     Effect.gen(function* () {
1495:       const { db } = yield* Database.Service
1496:       const validSession = SessionV2.ID.make("ses_recovery_valid")
1497:       yield* db
1498:         .insert(ProjectTable)
1499:         .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
1500:         .run()
1501:       yield* db
1502:         .insert(SessionTable)
1503:         .values(
1504:           [sessionID, validSession].map((id) => ({
1505:             id,
1506:             project_id: Project.ID.global,
1507:             slug: id,
1508:             directory: "/project",
1509:             title: "test",
1510:             version: "test",
1511:           })),
1512:         )
1513:         .run()
1514:  ...

<path>/tmp/opencode/session-recovery-v7-check/packages/core/test/database-migration.test.ts</path>
<type>file</type>
<content>
1: import { describe, expect, test } from "bun:test"
2: import { $ } from "bun"
3: import { fileURLToPath } from "url"
4: import path from "path"
5: import { SqliteClient } from "@effect/sql-sqlite-bun"
6: import { EffectDrizzleSqlite } from "@opencode-ai/effect-drizzle-sqlite"
7: import { Effect, Exit, Layer } from "effect"
8: import { eq, inArray, sql } from "drizzle-orm"
9: import { DatabaseMigration } from "@opencode-ai/core/database/migration"
10: import { migrations } from "@opencode-ai/core/database/migration.gen"
11: import workspaceNameMigration from "@opencode-ai/core/database/migration/20260410174513_workspace-name"
12: import sessionUsageMigration from "@opencode-ai/core/database/migration/20260510033149_session_usage"
13: import normalizeStoragePathsMigration from "@opencode-ai/core/database/migration/20260601010001_normalize_storage_paths"
14: ...

<path>/tmp/opencode/session-recovery-v7-check/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 7 matches
/tmp/opencode/session-recovery-v7-check/packages/core/schema.json:
  Line 1963:       "name": "session_execution_pk",

  Line 1972:       "name": "session_recovery_pk",

  Line 2256:       "name": "session_execution_session_idx",

  Line 2444:       "name": "session_recovery_continuation_message_idx",

  Line 2536:       "name": "session_execution_phase_check",

  Line 2542:       "name": "session_recovery_wake_attempts_check",

  Line 2548:       "name": "session_wake_attempts_check",

<path>/tmp/opencode/session-recovery-v7-check/packages/core/schema.json</path>
<type>file</type>
<content>
1930:       ],
1931:       "onUpdate": "NO ACTION",
1932:       "onDelete": "CASCADE",
1933:       "nameExplicit": false,
1934:       "name": "fk_session_share_session_id_session_id_fk",
1935:       "entityType": "fks",
1936:       "table": "session_share"
1937:     },
1938:     {
1939:       "columns": [
1940:         "email",
1941:         "url"
1942:       ],
1943:       "nameExplicit": false,
1944:       "name": "control_account_pk",
1945:       "entityType": "pks",
1946:       "table": "control_account"
1947:     },
1948:     {
1949:       "columns": [
1950:         "project_id",
1951:         "directory"
1952:       ],
1953:       "nameExplicit": false,
1954:       "name": "project_directory_pk",
1955:       "entityType": "pks",
1956:       "table": "project_directory"
1957:     },
1958:     {
1959:       "columns": [
1960:         "id"
1961:       ],
1962:       ...

<path>/tmp/opencode/session-recovery-v7-check/packages/core/schema.json</path>
<type>file</type>
<content>
2520:     {
2521:       "columns": [
2522:         {
2523:           "value": "session_id",
2524:           "isExpression": false
2525:         }
2526:       ],
2527:       "isUnique": false,
2528:       "where": null,
2529:       "origin": "manual",
2530:       "name": "todo_session_idx",
2531:       "entityType": "indexes",
2532:       "table": "todo"
2533:     },
2534:     {
2535:       "value": "\"phase\" IN ('ready', 'safe', 'unknown', 'continue')",
2536:       "name": "session_execution_phase_check",
2537:       "entityType": "checks",
2538:       "table": "session_execution"
2539:     },
2540:     {
2541:       "value": "\"wake_attempts\" >= 0 AND \"wake_attempts\" <= 9007199254740991",
2542:       "name": "session_recovery_wake_attempts_check",
2543:       "entityType": "checks",
2544:       "table": "session_recovery"
2545:     },
2546:     {
2547:       "value": ...

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

  Line 688:   it.effect("clears durable execution intent when ordinary input is promoted", () =>

  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 902:   it.effect("advertises and executes a globally attached application tool", () =>

  Line 958:   it.effect("starts a real runner turn after default prompt recording", () =>

  Line 977:   it.effect("streams one request with registry definitions from chronological ...

<path>/tmp/opencode/session-recovery-v7-check/packages/core/test/session-runner.test.ts</path>
<type>file</type>
<content>
1970:         { type: "assistant", finish: "stop", content: [{ type: "text", id: "text-final", text: "Done" }] },
1971:       ])
1972:     }),
1973:   )
1974: 
1975:   it.effect("never commits continuation before unresolved hosted tools are reconciled", () =>
1976:     Effect.gen(function* () {
1977:       yield* setup
1978:       const session = yield* SessionV2.Service
1979:       const { db } = yield* Database.Service
1980:       yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Mixed tools" }), resume: false })
1981:       responses = [
1982:         [
1983:           LLMEvent.stepStart({ index: 0 }),
1984:           LLMEvent.toolCall({ id: "call-local", name: "echo", input: { text: "mixed-local" } }),
1985:           LLMEvent.toolCall({
1986:             id: "call-hosted-pending",
1987:             name: "web_search",
1988:             input: { ...

<path>/tmp/opencode/session-recovery-v7-check/packages/core/test/session-runner.test.ts</path>
<type>file</type>
<content>
4180:       const executionCount = executions.length
4181:       response = [
4182:         LLMEvent.stepStart({ index: 0 }),
4183:         LLMEvent.toolCall({ id: "call-before-provider-error", name: "echo", input: { text: "settled" } }),
4184:         LLMEvent.providerError({ message: "Provider unavailable" }),
4185:       ]
4186: 
4187:       yield* session.resume(sessionID)
4188: 
4189:       expect(requests).toHaveLength(1)
4190:       expect(executions.slice(executionCount)).toEqual(["settled"])
4191:     }),
4192:   )
4193: 
4194:   it.effect("durably fails a hosted tool when its provider errors before returning a result", () =>
4195:     Effect.gen(function* () {
4196:       yield* setup
4197:       const session = yield* SessionV2.Service
4198:       yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail hosted tool durably" }), resume: false ...

Found 8 matches
/tmp/opencode/session-recovery-v7-check/packages/core/test/session-runner.test.ts:
  Line 505:           error: { type: "unknown", message: "Provider Step ended without settlement" },

  Line 2049:   it.effect("keeps a running assistant recoverable when Step failure publication defects", () =>

  Line 2061:           SELECT RAISE(ABORT, 'crash before Step failure publication');

  Line 2085:   it.effect("durably reconciles a local tool when success publication defects", () =>

  Line 4225:   it.effect("durably fails a hosted tool left unresolved at normal provider EOF", () =>

  Line 4230:       yield* session.prompt({ sessionID, prompt: Prompt.make({ text: "Fail hosted tool at EOF" }), resume: false })

  Line 4245:         { type: "user", text: "Fail hosted tool at EOF" },

  Line 4249:           error: { type: "unknown", message: "Provider Step ended without settlement" },

<path>/tmp/opencode/session-recovery-v7-check/packages/core/test/session-runner-tool-events.test.ts</path>
<type>file</type>
<content>
1: import { expect, test } from "bun:test"
2: import { Effect, Schema, Stream } from "effect"
3: import { LLMEvent } from "@opencode-ai/llm"
4: import { EventV2 } from "@opencode-ai/core/event"
5: import { SessionEvent } from "@opencode-ai/core/session/event"
6: import { SessionMessage } from "@opencode-ai/core/session/message"
7: import { SessionV2 } from "@opencode-ai/core/session"
8: import { ModelV2 } from "@opencode-ai/core/model"
9: import { ProviderV2 } from "@opencode-ai/core/provider"
10: import { createLLMEventPublisher } from "@opencode-ai/core/session/runner/publish-llm-event"
11: 
12: const sessionID = SessionV2.ID.make("ses_tool_event_test")
13: const base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB"
14: 
15: const capture = () => {
16:   const published: Array<{ readonly type: string; readonly data: unknown }> = []
17:   const events = ...

<path>/tmp/opencode/session-recovery-v7-check/packages/core/test/session-runner-recorded.test.ts</path>
<type>file</type>
<content>
1: import { HttpRecorder } from "@opencode-ai/http-recorder"
2: import { HttpRecorderInternal } from "@opencode-ai/http-recorder/internal"
3: import * as OpenAIChat from "@opencode-ai/llm/protocols/openai-chat"
4: import { Auth, LLMClient, RequestExecutor } from "@opencode-ai/llm/route"
5: import { Database } from "@opencode-ai/core/database/database"
6: import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
7: import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
8: import { LayerNode } from "@opencode-ai/core/effect/layer-node"
9: import { EventV2 } from "@opencode-ai/core/event"
10: import { EventTable } from "@opencode-ai/core/event/sql"
11: import { PermissionV2 } from "@opencode-ai/core/permission"
12: import { AgentV2 } from "@opencode-ai/core/agent"
13: import { Config } from ...

Found 2 matches
/tmp/opencode/session-recovery-v7-check/packages/core/test/session-prompt.test.ts:
  Line 19: import { SessionRecovery } from "@opencode-ai/core/session/recovery"

  Line 147:   it.effect("delegates execution continuation through SessionExecution", () =>

Found 1 matches
/tmp/opencode/session-recovery-v7-check/packages/core/test/session-projector.test.ts:
  Line 432:           continuation_message_id: continuation("lost-wake"),

Found 8 matches
/tmp/opencode/session-recovery-v7-check/packages/core/test/session-projector.test.ts:
  Line 73:       const continuationID = continuation("execution")

  Line 432:           continuation_message_id: continuation("lost-wake"),

  Line 475:       yield* db.run(sql`UPDATE session_input SET prompt = '{}' WHERE id = ${continuation("malformed-recovery-row")}`)

  Line 909:         sql`UPDATE session_input SET session_id = ${other} WHERE id = ${continuation("cross-session-continuation")}`,

  Line 1257:       const continuationID = continuation("stale-recovery-wake")

  Line 1357:       const promoted = yield* SessionInput.promoteExact(db, events, sessionID, continuation("exact-stale"), () =>

  Line 1367:         yield* db.select().from(SessionInputTable).where(eq(SessionInputTable.id, continuation("exact-stale"))).get(),

  Line 1462:       const continuationID = continuation("quarantined-steer")

<path>/tmp/opencode/session-recovery-v7-check/packages/core/test/session-projector.test.ts</path>
<type>file</type>
<content>
1320:       yield* db
1321:         .insert(ProjectTable)
1322:         .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
1323:         .run()
1324:       yield* db
1325:         .insert(SessionTable)
1326:         .values({
1327:           id: sessionID,
1328:           project_id: Project.ID.global,
1329:           slug: "test",
1330:           directory: "/project",
1331:           title: "test",
1332:           version: "test",
1333:         })
1334:         .run()
1335:       yield* events.publish(SessionEvent.Step.Started, {
1336:         sessionID,
1337:         timestamp: created,
1338:         assistantMessageID: recoveredID,
1339:         agent: "build",
1340:         model,
1341:       })
1342:       yield* events.publish(SessionEvent.Step.Recovered, {
1343:         sessionID,
1344:         timestamp: ...

No files found

/tmp/opencode/session-recovery-v7-check/packages/core/src/event.ts

Found 23 matches
/tmp/opencode/session-recovery-v7-check/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 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) {

  Line 356:                       pubsub.durable.get(committed.aggregateID) ?? [],

  Line 361:                   return committed

  Line 369:       function publishEvent<D extends Definition>(definition: D, event: Payload<D>, commit?: PublishOptions["commit"]) {

  Line 371:           if ...

<path>/tmp/opencode/session-recovery-v7-check/packages/core/src/event.ts</path>
<type>file</type>
<content>
195:           yield* PubSub.shutdown(pubsub.all)
196:           yield* Effect.forEach(
197:             pubsub.durable.values(),
198:             (pubsubs) => Effect.forEach(pubsubs, PubSub.shutdown, { discard: true }),
199:             { discard: true },
200:           )
201:           yield* Effect.forEach(pubsub.typed.values(), PubSub.shutdown, { discard: true })
202:         }),
203:       )
204: 
205:       function commitDurableEvent(
206:         definition: Definition,
207:         event: Payload,
208:         input?: {
209:           readonly seq: number
210:           readonly aggregateID: string
211:           readonly ownerID?: string
212:           readonly strictOwner?: boolean
213:         },
214:         commit?: (seq: number) => Effect.Effect<void>,
215:       ) {
216:         return Effect.gen(function* () {
217:           const durable = ...

<path>/tmp/opencode/session-recovery-v7-check/packages/schema/test/event-manifest.test.ts</path>
<type>file</type>
<content>
1: import { describe, expect, test } from "bun:test"
2: import { FileSystem, Integration, Permission, Project, Reference, Session, Workspace } from "../src"
3: import { EventManifest } from "../src/event-manifest"
4: import { IdeEvent } from "../src/ide-event"
5: import { SessionEvent } from "../src/session-event"
6: import { SessionTodo } from "../src/session-todo"
7: import { SessionV1 } from "../src/session-v1"
8: import { WorkspaceEvent } from "../src/workspace-event"
9: 
10: describe("public event manifest", () => {
11:   test("owns the complete public event surface", () => {
12:     expect(EventManifest.ServerDefinitions.length).toBe(61)
13:     expect(EventManifest.Definitions.length).toBe(91)
14:     expect(SessionV1.Event.Definitions).toEqual([
15:       SessionV1.Event.Created,
16:       SessionV1.Event.Updated,
17:       SessionV1.Event.Deleted,
18:   ...

Found 11 matches
/tmp/opencode/session-recovery-v7-check/packages/sdk/js/src/v2/gen/types.gen.ts:
  Line 33:   | EventSessionNextStepRecovered

  Line 983:         type: "session.next.step.recovered"

  Line 1659:     | SyncEventSessionNextStepRecovered

  Line 2794:   | SessionNextStepRecovered

  Line 2924:   | SessionNextStepRecovered

  Line 3602: export type SyncEventSessionNextStepRecovered = {

  Line 3606:     type: "session.next.step.recovered.1"

  Line 4560: export type SessionNextStepRecovered = {

  Line 4565:   type: "session.next.step.recovered"

  Line 6581: export type EventSessionNextStepRecovered = {

  Line 6583:   type: "session.next.step.recovered"

<path>/tmp/opencode/session-recovery-v7-check/packages/sdk/js/src/v2/gen/types.gen.ts</path>
<type>file</type>
<content>
3590:     id: string
3591:     seq: number
3592:     aggregateID: string
3593:     data: {
3594:       timestamp: number
3595:       sessionID: string
3596:       assistantMessageID: string
3597:       error: SessionErrorUnknown
3598:     }
3599:   }
3600: }
3601: 
3602: export type SyncEventSessionNextStepRecovered = {
3603:   type: "sync"
3604:   id: string
3605:   syncEvent: {
3606:     type: "session.next.step.recovered.1"
3607:     id: string
3608:     seq: number
3609:     aggregateID: string
3610:     data: {
3611:       timestamp: number
3612:       sessionID: string
3613:       executionID: string
3614:       assistantMessageID?: string
3615:       phase: "ready" | "unknown" | "continue"
3616:     }
3617:   }
3618: }
3619: 
3620: export type SyncEventSessionNextTextStarted = {
3621:   type: "sync"
3622:   id: string
3623:   syncEvent: {
3624:     type: ...

<path>/tmp/opencode/session-recovery-v7-check/packages/sdk/js/src/v2/gen/types.gen.ts</path>
<type>file</type>
<content>
4550:   }
4551:   location?: LocationRef
4552:   data: {
4553:     timestamp: number
4554:     sessionID: string
4555:     assistantMessageID: string
4556:     error: SessionErrorUnknown
4557:   }
4558: }
4559: 
4560: export type SessionNextStepRecovered = {
4561:   id: string
4562:   metadata?: {
4563:     [key: string]: unknown
4564:   }
4565:   type: "session.next.step.recovered"
4566:   durable?: {
4567:     aggregateID: string
4568:     seq: number
4569:     version: number
4570:   }
4571:   location?: LocationRef
4572:   data: {
4573:     timestamp: number
4574:     sessionID: string
4575:     executionID: string
4576:     assistantMessageID?: string
4577:     phase: "ready" | "unknown" | "continue"
4578:   }
4579: }
4580: 
4581: export type SessionNextTextStarted = {
4582:   id: string
4583:   metadata?: {
4584:     [key: string]: unknown
4585:   }
4586:   ...

Found 19 matches
/tmp/opencode/session-recovery-v7-check/packages/sdk/openapi.json:
  Line 15339:             "$ref": "#/components/schemas/EventSessionNextStepRecovered"

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

  Line 18301:                       "executionID": {

  Line 18313:                     "required": ["timestamp", "sessionID", "executionID", "phase"],

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

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

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

  Line 26283:       "SyncEventSessionNextStepRecovered": {

  Line 26299:                 "enum": ["session.next.step.recovered.1"]

  Line 26321:                   "executionID": {

  Line 26333:                 "required": ["timestamp", "sessionID", "executionID", "phase"],

  Line 29178:       "SessionNextStepRecovered": {

  Line ...

<path>/tmp/opencode/session-recovery-v7-check/packages/sdk/openapi.json</path>
<type>file</type>
<content>
18270:                         "$ref": "#/components/schemas/SessionErrorUnknown"
18271:                       }
18272:                     },
18273:                     "required": ["timestamp", "sessionID", "assistantMessageID", "error"],
18274:                     "additionalProperties": false
18275:                   }
18276:                 },
18277:                 "required": ["id", "type", "properties"],
18278:                 "additionalProperties": false
18279:               },
18280:               {
18281:                 "type": "object",
18282:                 "properties": {
18283:                   "id": {
18284:                     "type": "string",
18285:                     "pattern": "^evt_"
18286:                   },
18287:                   "type": {
18288:                     "type": "string",
18289:                     "enum": ...

Found 17 matches
/tmp/opencode/session-recovery-v7-check/packages/core/src/session/context-epoch.ts:
  Line 134:   yield* SessionExecutionClaim.transaction(

  Line 158:   const updated = yield* SessionExecutionClaim.transaction(

  Line 182:   const updated = yield* SessionExecutionClaim.transaction(


/tmp/opencode/session-recovery-v7-check/packages/core/src/session/execution/claim.ts:
  Line 38: export const update = Effect.fn("SessionExecutionClaim.update")(function* (

  Line 54: export const clear = Effect.fn("SessionExecutionClaim.clear")(function* (db: DatabaseService, claim: Claim) {


/tmp/opencode/session-recovery-v7-check/packages/core/src/session/execution/local.ts:
  Line 66:         SessionExecutionClaim.update(db, claim).pipe(

  Line 79:               yield* SessionExecutionClaim.clear(db, claim)

  Line 96:               yield* SessionExecutionClaim.clear(db, claim)

  Line 110:           yield* SessionExecutionClaim.update(db, claim)

  Line 111:           yield* ...

<path>/tmp/opencode/session-recovery-v7-check/packages/core/test/session-prompt.test.ts</path>
<type>file</type>
<content>
130:       SessionExecution.Service.of({
131:         active: Effect.succeed(new Set()),
132:         resume: () => Effect.void,
133:         interrupt: () => Effect.void,
134:         wake: (id) => Effect.sync(() => wakeCalls.push(id)).pipe(Effect.asVoid),
135:       }),
136:     ),
137:   )
138: 
139: describe("SessionV2.prompt", () => {
140:   it.effect("exposes the execution registry", () =>
141:     Effect.gen(function* () {
142:       activeSessions.add(sessionID)
143:       expect(Array.from(yield* (yield* SessionV2.Service).active)).toEqual([sessionID])
144:     }).pipe(Effect.ensuring(Effect.sync(() => activeSessions.clear()))),
145:   )
146: 
147:   it.effect("delegates execution continuation through SessionExecution", () =>
148:     Effect.gen(function* () {
149:       yield* setup
150:       const session = yield* SessionV2.Service
151:       ...

<path>/tmp/opencode/session-recovery-v7-check/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 ...

Found 1 matches
/tmp/opencode/session-recovery-v7-check/packages/core/src/session/projector.ts:
  Line 504:           .delete(SessionMessageTable)

Found 5 matches
/tmp/opencode/session-recovery-v7-check/packages/core/test/session-runner.test.ts:
  Line 212:         : SystemContext.empty,

  Line 215: const referenceGuidance = Layer.mock(ReferenceGuidance.Service, { load: () => Effect.succeed(SystemContext.empty) })

  Line 505:           error: { type: "unknown", message: "Provider Step ended without settlement" },

  Line 4225:   it.effect("durably fails a hosted tool left unresolved at normal provider EOF", () =>

  Line 4249:           error: { type: "unknown", message: "Provider Step ended without settlement" },

446412b56ac31b2a60f98765b5f14955a771f6074ebeb9309f603a0ceefad1bc  /tmp/opencode/session-recovery-final-v8.patch
f4f0bd585d33bd47114b2d8d54082c2b061380771c808e909223350e62c8c72f  /home/byk/Code/opencode/packages/opencode/dist/server/opencode-server
base-and-application-ok

 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 packages/core/test/session-runner-recorded.test.ts
 M packages/core/test/session-runner-tool-events.test.ts
 M packages/core/test/session-runner.test.ts
 ...

bun test v1.3.14 (0d9b296a)

test/session-prompt.test.ts:

# Unhandled error between tests
-------------------------------
error: Cannot find package 'effect' from '/tmp/opencode/session-recovery-v7-check/packages/core/test/session-prompt.test.ts'
-------------------------------


test/database-migration.test.ts:

# Unhandled error between tests
-------------------------------
error: Cannot find module '@effect/sql-sqlite-bun' from '/tmp/opencode/session-recovery-v7-check/packages/core/test/database-migration.test.ts'
-------------------------------


test/session-run-coordinator.test.ts:

# Unhandled error between tests
-------------------------------
error: Cannot find package 'effect' from '/tmp/opencode/session-recovery-v7-check/packages/core/test/session-run-coordinator.test.ts'
-------------------------------


test/session-projector.test.ts:

# Unhandled error between tests
-------------------------------
error: Cannot find package 'effect' from ...

<path>/tmp/opencode/session-recovery-v7-check/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: number) ...

<path>/tmp/opencode/session-recovery-v7-check/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. Future remote placement belongs here. ...