[diegosouzapw]

Summary

tests/unit/upstream-error-call-log-16558.test.ts reads each call-log row back through a helper
that polled 200 × 20 ms (~4 s) for the row to settle. The row's detail artifact is written by a
worker thread (src/lib/usage/callLogArtifactWriter.ts) that starts cold on the first write; in a
source checkout it is spawned with --import tsx/esm. On a loaded machine that start took 8–20 s,
so the first one or two cases failed with attempt did not reach durable call-log detail.

persistAttemptLogs hands the row to saveCallLog synchronously, so the helper now awaits
waitForCallLogSaves() (row inserted and detail published: ready, or missing if the write
failed) with a 60 s bound that only turns a hung save into a failure, then asserts the row settled
and reads it. The assertions are unchanged; no production code is touched.

Evidence

• Release tip a016744417, unchanged test, devbox load ~6–7: 3/3 runs red (pass 4 fail 2,
  pass 4 fail 2, pass 5 fail 1); the first case spent 14.1 s and the second 5.6 s before
  failing.
• The same failure on a clean base is recorded independently in feat(sse): opt-in relevance-based tool disclosure for large tool sets #16861 and fix(sse): preserve provider safety stops through routing #17049
  (tests 6 pass 5 fail 1).
• Hosted CI does not show it: in a run whose base already has fix(release): drain four more reds left by 2026-10-18 merges — ConnectionRow mocks, Docker heap anchor, call-log readiness (base-red #15306) #17060 the first case took 193 ms.
  The race only bites when the worker's cold start is slow — i.e. on the shared devbox where local
  validation runs.
• With this change: 5/5 runs pass 6 fail 0 at load ~5–6; the first case takes ~8 s (the
  worker start) and the others ~20–30 ms.
• Mutation check: with the artifact write disabled in publishCallLogDetail() the file goes
  pass 1 fail 5 — the readers still catch a missing detail (only the no-log case, which expects
  null, passes).

Same class elsewhere (not changed here)

The worker comes online in ~0.1 s, but its first reply took 6.7–8.4 s on the devbox at load
3–5: tsx loads its import graph in the fresh thread (callLogArtifacts.ts pulls
open-sse/utils/requestLogger.ts). Other call-log readers have shorter bounds and fail the same
way there, also when run alone (--test-concurrency=1): call-logs-id-collision (10 s),
image-usage-accounting (5 s), copilot-learned-catalog-15634 (2 s), chatcore-attempt-logging,
chat-keepalive-correlation-functional, estimated-usage-billing-guard,
provider-request-failure-pipeline, and tests/integration/reasoning-routing-pipeline.test.ts
(harness waitFor, 1.5 s default). They pass on hosted CI. Left for a follow-up: move those
bounds onto the same barrier, or make the worker's import graph lighter.

Validation

• Prettier and ESLint (with the suppressions file) clean.
• Typecheck of the touched file: 0 errors (2 inherited in the imported
  open-sse/transformer/responsesTransformer.ts and open-sse/utils/sseHeartbeat.ts).

Refs #15306

⚠️ base-red inherited: #15306

[github-actions]

CI Coverage Report

• Coverage job: skipped
• PR test policy: success

Coverage artifact was not available for this run.