Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

fix(opencode): resume the OpenCode session on follow-ups instead of starting an empty one (#3617)

Vadym Kotaif4da4f3b4037
diff --git a/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts b/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts
index 4358cf305..9e7211dc3 100644
--- a/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts
+++ b/apps/server/src/provider/Layers/OpenCodeAdapter.test.ts
@@ -5,8 +5,10 @@ import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
+import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
+import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";
import * as Stream from "effect/Stream";
@@ -31,6 +33,8 @@ import {
} from "../opencodeRuntime.ts";
import {
appendOpenCodeAssistantTextDelta,
+ isOpenCodeNotFound,
+ isSameOpenCodeDirectory,
makeOpenCodeAdapter,
mergeOpenCodeAssistantText,
} from "./OpenCodeAdapter.ts";
@@ -64,6 +68,12 @@ const runtimeMock = {
closeError: null as Error | null,
messages: [] as MessageEntry[],
subscribedEvents: [] as unknown[],
+ sessionGetIds: [] as string[],
+ missingSessionIds: new Set<string>(),
+ transientErrorSessionIds: new Set<string>(),
+ sessionDirectoryById: new Map<string, string>(),
+ sessionUpdateCalls: [] as Array<{ sessionID: string; permission: unknown }>,
+ forkCalls: [] as Array<{ sessionID: string; directory?: string }>,
},
reset() {
this.state.startCalls.length = 0;
@@ -78,6 +88,12 @@ const runtimeMock = {
this.state.closeError = null;
this.state.messages = [];
this.state.subscribedEvents = [];
+ this.state.sessionGetIds.length = 0;
+ this.state.missingSessionIds.clear();
+ this.state.transientErrorSessionIds.clear();
+ this.state.sessionDirectoryById.clear();
+ this.state.sessionUpdateCalls.length = 0;
+ this.state.forkCalls.length = 0;
},
};
@@ -102,10 +118,8 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = {
connectToOpenCodeServer: ({ serverUrl }) =>
Effect.gen(function* () {
const url = serverUrl ?? "http://127.0.0.1:4301";
- // Unconditionally register a scope finalizer for test observability —
- // preserves the `closeCalls` / `closeError` probes that the existing
- // suites rely on. Production code never attaches a finalizer to an
- // external server (it simply returns `Effect.succeed(...)`).
+ // Always register a finalizer so the closeCalls/closeError probes fire;
+ // production attaches none for external servers.
yield* Effect.addFinalizer(() =>
Effect.sync(() => {
runtimeMock.state.closeCalls.push(url);
@@ -132,6 +146,34 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = {
);
return { data: { id: `${baseUrl}/session` } };
},
+ get: async ({ sessionID }: { sessionID: string }) => {
+ runtimeMock.state.sessionGetIds.push(sessionID);
+ // The real client is `throwOnError: true`: non-2xx rejects rather
+ // than resolving, so missing → 404 throw, transient → 500 throw.
+ if (runtimeMock.state.transientErrorSessionIds.has(sessionID)) {
+ throw new Error("opencode server error", { cause: { status: 500 } });
+ }
+ if (runtimeMock.state.missingSessionIds.has(sessionID)) {
+ throw new Error(`Session not found: ${sessionID}`, {
+ cause: { status: 404, body: { name: "NotFoundError" } },
+ });
+ }
+ const directory = runtimeMock.state.sessionDirectoryById.get(sessionID);
+ return { data: { id: sessionID, ...(directory ? { directory } : {}) } };
+ },
+ update: async ({ sessionID, permission }: { sessionID: string; permission: unknown }) => {
+ runtimeMock.state.sessionUpdateCalls.push({ sessionID, permission });
+ return { data: { id: sessionID } };
+ },
+ fork: async ({ sessionID, directory }: { sessionID: string; directory?: string }) => {
+ // Fork clones history into a new session bound to the directory.
+ const forkedId = `${sessionID}_fork`;
+ runtimeMock.state.forkCalls.push({ sessionID, ...(directory ? { directory } : {}) });
+ if (directory) {
+ runtimeMock.state.sessionDirectoryById.set(forkedId, directory);
+ }
+ return { data: { id: forkedId, ...(directory ? { directory } : {}) } };
+ },
abort: async ({ sessionID }: { sessionID: string }) => {
runtimeMock.state.abortCalls.push(sessionID);
},
@@ -251,6 +293,256 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
}),
);
+ it.effect("returns a durable resume cursor for a freshly created session", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-cursor");
+
+ const session = yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ });
+
+ // Without a persisted cursor, a session is created and its id is
+ // surfaced as a resume cursor so the upper layer can persist it.
+ NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, []);
+ NodeAssert.deepEqual(session.resumeCursor, {
+ schemaVersion: 1,
+ sessionId: "http://127.0.0.1:9999/session",
+ });
+
+ yield* adapter.stopSession(threadId);
+ }),
+ );
+
+ it.effect("resumes the persisted OpenCode session instead of creating a new one", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-resume");
+
+ const session = yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ resumeCursor: { schemaVersion: 1, sessionId: "ses_persisted" },
+ });
+
+ // The adapter validates the persisted id with session.get and re-adopts
+ // it — no new session is minted (issue #3604).
+ NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_persisted"]);
+ NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
+ NodeAssert.deepEqual(session.resumeCursor, {
+ schemaVersion: 1,
+ sessionId: "ses_persisted",
+ });
+ // Resume re-asserts the permission ruleset for the current runtimeMode.
+ NodeAssert.equal(runtimeMock.state.sessionUpdateCalls.length, 1);
+ NodeAssert.equal(runtimeMock.state.sessionUpdateCalls[0]?.sessionID, "ses_persisted");
+ NodeAssert.equal(runtimeMock.state.sessionUpdateCalls[0]?.permission != null, true);
+
+ yield* adapter.stopSession(threadId);
+ }),
+ );
+
+ it.effect("sends follow-up turns to the resumed session id", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-resume-turn");
+
+ yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ resumeCursor: { schemaVersion: 1, sessionId: "ses_persisted" },
+ });
+
+ const result = yield* adapter.sendTurn({
+ threadId,
+ input: "continue where we left off",
+ modelSelection: createModelSelection(
+ ProviderInstanceId.make("opencode"),
+ "anthropic/sonnet",
+ ),
+ });
+
+ // The prompt targets the resumed id, and the turn re-surfaces the cursor.
+ NodeAssert.deepEqual(
+ (runtimeMock.state.promptCalls[0] as { sessionID: string }).sessionID,
+ "ses_persisted",
+ );
+ NodeAssert.deepEqual(result.resumeCursor, {
+ schemaVersion: 1,
+ sessionId: "ses_persisted",
+ });
+
+ yield* adapter.stopSession(threadId);
+ }),
+ );
+
+ it.effect("falls back to a fresh session when the persisted session is gone", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-stale");
+ runtimeMock.state.missingSessionIds.add("ses_stale");
+
+ const session = yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ resumeCursor: { schemaVersion: 1, sessionId: "ses_stale" },
+ });
+
+ // get probed the stale id, found nothing, then created a new session and
+ // emitted a fresh cursor rather than wedging the thread.
+ NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_stale"]);
+ NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]);
+ NodeAssert.deepEqual(session.resumeCursor, {
+ schemaVersion: 1,
+ sessionId: "http://127.0.0.1:9999/session",
+ });
+
+ yield* adapter.stopSession(threadId);
+ }),
+ );
+
+ it.effect("ignores a malformed or wrong-version resume cursor", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-badcursor");
+
+ const session = yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ resumeCursor: { schemaVersion: 99, sessionId: "ses_persisted" },
+ });
+
+ // A foreign/stale-shaped cursor is treated as "no resume": never probed,
+ // a fresh session is created.
+ NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, []);
+ NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]);
+ NodeAssert.deepEqual(session.resumeCursor, {
+ schemaVersion: 1,
+ sessionId: "http://127.0.0.1:9999/session",
+ });
+
+ yield* adapter.stopSession(threadId);
+ }),
+ );
+
+ it.effect("surfaces a non-not-found resume probe error instead of silently starting fresh", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-transient");
+ // session.get returns a 500 (not a 404) for this id.
+ runtimeMock.state.transientErrorSessionIds.add("ses_transient");
+
+ const exit = yield* Effect.exit(
+ adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ resumeCursor: { schemaVersion: 1, sessionId: "ses_transient" },
+ }),
+ );
+
+ // A transient/transport/auth failure must propagate — NOT be masked as a
+ // brand-new empty session (the #3604 class of silent context loss).
+ NodeAssert.equal(Exit.isFailure(exit), true);
+ NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_transient"]);
+ NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
+ }),
+ );
+
+ it.effect("re-applies the current runtimeMode permissions when resuming", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-perms");
+
+ yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ // A different runtimeMode than the original create — resume must not
+ // leave the upstream session on stale permissions.
+ runtimeMode: "approval-required",
+ threadId,
+ resumeCursor: { schemaVersion: 1, sessionId: "ses_perms" },
+ });
+
+ NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_perms"]);
+ NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
+ NodeAssert.equal(runtimeMock.state.sessionUpdateCalls.length, 1);
+ NodeAssert.equal(runtimeMock.state.sessionUpdateCalls[0]?.sessionID, "ses_perms");
+ NodeAssert.equal(runtimeMock.state.sessionUpdateCalls[0]?.permission != null, true);
+
+ yield* adapter.stopSession(threadId);
+ }),
+ );
+
+ it.effect(
+ "forks the resumed session into the requested directory instead of losing context",
+ () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-cwd");
+ // The persisted session still exists but was created in another working dir
+ // (e.g. the thread moved from the project root into a git worktree).
+ runtimeMock.state.sessionDirectoryById.set("ses_otherdir", "/some/other/worktree");
+
+ const session = yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ resumeCursor: { schemaVersion: 1, sessionId: "ses_otherdir" },
+ });
+
+ // A cwd change must not mint an empty session: the adapter forks the
+ // persisted session into the requested cwd, carrying history forward.
+ NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_otherdir"]);
+ NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
+ NodeAssert.equal(runtimeMock.state.forkCalls.length, 1);
+ NodeAssert.equal(runtimeMock.state.forkCalls[0]?.sessionID, "ses_otherdir");
+ NodeAssert.equal(typeof runtimeMock.state.forkCalls[0]?.directory, "string");
+ // Permission ruleset re-asserted on the fork for the current runtimeMode.
+ NodeAssert.equal(runtimeMock.state.sessionUpdateCalls.length, 1);
+ NodeAssert.equal(runtimeMock.state.sessionUpdateCalls[0]?.sessionID, "ses_otherdir_fork");
+ // Durable cursor now points at the history-complete fork in the new directory.
+ NodeAssert.deepEqual(session.resumeCursor, {
+ schemaVersion: 1,
+ sessionId: "ses_otherdir_fork",
+ });
+
+ yield* adapter.stopSession(threadId);
+ }),
+ );
+
+ it.effect("reuses the resumed session when the stored directory differs only lexically", () =>
+ Effect.gen(function* () {
+ const adapter = yield* OpenCodeAdapter;
+ const threadId = asThreadId("thread-opencode-samedir");
+ // Same working tree, different spelling (trailing slash) — must reuse,
+ // not fork.
+ runtimeMock.state.sessionDirectoryById.set("ses_samedir", `${process.cwd()}/`);
+
+ const session = yield* adapter.startSession({
+ provider: ProviderDriverKind.make("opencode"),
+ threadId,
+ runtimeMode: "full-access",
+ resumeCursor: { schemaVersion: 1, sessionId: "ses_samedir" },
+ });
+
+ NodeAssert.deepEqual(runtimeMock.state.sessionGetIds, ["ses_samedir"]);
+ NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
+ NodeAssert.deepEqual(runtimeMock.state.forkCalls, []);
+ NodeAssert.deepEqual(session.resumeCursor, {
+ schemaVersion: 1,
+ sessionId: "ses_samedir",
+ });
+
+ yield* adapter.stopSession(threadId);
+ }),
+ );
+
it.effect("fails sendTurn for missing sessions through the typed error channel", () =>
Effect.gen(function* () {
const adapter = yield* OpenCodeAdapter;
@@ -673,6 +965,88 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
}),
);
+ it.effect("classifies a confirmed not-found across the shapes the SDK/runtime can produce", () =>
+ Effect.sync(() => {
+ // The real production shape: runOpenCodeSdk wraps the thrown Error
+ // (cause = { body, status }) under OpenCodeRuntimeError.
+ const wrappedError = new Error("Session not found: ses_x", {
+ cause: { body: { name: "NotFoundError" }, status: 404 },
+ });
+ NodeAssert.equal(
+ isOpenCodeNotFound({
+ _tag: "OpenCodeRuntimeError",
+ operation: "session.get",
+ detail: "Session not found: ses_x",
+ cause: wrappedError,
+ }),
+ true,
+ );
+
+ // 404 expressed only via response.status (the bot's flagged shape).
+ NodeAssert.equal(isOpenCodeNotFound({ cause: { response: { status: 404 } } }), true);
+ // 404 via a bare numeric status / statusCode.
+ NodeAssert.equal(isOpenCodeNotFound(new Error("x", { cause: { status: 404 } })), true);
+ NodeAssert.equal(isOpenCodeNotFound({ statusCode: 404 }), true);
+ // OpenCode NotFoundError body name with no status.
+ NodeAssert.equal(isOpenCodeNotFound({ body: { name: "NotFoundError" } }), true);
+
+ // NOT a miss: only structured signals count, never free text. A non-404
+ // error whose message/detail merely contains "not found" must propagate,
+ // not be misread as a missing session and silently start fresh.
+ NodeAssert.equal(
+ isOpenCodeNotFound(new Error("upstream provider not found", { cause: { status: 500 } })),
+ false,
+ );
+ NodeAssert.equal(isOpenCodeNotFound({ detail: "status=500 body={...not found...}" }), false);
+ // An explicit non-404 status seals its subtree: a 500 whose serialized
+ // body echoes a NotFoundError name — or that is itself named
+ // *NotFound* — is a real failure, never a miss.
+ NodeAssert.equal(isOpenCodeNotFound({ status: 500, body: { name: "NotFoundError" } }), false);
+ NodeAssert.equal(isOpenCodeNotFound({ name: "UpstreamNotFoundError", status: 500 }), false);
+ // A "NotFound"-flavored name that isn't OpenCode's exact `NotFoundError`
+ // is not a confirmed miss even without a sealing status.
+ NodeAssert.equal(isOpenCodeNotFound({ name: "UpstreamNotFoundError" }), false);
+ NodeAssert.equal(isOpenCodeNotFound({ cause: { name: "ProviderNotFoundError" } }), false);
+ NodeAssert.equal(
+ isOpenCodeNotFound(
+ new Error("x", { cause: { status: 502, body: { name: "NotFoundError" } } }),
+ ),
+ false,
+ );
+ // Other transient/auth/network failures must propagate too.
+ NodeAssert.equal(isOpenCodeNotFound(new Error("boom", { cause: { status: 500 } })), false);
+ NodeAssert.equal(isOpenCodeNotFound({ cause: { response: { status: 401 } } }), false);
+ NodeAssert.equal(isOpenCodeNotFound(new Error("network error (no response)")), false);
+ NodeAssert.equal(isOpenCodeNotFound(undefined), false);
+ }),
+ );
+
+ it.effect("treats lexically or physically identical directories as the same", () =>
+ Effect.gen(function* () {
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const sameDirectory = (left: string, right: string) =>
+ isSameOpenCodeDirectory(fileSystem, path, left, right);
+
+ // Lexical-only differences (trailing slash, dot segments) short-circuit
+ // without touching the filesystem — the paths need not exist.
+ NodeAssert.equal(yield* sameDirectory("/repo/project/", "/repo/project"), true);
+ NodeAssert.equal(yield* sameDirectory("/repo/nested/../project", "/repo/project"), true);
+ // Nonexistent paths degrade to the lexical comparison instead of failing.
+ NodeAssert.equal(yield* sameDirectory("/repo/project", "/repo/other"), false);
+
+ // A symlinked cwd (the macOS `/tmp` → `/private/tmp` shape) resolves to
+ // the directory it points at, so the two spellings compare equal.
+ const base = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-opencode-dir-" });
+ const real = path.join(base, "real");
+ const link = path.join(base, "link");
+ yield* fileSystem.makeDirectory(real);
+ yield* fileSystem.symlink(real, link);
+ NodeAssert.equal(yield* sameDirectory(link, real), true);
+ NodeAssert.equal(yield* sameDirectory(link, path.join(base, "other")), false);
+ }).pipe(Effect.scoped),
+ );
+
it.effect("appends raw assistant text deltas and reconciles part update snapshots", () =>
Effect.sync(() => {
const firstUpdate = mergeOpenCodeAssistantText(undefined, "Hello");
diff --git a/apps/server/src/provider/Layers/OpenCodeAdapter.ts b/apps/server/src/provider/Layers/OpenCodeAdapter.ts
index e7622e6c7..73c23b77e 100644
--- a/apps/server/src/provider/Layers/OpenCodeAdapter.ts
+++ b/apps/server/src/provider/Layers/OpenCodeAdapter.ts
@@ -17,6 +17,8 @@ import * as Crypto from "effect/Crypto";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as Scope from "effect/Scope";
@@ -53,6 +55,114 @@ import * as Option from "effect/Option";
const PROVIDER = ProviderDriverKind.make("opencode");
+/**
+ * Version tag stamped into the OpenCode resume cursor. Bump if the cursor
+ * shape changes so stale-shaped cursors written by older builds are ignored
+ * rather than misread (mirrors GROK_RESUME_VERSION / CURSOR_RESUME_VERSION).
+ */
+const OPENCODE_RESUME_VERSION = 1 as const;
+
+/**
+ * Decode a persisted resume cursor into the upstream `ses_…` id. Anything
+ * that isn't a current-version cursor with a non-empty id means "no resume"
+ * rather than an error. Re-adopting the session id IS the resume mechanism —
+ * OpenCode scopes a conversation's history by session id.
+ */
+function parseOpenCodeResume(raw: unknown): { readonly sessionId: string } | undefined {
+ if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+ return undefined;
+ }
+ const record = raw as Record<string, unknown>;
+ if (record.schemaVersion !== OPENCODE_RESUME_VERSION) {
+ return undefined;
+ }
+ if (typeof record.sessionId !== "string" || record.sessionId.trim().length === 0) {
+ return undefined;
+ }
+ return { sessionId: record.sessionId.trim() };
+}
+
+/**
+ * Whether an error definitively reports a missing session. Only a confirmed
+ * miss may silently start a fresh session; any other failure (the SDK client
+ * is `throwOnError: true`, so `session.get` rejects on every non-2xx) must
+ * propagate, or a transient blip resets a live thread to an empty one — the
+ * #3604 silent context loss. Decides on structured signals only, never free
+ * text: a numeric 404 or the exact `NotFoundError` name, found via a bounded walk
+ * over `cause`/`body`/`error`/`data`. An explicit non-404 status seals its
+ * subtree so a wrapped "NotFound" name can't reclassify a real failure.
+ * Exported for unit testing.
+ */
+export function isOpenCodeNotFound(cause: unknown): boolean {
+ const seen = new Set<unknown>();
+ const queue: Array<unknown> = [cause];
+ for (let steps = 0; queue.length > 0 && steps < 32; steps += 1) {
+ const node = queue.shift();
+ if (node === null || typeof node !== "object" || seen.has(node)) {
+ continue;
+ }
+ seen.add(node);
+ const record = node as Record<string, unknown>;
+
+ const response = record.response;
+ const statuses = [
+ record.status,
+ record.statusCode,
+ response !== null && typeof response === "object"
+ ? (response as { readonly status?: unknown }).status
+ : undefined,
+ ].filter((status): status is number => typeof status === "number");
+ if (statuses.includes(404)) {
+ return true;
+ }
+ if (statuses.length > 0) {
+ continue;
+ }
+
+ const name = record.name;
+ if (typeof name === "string" && name.toLowerCase() === "notfounderror") {
+ return true;
+ }
+
+ for (const key of ["cause", "body", "error", "data"] as const) {
+ if (record[key] !== undefined) {
+ queue.push(record[key]);
+ }
+ }
+ }
+ return false;
+}
+
+/**
+ * Whether two directory spellings name the same location. Raw string
+ * equality misreads a trailing slash, `.`/`..` segment, or symlinked cwd
+ * (macOS `/tmp` → `/private/tmp`) as a cwd change, needlessly forking the
+ * session on every resume. Lexically equal paths short-circuit; otherwise
+ * both sides go through `realPath`, each falling back to its lexical form
+ * on failure (deleted directory, external-server path) — so the probe can
+ * only widen matches, never split them. Takes the services as arguments so
+ * adapter methods stay service-free. Exported for unit testing.
+ */
+export function isSameOpenCodeDirectory(
+ fileSystem: FileSystem.FileSystem,
+ path: Path.Path,
+ left: string,
+ right: string,
+): Effect.Effect<boolean> {
+ const lexicalLeft = path.resolve(left);
+ const lexicalRight = path.resolve(right);
+ if (lexicalLeft === lexicalRight) {
+ return Effect.succeed(true);
+ }
+ const canonicalize = (lexical: string) =>
+ fileSystem.realPath(lexical).pipe(Effect.orElseSucceed(() => lexical));
+ return Effect.zipWith(
+ canonicalize(lexicalLeft),
+ canonicalize(lexicalRight),
+ (canonicalLeft, canonicalRight) => canonicalLeft === canonicalRight,
+ );
+}
+
interface OpenCodeTurnSnapshot {
readonly id: TurnId;
readonly items: Array<unknown>;
@@ -459,6 +569,10 @@ export function makeOpenCodeAdapter(
const serverConfig = yield* ServerConfig;
const openCodeRuntime = yield* OpenCodeRuntime;
const crypto = yield* Crypto.Crypto;
+ const fileSystem = yield* FileSystem.FileSystem;
+ const path = yield* Path.Path;
+ const sameDirectory = (left: string, right: string) =>
+ isSameOpenCodeDirectory(fileSystem, path, left, right);
const nativeEventLogger =
options?.nativeEventLogger ??
(options?.nativeEventLogPath !== undefined
@@ -1076,6 +1190,7 @@ export function makeOpenCodeAdapter(
const serverUrl = openCodeSettings.serverUrl;
const serverPassword = openCodeSettings.serverPassword;
const directory = input.cwd ?? serverConfig.cwd;
+ const resumeSessionId = parseOpenCodeResume(input.resumeCursor)?.sessionId;
const existing = sessions.get(input.threadId);
if (existing) {
yield* stopOpenCodeContext(existing);
@@ -1115,22 +1230,96 @@ export function makeOpenCodeAdapter(
}),
);
}
- const openCodeSession = yield* runOpenCodeSdk("session.create", () =>
- client.session.create({
- permission: buildOpenCodePermissionRules(input.runtimeMode),
- }),
- );
- if (!openCodeSession.data) {
- return yield* new OpenCodeRuntimeError({
- operation: "session.create",
- detail: "OpenCode session.create returned no session payload.",
- });
- }
+ // Resume: re-adopt the session named by the durable cursor —
+ // OpenCode scopes history by session id. The probe recovers only
+ // a confirmed not-found (start fresh); transport/auth/server
+ // errors propagate instead of masking as a new empty session.
+ const resolved = yield* Effect.gen(function* () {
+ const adopted = resumeSessionId
+ ? yield* runOpenCodeSdk("session.get", () =>
+ client.session.get({ sessionID: resumeSessionId }),
+ ).pipe(
+ Effect.map((response) => response.data),
+ Effect.catchIf(
+ (cause) => isOpenCodeNotFound(cause),
+ () => Effect.void,
+ ),
+ )
+ : undefined;
+
+ // Reuse in place only when the session still matches the
+ // requested cwd; on a cwd change it is forked below instead.
+ const reusable =
+ adopted &&
+ (!adopted.directory || (yield* sameDirectory(adopted.directory, directory)))
+ ? adopted
+ : undefined;
+
+ if (reusable) {
+ // Resume skips `session.create`, so re-assert the ruleset —
+ // a runtime-mode change would otherwise leave the session on
+ // its original permissions.
+ yield* runOpenCodeSdk("session.update", () =>
+ client.session.update({
+ sessionID: reusable.id,
+ permission: buildOpenCodePermissionRules(input.runtimeMode),
+ }),
+ );
+ return { openCodeSession: reusable, created: false };
+ }
+
+ // The session lives under a different cwd (e.g. the thread
+ // moved into a git worktree). Fork it into the requested
+ // directory instead of minting an empty one — the fork carries
+ // the full history, so the follow-up keeps its context (#3604).
+ if (adopted) {
+ yield* Effect.logInfo(
+ `OpenCode session '${adopted.id}' was created under a different working directory; forking into '${directory}' to preserve conversation history.`,
+ );
+ const forkedSession = yield* runOpenCodeSdk("session.fork", () =>
+ client.session.fork({ sessionID: adopted.id, directory }),
+ );
+ const forked = forkedSession.data;
+ if (!forked) {
+ return yield* new OpenCodeRuntimeError({
+ operation: "session.fork",
+ detail: "OpenCode session.fork returned no session payload.",
+ });
+ }
+ yield* runOpenCodeSdk("session.update", () =>
+ client.session.update({
+ sessionID: forked.id,
+ permission: buildOpenCodePermissionRules(input.runtimeMode),
+ }),
+ );
+ return { openCodeSession: forked, created: true };
+ }
+
+ if (resumeSessionId) {
+ yield* Effect.logWarning(
+ `OpenCode session '${resumeSessionId}' no longer exists; starting a fresh session.`,
+ );
+ }
+ const createdSession = yield* runOpenCodeSdk("session.create", () =>
+ client.session.create({
+ permission: buildOpenCodePermissionRules(input.runtimeMode),
+ }),
+ );
+ if (!createdSession.data) {
+ return yield* new OpenCodeRuntimeError({
+ operation: "session.create",
+ detail: "OpenCode session.create returned no session payload.",
+ });
+ }
+ return { openCodeSession: createdSession.data, created: true };
+ });
+
return {
sessionScope,
server,
client,
- openCodeSession: openCodeSession.data,
+ openCodeSession: resolved.openCodeSession,
+ created: resolved.created,
};
}).pipe(Effect.provideService(Scope.Scope, sessionScope)),
);
@@ -1145,13 +1334,16 @@ export function makeOpenCodeAdapter(
// and already inserted a session while we were awaiting async work.
const raceWinner = sessions.get(input.threadId);
if (raceWinner) {
- // Another call won the race – clean up the session we just created
- // (including the remote SDK session) and return the existing one.
- yield* runOpenCodeSdk("session.abort", () =>
- started.client.session.abort({
- sessionID: started.openCodeSession.id,
- }),
- ).pipe(Effect.ignore);
+ // Another call won the race — clean up. Only abort the remote
+ // session if we created it here; a resumed one is shared upstream
+ // state the winner is now using.
+ if (started.created) {
+ yield* runOpenCodeSdk("session.abort", () =>
+ started.client.session.abort({
+ sessionID: started.openCodeSession.id,
+ }),
+ ).pipe(Effect.ignore);
+ }
yield* Scope.close(started.sessionScope, Exit.void).pipe(Effect.ignore);
return raceWinner.session;
}
@@ -1165,6 +1357,13 @@ export function makeOpenCodeAdapter(
cwd: directory,
...(input.modelSelection ? { model: input.modelSelection.model } : {}),
threadId: input.threadId,
+ // ProviderService persists this cursor and feeds it back into
+ // `startSession` after the in-memory session is lost (reaper /
+ // restart), so follow-ups continue the same conversation (#3604).
+ resumeCursor: {
+ schemaVersion: OPENCODE_RESUME_VERSION,
+ sessionId: started.openCodeSession.id,
+ },
createdAt,
updatedAt: createdAt,
};
@@ -1330,6 +1529,11 @@ export function makeOpenCodeAdapter(
return {
threadId: input.threadId,
turnId,
+ // Re-surface the durable cursor on every turn so the persisted binding
+ // is refreshed alongside last-seen/runtime state (mirrors Grok/Codex).
+ ...(context.session.resumeCursor !== undefined
+ ? { resumeCursor: context.session.resumeCursor }
+ : {}),
};
});