From b226bb5b7a64e6919e2fbd3882dd54b91b59ed77 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 4 Nov 2026 18:09:18 +0000 Subject: [PATCH 1/6] test(opencode): reproduce cold-directory builtins-only skill snapshot (#31042) These tests reproduce #31042: a never-served OpenCode 2 directory whose first read lists the built-in commands and only built-in skills is returned as-is instead of waiting for its scan. They target the intended loadOpenCode2Workspace(read, scanned, loaded) signature, and a warm location is pinned to a single read without waiting. Co-Authored-By: Claude Opus 5.5 --- .../src/server/status.test.ts | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/packages/provider-opencode/src/server/status.test.ts b/packages/provider-opencode/src/server/status.test.ts index 802f544ae6f2d..d6aeee3734e9a 100644 --- a/packages/provider-opencode/src/server/status.test.ts +++ b/packages/provider-opencode/src/server/status.test.ts @@ -1076,3 +1076,33 @@ it.effect("reads a fresh OpenCode 2 directory again once its scan has ended", () NodeAssert.deepEqual(yield* Fiber.join(load), scanned); }), ); + +it.effect("waits for the scan of a cold OpenCode 2 directory that first lists only built-ins", () => + Effect.gen(function* () { + const calls: Array = []; + const reads: Array = [ + { commands: builtinCommands, skills: builtinSkills }, + scanned, + ]; + const workspace = yield* loadOpenCode2Workspace( + Effect.sync(() => (calls.push("read"), reads.shift()!)), + Effect.sync(() => void calls.push("scanned")), + Effect.sync(() => (calls.push("loaded"), false)), + ); + NodeAssert.deepEqual(workspace, scanned); + NodeAssert.deepEqual(calls, ["loaded", "read", "scanned", "read"]); + }), +); + +it.effect("reads an already loaded OpenCode 2 directory once without waiting for a scan", () => + Effect.gen(function* () { + const calls: Array = []; + const workspace = yield* loadOpenCode2Workspace( + Effect.sync(() => (calls.push("read"), scanned)), + Effect.sync(() => void calls.push("scanned")), + Effect.succeed(true), + ); + NodeAssert.deepEqual(workspace, scanned); + NodeAssert.deepEqual(calls, ["read"]); + }), +); From 878bef4d524059965e62037fc8e3f500387dcc44 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 4 Nov 2026 18:14:23 +0000 Subject: [PATCH 2/6] fix(opencode): wait for a cold directory's scan before caching its skills OpenCode 2 can answer the first read of a directory it has not loaded yet with built-ins only (or a partial list) while its background scan runs, so the `$` picker cached just `opencode` and `report` for the snapshot TTL. Ask the server which locations it has loaded (`GET /api/debug/location`) before the first read. A cold location waits for the scan's `command.updated` + `skill.updated` events and reads again; a loaded one returns the first read. Servers without the debug route keep the previous "first read lists commands" heuristic. Co-Authored-By: Claude Opus 5.5 --- packages/provider-opencode/src/server/driver.ts | 4 ++++ .../provider-opencode/src/server/status.test.ts | 14 ++++++++++++++ packages/provider-opencode/src/server/status.ts | 17 +++++++++++------ 3 files changed, 29 insertions(+), 6 deletions(-) diff --git a/packages/provider-opencode/src/server/driver.ts b/packages/provider-opencode/src/server/driver.ts index eb62d44b9aa94..849b852f5e131 100644 --- a/packages/provider-opencode/src/server/driver.ts +++ b/packages/provider-opencode/src/server/driver.ts @@ -325,6 +325,10 @@ export const OpenCodeDriver: ProviderDriver< { concurrency: "unbounded" }, ), Deferred.await(scanned), + client.debug.location.list().pipe( + Effect.map((loaded) => loaded.some((entry) => entry.directory === cwd)), + Effect.orElseSucceed(() => undefined), + ), ); }).pipe(Effect.scoped), ); diff --git a/packages/provider-opencode/src/server/status.test.ts b/packages/provider-opencode/src/server/status.test.ts index d6aeee3734e9a..b470776a6965f 100644 --- a/packages/provider-opencode/src/server/status.test.ts +++ b/packages/provider-opencode/src/server/status.test.ts @@ -1069,6 +1069,7 @@ it.effect("reads a fresh OpenCode 2 directory again once its scan has ended", () const load = yield* loadOpenCode2Workspace( Effect.sync(() => reads.shift()!), Deferred.await(scanEnded), + Effect.succeed(false), ).pipe(Effect.forkChild); yield* Effect.yieldNow; NodeAssert.equal(reads.length, 1); @@ -1106,3 +1107,16 @@ it.effect("reads an already loaded OpenCode 2 directory once without waiting for NodeAssert.deepEqual(calls, ["read"]); }), ); + +it.effect("trusts a first read that lists commands when the loaded locations are unknown", () => + Effect.gen(function* () { + const calls: Array = []; + const workspace = yield* loadOpenCode2Workspace( + Effect.sync(() => (calls.push("read"), scanned)), + Effect.sync(() => void calls.push("scanned")), + Effect.sync(() => undefined), + ); + NodeAssert.deepEqual(workspace, scanned); + NodeAssert.deepEqual(calls, ["read"]); + }), +); diff --git a/packages/provider-opencode/src/server/status.ts b/packages/provider-opencode/src/server/status.ts index c113bd5551e84..c52c08294660d 100644 --- a/packages/provider-opencode/src/server/status.ts +++ b/packages/provider-opencode/src/server/status.ts @@ -526,15 +526,20 @@ export interface OpenCode2Workspace { } /** - * A server scans a directory it has not served yet in the background: its first read lists - * no commands at all (not even the built-ins), and `command.updated` plus `skill.updated` - * for the directory end the scan. `scanned` must be listening before `read` runs, since - * the read is what starts the scan. + * Reading a location the server has not loaded boots its scan, and only reads after the + * scan's `command.updated` plus `skill.updated` are complete; `scanned` must listen before + * `read`. `loaded` is checked before the first read; when unknown (`undefined`), a first read + * listing commands is taken as done. */ export const loadOpenCode2Workspace = Effect.fn("OpencodeProviderStatus.loadOpenCode2Workspace")( - function* (read: Effect.Effect, scanned: Effect.Effect) { + function* ( + read: Effect.Effect, + scanned: Effect.Effect, + loaded: Effect.Effect, + ) { + const wasLoaded = yield* loaded; const first = yield* read; - if (first.commands.length > 0) return first; + if (wasLoaded ?? first.commands.length > 0) return first; yield* scanned.pipe(Effect.timeoutOption("10 seconds")); return yield* read; }, From 4be38a26b80fa35a13198a951961d20a132dc4b6 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 4 Nov 2026 18:28:46 +0000 Subject: [PATCH 3/6] fix(opencode): wait for a loaded directory whose scan has not settled A location another caller just booted is listed as loaded while its first read still lists no commands; keep waiting for its scan in that case. Treat an unknown loaded state like a loaded one, and compare OpenCode's resolved location path so a trailing slash does not make a warm read wait. Co-Authored-By: Claude Opus 5.5 --- packages/provider-opencode/src/server/driver.ts | 10 ++++++---- packages/provider-opencode/src/server/status.test.ts | 9 +++++---- packages/provider-opencode/src/server/status.ts | 11 +++++------ 3 files changed, 16 insertions(+), 14 deletions(-) diff --git a/packages/provider-opencode/src/server/driver.ts b/packages/provider-opencode/src/server/driver.ts index 849b852f5e131..e05c7bb6d9d61 100644 --- a/packages/provider-opencode/src/server/driver.ts +++ b/packages/provider-opencode/src/server/driver.ts @@ -298,7 +298,9 @@ export const OpenCodeDriver: ProviderDriver< const listOpenCode2Workspace = (cwd: string) => openCode2Server.withConnection(({ client, events }) => Effect.gen(function* () { - const location = { directory: cwd }; + // OpenCode names a location by its resolved path (no trailing slash or `..`). + const directory = pathService.resolve(cwd); + const location = { directory }; const scanned = yield* Deferred.make(); const pending = new Set(["command.updated", "skill.updated"]); const stream = yield* events.pipe(Effect.option); @@ -306,7 +308,7 @@ export const OpenCodeDriver: ProviderDriver< yield* stream.value.pipe( Stream.runForEach((event) => "location" in event && - event.location?.directory === cwd && + event.location?.directory === directory && pending.delete(event.type) && pending.size === 0 ? Deferred.succeed(scanned, undefined) @@ -326,8 +328,8 @@ export const OpenCodeDriver: ProviderDriver< ), Deferred.await(scanned), client.debug.location.list().pipe( - Effect.map((loaded) => loaded.some((entry) => entry.directory === cwd)), - Effect.orElseSucceed(() => undefined), + Effect.map((loaded) => loaded.some((entry) => entry.directory === directory)), + Effect.orElseSucceed(() => true), ), ); }).pipe(Effect.scoped), diff --git a/packages/provider-opencode/src/server/status.test.ts b/packages/provider-opencode/src/server/status.test.ts index b470776a6965f..d34e2c8bf66fd 100644 --- a/packages/provider-opencode/src/server/status.test.ts +++ b/packages/provider-opencode/src/server/status.test.ts @@ -1108,15 +1108,16 @@ it.effect("reads an already loaded OpenCode 2 directory once without waiting for }), ); -it.effect("trusts a first read that lists commands when the loaded locations are unknown", () => +it.effect("waits for the scan of a loaded OpenCode 2 directory that lists no commands yet", () => Effect.gen(function* () { const calls: Array = []; + const reads: Array = [{ commands: [], skills: [] }, scanned]; const workspace = yield* loadOpenCode2Workspace( - Effect.sync(() => (calls.push("read"), scanned)), + Effect.sync(() => (calls.push("read"), reads.shift()!)), Effect.sync(() => void calls.push("scanned")), - Effect.sync(() => undefined), + Effect.succeed(true), ); NodeAssert.deepEqual(workspace, scanned); - NodeAssert.deepEqual(calls, ["read"]); + NodeAssert.deepEqual(calls, ["read", "scanned", "read"]); }), ); diff --git a/packages/provider-opencode/src/server/status.ts b/packages/provider-opencode/src/server/status.ts index c52c08294660d..c8c7829d40166 100644 --- a/packages/provider-opencode/src/server/status.ts +++ b/packages/provider-opencode/src/server/status.ts @@ -526,20 +526,19 @@ export interface OpenCode2Workspace { } /** - * Reading a location the server has not loaded boots its scan, and only reads after the - * scan's `command.updated` plus `skill.updated` are complete; `scanned` must listen before - * `read`. `loaded` is checked before the first read; when unknown (`undefined`), a first read - * listing commands is taken as done. + * Reading a location the server has not loaded boots its scan, and a location another caller + * just booted lists no commands until its scan settles. Only reads after the scan's + * `command.updated` plus `skill.updated` are complete; `scanned` must listen before `read`. */ export const loadOpenCode2Workspace = Effect.fn("OpencodeProviderStatus.loadOpenCode2Workspace")( function* ( read: Effect.Effect, scanned: Effect.Effect, - loaded: Effect.Effect, + loaded: Effect.Effect, ) { const wasLoaded = yield* loaded; const first = yield* read; - if (wasLoaded ?? first.commands.length > 0) return first; + if (wasLoaded && first.commands.length > 0) return first; yield* scanned.pipe(Effect.timeoutOption("10 seconds")); return yield* read; }, From 1c3eaa0316cd64ba3ed31cd5d1e1ff6087b4638c Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 4 Nov 2026 18:39:01 +0000 Subject: [PATCH 4/6] docs(opencode): state the remaining readiness gap in the workspace loader Co-Authored-By: Claude Opus 5.5 --- packages/provider-opencode/src/server/status.ts | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/packages/provider-opencode/src/server/status.ts b/packages/provider-opencode/src/server/status.ts index c8c7829d40166..3fa6ca3c3c578 100644 --- a/packages/provider-opencode/src/server/status.ts +++ b/packages/provider-opencode/src/server/status.ts @@ -526,9 +526,10 @@ export interface OpenCode2Workspace { } /** - * Reading a location the server has not loaded boots its scan, and a location another caller - * just booted lists no commands until its scan settles. Only reads after the scan's - * `command.updated` plus `skill.updated` are complete; `scanned` must listen before `read`. + * Reading a location the server has not loaded boots its scan, and only reads after the scan's + * `command.updated` plus `skill.updated` are complete; `scanned` must listen before `read`. A + * loaded location listing no commands is still scanning. OpenCode exposes no readiness signal, + * so one another caller booted moments earlier can still read partial. */ export const loadOpenCode2Workspace = Effect.fn("OpencodeProviderStatus.loadOpenCode2Workspace")( function* ( From d062c5db47ab6ef239526507cbe3a7c794d71097 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 10 Nov 2026 23:24:14 +0000 Subject: [PATCH 5/6] fix(opencode): a stalled location list or event stream no longer blocks workspace discovery Bound the loaded-location check to 2 seconds and skip it when the event stream is unavailable, so the cold-directory wait cannot outlast the snapshot deadline on servers where discovery works on main. AI-assisted; verified with the tests and tools listed above. Co-Authored-By: Claude Opus 5.5 --- .../src/server/driver.test.ts | 45 ++++++++++++++++++- .../provider-opencode/src/server/driver.ts | 12 +++-- 2 files changed, 52 insertions(+), 5 deletions(-) diff --git a/packages/provider-opencode/src/server/driver.test.ts b/packages/provider-opencode/src/server/driver.test.ts index 0dcb6cc53997d..5e5df4e0c5c77 100644 --- a/packages/provider-opencode/src/server/driver.test.ts +++ b/packages/provider-opencode/src/server/driver.test.ts @@ -36,7 +36,11 @@ import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEve import * as ProviderMaintenance from "@t3tools/provider-core/server/maintenanceResolver"; import * as OpenCodeRuntime from "./OpenCodeRuntime.ts"; import * as OpenCodeServerLedger from "./OpenCodeServerLedger.ts"; -import { OPENCODE_2_RESPONSES, replayOpenCodeServer } from "./probeResponses.fixture.ts"; +import { + OPENCODE_2_RESPONSES, + OPENCODE_2_WORKSPACE_RESPONSES, + replayOpenCodeServer, +} from "./probeResponses.fixture.ts"; import { OpenCodeDriver, openCodeUpdateFor } from "./driver.ts"; import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost"; @@ -347,6 +351,45 @@ it.layer(layer)("OpenCodeDriver runtime selection", (it) => { }).pipe(Effect.scoped, Effect.provide(TestClock.layer())), ); + it.effect.each(["/api/debug/location", "/api/event"])( + "lists workspace skills from an external OpenCode 2 server whose %s never answers", + (stalled) => + Effect.gen(function* () { + const answers: Record = { + "/api/info": OPENCODE_2_RESPONSES["/api/info"].body, + "/api/debug/location": "[]", + "/api/command": OPENCODE_2_WORKSPACE_RESPONSES["/api/command"].body, + "/api/skill": OPENCODE_2_WORKSPACE_RESPONSES["/api/skill"].body, + }; + const http = HttpClient.make((request) => { + const path = new URL(request.url).pathname; + if (path === stalled) return Effect.never; + if (path === "/api/event") + return Effect.succeed( + HttpClientResponse.fromWeb( + request, + new Response(new ReadableStream(), { + headers: { "content-type": "text/event-stream" }, + }), + ), + ); + const body = answers[path]; + return body === undefined + ? Effect.die(`Unexpected request: ${path}`) + : Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(JSON.parse(body)))); + }); + const instance = yield* create({ serverUrl: "http://127.0.0.1:4096" }, http); + + const snapshot = yield* instance.snapshotForCwd!("/work").pipe(Effect.forkChild); + yield* TestClock.adjust("30 seconds"); + const { skills } = yield* Fiber.join(snapshot); + assert.include( + skills.map((skill) => skill.name), + "plum", + ); + }).pipe(Effect.scoped, Effect.provide(TestClock.layer())), + ); + it.effect.each(["probe", "error", "empty"] as const)( "recovers discovery without a manual refresh after %s", (initialCatalog) => diff --git a/packages/provider-opencode/src/server/driver.ts b/packages/provider-opencode/src/server/driver.ts index 9f0a068434f9e..c87daee4dea14 100644 --- a/packages/provider-opencode/src/server/driver.ts +++ b/packages/provider-opencode/src/server/driver.ts @@ -368,10 +368,14 @@ export const OpenCodeDriver: ProviderDriver< { concurrency: "unbounded" }, ), Deferred.await(scanned), - client.debug.location.list().pipe( - Effect.map((loaded) => loaded.some((entry) => entry.directory === directory)), - Effect.orElseSucceed(() => true), - ), + // Without events no scan can be awaited, so trust the first read as before. + stream._tag === "None" + ? Effect.succeed(true) + : client.debug.location.list().pipe( + Effect.map((loaded) => loaded.some((entry) => entry.directory === directory)), + Effect.timeout("2 seconds"), + Effect.orElseSucceed(() => true), + ), ); }).pipe(Effect.scoped), ); From 15cca99a5265589e2b2444e5dd1d0b8a72913fd7 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Wed, 11 Nov 2026 00:04:47 +0000 Subject: [PATCH 6/6] test(opencode): fold the loaded-but-empty case into the existing scan test AI-assisted; verified with the tests and tools listed above. --- .../src/server/status.test.ts | 44 +++++++------------ 1 file changed, 16 insertions(+), 28 deletions(-) diff --git a/packages/provider-opencode/src/server/status.test.ts b/packages/provider-opencode/src/server/status.test.ts index 06c38d06dfb55..11dbaff6b51ff 100644 --- a/packages/provider-opencode/src/server/status.test.ts +++ b/packages/provider-opencode/src/server/status.test.ts @@ -1066,20 +1066,22 @@ const scanned: OpenCode2Workspace = { ], }; -it.effect("reads a fresh OpenCode 2 directory again once its scan has ended", () => - Effect.gen(function* () { - const reads: Array = [{ commands: [], skills: [] }, scanned]; - const scanEnded = yield* Deferred.make(); - const load = yield* loadOpenCode2Workspace( - Effect.sync(() => reads.shift()!), - Deferred.await(scanEnded), - Effect.succeed(false), - ).pipe(Effect.forkChild); - yield* Effect.yieldNow; - NodeAssert.equal(reads.length, 1); - yield* Deferred.succeed(scanEnded, undefined); - NodeAssert.deepEqual(yield* Fiber.join(load), scanned); - }), +it.effect( + "reads a loaded OpenCode 2 directory listing no commands again once its scan has ended", + () => + Effect.gen(function* () { + const reads: Array = [{ commands: [], skills: [] }, scanned]; + const scanEnded = yield* Deferred.make(); + const load = yield* loadOpenCode2Workspace( + Effect.sync(() => reads.shift()!), + Deferred.await(scanEnded), + Effect.succeed(true), + ).pipe(Effect.forkChild); + yield* Effect.yieldNow; + NodeAssert.equal(reads.length, 1); + yield* Deferred.succeed(scanEnded, undefined); + NodeAssert.deepEqual(yield* Fiber.join(load), scanned); + }), ); it.effect("waits for the scan of a cold OpenCode 2 directory that first lists only built-ins", () => @@ -1111,17 +1113,3 @@ it.effect("reads an already loaded OpenCode 2 directory once without waiting for NodeAssert.deepEqual(calls, ["read"]); }), ); - -it.effect("waits for the scan of a loaded OpenCode 2 directory that lists no commands yet", () => - Effect.gen(function* () { - const calls: Array = []; - const reads: Array = [{ commands: [], skills: [] }, scanned]; - const workspace = yield* loadOpenCode2Workspace( - Effect.sync(() => (calls.push("read"), reads.shift()!)), - Effect.sync(() => void calls.push("scanned")), - Effect.succeed(true), - ); - NodeAssert.deepEqual(workspace, scanned); - NodeAssert.deepEqual(calls, ["read", "scanned", "read"]); - }), -);