fix(client): bound unresponsive service recovery

packages/client/src/effect/service.ts

@@ -48,11 +48,11 @@ const discoverLocal = Effect.fnUntraced(function* (options: DiscoverOptions) {
 })
 
 // Idempotent ensure-running: reuses a healthy compatible server, replaces a
-// version-mismatched one, and otherwise spawns small contenders until a server
-// becomes discoverable. A contender is never killed merely for slow startup.
+// version-mismatched one, and otherwise spawns one contender until a server
+// becomes discoverable. The contender is never killed merely for slow startup.
 /** Ensure a healthy, compatible local service is running. */
 export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOptions = {}) {
-  const contenders = new Set<Contender>()
+  let contender: Contender | undefined
   let timeouts: { readonly info: Info; readonly count: number } | undefined
   let announced = false
   let lastSpawn = 0
@@ -108,17 +108,16 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
       return Option.none<LocalService>()
     } else if (lastSpawn === 0 && info !== undefined) lastSpawn = Date.now()
 
-    const finished = [...contenders].filter(contenderFinished)
-    const failure = finished.map(contenderFailure).find((error): error is Error => error !== undefined)
-    if (finished.some((item) => item.child.exitCode === 0)) {
+    const finished = contender !== undefined && contenderFinished(contender) ? contender : undefined
+    const failure = finished === undefined ? undefined : contenderFailure(finished)
+    if (finished?.child.exitCode === 0) {
       spawnDelay = Math.min(spawnDelay * 2, 30_000)
     }
-    finished.forEach((item) => contenders.delete(item))
-    if (failure !== undefined && contenders.size === 0) return yield* Effect.fail(failure)
-    // Keep one candidate plus one lock probe so a pre-lock stall cannot block recovery.
-    if (contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay) {
+    if (finished !== undefined) contender = undefined
+    if (failure !== undefined) return yield* Effect.fail(failure)
+    if (contender === undefined && Date.now() - lastSpawn >= spawnDelay) {
       yield* announce("missing")
-      contenders.add(yield* spawnContender)
+      contender = yield* spawnContender
       lastSpawn = Date.now()
     }
     return Option.none<LocalService>()
@@ -206,7 +205,7 @@ const probeResult = Effect.fnUntraced(function* (info: Info, allowLegacy = false
         ? undefined
         : { type: "basic" as const, username: "opencode", password: info.password },
   } satisfies Endpoint
-  const signal = AbortSignal.timeout(2_000)
+  const signal = AbortSignal.timeout(3_000)
   const result = yield* Effect.promise(() =>
     fetch(new URL("/api/health", info.url), {
       headers: headers(endpoint),

packages/client/src/promise/service.ts

@@ -33,7 +33,7 @@ async function discoverLocal(options: DiscoverOptions) {
 /** Ensure a healthy, compatible local service is running. */
 export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
   const deadline = Date.now() + 120_000
-  const contenders = new Set<Contender>()
+  let contender: Contender | undefined
   let timeouts: { readonly info: Info; readonly count: number } | undefined
   let announced = false
   let lastSpawn = 0
@@ -89,17 +89,16 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
       }
     } else {
       if (lastSpawn === 0 && registration.info !== undefined) lastSpawn = Date.now()
-      const finished = [...contenders].filter(contenderFinished)
-      const failure = finished.map(contenderFailure).find((error) => error !== undefined)
-      if (finished.some((item) => item.child.exitCode === 0)) {
+      const finished = contender !== undefined && contenderFinished(contender) ? contender : undefined
+      const failure = finished === undefined ? undefined : contenderFailure(finished)
+      if (finished?.child.exitCode === 0) {
         spawnDelay = Math.min(spawnDelay * 2, 30_000)
       }
-      finished.forEach((item) => contenders.delete(item))
-      if (failure !== undefined && contenders.size === 0) throw failure
-      // Keep one candidate plus one lock probe so a pre-lock stall cannot block recovery.
-      if (contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay) {
+      if (finished !== undefined) contender = undefined
+      if (failure !== undefined) throw failure
+      if (contender === undefined && Date.now() - lastSpawn >= spawnDelay) {
         announce("missing")
-        contenders.add(spawnContender())
+        contender = spawnContender()
         lastSpawn = Date.now()
       }
     }
@@ -169,7 +168,7 @@ async function probeResult(info: Info, allowLegacy = false) {
         ? undefined
         : { type: "basic" as const, username: "opencode", password: info.password },
   } satisfies Endpoint
-  const signal = AbortSignal.timeout(2_000)
+  const signal = AbortSignal.timeout(3_000)
   const result = await fetch(new URL("/api/health", info.url), {
     headers: headers(endpoint),
     signal,

packages/client/test/fixture/service.ts

@@ -9,16 +9,13 @@ if (mode === "record-start") {
 }
 if (mode === "signal") process.kill(process.pid, process.platform === "win32" ? "SIGTERM" : "SIGKILL")
 
-if (mode === "delayed" || mode === "delayed-failed" || mode === "coordinated" || mode === "coordinated-failed-loser") {
+if (mode === "delayed" || mode === "delayed-failed") {
   await appendFile(registration + ".starts", process.pid + "\n")
   const owner = await writeFile(registration + ".owner", String(process.pid), { flag: "wx" })
     .then(() => true)
     .catch(() => false)
-  if (!owner) process.exit(mode === "coordinated-failed-loser" ? 1 : 0)
-  if (mode === "coordinated" || mode === "coordinated-failed-loser") {
-    while ((await Bun.file(registration + ".starts").text()).trim().split("\n").length < 2) await Bun.sleep(10)
-    if (mode === "coordinated-failed-loser") await Bun.sleep(1_500)
-  } else await Bun.sleep(Number(delay))
+  if (!owner) process.exit(0)
+  await Bun.sleep(Number(delay))
   if (mode === "delayed-failed") process.exit(1)
 }
 

packages/client/test/promise-service.test.ts

@@ -31,7 +31,7 @@ test("ensures a missing service with native promises", async () => {
   const endpoint = await Service.ensure({
     file: registration,
     version: "test",
-    command: [process.execPath, fixture, registration, "coordinated"],
+    command: [process.execPath, fixture, registration, "delayed", "100"],
     onStart: (reason) => starts.push(reason),
   })
   const info = await Bun.file(registration).json()
@@ -44,24 +44,6 @@ test("ensures a missing service with native promises", async () => {
   }
 }, 15_000)
 
-test("waits for a live contender when another native contender fails", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-
-  const endpoint = await Service.ensure({
-    file: registration,
-    version: "test",
-    command: [process.execPath, fixture, registration, "coordinated-failed-loser"],
-  })
-  const info = await Bun.file(registration).json()
-  try {
-    expect(endpoint.url).toBe(info.url)
-  } finally {
-    process.kill(info.pid, "SIGTERM")
-    await waitForExit(info.pid)
-  }
-}, 15_000)
-
 test("reports a failed registered service", async () => {
   const registration = await setup("failed-owner")
 
@@ -88,13 +70,13 @@ test("evicts an unresponsive registered service before starting its replacement"
   })
   const replacement = await Bun.file(registration).json()
 
-  expect((await Bun.file(registration + ".requests").text()).trim().split("\n")).toHaveLength(3)
+  expect((await Bun.file(registration + ".requests").text()).trim().split("\n").length).toBeGreaterThanOrEqual(2)
   expect(await existing.exited).toBe(0)
   expect(replacement.pid).not.toBe(original.pid)
   expect(endpoint.url).toBe(replacement.url)
   process.kill(replacement.pid, "SIGTERM")
   await waitForExit(replacement.pid)
-}, 20_000)
+}, 30_000)
 
 test("requests graceful stop of the exact service instance", async () => {
   const registration = await setup("graceful")

packages/client/test/service.test.ts

@@ -86,13 +86,13 @@ test("evicts an unresponsive registered service before starting its replacement"
   )
   const replacement = await Bun.file(registration).json()
 
-  expect((await Bun.file(registration + ".requests").text()).trim().split("\n")).toHaveLength(3)
+  expect((await Bun.file(registration + ".requests").text()).trim().split("\n").length).toBeGreaterThanOrEqual(2)
   expect(await existing.exited).toBe(0)
   expect(replacement.pid).not.toBe(original.pid)
   expect(endpoint.url).toBe(replacement.url)
   expect(await health(endpoint.url)).toEqual({ healthy: true, version: "test", pid: replacement.pid })
   process.kill(replacement.pid, "SIGTERM")
-}, 20_000)
+}, 30_000)
 
 test("requests graceful stop of the exact service instance", async () => {
   const directory = await temp()
@@ -145,39 +145,21 @@ test("a legacy health response is still replaced", async () => {
   await existing.exited
 }, 10_000)
 
-test("waits for a slow winner while bounding lock probes", async () => {
+test("does not spawn another contender while the first is starting", async () => {
   const directory = await temp()
   const registration = join(directory, "service.json")
   const endpoint = await run(
     Service.ensure({
       file: registration,
       version: "test",
-      command: [process.execPath, fixture, registration, "coordinated"],
+      command: [process.execPath, fixture, registration, "delayed", "6000"],
     }),
   )
   const info = await Bun.file(registration).json()
   try {
     expect(endpoint.url).toBe(info.url)
     expect(await health(endpoint.url)).toEqual({ healthy: true, version: "test", pid: info.pid })
-    expect((await Bun.file(registration + ".starts").text()).trim().split("\n")).toHaveLength(2)
-  } finally {
-    process.kill(info.pid, "SIGTERM")
-  }
-}, 15_000)
-
-test("waits for a live contender when another contender fails", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const endpoint = await run(
-    Service.ensure({
-      file: registration,
-      version: "test",
-      command: [process.execPath, fixture, registration, "coordinated-failed-loser"],
-    }),
-  )
-  const info = await Bun.file(registration).json()
-  try {
-    expect(endpoint.url).toBe(info.url)
+    expect((await Bun.file(registration + ".starts").text()).trim().split("\n")).toHaveLength(1)
   } finally {
     process.kill(info.pid, "SIGTERM")
   }

packages/core/src/config.ts

@@ -151,7 +151,13 @@ export const layer = (options?: Options) =>
             )
             if (!credential || credential.value.type !== "key") return []
             const variables = { [auth.env]: credential.value.key }
-            const configs = yield* wellknown.resolve(entry, variables).pipe(Effect.orDie)
+            const configs = yield* wellknown.resolve(entry, variables).pipe(
+              Effect.catch(() =>
+                Effect.logWarning("failed to load wellknown config", { source: entry.origin }).pipe(
+                  Effect.as([] as const),
+                ),
+              ),
+            )
             return yield* Effect.forEach(configs, (config) =>
               ConfigVariable.substitute({
                 type: "virtual",

packages/core/test/config/config.test.ts

@@ -307,7 +307,7 @@ describe("Config", () => {
     }),
   )
 
-  it.live("loads authenticated wellknown config before user configuration", () =>
+  it.live("tolerates unavailable authenticated wellknown config and reloads it later", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),
       (tmp) =>
@@ -322,6 +322,7 @@ describe("Config", () => {
           })
 
           const integrationID = Integration.ID.make("https://example.com")
+          let available = false
           let key = "secret"
           const credentialNode = makeGlobalNode({
             service: Credential.Service,
@@ -361,7 +362,10 @@ describe("Config", () => {
                 refresh: () => Effect.succeed(false),
                 add: () => Effect.die("unused Wellknown.add"),
                 remove: () => Effect.die("unused Wellknown.remove"),
-                resolve: (_entry, variables) => Effect.succeed([{ shell: variables.TOKEN }]),
+                resolve: (_entry, variables) =>
+                  available
+                    ? Effect.succeed([{ shell: variables.TOKEN }])
+                    : Effect.fail(new Error("expired credential")),
               }),
             ),
             deps: [],
@@ -374,11 +378,12 @@ describe("Config", () => {
             expect(Config.latest(initial, "shell")).toBe("project")
             expect(
               initial.flatMap((entry) => (entry.type === "document" && entry.info.shell ? [entry.info.shell] : [])),
-            ).toEqual(["secret", "global", "project"])
+            ).toEqual(["global", "project"])
             const updated = yield* bus
               .subscribe(Event.Updated)
               .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped)
             yield* Effect.yieldNow
+            available = true
             key = "next"
             yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID })
             expect(yield* Fiber.join(updated)).toHaveLength(1)

packages/theme/src/tui/syntax.ts

@@ -12,7 +12,7 @@ export function generateSyntax(theme: ResolvedThemeTokens, mode: Mode) {
     rule(["prompt"], theme.hue.accent[step]),
     rule(["extmark.file"], feedback.warning.default, { bold: true }),
     rule(["extmark.agent"], theme.categorical[0][step], { bold: true }),
-    rule(["extmark.skill"], theme.categorical[1][step], { bold: true }),
+    rule(["extmark.skill"], (theme.categorical[1] ?? theme.categorical[0])[step], { bold: true }),
     // V1 migration preserves its selected/inverse foreground in this action state.
     rule(["extmark.paste"], theme.text.action.primary.focused, {
       background: feedback.warning.default,

packages/tui/test/theme/v2/resolve.test.ts

@@ -2,6 +2,7 @@ import { expect, test } from "bun:test"
 import { RGBA } from "@opentui/core"
 import {
   DEFAULT_THEME,
+  generateSyntax,
   resolveTheme,
   resolveThemeDocument,
   selectTheme,
@@ -42,6 +43,14 @@ test("validates and resolves categorical hues in configured order", () => {
   expect(() => resolveSource({ version: 2, light: { categorical: ["magenta"] } }, "light")).toThrow("Invalid theme")
 })
 
+test("generates syntax with one categorical hue", () => {
+  const theme = resolveSource({ version: 2, light: { categorical: ["red"] } }, "light")
+  const syntax = generateSyntax(theme, "light")
+
+  expect(syntax.getStyleId("extmark.skill")).not.toBeNull()
+  syntax.destroy()
+})
+
 test("uses the default categorical order for direct definitions", () => {
   const theme = resolveTheme({ ...light, categorical: undefined })