Dashboard › opencode-lore › Session 0CqgbioExxLG
0CqgbioExxLGYeO9wREAD-ONLY adversarial audit of Codex correction in /home/byk/Code/opencode-lore-codex-reasoning. Base parent uyznyvwt / commit 1ff66d14757b; correction head rtwyxzrr / b9feb17a1feb. Do not edit/format/install/VCS/server/network/DB. Read AGENTS.md, quality/REVIEW.md, scripts. Verify identities/conflicts/files. Inspect the two-file child diff and surrounding lifecycle code/tests. Determine whether it fully fixes prior findings: terminal-only nonempty summary introduced when added/done omit summary, malformed/gapped/over-ceiling/extra-field parts, principal and continuation zero recall side effects; high-cardinality lifecycle amplification/quadratic identity/terminal scans and bounded sparse coordinates. Evaluate fail-first and guard mutation discrimination. Identify exact remaining defects with file:line, smallest needed tests/fixes, or report readiness for full validation/reviews. Never return empty; end with AUDIT-PASS or AUDIT-BLOCKED.
<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-codex-reasoning</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-codex-reasoning/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-codex-reasoning/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-codex-reasoning/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: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/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>
/home/byk/Code/opencode-lore-codex-reasoning/AGENTS.md
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/package.json</path>
<type>file</type>
<content>
1: {
2: "name": "@loreai/gateway",
3: "version": "0.40.0",
4: "type": "module",
5: "license": "FSL-1.1-Apache-2.0",
6: "description": "Lore as a transparent LLM proxy — context management for any AI coding client",
7: "main": "./dist/index.cjs",
8: "types": "./dist/index.d.cts",
9: "exports": {
10: ".": {
11: "types": "./dist/index.d.cts",
12: "bun": "./dist/index.bun.js",
13: "require": "./dist/index.cjs",
14: "default": "./dist/index.cjs"
15: }
16: },
17: "bin": {
18: "lore": "./dist/bin.cjs",
19: "lore-gateway": "./dist/bin.cjs"
20: },
21: "scripts": {
22: "typecheck": "tsc --noEmit",
23: "build": "tsx script/build.ts",
24: "bundle": "tsx script/bundle.ts",
25: "build:binary": "tsx script/build.ts --binary",
26: "build:binary:sea": "tsx script/build-binary-sea.ts",
27: "start": ...
The working copy has no changes. Working copy (@) : youvttks d236533a (empty) (no description set) Parent commit (@-): rtwyxzrr b9feb17a fix/codex-sparse-reasoning | fix(responses): reject untracked Codex reasoning 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.
youvttksqllk d236533a8d57 parents=rtwyxzrrqnqs/b9feb17a1feb conflict=false empty=true desc= rtwyxzrrqnqs b9feb17a1feb parents=uyznyvwtuxrk/1ff66d14757b conflict=false empty=false desc=fix(responses): reject untracked Codex reasoning uyznyvwtuxrk 1ff66d14757b parents=pxrvwsvvkmpo/2cbf40060c67 conflict=false empty=false desc=fix(responses): validate Codex reasoning summaries
M packages/gateway/src/pipeline.ts
M packages/gateway/test/openai-responses-recall-aware-stream.test.ts
packages/gateway/src/pipeline.ts | 144 +++++++++-----
...est/openai-responses-recall-aware-stream.test.ts | 224 ++++++++++++++++++++++
2 files changed, 321 insertions(+), 47 deletions(-)
diff --git a/packages/gateway/src/pipeline.ts b/packages/gateway/src/pipeline.ts
index 6b2896a4b2..60b7e2621b 100644
--- a/packages/gateway/src/pipeline.ts
+++ b/packages/gateway/src/pipeline.ts
@@ -8475,24 +8475,6 @@
throw new Error("duplicate Responses item identity");
}
for (const identity of identities) outputIdentities.add(identity);
- for (const [existingIndex, existing] of state.rawItems) {
- const newIdentities = [item.id, item.call_id].filter(
- (value): value is string =>
- typeof value === "string" && value.length > 0,
- );
- const existingIdentities = new Set(
- [existing.id, ...
89d8ebbf199179b0b329c7bc95b969cb9274c1dcbdfc652c89417fc24b938744 -
Found 48 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 7897: type TextPartLifecycle = {
Line 7908: type OutputLifecycle = {
Line 7913: reasoning: Map<number, TextPartLifecycle>;
Line 7914: content: Map<number, TextPartLifecycle>;
Line 7918: Map<number, OutputLifecycle>
Line 7920: const lifecyclesFor = (
Line 7922: ): Map<number, OutputLifecycle> => {
Line 7953: const emptyTextPartLifecycle = (kind: string): TextPartLifecycle => ({
Line 7974: lifecycle: OutputLifecycle,
Line 7986: target: Map<number, TextPartLifecycle>,
Line 8007: const lifecycle = emptyTextPartLifecycle(part.type);
Line 8340: event === "response.reasoning_summary_part.added" ||
Line 8341: event === "response.reasoning_summary_part.done" ||
Line 8342: event === "response.reasoning_summary_text.delta" ||
Line 8343: event === "response.reasoning_summary_text.done";
Line ...
Found 42 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 176: MAX_OUTPUT_RESERVE,
Line 252: DEFAULT_MAX_SSE_FRAMES,
Line 6806: const maxOutput = entry.limit?.output ?? MAX_OUTPUT_RESERVE;
Line 7043: maxFrames: DEFAULT_MAX_SSE_FRAMES,
Line 7569: maxFrames: DEFAULT_MAX_SSE_FRAMES,
Line 7784: * events inline continuing the `output_index` numbering, then rebuilds the
Line 7878: const maxSSEFrames = opts.maxSSEFrames ?? DEFAULT_MAX_SSE_FRAMES;
Line 7879: const maxSparseIndex = Math.min(maxSSEFrames, DEFAULT_MAX_SSE_FRAMES);
Line 8354: const hasOutputIndex = Object.hasOwn(parsed, "output_index");
Line 8356: const index = parsed.output_index;
Line 8358: throw new Error(`invalid Responses output_index for ${event}`);
Line 8381: { output_index: outputIndex, item: seedItem },
Line 8385: output_index: outputIndex,
Line 8407: throw ...
Found 27 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/cli-data-contract.test.ts:
Line 385: test("move from untracked project surfaces Project not found before Session not found", async () => {
Line 389: // untracked-project branch we fixed.
Line 413: "/tmp/truly-untracked-project",
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/cost-tracker-historical.test.ts:
Line 359: // to 0 and shift historical dashboards ~7× for untracked sessions.
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/data-dedup-policy.test.ts:
Line 78: "%s preview does not create an untracked project",
Line 97: test("--dry-run does not create an untracked project", async () => {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 2402: test("rejects a terminal-only principal reasoning summary before recall execution", async () => {
Line ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
7840: detailOffset?: number;
7841: detailLimit?: number;
7842: outputIndex: number;
7843: toolUseId: string;
7844: /** Position in the normalized GatewayResponse content array. */
7845: contentPosition: number;
7846: /** The accumulated response INCLUDING the recall tool_use, so the caller
7847: * can build the follow-up request from the same accumulation the
7848: * streamer uses. */
7849: acc: GatewayResponse;
7850: signal: AbortSignal;
7851: }) => Promise<{
7852: anchorText: string;
7853: resultText: string;
7854: /** Private source coverage; never emitted to the client. */
7855: coverage?: readonly import("@loreai/core").RecallCoverage[];
7856: commit?: () => void;
7857: rollback?: () => void;
7858: }>;
7859: /** Streaming follow-up stage: build + ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
8890: ) {
8891: throw new Error(
8892: `Responses function arguments changed after completion for index ${outputIndex}`,
8893: );
8894: } else if (event === "response.function_call_arguments.delta") {
8895: if (typeof parsed.delta !== "string") {
8896: throw new Error("invalid Responses function arguments delta");
8897: }
8898: lifecycle.argumentDeltaSeen = true;
8899: lifecycle.argumentDeltas += parsed.delta;
8900: }
8901: if (event === "response.output_item.done") {
8902: if (declaredType === "function_call") {
8903: const normalized = state.items.get(outputIndex);
8904: if (
8905: normalized?.type !== "tool_use" ||
8906: typeof item?.arguments !== "string"
8907: ) {
8908: throw new Error(
8909: ...
Found 3 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts: Line 1750: export function normalizeCodexResponsesEvent( /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts: Line 215: normalizeCodexResponsesEvent, Line 7945: normalizeCodexResponsesEvent(
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1580:
1581: const existing = state.rawItems.get(outputIndex);
1582: if (event === "response.output_item.added" && existing) {
1583: malformedResponsesEvent();
1584: }
1585: if (event === "response.output_item.done" && existing) {
1586: if (
1587: existing.type !== item.type ||
1588: (isNonEmptyString(existing.id) &&
1589: isNonEmptyString(item.id) &&
1590: existing.id !== item.id)
1591: ) {
1592: malformedResponsesEvent();
1593: }
1594: } else if (event === "response.output_item.done") {
1595: const seedItem = { ...item };
1596: delete seedItem.content;
1597: applyResponsesEvent(state, "response.output_item.added", {
1598: output_index: outputIndex,
1599: item: seedItem,
1600: });
1601: }
1602: if (event === "response.output_item.done") {
1603: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10070: ) {
10071: await new Promise<void>((resolve) => {
10072: resumeDemand = resolve;
10073: });
10074: }
10075: signal.throwIfAborted();
10076: };
10077: let principalEventEmitted = false;
10078: let ordinaryToolEmitted = false;
10079: const safeEnqueue = async (
10080: chunk: Uint8Array,
10081: afterEnqueue?: () => void,
10082: ): Promise<boolean> => {
10083: if (cancelled) return false;
10084: await waitForDemand();
10085: if (cancelled) return false;
10086: try {
10087: controller.enqueue(sequenceChunk(chunk));
10088: } catch {
10089: cancelled = true;
10090: return false;
10091: }
10092: afterEnqueue?.();
10093: return ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10770: let index = heldContinuationEvents.length - 1;
10771: index >= 0;
10772: index--
10773: ) {
10774: if (
10775: heldContinuationEvents[index].candidateIndex ===
10776: outputIndex
10777: ) {
10778: if (!heldContinuationEvents[index].transactional) {
10779: deferredContinuationBytes -=
10780: heldContinuationEvents[index].chunk.byteLength;
10781: }
10782: heldContinuationEvents.splice(index, 1);
10783: }
10784: }
10785: };
10786: ...
Found 24 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts: Line 7916: const outputLifecycles = new WeakMap< Line 7923: let lifecycles = outputLifecycles.get(acc); Line 7926: outputLifecycles.set(acc, lifecycles); Line 7930: const codexNormalizationStates = new WeakMap< Line 7940: let normalizationState = codexNormalizationStates.get(acc); Line 7943: codexNormalizationStates.set(acc, normalizationState); Line 8470: outputIdentities.has(identity) || Line 8471: referenceIdentities.has(identity) || Line 8477: for (const identity of identities) outputIdentities.add(identity); Line 8575: (outputIdentities.has(finalCallId) || Line 8576: referenceIdentities.has(finalCallId) || Line 8939: outputIdentities.add(finalFunctionIdentity.callId); Line 9599: outputIdentities.has(item.id) || Line 9603: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10640: outputIndex: recall.outputIndex,
10641: toolUseId: recall.toolUseId,
10642: contentPosition,
10643: acc: recallAcc,
10644: signal,
10645: });
10646: } catch (error) {
10647: if (signal.aborted) throw error;
10648: if (error instanceof RecallContinuationFailure) throw error;
10649: throw new RecallContinuationFailure("recall_execution");
10650: }
10651: anchorTexts.push(executed.anchorText);
10652: if (executed.commit) pendingCommits.push(executed.commit);
10653: if (executed.rollback) {
10654: transactionRollbacks.push(executed.rollback);
10655: }
10656: const ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11550: ) {
11551: throw new Error(
11552: "client disconnected while delivering recall terminal",
11553: );
11554: }
11555: if (cancelled) throw signal.reason;
11556: cancelAndReleaseReader(reader, signal.reason);
11557: principalReader = null;
11558: safeClose();
11559: return;
11560: }
11561:
11562: // Non-terminal, non-recall event: forward verbatim.
11563: const chunk = encoder.encode(formatResponsesEvent(event, data));
11564: if (recallIndices.size > 0 || unresolvedToolIndices.size > 0) {
11565: deferredBytes += chunk.byteLength;
11566: if (deferredBytes > maxDeferredBytes) {
11567: throw new SSEStreamLimitError(
11568: ...
M packages/gateway/src/pipeline.ts M packages/gateway/test/openai-responses-recall-aware-stream.test.ts packages/gateway/src/pipeline.ts | 185 +++-- ...est/openai-responses-recall-aware-stream.test.ts | 739 +++++++++++++++++++++- 2 files changed, 868 insertions(+), 56 deletions(-)
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
2260: expect(output).not.toContain("response.failed");
2261: expect(completedResponse?.rawOutputItems).toContainEqual(
2262: expect.objectContaining({
2263: id: reasoningId,
2264: summary: [
2265: { type: "summary_text", text: "first continuation summary" },
2266: { type: "summary_text", text: "second continuation summary" },
2267: ],
2268: }),
2269: );
2270: },
2271: );
2272:
2273: test.each(["empty", "omitted"] as const)(
2274: "reconstructs a %s sparse Codex terminal summary after matching principal added and done items",
2275: async (terminalSummary) => {
2276: let completedResponse: GatewayResponse | undefined;
2277: const responseId = `resp_matching_principal_${terminalSummary}_summary`;
2278: const ...
Found 20 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts: Line 252: DEFAULT_MAX_SSE_FRAMES, Line 7043: maxFrames: DEFAULT_MAX_SSE_FRAMES, Line 7569: maxFrames: DEFAULT_MAX_SSE_FRAMES, Line 7878: const maxSSEFrames = opts.maxSSEFrames ?? DEFAULT_MAX_SSE_FRAMES; Line 7879: const maxSparseIndex = Math.min(maxSSEFrames, DEFAULT_MAX_SSE_FRAMES); Line 15413: maxFrames: DEFAULT_MAX_SSE_FRAMES, /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai.ts: Line 27: DEFAULT_MAX_SSE_FRAMES, Line 194: maxFrames: opts.strict ? DEFAULT_MAX_SSE_FRAMES : undefined, Line 621: ? (opts.maxFrames ?? DEFAULT_MAX_SSE_FRAMES) /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts: Line 26: DEFAULT_MAX_SSE_FRAMES, Line 1754: maxSparseIndex = DEFAULT_MAX_SSE_FRAMES, Line 1913: opts.maxFrames ?? ...
Found 91 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/llm-adapter.test.ts:
Line 5767: test("github-copilot: preferred first, then same-provider backups (deduped)", () => {
Line 5784: // Every candidate stays on the same provider — a worker must never switch.
Line 5809: describe("worker 400 model-not-supported: fall back to a same-provider backup", () => {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/lint-action-report.test.ts:
Line 266: test("accepts the same boundary report as the CLI validator", () => {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/cache-analytics.test.ts:
Line 856: // The turn after that repeats the same body: it must be identical, proving
Line 920: expect(body1).toBe(body2); // same base version → identical
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/compact-endpoint.test.ts:
Line 390: it("uses provider-scoped model resolution ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
7320: {
7321: onComplete: (response) => {
7322: completedResponse = response;
7323: },
7324: onRecall: async () => ({
7325: anchorText: buildAnchor("architecture"),
7326: resultText: "results",
7327: }),
7328: runFollowUp: async () => ({ reader: followUp.body!.getReader() }),
7329: },
7330: );
7331:
7332: const out = await drain(client);
7333: expect(out).toContain('"type":"refusal"');
7334: expect(out).toContain("cannot comply");
7335: expect(JSON.stringify(completedResponse)).toContain("cannot comply");
7336: });
7337:
7338: test("rejects an upstream item that collides with the synthetic anchor ID", async () => {
7339: let recalled = 0;
7340: const client = streamResponsesRecallAware(
7341: streamFrom([
7342: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
8270: {
8271: maxRecallDepth,
8272: signal: foreground.signal,
8273: onComplete: () => {},
8274: onRecall: async () => ({
8275: anchorText: buildAnchor("architecture"),
8276: resultText: "results",
8277: }),
8278: runFollowUp: async () => ({ reader: continuation.body!.getReader() }),
8279: },
8280: );
8281: const pending = drain(client);
8282: await continuationStarted.promise;
8283: foreground.abort(new DOMException("caller aborted", "AbortError"));
8284: await expect(pending).rejects.toMatchObject({ name: "AbortError" });
8285: expect(cancelled).toBe(true);
8286: expect(continuation.body?.locked).toBe(false);
8287: },
8288: );
8289:
8290: test("rejects a chained recall whose arguments ...
Found 8 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 39: function sseEvent(event: string, data: unknown): string {
Line 48: function streamFrom(events: string[]): Response {
Line 176: const textItem = (
Line 208: const reasoningSummaryEvents = (
Line 244: const reasoningSummaryParts = (summaries: readonly string[]) =>
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/helpers/replay.ts:
Line 51: function sseEvent(type: string, data: unknown): string {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/recall-marker-split.e2e.test.ts:
Line 39: function sseEvent(event: string, data: unknown): string {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/recall-codex-stream.test.ts:
Line 35: function sseEvent(event: string, data: unknown): string {
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
1: /**
2: * Unit tests for `streamResponsesRecallAware` — the true-streaming,
3: * recall-aware OpenAI Responses (codex/ChatGPT) streamer.
4: *
5: * Regression for the "Provider response headers timed out after 10000ms" issue:
6: * the buffered `accumulateResponsesSSEStream` path withholds ALL client bytes
7: * until the entire (slow, reasoning-heavy) upstream completes, so opencode's
8: * 10s `ProviderHeaderTimeoutError` fired on ChatGPT sessions. This streamer
9: * forwards events live while transparently intercepting a `recall`
10: * function_call (emit marker, run follow-up, rebuild the terminal
11: * `response.completed`).
12: */
13: import { log } from "@loreai/core";
14: import { afterEach, describe, test, expect, vi } from "vitest";
15: import { streamResponsesRecallAware } from "../src/pipeline";
16: import {
17: ...
Found 19 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 272: test("finalizes when the client cancels immediately after a no-recall terminal", async () => {
Line 5252: test("uses the finalized content position for interleaved recall items", async () => {
Line 6222: runFollowUp: async ({ finalRecallRound }) => {
Line 6224: finalFlags.push(finalRecallRound);
Line 6301: runFollowUp: async ({ finalRecallRound }) => {
Line 6303: expect(finalRecallRound).toBe(true);
Line 6386: test("allows the final answer after one recall at depth one", async () => {
Line 6405: runFollowUp: async ({ finalRecallRound }) => {
Line 6406: expect(finalRecallRound).toBe(true);
Line 6418: test("reaches a final fact after twelve sequential productive recalls", async () => {
Line 7530: test("rejects a call_id that collides with the ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-stream.test.ts</path>
<type>file</type>
<content>
900:
901: test("public validation rejects duplicate effective function call IDs", async () => {
902: await expect(
903: accumulateResponsesSSEStream(
904: buildSSEResponse([
905: {
906: event: "response.output_item.added",
907: data: {
908: output_index: 0,
909: item: {
910: type: "function_call",
911: id: "fc_first",
912: call_id: "call_duplicate",
913: name: "first",
914: arguments: "",
915: },
916: },
917: },
918: {
919: event: "response.output_item.added",
920: data: {
921: output_index: 1,
922: item: {
923: type: "function_call",
924: id: ...
Found 6 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts:
Line 349: export function responsesDoneItemMatchesAdded(
Line 1077: !responsesDoneItemMatchesAdded(doneItem, addedItem) ||
Line 1604: if (existing && !responsesDoneItemMatchesAdded(item, existing)) {
Line 2240: !responsesDoneItemMatchesAdded(completedSnapshot, accumulated)
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 213: responsesDoneItemMatchesAdded,
Line 8537: !responsesDoneItemMatchesAdded(item, declared))
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
300: sparseValueExtends(actual[field], value),
301: );
302: }
303: return isDeepStrictEqual(actual, established);
304: }
305:
306: function sparseTextPartsExtend(actual: unknown, established: unknown): boolean {
307: if (!Array.isArray(established)) return established === undefined;
308: if (!Array.isArray(actual) || actual.length < established.length)
309: return false;
310: return established.every((rawPart, index) => {
311: const actualPart = actual[index];
312: if (!isRecord(rawPart) || !isRecord(actualPart)) return false;
313: return Object.entries(rawPart).every(([field, value]) => {
314: if (
315: (field === "text" || field === "refusal") &&
316: typeof value === "string"
317: ) {
318: return (
319: typeof actualPart[field] === "string" &&
320: ...
Found 1 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 9846: const shiftedOutputIndex = (index: number, offset: number): number => {
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9800: );
9801: return result;
9802: };
9803: const settleFollowUp = async (
9804: input: Parameters<typeof opts.runFollowUp>[0],
9805: ): ReturnType<typeof opts.runFollowUp> => {
9806: const operation = opts.runFollowUp({
9807: ...input,
9808: resultText: recallBudgetGuidance(
9809: input.resultText,
9810: input.finalRecallRound ? recallBudget.stopReason() : undefined,
9811: ),
9812: });
9813: const cancelLateReader = async (): Promise<void> => {
9814: try {
9815: const late = await operation;
9816: cancelAndReleaseReader(late.reader, signal.reason);
9817: } catch {
9818: // The aborted request no longer observes the callback result.
9819: }
9820: };
9821: if (signal.aborted) {
9822: void cancelLateReader();
9823: throw signal.reason;
9824: ...
Found 16 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 1442: maxSSEFrames: 6,
Line 2657: maxSSEFrames: 16,
Line 2694: maxSSEFrames: 16,
Line 2846: maxSSEFrames: undefined,
Line 2854: maxSSEFrames: undefined,
Line 2862: maxSSEFrames: undefined,
Line 2878: maxSSEFrames: undefined,
Line 2894: maxSSEFrames: 16,
Line 2902: summary_index: 16,
Line 2957: ...(testCase.maxSSEFrames === undefined
Line 2959: : { maxSSEFrames: testCase.maxSSEFrames }),
Line 6675: maxSSEFrames: 8,
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/foreground-body-limit.test.ts:
Line 157: test("buffered Codex accepts sparse events without output_index", async () => {
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-stream.test.ts:
Line 2616: "%s ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
1360: expect(failures).toEqual(["follow_up_missing_output"]);
1361: });
1362:
1363: test("counts failed continuation bytes against the request-wide stream limit", async () => {
1364: const failures: RecallContinuationFailureCategory[] = [];
1365: setRecallContinuationFailureHook((category) => failures.push(category));
1366: const principal = [
1367: created("resp_retry_limit_principal", "gpt-5.6-terra"),
1368: recallCall(0, { query: "retry byte budget" }),
1369: completed("resp_retry_limit_principal"),
1370: ];
1371: const dropped = created("resp_retry_limit_dropped", "gpt-5.6-terra");
1372: const recovered = [
1373: created("resp_retry_limit_recovered", "gpt-5.6-terra"),
1374: textItem(0, "recovered after budget", "msg_retry_limit"),
1375: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
6600: runFollowUp: async () => ({ reader: followUp.body!.getReader() }),
6601: },
6602: );
6603:
6604: const out = await drain(client);
6605: const terminal = JSON.parse(
6606: /event: response\.completed\ndata: (.+)/.exec(out)?.[1] ?? "{}",
6607: ) as { response?: { output?: Array<{ content?: unknown }> } };
6608: expect(out).toContain('"output_index":1');
6609: expect(out).toContain('"output_index":2');
6610: expect(JSON.stringify(terminal.response?.output)).toContain("principal");
6611: expect(JSON.stringify(terminal.response?.output)).toContain("continuation");
6612: });
6613:
6614: test("rejects continuation identities that collide with principal output", async () => {
6615: const followUp = streamFrom([
6616: created("resp_followup", "gpt-5.6-terra"),
6617: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
6480: const followUp = streamFrom([
6481: created("resp_depth_exhausted_followup", "gpt-5.6-terra"),
6482: recallCall(0, { query: "more detail" }, "fc_depth", "call_depth"),
6483: completed("resp_depth_exhausted_followup"),
6484: ]);
6485: let recalls = 0;
6486: const client = streamResponsesRecallAware(
6487: streamFrom([
6488: created("resp_depth_exhausted_principal", "gpt-5.6-terra"),
6489: recallCall(
6490: 0,
6491: { query: "architecture" },
6492: "fc_principal",
6493: "call_principal",
6494: ),
6495: completed("resp_depth_exhausted_principal"),
6496: ]),
6497: {
6498: maxRecallDepth: 1,
6499: onComplete: () => {},
6500: onRecall: async ({ query }) => {
6501: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-stream.test.ts</path>
<type>file</type>
<content>
2470: accumulateResponsesSSEStream(
2471: buildSSEResponse([
2472: {
2473: event: "response.output_item.added",
2474: data: {
2475: ...(validation === "public" ? { output_index: 0 } : {}),
2476: item: { type: "message", id: itemId },
2477: },
2478: },
2479: {
2480: event: "response.content_part.added",
2481: data: {
2482: ...reference,
2483: part: { type: "output_text", text: "" },
2484: },
2485: },
2486: {
2487: event: "response.output_text.done",
2488: data: { ...reference, text: "one" },
2489: },
2490: {
2491: event: "response.content_part.done",
2492: ...
Found 7 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts: Line 10826: const contIndex = shiftedOutputIndex( Line 10996: output_index: shiftedOutputIndex( Line 11144: output_index: shiftedOutputIndex( Line 11276: shiftedOutputIndex(idx, contIndex), Line 11282: shiftedOutputIndex(idx, contIndex), Line 11369: const shiftedRecallIndex = shiftedOutputIndex( Line 11419: recallIndices.add(shiftedOutputIndex(index, contIndex));
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
1760: onRecall: async () => {
1761: recallCalls++;
1762: return { anchorText: "", resultText: "" };
1763: },
1764: runFollowUp: async () => {
1765: throw new Error("should not run");
1766: },
1767: },
1768: );
1769:
1770: const output = await drain(client);
1771: const terminal = JSON.parse(
1772: /event: response\.failed\ndata: (.+)/.exec(output)?.[1] ?? "{}",
1773: ) as { response?: { output?: Array<Record<string, unknown>> } };
1774: expect(output.match(/^event: response\.failed$/gm)).toHaveLength(1);
1775: expect(terminal.response?.output).toContainEqual(
1776: expect.objectContaining({
1777: id: "fc_terminal_name",
1778: call_id: "call_terminal_name",
1779: name: "read",
1780: }),
1781: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
401: export function responsesTerminalItemMatches(
402: actual: Record<string, unknown>,
403: streamed: Record<string, unknown>,
404: ): boolean {
405: if (
406: actual.type !== streamed.type ||
407: actual.id !== streamed.id ||
408: !isValidResponsesReasoningEncryptedContent(actual) ||
409: !isValidResponsesReasoningEncryptedContent(streamed)
410: ) {
411: return false;
412: }
413: if (
414: !isValidResponsesOutputItemStatus(actual.type, actual.status, "terminal") ||
415: !isValidResponsesOutputItemStatus(streamed.type, streamed.status, "done")
416: ) {
417: return false;
418: }
419: if (
420: streamed.status !== undefined &&
421: actual.status !== undefined &&
422: actual.status !== streamed.status
423: ) {
424: return false;
425: }
426: if (actual.type === "function_call") {
427: ...
Found 36 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/llm-adapter.test.ts:
Line 5167: // budget on hidden reasoning and returns an EMPTY completion with
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 217: sseEvent("response.reasoning_summary_part.added", {
Line 223: sseEvent("response.reasoning_summary_text.delta", {
Line 235: sseEvent("response.reasoning_summary_part.done", {
Line 2092: sseEvent("response.reasoning_summary_text.delta", {
Line 2121: expect(out).toContain("response.reasoning_summary_text.delta");
Line 2881: sseEvent("response.reasoning_summary_part.added", {
Line 2899: sseEvent("response.reasoning_summary_part.added", {
Line 2996: sseEvent("response.reasoning_summary_part.added", {
Line 3002: sseEvent("response.reasoning_summary_text.delta", {
Line 3014: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
4290: summary: [],
4291: ...terminalEnvelope,
4292: },
4293: ],
4294: },
4295: }),
4296: ]),
4297: {
4298: validation: "codex",
4299: onComplete: () => {},
4300: onRecall: async () => ({ anchorText: "", resultText: "" }),
4301: runFollowUp: async () => {
4302: throw new Error("should not run");
4303: },
4304: },
4305: );
4306:
4307: expect(await drain(client)).toContain("response.failed");
4308: },
4309: );
4310:
4311: test("rejects malformed terminal reasoning ciphertext before recall execution", async () => {
4312: let recalls = 0;
4313: let followUps = 0;
4314: const reasoning = {
4315: type: "reasoning",
4316: id: ...
cd24c6f95410065b21f3272ba2e0213362c77c2301cf0dd0034dedc178455f66 packages/gateway/src/pipeline.ts f3a888e6f81e877a42b30d68119c3f8e3b0248042f74639881a51896688327ab packages/gateway/test/openai-responses-recall-aware-stream.test.ts 89d8ebbf199179b0b329c7bc95b969cb9274c1dcbdfc652c89417fc24b938744 - The working copy has no changes. Working copy (@) : youvttks d236533a (empty) (no description set) Parent commit (@-): rtwyxzrr b9feb17a fix/codex-sparse-reasoning | fix(responses): reject untracked Codex reasoning 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. youvttksqllk d236533a8d57 conflict=false empty=true parents=rtwyxzrrqnqs/b9feb17a1feb rtwyxzrrqnqs b9feb17a1feb conflict=false empty=false parents=uyznyvwtuxrk/1ff66d14757b uyznyvwtuxrk 1ff66d14757b conflict=false empty=false parents=pxrvwsvvkmpo/2cbf40060c67
The correction is not ready for full validation or independent reviews. It fixes the main terminal-only summary case, but leaves three blockers.
maxSparseIndex caps provider indexes at the frame ceiling (pipeline.ts:7878-7879; openai-responses.ts:1634-1648). However, shiftedOutputIndex() checks only safe-integer overflow (pipeline.ts:9846-9851).
Continuation offsets and emitted indexes can exceed the ceiling at:
pipeline.ts:10826-10833pipeline.ts:10996-11000pipeline.ts:11144-11147pipeline.ts:11274-11283Counterexample: with maxSSEFrames: 16, a principal recall at index 15 makes the continuation offset 16; a continuation item at index 0 is then emitted and stored at index 16, outside the valid [0, 15] range.
Smallest fix: reject any shifted index >= maxSparseIndex, as a continuation resource-limit failure.
Required regression: principal recall at the last valid index plus a continuation item whose shifted coordinate reaches the ceiling. Assert one sanitized failure, no out-of-range public index, rollback, and no nested recall.
The new assertReasoningPartsMatchLifecycle() correctly rejects untracked and extra-field terminal parts (pipeline.ts:9283-9326, called at 9388-9394). Earlier lifecycle stages remain permissive:
pipeline.ts:7999-8014pipeline.ts:8779-8831output_item.done summary parts accept extra fields: pipeline.ts:9023-9043output_item.done reasoning content validates only already-tracked states: pipeline.ts:9045-9090When no reasoning-content lifecycle exists, output_item.done can therefore introduce malformed, gapped, over-ceiling, or extra-field content. If the Codex terminal omits response.output, ...