Session 0hNPvDPCvLOp

<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`. ...

<path>/home/byk/Code/opencode-lore-provider-error</path>
<type>directory</type>
<entries>
.craft.yml
.git
.github/
.gitignore
.jj/
.lore.md
.oxfmtrc.json
.oxlintrc.json
AGENTS.md
CHANGELOG.md
codecov.yml
LICENSE
node_modules/
package.json
packages/
patches/
pnpm-lock.yaml
pnpm-workspace.yaml
quality/
README.md
scripts/
stryker.config.mjs
supabase/
tsconfig.base.json
tsconfig.json
vitest.config.ts
vitest.evals.config.ts
vitest.mutation.config.ts

(28 entries)
</entries>

<path>/home/byk/Code/opencode-lore-provider-error/AGENTS.md</path>
<type>file</type>
<content>
1: <!-- This section is maintained by the coding agent via lore (https://github.com/BYK/loreai) -->
2: ## Long-term Knowledge
3: 
4: For long-term knowledge entries managed by [lore](https://github.com/BYK/loreai) (gotchas, patterns, decisions, architecture), see [`.lore.md`](.lore.md) in the project root.
5: <!-- End lore-managed section -->
6: 
7: ## Review
8: 
9: See [`quality/REVIEW.md`](quality/REVIEW.md) for the review heuristics and workflow — regression-test discipline, adversarial-order state setup, fan-out registry coverage, recurring bug-class batteries, and the two-reviewer rule. Every non-trivial PR requires an adversarial correctness review before merge.
10: 
11: # Project Overview
12: 
13: Lore is a **three-tier memory architecture** for AI coding agents. ...

<path>/home/byk/Code/opencode-lore-provider-error/quality/REVIEW.md</path>
<type>file</type>
<content>
1: # Review Heuristics — Lore
2: 
3: This document codifies the review bar for pull requests. It exists because
4: adversarial review has repeatedly caught correctness bugs that a green test
5: suite missed — skip/early-return branches, lifecycle sequences, and fan-out
6: registry gaps. Institutionalizing these patterns so they compound.
7: 
8: The review workflow (§6) is referenced from AGENTS.md.
9: 
10: ---
11: 
12: ## 1. Regression-test discipline
13: 
14: Every adversarial-review finding that surfaces a defect **must** land a
15: deterministic regression test in the same PR. The test:
16: - fails on the base branch (proving it reproduces the bug),
17: - passes on the fix (proving the fix works),
18: - drives the *real* precondition, not an artificially-constructed state (e.g. ...

<path>/home/byk/Code/opencode-lore-provider-error/scripts</path>
<type>directory</type>
<entries>
bump-version.sh
cch-scan.c
check-cc-version.ts
check-docs-links.mjs
check-patches.ts
check-preview-links.mjs
check-social-meta.mjs
extract-cch-seed.ts
generate-config-docs.ts
generate-env-docs.ts
generate-release-checksums.mjs
smoke-install.mjs

(12 entries)
</entries>

The working copy has no changes.
Working copy  (@) : qnmstlol 248b42ff (empty) (no description set)
Parent commit (@-): qzwttkwl 493b0655 fix/responses-provider-failures | fix(responses): isolate failure telemetry
Warning: These bookmarks have conflicts:
  fix/responses-private-references
Hint: Use `jj bookmark list` to see details. Use `jj bookmark set <name> -r <rev>` to resolve.
qnmstlolnsoz 248b42ffd04c parents=493b0655a388 conflict=false empty=true desc=
qzwttkwltwzr 493b0655a388 parents=0dd569b520ba conflict=false empty=false desc=fix(responses): isolate failure telemetry
lpmvqrurxwlm 0dd569b520ba parents=24880457763b conflict=false empty=false desc=fix(responses): unify provider failure handling
pxrvwsvvkmpo 2cbf40060c67 parents=e977b4b1da8f conflict=false empty=false desc=feat(cch): add seeds for Claude Code up to 2.1.272 ...

packages/gateway/src/pipeline.ts                   |  369 ++++-
packages/gateway/src/stream/openai-responses.ts    | 1099 ++++++++++------
...st/openai-responses-recall-aware-stream.test.ts | 1440 +++++++++++++++++++++-
...es/gateway/test/openai-responses-stream.test.ts | 1129 ++++++++++++++++-
packages/gateway/test/pipeline-streaming.test.ts   |  147 +-
packages/gateway/test/recall-codex-stream.test.ts  |    3 +-
6 files changed, 3687 insertions(+), 500 deletions(-)
qzwttkwltwzr 493b0655a388 parents=0dd569b520ba conflict=false desc=fix(responses): isolate failure telemetry
lpmvqrurxwlm 0dd569b520ba parents=24880457763b conflict=false desc=fix(responses): unify provider failure handling
wswlsmrnuzlq 24880457763b parents=a1020a45be13 conflict=false desc=fix(responses): reject non-monotonic provider failures
plzxzousrzuv a1020a45be13 parents=01a6e06b08ba conflict=false desc=fix(responses): preserve trusted failure metadata
skwrwnvkvulp 01a6e06b08ba parents=b1bc7cd46c4e conflict=false ...

diff --git a/packages/gateway/src/pipeline.ts b/packages/gateway/src/pipeline.ts
index 004e03b3e2..b6c101d538 100644
--- a/packages/gateway/src/pipeline.ts
+++ b/packages/gateway/src/pipeline.ts
@@ -203,7 +203,9 @@
   streamResponsesPassthrough,
   translateAnthropicStreamToResponses,
   applyResponsesEvent,
+  cloneResponsesAccState,
   finalizeResponsesAcc,
+  finalizeUnsuccessfulResponsesAcc,
   formatResponsesEvent,
   makeResponsesAccState,
   mapStatusFromStopReason,
@@ -212,7 +214,13 @@
   isValidResponsesReasoningEncryptedContent,
   responsesDoneItemMatchesAdded,
   responsesTerminalItemMatches,
+  restoreResponsesAccState,
   normalizeCodexResponsesEvent,
+  projectResponsesInProgressEvent,
+  reportResponsesProviderFailure,
+  sanitizeResponsesProviderFailureTerminal,
+  validateResponsesProviderFailureTerminal,
+  validateResponsesSourceSequence,
   ResponsesTerminalError,
   type ResponsesAccState,
 } from "./stream/openai-responses";
@@ -10023,6 +10031,9 @@
           | ...

diff --git a/packages/gateway/src/stream/openai-responses.ts b/packages/gateway/src/stream/openai-responses.ts
index 4c33c821b5..6530135963 100644
--- a/packages/gateway/src/stream/openai-responses.ts
+++ b/packages/gateway/src/stream/openai-responses.ts
@@ -48,6 +48,9 @@
 export interface ResponsesAccState {
   id: string;
   model: string;
+  created: boolean;
+  createdAt?: number;
+  lastAcceptedSequenceNumber?: number;
   stopReason: string;
   usage: GatewayUsage;
   terminalEvent?:
@@ -557,6 +560,7 @@
   return {
     id: "",
     model: "",
+    created: false,
     stopReason: "end_turn",
     usage: { inputTokens: 0, outputTokens: 0 },
     items: new Map(),
@@ -575,6 +579,125 @@
   };
 }
 
+export function cloneResponsesAccState(
+  state: ResponsesAccState,
+): ResponsesAccState {
+  return structuredClone(state);
+}
+
+export function restoreResponsesAccState(
+  state: ResponsesAccState,
+  snapshot: ResponsesAccState,
+): void {
+  for (const key of Object.keys(state) ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1: /**
2:  * OpenAI Responses API SSE stream accumulator.
3:  *
4:  * Parses upstream Responses API streaming events and accumulates the full
5:  * response into a `GatewayResponse`. The Responses API uses a different
6:  * SSE event lifecycle than Anthropic:
7:  *
8:  *   response.created → response.in_progress →
9:  *   response.output_item.added → response.output_text.delta (repeated) →
10:  *   response.output_item.done → response.function_call_arguments.delta →
11:  *   response.function_call_arguments.done →
12:  *   response.completed
13:  *
14:  * Reuses `parseSSEStream` from the Anthropic stream module since the
15:  * underlying SSE wire format is the same. ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1080: // ---------------------------------------------------------------------------
1081: // Stream accumulator (buffered)
1082: // ---------------------------------------------------------------------------
1083: 
1084: function validatePublicResponsesEvent(
1085:   state: ResponsesAccState,
1086:   event: string,
1087:   parsed: Record<string, unknown>,
1088:   maxSparseIndex: number,
1089: ): void {
1090:   const outputIndex = parsed.output_index;
1091:   const validOutputIndex =
1092:     Number.isSafeInteger(outputIndex) &&
1093:     (outputIndex as number) >= 0 &&
1094:     (outputIndex as number) < maxSparseIndex;
1095:   const item = validOutputIndex
1096:     ? state.items.get(outputIndex as number)
1097:     : undefined;
1098:   const malformed = (): never => {
1099:     throw new Error("malformed Responses stream event");
1100:   };
1101: ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
2240:       }
2241:       if (opts.validation && event === "response.failed") {
2242:         validateFailureTerminal(parsed);
2243:       }
2244:       const terminalStateSnapshot =
2245:         event === "response.completed" ||
2246:         event === "response.done" ||
2247:         event === "response.incomplete" ||
2248:         event === "response.failed"
2249:           ? cloneResponsesAccState(state)
2250:           : undefined;
2251:       try {
2252:         if (opts.validation === "public") {
2253:           validatePublicResponsesEvent(state, event, parsed, maxSparseIndex);
2254:         } else if (opts.validation === "codex") {
2255:           validateCodexResponsesEvent(state, event, parsed, maxSparseIndex);
2256:         }
2257:         const prevalidatedTerminalStatus =
2258:           opts.validation &&
2259:           !sanitizedFailure ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9890:               role: "assistant",
9891:               status: "completed",
9892:             }),
9893:             content: Array.isArray(raw?.content) ? raw.content : item.content,
9894:           });
9895:           continue;
9896:         }
9897:         if (item.refusal !== undefined) {
9898:           finalOutput.push({
9899:             type: "message",
9900:             id: item.id,
9901:             role: "assistant",
9902:             status: "completed",
9903:             content: [{ type: "refusal", refusal: item.refusal }],
9904:           });
9905:           continue;
9906:         }
9907:         finalOutput.push({
9908:           type: "message",
9909:           id: item.id,
9910:           role: "assistant",
9911:           status: "completed",
9912:           content: [{ type: "output_text", text: item.text, annotations: [] }],
9913:         ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10530:                     (item as Record<string, unknown>).name === RECALL_TOOL_NAME,
10531:                 )
10532:               ) {
10533:                 recallDetected = true;
10534:               }
10535:               try {
10536:                 if (opts.validation === "codex") {
10537:                   assertTerminalOutputMatches(
10538:                     state,
10539:                     terminalParsed,
10540:                     (outputIndex, item) => {
10541:                       if (
10542:                         item.type !== "function_call" ||
10543:                         item.name !== RECALL_TOOL_NAME ||
10544:                         (!recallIndices.has(outputIndex) &&
10545:                           !unresolvedToolIndices.has(outputIndex))
10546:                       ) {
10547:                         return;
10548:                       ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11340:                           continuationFollowUpInput,
11341:                         );
11342:                         continuationFailureCategory = "follow_up_protocol";
11343:                         continue;
11344:                       }
11345:                       const mergeContinuation = (): void => {
11346:                         for (const item of contState.rawItems.values()) {
11347:                           const itemIdentities = [item.id, item.call_id].filter(
11348:                             (value): value is string =>
11349:                               typeof value === "string" && value.length > 0,
11350:                           );
11351:                           for (const existing of state.items.values()) {
11352:                             const existingIdentities = new Set(
11353:                               [
11354:                ...

Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
  Line 173: const PUBLIC_RECALL_ERROR = "Lore could not continue the response after recall";

  Line 174: const PUBLIC_GATEWAY_ERROR = "Gateway request failed";

  Line 178:     ["response.failed", "response.failed", "failed"],

  Line 182:     ["response.error", "response.error", undefined],

  Line 244:     expect(out).not.toContain("response.failed");

  Line 295:     ["response.failed", "failed"],

  Line 296:     ["response.failed", "cancelled"],

  Line 300:     "sanitizes a principal provider failure received as %s with status %s",

  Line 373:       expect(capturedLogs).toEqual(["openai-responses provider failure"]);

  Line 376:         .find((frame) => frame.startsWith("event: response.failed\n"));

  Line 384:         type: "response.failed",

  Line 420:         if (message === "openai-responses provider failure") {

  ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
8850:       sseEvent("response.output_item.added", {
8851:         output_index: 0,
8852:         item: {
8853:           type: "function_call",
8854:           id: "fc_malformed",
8855:           call_id: "call_malformed",
8856:           name: "recall",
8857:         },
8858:       }),
8859:       sseEvent("response.custom", { secret: "must-not-leak" }),
8860:       completed("resp_malformed"),
8861:     ]);
8862:     const client = streamResponsesRecallAware(
8863:       streamFrom([
8864:         created("resp_first", "gpt-5.6-terra"),
8865:         recallCall(0, { query: "architecture" }),
8866:         completed("resp_first"),
8867:       ]),
8868:       {
8869:         onComplete: () => {},
8870:         onRecall: async ({ query }) => ({
8871:           anchorText: buildAnchor(query),
8872:           resultText: "results",
8873: ...

Found 18 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts:
  Line 6835:   onComplete: (response: GatewayResponse) => void,

  Line 6904:     onComplete(response);

  Line 7795:  * `onComplete` mirrors `streamResponsesPassthrough` (invoked exactly once with

  Line 7805:     onComplete: (response: GatewayResponse, successful: boolean) => void;

  Line 9621:   const finish = (resp: GatewayResponse, successful: boolean): boolean => {

  Line 9626:       opts.onComplete(resp, successful);

  Line 9630:       log.error("openai-responses recall-aware onComplete error:", err);

  Line 10896:                       let continuationCompleted = false;

  Line 10996:                             continuationCompleted = true;

  Line 11243:                             continuationCompleted =

  Line 11419:                         !continuationCompleted ||

  Line 11657:                         "recall onComplete failed after delivery",

  Line 15191:     const ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
7750:   });
7751:   if (!recallPersistence || recallContext?.onTransactionReady) return response;
7752:   // Standalone callers also commit only when the returned body reaches EOF.
7753:   return wrapBodyWithCleanup(
7754:     response,
7755:     () => {
7756:       if (!sourceSucceeded || cancelled || streamSignal.aborted) {
7757:         recallPersistence.rollback();
7758:         return;
7759:       }
7760:       try {
7761:         withTenant(recallContext?.sessionState.storageTenantId ?? "", () =>
7762:           withSavepoint("native_recall_delivery", recallPersistence.commit),
7763:         );
7764:       } catch (error) {
7765:         recallPersistence.rollback();
7766:         throw error;
7767:       }
7768:     },
7769:     streamSignal,
7770:     recallPersistence.rollback,
7771:   );
7772: }
7773: 
7774: /**
7775:  * True-streaming, recall-aware variant ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9550:           referenceIdentities.has(
9551:             (item as Record<string, unknown>).id as string,
9552:           )
9553:         ),
9554:     );
9555:     if (output.length === response.output.length) return parsed;
9556:     return { ...parsed, response: { ...response, output } };
9557:   };
9558:   const reserveSyntheticIdentity = (
9559:     syntheticId: string,
9560:     states: readonly ResponsesAccState[],
9561:   ): void => {
9562:     if (
9563:       syntheticIdentities.has(syntheticId) ||
9564:       referenceIdentities.has(syntheticId) ||
9565:       outputIdentities.has(syntheticId) ||
9566:       states.some(
9567:         (acc) =>
9568:           [...acc.items.values()].some(
9569:             (item) =>
9570:               item.id === syntheticId ||
9571:               (item.type === "tool_use" && item.callId === syntheticId),
9572:           ) ...

Found 3 matches
/home/byk/Code/opencode-lore-provider-error/packages/core/src/log.ts:
  Line 13:  * An optional {@link LogSink} can be registered via {@link registerSink}.

  Line 66: export function registerSink(s: LogSink): void {

  Line 497: export function error(...args: unknown[]): void {

<path>/home/byk/Code/opencode-lore-provider-error/packages/core/src/log.ts</path>
<type>file</type>
<content>
450:     fd = openLogFileForAppend(path);
451:     writeFileSync(fd, line, "utf8");
452:   } catch {
453:     // Silently degrade — logging failure shouldn't crash the app
454:   } finally {
455:     if (fd !== undefined) closeSync(fd);
456:   }
457: }
458: 
459: // ---------------------------------------------------------------------------
460: // Public API
461: // ---------------------------------------------------------------------------
462: 
463: /** Log an informational status message. Suppressed unless LORE_DEBUG=1. */
464: export function info(...args: unknown[]): void {
465:   const msg = redactSensitiveLogText(formatArgs(args));
466:   if (isDebug && !readStderrSilenced())
467:     console.error("[lore]", ...safeArgs(args));
468:   sink?.info(msg);
469:   writeToFile("info", msg);
470: }
471: 
472: /** Log a warning. Suppressed unless LORE_DEBUG=1. ...

Found 13 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-stream.test.ts:
  Line 691:   test("contains a throwing failure log sink in the plain passthrough settlement path", async () => {

  Line 693:     const loggerSecret = "private-plain-logger-failure";

  Line 701:           throw new Error(loggerSecret);

  Line 768:     for (const secret of [providerSecret, loggerSecret]) {

  Line 4250:   test("does not emit a second terminal when onComplete throws", async () => {


/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
  Line 411:   test("contains a throwing failure log sink in the recall-aware principal settlement path", async () => {

  Line 413:     const loggerSecret = "private-principal-logger-failure";

  Line 421:           throw new Error(loggerSecret);

  Line 492:     for (const secret of [providerSecret, loggerSecret]) {

  Line 9020:   test("contains a throwing ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-stream.test.ts</path>
<type>file</type>
<content>
600:               id: "resp_empty_incomplete",
601:               status: "incomplete",
602:               incomplete_details: { reason },
603:             },
604:           },
605:         },
606:       ]);
607: 
608:       const result = await accumulateResponsesSSEStream(response, {
609:         validation: "public",
610:         stopAtTerminal: true,
611:       });
612: 
613:       expect(result.content).toEqual([]);
614:       expect(result.stopReason).toBe(stopReason);
615:     },
616:   );
617: 
618:   test("uses created metadata and failure usage in the plain streaming route", async () => {
619:     const secrets = [
620:       "private-plain-terminal-id",
621:       "private-plain-terminal-model",
622:       "private-plain-terminal-diagnostic",
623:     ];
624:     const capturedLogs: string[] = [];
625:     log.registerSink({
626:       ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-stream.test.ts</path>
<type>file</type>
<content>
4200:   });
4201: 
4202:   test("downstream cancel before reader acquisition is silent and cancels the source", async () => {
4203:     let sourceCancelled = false;
4204:     const upstream = new Response(
4205:       new ReadableStream<Uint8Array>({
4206:         cancel() {
4207:           sourceCancelled = true;
4208:         },
4209:       }),
4210:     );
4211:     const downstream = streamResponsesPassthrough(upstream, () => {});
4212:     await downstream.body?.cancel();
4213:     await new Promise((resolve) => setImmediate(resolve));
4214:     expect(sourceCancelled).toBe(true);
4215:   });
4216: 
4217:   test("downstream cancel does not await a hostile upstream cancel", async () => {
4218:     let sourceCancelled = false;
4219:     const upstream = new Response(
4220:       new ReadableStream<Uint8Array>({
4221:         start(controller) ...

Commit ID: 493b0655a38874746f0b647fad2bcd108433960b
Change ID: qzwttkwltwzroqvkvvuroqutmtumrwop
Bookmarks: fix/responses-provider-failures fix/responses-provider-failures@git
Author   : Burak Yigit Kaya <ben@byk.im> (2026-09-16 17:52:49)
Committer: Burak Yigit Kaya <ben@byk.im> (2026-09-16 22:33:54)

    fix(responses): isolate failure telemetry

packages/gateway/src/pipeline.ts                    |   6 +-
packages/gateway/src/stream/openai-responses.ts     |  11 +-
...est/openai-responses-recall-aware-stream.test.ts | 195 ++++++++++++++++++++++
...ges/gateway/test/openai-responses-stream.test.ts |  85 +++++++++
4 files changed, 293 insertions(+), 4 deletions(-)
diff --git a/packages/gateway/src/pipeline.ts b/packages/gateway/src/pipeline.ts
index a03a58d8da..b6c101d538 100644
--- a/packages/gateway/src/pipeline.ts
+++ b/packages/gateway/src/pipeline.ts
@@ -217,7 +217,7 @@
   restoreResponsesAccState,
   normalizeCodexResponsesEvent,
   projectResponsesInProgressEvent,
-  ...

diff --git a/packages/gateway/test/pipeline-streaming.test.ts b/packages/gateway/test/pipeline-streaming.test.ts
index 544a2f6ec1..694e9cf562 100644
--- a/packages/gateway/test/pipeline-streaming.test.ts
+++ b/packages/gateway/test/pipeline-streaming.test.ts
@@ -85,6 +85,7 @@
 import { translateAnthropicStreamToOpenAI } from "../src/stream/openai";
 import { translateAnthropicStreamToResponses } from "../src/stream/openai-responses";
 import { translateAnthropicStreamToGemini } from "../src/stream/gemini";
+import { setRecallContinuationFailureHook } from "../src/recall-continuation-failure";
 import {
   makeConversationFixtures,
   STANDARD_TOOLS,
@@ -726,6 +727,7 @@
   afterEach(() => harness?.teardown());
   afterEach(() => vi.mocked(getDegradationWarning).mockReset());
   afterEach(() => vi.mocked(Sentry.startInactiveSpan).mockReset());
+  afterEach(() => setRecallContinuationFailureHook(undefined));
 
   it("does not deadlock when an OpenAI translator drops Anthropic lifecycle ...

diff --git a/packages/gateway/test/openai-responses-stream.test.ts b/packages/gateway/test/openai-responses-stream.test.ts
index 2a33ab9a35..c23ef01642 100644
--- a/packages/gateway/test/openai-responses-stream.test.ts
+++ b/packages/gateway/test/openai-responses-stream.test.ts
@@ -8,11 +8,13 @@
  *  - Stop reason mapping from status
  *  - Mixed text + function_call output
  */
-import { describe, test, expect, vi } from "vitest";
+import { log } from "@loreai/core";
+import { afterEach, describe, test, expect, vi } from "vitest";
 import {
   accumulateResponsesSSEStream,
   isSupportedResponsesOutputItemType,
   isValidResponsesOutputItemStatus,
+  makeResponsesAccState,
   responsesDoneItemMatchesAdded,
   responsesTerminalItemMatches,
   SUPPORTED_RESPONSES_OUTPUT_ITEM_TYPES,
@@ -23,6 +25,17 @@
 import type { GatewayResponse } from "../src/translate/types";
 import { validateResponsesUsage } from "../src/usage-validation";
 
+const silentLogSink = {
+  info: () => {},
+  warn: () ...

...output truncated...

Full output saved to: /home/byk/.local/share/opencode/tool-output/tool_0ac8a7126001BYdbsFxRzc0M6F

+    ["error", "error", undefined],
+    ["response.error", "response.error", undefined],
+  ] as const
+).flatMap(([alias, event, status]) =>
+  ([10, 9] as const).map(
+    (sequence) => [alias, sequence, event, status] as const,
+  ),
+);
+
 const textItem = (
   outputIndex: number,
   text: string,
@@ -277,32 +291,1092 @@
     expect(upstreamCancelled).toBe(true);
   });
 
-  test("forwards a principal response.failed exactly once when no recall occurs", async () => {
-    const client = streamResponsesRecallAware(
-      streamFrom([
-        created("resp_failed", "gpt-5.6-terra"),
-        sseEvent("response.failed", {
-          response: {
-            id: "resp_failed",
-            model: "gpt-5.6-terra",
-            status: "failed",
-            error: { message: "provider failed" },
-          },
-        }),
-      ]),
-      {
-        ...

<path>/home/byk/.local/share/opencode/tool-output/tool_0ac8a7126001BYdbsFxRzc0M6F</path>
<type>file</type>
<content>
1: diff --git a/packages/gateway/test/openai-responses-recall-aware-stream.test.ts b/packages/gateway/test/openai-responses-recall-aware-stream.test.ts
2: index dca2a57d78..ca3a97c244 100644
3: --- a/packages/gateway/test/openai-responses-recall-aware-stream.test.ts
4: +++ b/packages/gateway/test/openai-responses-recall-aware-stream.test.ts
5: @@ -173,6 +173,20 @@
6:  const PUBLIC_RECALL_ERROR = "Lore could not continue the response after recall";
7:  const PUBLIC_GATEWAY_ERROR = "Gateway request failed";
8:  
9: +const nonMonotonicProviderFailures = (
10: +  [
11: +    ["response.failed", "response.failed", "failed"],
12: +    ["failed response.done", "response.done", "failed"],
13: +    ["cancelled response.done", "response.done", "cancelled"],
14: +    ["error", "error", undefined],
15: +    ["response.error", "response.error", undefined],
16: +  ] as const
17: ...

<path>/home/byk/.local/share/opencode/tool-output/tool_0ac8a7126001BYdbsFxRzc0M6F</path>
<type>file</type>
<content>
800: +        onRecall: async () => {
801: +          throw new Error("should not execute");
802: +        },
803: +        runFollowUp: async () => {
804: +          throw new Error("should not run");
805: +        },
806: +      },
807: +    );
808: +
809: +    const out = await drain(client);
810: +    expect(out).not.toContain(hostileModel);
811: +    expect(JSON.stringify(completions)).not.toContain(hostileModel);
812: +    expect(capturedLogs).toEqual(["openai-responses provider failure"]);
813: +    expect(completions).toEqual([
814: +      {
815: +        successful: false,
816: +        response: expect.objectContaining({
817: +          id: "resp_visible_in_progress_failure",
818: +          model: "gpt-5.6-terra",
819: +          content: [],
820: +          rawOutputItems: [],
821: +          usage: { inputTokens: 7, outputTokens: 3 },
822: +        }),
823: ...

Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/codex-usage-metadata.test.ts:
  Line 65:     const response = await accumulateResponsesSSEStream(upstream(events), {

  Line 80:       await accumulateResponsesSSEStream(upstream([limits], true), {

  Line 98:     const response = await accumulateResponsesSSEStream(

  Line 115:     const first = await accumulateResponsesSSEStream(upstream([limits]), {

  Line 122:     const second = await accumulateResponsesSSEStream(upstream([]), {

  Line 132:     const afterTerminal = await accumulateResponsesSSEStream(

  Line 144:     const response = streamResponsesPassthrough(

  Line 174:             const accumulated = await accumulateResponsesSSEStream(


/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/llm-adapter.ts:
  Line 2985:       return accumulateResponsesSSEStream(response, {

  Line 2996:       return accumulateResponsesSSEStream(response, ...

Found 14 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/llm-adapter.ts:
  Line 2985:       return accumulateResponsesSSEStream(response, {

  Line 2996:       return accumulateResponsesSSEStream(response, {


/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts:
  Line 7802: export function streamResponsesRecallAware(

  Line 12230:         return accumulateResponsesSSEStream(sse, {

  Line 15475:     return streamResponsesPassthrough(

  Line 15746:           ? accumulateResponsesSSEStream(upstreamResponse, {

  Line 15845:         ? ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/llm-adapter.ts</path>
<type>file</type>
<content>
2940: function parseWorkerResponse(
2941:   protocol: WorkerProtocol,
2942:   rawData: unknown,
2943: ): { text: string | null; usage: AnthropicUsage | null; model: string | null } {
2944:   switch (protocol) {
2945:     case "openai-codex-responses":
2946:       return parseResponsesWorkerResponse(
2947:         rawData as Parameters<typeof parseResponsesWorkerResponse>[0],
2948:       );
2949:     case "openai-responses":
2950:       // Same wire shape as the Codex path — reuse the existing Responses-API
2951:       // worker parser; openai-responses and openai-codex-responses both
2952:       // produce `{ output: [...], usage: { input_tokens, output_tokens, ... } }`. ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
12180: }
12181: 
12182: /** Parsed usage from a buffered response that lacks a valid completion. */
12183: class NonStreamCompletionError extends Error {
12184:   constructor(readonly response: GatewayResponse) {
12185:     super("upstream response did not complete");
12186:     this.name = "NonStreamCompletionError";
12187:   }
12188: }
12189: 
12190: export async function accumulateNonStreamResponse(
12191:   upstreamResponse: Response,
12192:   protocol:
12193:     | "anthropic"
12194:     | "openai"
12195:     | "openai-responses"
12196:     | "vertex"
12197:     | "gemini" = "anthropic",
12198:   codex = false,
12199:   signal?: AbortSignal,
12200:   requireValidCompletion = false,
12201: ): Promise<GatewayResponse> {
12202:   // Some providers (the ChatGPT/Copilot/Codex backend, DeepSeek) return an SSE
12203:   // stream even when stream: false was sent — ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
15420:     finished = true;
15421:     signal.removeEventListener("abort", onAbort);
15422:     while (pendingOperations.size > 0) {
15423:       await Promise.all(pendingOperations);
15424:     }
15425:     activePipelineRequests.delete(active);
15426:     detachedPipelineRequests.delete(active);
15427:     pumpPendingSessionClaims();
15428:     settle?.();
15429:   }
15430:   function settleResponse(): void {
15431:     if (bodySettled) return;
15432:     bodySettled = true;
15433:     onResponseBodySettled?.();
15434:     void finish();
15435:   }
15436:   const active: ActivePipelineRequest = {
15437:     admissionKey,
15438:     abort: (reason) => {
15439:       lifecycle.abort(reason);
15440:       if (responseReturned) settleResponse();
15441:     },
15442:     settled,
15443:     sessionIDs: new Set(),
15444:   };
15445:   ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
15690:       );
15691:     }
15692:     const headers = new Headers({ "content-type": "application/json" });
15693:     copyUsageLimitHeaders(upstreamResponse.headers, headers);
15694:     return new Response(body, { status: upstreamResponse.status, headers });
15695:   }
15696: 
15697:   // Cross-protocol: accumulate the upstream response and re-emit in the
15698:   // client's wire format (reuses the same translation infrastructure as
15699:   // conversation turns).
15700:   if (req.stream && upstreamResponse.body) {
15701:     if (wireProtocol === "anthropic") {
15702:       // Anthropic SSE upstream (incl. Vertex) → translate to client's format
15703:       const anthropicSSE = new Response(upstreamResponse.body, {
15704:         status: upstreamResponse.status,
15705:         headers: {
15706:           "content-type": "text/event-stream",
15707:           ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
15870:           upstreamResponse,
15871:           forwarded.effectiveProtocol,
15872:           req.codex === true,
15873:           abortScope.signal,
15874:           true,
15875:         );
15876:   } catch (error) {
15877:     abortScope.dispose();
15878:     if (!(error instanceof ResponsesTerminalError)) throw error;
15879:     scheduleStreamingPostResponse(
15880:       identified.sessionID,
15881:       requestGeneration,
15882:       async () => {
15883:         await downstreamSettled;
15884:         await new Promise<void>((resolve) => setImmediate(resolve));
15885:         const pause = provisionalFinalizerPauseForTest;
15886:         if (pause) {
15887:           pause.onWait();
15888:           await pause.pause;
15889:         }
15890:         if (requestGeneration !== streamingPostResponseGeneration) return;
15891:         if (
15892:           ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18490:       }
18491: 
18492:       const markerText = buildAnchoredRecallMarker(
18493:         input.query,
18494:         scope,
18495:         input.id,
18496:         input.ids,
18497:         anchorId,
18498:       );
18499:       const markerResp = replaceRecallWithMarker(
18500:         currentResp,
18501:         new Map([[recallBlock.id, markerText]]),
18502:       );
18503:       responsesVisibleContent.push(
18504:         ...responsesProvenanceContent(
18505:           currentResp,
18506:           new Map([[recallBlock.id, markerText]]),
18507:         ),
18508:       );
18509: 
18510:       if (hasOtherToolUse(currentResp)) {
18511:         // Mixed tools — return response with marker, client handles the rest
18512:         log.info(
18513:           `recall (non-stream, mixed, depth=${recallDepth}): stored result for session ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18830:         ) {
18831:           dropStreamingFinalizer();
18832:           return;
18833:         }
18834:         accountUnsuccessfulResponse(
18835:           resp,
18836:           sessionState.sessionID,
18837:           sessionState.resolvedConversationTTL,
18838:           genAiSpan,
18839:           endGenAiSpan,
18840:           () => {
18841:             sessionState._dirty = true;
18842:           },
18843:         );
18844:       },
18845:       dropStreamingFinalizer,
18846:       true,
18847:       requestCredentialFingerprint(req.rawHeaders, config) ?? ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18710:         `empty completion → client: protocol=${effectiveProtocol} ` +
18711:           `model=${req.model} stopReason=${currentResp.stopReason} ` +
18712:           `outputTokens=${emptyOutputTokens} recallDepth=${recallDepth} ` +
18713:           `session=${sessionState.sessionID.slice(0, 16)}`,
18714:       );
18715:       captureEmptyCompletion({
18716:         protocol: effectiveProtocol,
18717:         model: req.model,
18718:         sessionID: sessionState.sessionID,
18719:         stopReason: currentResp.stopReason,
18720:         outputTokens: emptyOutputTokens,
18721:         recallDepth,
18722:       });
18723:     }
18724:     const recallHeaders =
18725:       recallDepth > 0 ? { "x-lore-recall-invoked": "true" } : undefined;
18726:     return nonStreamHttpResponse(
18727:       shouldInjectWarning
18728:         ? ...

Found 20 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts:
  Line 15369:   onResponseBodySettled?: () => void,

  Line 15407:       settleResponse();

  Line 15430:   function settleResponse(): void {

  Line 15433:     onResponseBodySettled?.();

  Line 15440:       if (responseReturned) settleResponse();

  Line 15455:       settleResponse();

  Line 15457:     return wrapBodyWithCleanup(response, settleResponse, undefined, () => {

  Line 15459:       settleResponse();

  Line 15462:     onResponseBodySettled?.();

  Line 15808:   downstreamSettled: Promise<void>,

  Line 15883:         await downstreamSettled;

  Line 16155:       await downstreamSettled;

  Line 16334:   downstreamSettled: Promise<void>,

  Line 16423:       downstreamSettled,

  Line 18756:         await downstreamSettled;

  Line 18824:         await downstreamSettled;

  Line 20051:   const downstreamSettled = new Promise<void>((resolve) => {

  Line 20061:         ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
20020:     {
20021:       status,
20022:       headers: { "content-type": "application/json" },
20023:     },
20024:   );
20025: }
20026: 
20027: // ---------------------------------------------------------------------------
20028: // Main entry point
20029: // ---------------------------------------------------------------------------
20030: 
20031: /**
20032:  * Process an incoming gateway request through the full Lore pipeline.
20033:  *
20034:  * Returns a standard `Response` object — either a streaming SSE response
20035:  * or a JSON response, depending on the client's `stream` setting.
20036:  */
20037: async function handleRequestForTenant(
20038:   req: GatewayRequest,
20039:   config: GatewayConfig,
20040: ): Promise<Response> {
20041:   if (!req?.rawHeaders) {
20042:     return errorResponse(400, "Malformed request: missing headers");
20043:   }
20044:   if ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
8015:       target.set(index, lifecycle);
8016:     }
8017:   };
8018:   let transactionBaseline: ResponsesAccState | undefined;
8019:   let transactionProviderUsage: GatewayUsage = { ...ZERO_USAGE };
8020:   const transactionRollbacks: Array<() => void> = [];
8021:   let deferredTransaction:
8022:     | { commit: () => void; rollback: () => void }
8023:     | undefined;
8024:   const restoreTransactionBaseline = (): void => {
8025:     if (!transactionBaseline) return;
8026:     state.id = transactionBaseline.id;
8027:     state.model = transactionBaseline.model;
8028:     state.stopReason = transactionBaseline.stopReason;
8029:     state.terminalEvent = transactionBaseline.terminalEvent;
8030:     state.terminalResponse = transactionBaseline.terminalResponse;
8031:     state.usage = { ...transactionBaseline.usage };
8032:     state.items = new ...

Found 8 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts:
  Line 3574:   const signal = stableLtmComputeSignal(sessionID);

  Line 8325:   const abortController = new AbortController();

  Line 8326:   const signal = opts.signal

  Line 8327:     ? AbortSignal.any([opts.signal, abortController.signal])

  Line 8328:     : abortController.signal;

  Line 11997:       abortController.abort(

  Line 13576:   const signal = AbortSignal.any([

  Line 15387:   const signal = callerSignal

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
8300:   ): void => {
8301:     const inputTokens = addUsageTokens(target.inputTokens, source.inputTokens);
8302:     const outputTokens = addUsageTokens(
8303:       target.outputTokens,
8304:       source.outputTokens,
8305:     );
8306:     const cacheReadInputTokens = addUsageTokens(
8307:       target.cacheReadInputTokens ?? 0,
8308:       source.cacheReadInputTokens ?? 0,
8309:     );
8310:     const cacheCreationInputTokens = addUsageTokens(
8311:       target.cacheCreationInputTokens ?? 0,
8312:       source.cacheCreationInputTokens ?? ...

No files found

Found 25 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-stream.test.ts:
  Line 653:             provider_trace: secrets[2],

  Line 729:             provider_trace: providerSecret,

  Line 4360:         "provider-diagnostics-secret",

  Line 4387:               provider_trace: secrets[2],

  Line 4401:                 diagnostics: { detail: secrets[3] },

  Line 4547:               diagnostics: { detail: secret },

  Line 4620:     "returns an empty failed projection for buffered provider %s diagnostics",

  Line 4880:                   diagnostics: { detail: secret },


/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
  Line 306:         "principal-diagnostics-secret",

  Line 330:             provider_trace: secrets[2],

  Line 344:               diagnostics: { detail: secrets[3] },

  Line 443:           provider_trace: providerSecret,

  Line 528:             diagnostics: { ...

Found 1 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts:
  Line 9152:   const validateResponseLifecycle = (

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9100:               );
9101:               if (
9102:                 (contentState.authoritativeValueSeen &&
9103:                   contentState.authoritativeValue !== finalValue) ||
9104:                 (contentState.finalValue !== undefined &&
9105:                   contentState.finalValue !== finalValue) ||
9106:                 (contentState.partFinalValue !== undefined &&
9107:                   contentState.partFinalValue !== finalValue)
9108:               ) {
9109:                 throw new Error(
9110:                   `Responses output_item.done changed reasoning content for index ${outputIndex}:${contentIndex}`,
9111:                 );
9112:               }
9113:             }
9114:           }
9115:         }
9116:         lifecycle.outputDone = true;
9117:       }
9118:     }
9119:     return outputIndex;
9120:   };
9121:   const ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9180:       lifecycle.created = true;
9181:       return;
9182:     }
9183:     if (!lifecycle.created && event.startsWith("response.")) {
9184:       throw new Error(`Responses event before response.created: ${event}`);
9185:     }
9186:     if (event === "response.in_progress") {
9187:       const response = parsed.response as Record<string, unknown> | undefined;
9188:       if (acc.id && response?.id !== undefined && response.id !== acc.id) {
9189:         throw new Error(
9190:           "Responses in-progress event changed response identity",
9191:         );
9192:       }
9193:       if (response?.status !== undefined && response.status !== "in_progress") {
9194:         throw new Error("response.in_progress has invalid status");
9195:       }
9196:       if (
9197:         response?.output !== undefined &&
9198:         (!Array.isArray(response.output) || ...

<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9250:           reason !== "content_filter"
9251:         ) {
9252:           throw new Error("malformed Responses terminal event");
9253:         }
9254:       }
9255:       lifecycle.terminal = true;
9256:     }
9257:   };
9258:   const assertOutputLifecyclesComplete = (
9259:     acc: ResponsesAccState,
9260:     allowedIncompleteIndices: ReadonlySet<number> = new Set(),
9261:   ): void => {
9262:     const lifecycles = lifecyclesFor(acc);
9263:     for (const index of acc.rawItems.keys()) {
9264:       if (lifecycles.get(index)?.outputDone) continue;
9265:       if (allowedIncompleteIndices.has(index)) continue;
9266:       if (opts.validation !== "codex") {
9267:         throw new Error(
9268:           `Responses stream ended before output_item.done for index ${index}`,
9269:         );
9270:       }
9271:       const item = acc.rawItems.get(index);
9272:       ...

<path>/home/byk/Code/opencode-lore-provider-error/package.json</path>
<type>file</type>
<content>
1: {
2:   "name": "lore-monorepo",
3:   "private": true,
4:   "type": "module",
5:   "license": "FSL-1.1-Apache-2.0",
6:   "description": "Monorepo root for Lore — three-tier memory architecture",
7:   "main": "./packages/opencode/src/index.ts",
8:   "exports": {
9:     ".": "./packages/opencode/src/index.ts"
10:   },
11:   "packageManager": "pnpm@10.28.0",
12:   "volta": {
13:     "node": "24.16.0",
14:     "pnpm": "10.28.0"
15:   },
16:   "pnpm": {
17:     "onlyBuiltDependencies": [
18:       "esbuild",
19:       "onnxruntime-node",
20:       "sharp"
21:     ],
22:     "overrides": {
23:       "basic-ftp": "5.3.1",
24:       "ip-address": "10.2.0",
25:       "fast-xml-parser": "5.7.3",
26:       "@huggingface/hub": "2.11.0",
27:       "onnxruntime-node": "1.27.0",
28:       "yaml": ">=2.8.3",
29:       "esbuild": ">=0.28.1",
30:       "@opentelemetry/core": ">=2.8.0",
31:       ...

Found 5 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
  Line 1336:   test("finalizes validated failure usage when cancellation wins terminal backpressure", async () => {

  Line 9233:   test("finalizes failed continuation usage when cancellation wins terminal backpressure", async () => {


/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-stream.test.ts:
  Line 5137:   test("finalizes validated failure usage when cancellation wins terminal backpressure", async () => {


/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/pipeline-streaming.test.ts:
  Line 1666:   it("accounts a failed recall continuation cancelled under terminal backpressure", async () => {

  Line 1770:       await response.body?.cancel("cancelled under terminal backpressure");

The working copy has no changes.
Working copy  (@) : qnmstlol 248b42ff (empty) (no description set)
Parent commit (@-): qzwttkwl 493b0655 fix/responses-provider-failures | fix(responses): isolate failure telemetry
Warning: These bookmarks have conflicts:
  fix/responses-private-references
Hint: Use `jj bookmark list` to see details. Use `jj bookmark set <name> -r <rev>` to resolve.
qnmstlolnsoz 248b42ffd04c parents=493b0655a388 conflict=false empty=true desc=
qzwttkwltwzr 493b0655a388 parents=0dd569b520ba conflict=false empty=false desc=fix(responses): isolate failure telemetry
lpmvqrurxwlm 0dd569b520ba parents=24880457763b conflict=false empty=false desc=fix(responses): unify provider failure handling
pxrvwsvvkmpo 2cbf40060c67 parents=e977b4b1da8f conflict=false empty=false desc=feat(cch): add seeds for Claude Code up to 2.1.272 ...