Dashboard › opencode-lore › Session 1Ptm9SCYpU9S
1Ptm9SCYpU9Sq7m68Strict READ-ONLY adversarial correctness review in /home/byk/Code/opencode-lore-codex-reasoning. No edits/VCS/server/network/prod DB. Candidate stable head rtwyxzrrqnqspzypxtymnolzwmpnnumv commit b9feb17a1feb58a72a080cca0e493130427c506f; base literal 2cbf40060c67df229731cf1b9e34d5bf22ec2145; expected plain diff SHA-256 caf10519f08fc9a396b3413617f4e9fca740f3c87c196455e56791d51709a354; exactly pipeline.ts + recall-aware test. Verify identity/status/conflicts/scope/hash start/end. Read instructions/scripts/all changed lines/callers. Review lifecycle-backed Codex summary reconciliation principal+continuation; absent/empty terminal summary; added-only/no done; done-only/malformed/gapped/oversized/untracked/terminal-only summaries; reasoning content; sparse indices; recall side effects before rejection; callback/raw state; identity/status/encrypted content; final text authority; retries/cancel/backpressure. Review indexed identity handling and terminal matcher for semantic parity and high-cardinality bounded work. Assess fail-first and guard-removal evidence: terminal-only tests failed with recalls 1/2; terminal guard mutation reproduces; per-item scan gave 131840 visits vs bound 20480; findIndex mutation 131328 vs bound 2048; 410 tests + 30 repeated passed; exhaustive separate. Focused tests allowed. Return PASS/CONCERN/MUST-FIX exact file:line and residual risks. End exactly MERGE or DO-NOT-MERGE.
<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>
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. youvttksqllkxurqlpxypvrnzpsvxvoq d236533a8d57df57ea780c8729978b7d15c6ea85 clean parents=b9feb17a1feb58a72a080cca0e493130427c506f rtwyxzrrqnqspzypxtymnolzwmpnnumv b9feb17a1feb58a72a080cca0e493130427c506f clean parents=1ff66d14757b98d3ec7bdb8012104d1f10b292b8 pxrvwsvvkmpoxnsqmrkwrnlqvvkoltwz 2cbf40060c67df229731cf1b9e34d5bf22ec2145 clean parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 --- changed paths --- packages/gateway/src/pipeline.ts packages/gateway/test/openai-responses-recall-aware-stream.test.ts --- conflict revisions --- --- plain diff hash ...
<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: ...
No files found
...output truncated...
Full output saved to: /home/byk/.local/share/opencode/tool-output/tool_0ab26c57d001HXsKSJmida8DHD
const maxPrincipalTransportRetries = 1;
@@ -8330,6 +8336,17 @@
item: Record<string, unknown>,
) => void,
): number | undefined => {
+ const reasoningSummaryEvent =
+ event === "response.reasoning_summary_part.added" ||
+ event === "response.reasoning_summary_part.done" ||
+ event === "response.reasoning_summary_text.delta" ||
+ event === "response.reasoning_summary_text.done";
+ if (
+ event.startsWith("response.reasoning_summary") &&
+ !reasoningSummaryEvent
+ ) {
+ throw new Error(`unsupported Responses reasoning summary event ${event}`);
+ }
const requiresOutputIndex =
/^response\.(?:output_item|output_text|function_call_arguments|content_part|reasoning_(?:summary|text)|refusal)/.test(
event,
@@ -8458,24 +8475,6 @@
throw new Error("duplicate Responses item ...
<path>/home/byk/.local/share/opencode/tool-output/tool_0ab26c57d001HXsKSJmida8DHD</path>
<type>file</type>
<content>
1: diff --git a/packages/gateway/src/pipeline.ts b/packages/gateway/src/pipeline.ts
2: index 004e03b3e2..60b7e2621b 100644
3: --- a/packages/gateway/src/pipeline.ts
4: +++ b/packages/gateway/src/pipeline.ts
5: @@ -7875,6 +7875,8 @@
6: ): Response {
7: const recallDiagnostics = createRecallDiagnostics(!opts.noStore);
8: let state = makeResponsesAccState();
9: + const maxSSEFrames = opts.maxSSEFrames ?? DEFAULT_MAX_SSE_FRAMES;
10: + const maxSparseIndex = Math.min(maxSSEFrames, DEFAULT_MAX_SSE_FRAMES);
11: const syntheticIdentities = new Set<string>();
12: const referenceIdentities = new Set<string>();
13: const outputIdentities = new Set<string>();
14: @@ -7944,7 +7946,7 @@
15: normalizationState,
16: event,
17: parsed,
18: - Math.min(maxSSEFrames, DEFAULT_MAX_SSE_FRAMES),
19: + maxSparseIndex,
20: );
21: return ...
<path>/home/byk/.local/share/opencode/tool-output/tool_0ab26c57d001HXsKSJmida8DHD</path>
<type>file</type>
<content>
1406: + onComplete: () => {},
1407: + onRecall: async () => ({ anchorText: "", resultText: "" }),
1408: + runFollowUp: async () => {
1409: + throw new Error("should not run");
1410: + },
1411: + },
1412: + );
1413: +
1414: + const output = await drain(client);
1415: + expect(output).toContain("response.failed");
1416: + if (testCase.acceptedMarker) {
1417: + expect(output).toContain(testCase.acceptedMarker);
1418: + }
1419: + if (testCase.rejectedMarker) {
1420: + expect(output).not.toContain(testCase.rejectedMarker);
1421: + }
1422: + });
1423: +
1424: + test("rejects a non-empty Codex terminal reasoning summary contradiction", async () => {
1425: + const reasoningItem = {
1426: + type: "reasoning",
1427: + id: "rs_terminal_summary_changed",
1428: + status: "completed",
1429: + ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
2060:
2061: test("rejects an item_reference missing output_item.done", async () => {
2062: const client = streamResponsesRecallAware(
2063: streamFrom([
2064: created("resp_reference_incomplete", "gpt-5.6-terra"),
2065: sseEvent("response.output_item.added", {
2066: output_index: 0,
2067: item: { type: "item_reference", id: "msg_reference_incomplete" },
2068: }),
2069: completed("resp_reference_incomplete"),
2070: ]),
2071: {
2072: onComplete: () => {},
2073: onRecall: async () => ({ anchorText: "", resultText: "" }),
2074: runFollowUp: async () => {
2075: throw new Error("should not run");
2076: },
2077: },
2078: );
2079:
2080: expect(await drain(client)).toContain("response.failed");
2081: });
2082: ...
Found 100 matches (more matches available) /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts: Line 1044: * callback before closing so registration is atomic with terminal delivery, Line 7362: // mixed-tools terminal-close branch can't double-emit the same Line 7585: // below only for the final continuation's terminal events. Line 7631: // continuation. The continuation's terminal message_delta + Line 7645: for (const terminal of finalTerminalEvents) Line 7646: await safeEnqueue(encoder.encode(terminal)); Line 7716: // A translator may cancel its source after consuming a valid terminal. Line 7781: * terminal `response.completed` reflecting only client-visible output. Line 7785: * terminal `response.completed` reflecting marker + continuation. ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
7750: return;
7751: }
7752: try {
7753: withTenant(recallContext?.sessionState.storageTenantId ?? "", () =>
7754: withSavepoint("native_recall_delivery", recallPersistence.commit),
7755: );
7756: } catch (error) {
7757: recallPersistence.rollback();
7758: throw error;
7759: }
7760: },
7761: streamSignal,
7762: recallPersistence.rollback,
7763: );
7764: }
7765:
7766: /**
7767: * True-streaming, recall-aware variant of `streamResponsesPassthrough` for the
7768: * OpenAI Responses API (codex/ChatGPT) — used when the request carries the
7769: * gateway-injected `recall` tool but the client speaks the Responses API. ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
8330: const outputIndexForEvent = (
8331: event: string,
8332: parsed: Record<string, unknown>,
8333: state: ResponsesAccState,
8334: onDoneOnlyItem?: (
8335: outputIndex: number,
8336: item: Record<string, unknown>,
8337: ) => void,
8338: ): number | undefined => {
8339: const reasoningSummaryEvent =
8340: event === "response.reasoning_summary_part.added" ||
8341: event === "response.reasoning_summary_part.done" ||
8342: event === "response.reasoning_summary_text.delta" ||
8343: event === "response.reasoning_summary_text.done";
8344: if (
8345: event.startsWith("response.reasoning_summary") &&
8346: !reasoningSummaryEvent
8347: ) {
8348: throw new Error(`unsupported Responses reasoning summary event ${event}`);
8349: }
8350: const requiresOutputIndex =
8351: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
8940: normalized.callId = finalFunctionIdentity.callId;
8941: normalized.name = finalFunctionIdentity.name;
8942: normalized.args = item.arguments;
8943: }
8944: if (declaredType === "message") {
8945: const finalContent = item?.content;
8946: if (!Array.isArray(finalContent)) {
8947: throw new Error(
8948: `Responses message completed without content for index ${outputIndex}`,
8949: );
8950: }
8951: const orderedContent = Array.from(lifecycle.content).sort(
8952: ([left], [right]) => left - right,
8953: );
8954: if (
8955: orderedContent.length > 0 &&
8956: finalContent.length !== orderedContent.length
8957: ) {
8958: throw new Error(
8959: `Responses ...
Found 21 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 205: applyResponsesEvent,
Line 212: isValidResponsesReasoningEncryptedContent,
Line 213: responsesDoneItemMatchesAdded,
Line 214: responsesTerminalItemMatches,
Line 215: normalizeCodexResponsesEvent,
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 7945: normalizeCodexResponsesEvent(
Line 8384: applyResponsesEvent(state, "response.output_item.added", {
Line 8416: !isValidResponsesReasoningEncryptedContent(item) ||
Line 8536: !isValidResponsesReasoningEncryptedContent(item) ||
Line 8537: !responsesDoneItemMatchesAdded(item, ...
Found 5 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts: Line 338: export function isValidResponsesReasoningEncryptedContent( Line 349: export function responsesDoneItemMatchesAdded( Line 401: export function responsesTerminalItemMatches( Line 582: export function applyResponsesEvent( Line 1750: export function normalizeCodexResponsesEvent(
<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: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
560: stopReason: "end_turn",
561: usage: { inputTokens: 0, outputTokens: 0 },
562: items: new Map(),
563: rawItems: new Map(),
564: itemIndexById: new Map(),
565: callIndexById: new Map(),
566: effectiveToolIndexById: new Map(),
567: nextOutputIndex: 0,
568: activeTextItems: new Set(),
569: activeToolItems: new Set(),
570: unboundTextItems: new Set(),
571: unboundToolItems: new Set(),
572: textDoneItems: new Set(),
573: refusalDoneItems: new Set(),
574: argumentDoneItems: new Set(),
575: };
576: }
577:
578: /**
579: * Apply one parsed Responses SSE event to the accumulation state. Never touches
580: * I/O — safe to call while forwarding the same event verbatim to the client. ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path> <type>file</type> <content> 1710: case "response.output_item.done": 1711: normalizeCodexItemEvent(state, event, parsed, maxSparseIndex); 1712: break; 1713: case "response.content_part.added": 1714: case "response.content_part.done": 1715: if (!isRecord(parsed.part)) malformedResponsesEvent(); 1716: normalizeCodexDataEvent(state, event, parsed, maxSparseIndex); 1717: break; 1718: case "response.output_text.delta": 1719: if (typeof parsed.delta !== "string") malformedResponsesEvent(); 1720: normalizeCodexDataEvent(state, event, parsed, maxSparseIndex); 1721: break; 1722: case "response.output_text.done": 1723: if (typeof parsed.text !== "string") malformedResponsesEvent(); 1724: normalizeCodexDataEvent(state, event, parsed, maxSparseIndex); 1725: break; 1726: case ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
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 true;
10094: };
10095: const enqueuePrincipal = async (
10096: chunk: Uint8Array,
10097: emitsOrdinaryTool = false,
10098: afterEnqueue?: () => void,
10099: ): Promise<boolean> =>
10100: safeEnqueue(chunk, () => {
10101: principalEventEmitted = true;
10102: if (emitsOrdinaryTool) ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10790: if (held.candidateIndex !== outputIndex) continue;
10791: deferredContinuationBytes -= held.chunk.byteLength;
10792: reserveTransactionalBytes(held.chunk);
10793: held.transactional = true;
10794: }
10795: };
10796: const flushHeldContinuation = (): void => {
10797: for (const held of heldContinuationEvents) {
10798: if (held.transactional) {
10799: transactionalEvents.push(held.chunk);
10800: } else {
10801: queueTransactional(held.chunk);
10802: }
10803: }
10804: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11540: "recall onComplete failed after delivery",
11541: );
11542: }
11543: if (successful) {
11544: if (!opts.onTransactionReady) transaction.commit();
11545: } else {
11546: transaction.rollback();
11547: }
11548: },
11549: ))
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: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
810: // response.reasoning_summary_*, etc.) — ignored for accumulation
811: }
812: }
813:
814: /** Build the final GatewayResponse from accumulated state. */
815: export function finalizeResponsesAcc(
816: state: ResponsesAccState,
817: ): GatewayResponse {
818: const content: GatewayContentBlock[] = [];
819: const sortedIndices = Array.from(state.items.keys()).sort((a, b) => a - b);
820:
821: for (const index of sortedIndices) {
822: const item = state.items.get(index);
823: if (!item) continue;
824: if (item.type === "text") {
825: if (item.content) {
826: for (const part of item.content) {
827: if (part.type === "output_text" && typeof part.text === "string") {
828: content.push({ type: "text", text: part.text });
829: } else {
830: content.push({
831: ...
Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/worker-effort.test.ts:
Line 33: { status: 200, headers: { "content-type": "application/json" } },
Line 44: { status: 200, headers: { "content-type": "application/json" } },
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/cli-stricli-contract.test.ts:
Line 29: status: "ready",
Line 33: checkReadOffload: async () => ({ status: "ok", error: undefined }),
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/cli-bundle-smoke.test.ts:
Line 66: statusCode = 200,
Line 69: response.statusCode = statusCode;
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/context-capability-note.test.ts:
Line 58: { status: 200, headers: { "content-type": "application/json" } },
Line 116: ...
Found 64 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 347: test("accepts an empty Codex terminal output after streamed items", async () => {
Line 376: test("accepts a partial Codex terminal output after streamed items", async () => {
Line 414: test.each(["failed", "cancelled"])(
Line 757: test("does not retry a pre-output principal resource limit", async () => {
Line 1053: test("does not retry a pre-output principal inactivity failure", async () => {
Line 1084: test("does not retry when the client cancels a stalled principal read", async () => {
Line 1114: test("cancels a retry response returned after foreground abort", async () => {
Line 1176: test("rejects response.in_progress changing the created response identity", async () => {
Line 1585: ...
rtwyxzrrqnqspzypxtymnolzwmpnnumv b9feb17a1feb58a72a080cca0e493130427c506f parents=1ff66d14757b98d3ec7bdb8012104d1f10b292b8
fix(responses): reject untracked Codex reasoning
uyznyvwtuxrkvnppulnwlpryssrywsrt 1ff66d14757b98d3ec7bdb8012104d1f10b292b8 parents=2cbf40060c67df229731cf1b9e34d5bf22ec2145
fix(responses): validate Codex reasoning summaries
pxrvwsvvkmpoxnsqmrkwrnlqvvkoltwz 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054
feat(cch): add seeds for Claude Code up to 2.1.272 (#1780)
--- ancestry ---
--- commit stats ---
Commit ID: b9feb17a1feb58a72a080cca0e493130427c506f
Change ID: rtwyxzrrqnqspzypxtymnolzwmpnnumv
Bookmarks: fix/codex-sparse-reasoning fix/codex-sparse-reasoning@git
Author : Burak Yigit Kaya <ben@byk.im> (2026-09-16 15:58:16)
Committer: Burak Yigit Kaya <ben@byk.im> (2026-09-16 16:44:49)
fix(responses): reject untracked Codex reasoning
packages/gateway/src/pipeline.ts | 144 ...
Found 28 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 8342: event === "response.reasoning_summary_text.delta" ||
Line 8343: event === "response.reasoning_summary_text.done";
Line 8501: new Set(["summary_text"]),
Line 8507: new Set(["reasoning_text"]),
Line 8596: event.startsWith("response.reasoning_text") ||
Line 8606: event.startsWith("response.reasoning_text") ||
Line 8614: : event.startsWith("response.reasoning_text")
Line 8615: ? "reasoning_text"
Line 8626: !["output_text", "refusal", "reasoning_text"].includes(kind)
Line 8631: kind === "reasoning_text" ? "reasoning" : "message";
Line 8768: emptyTextPartLifecycle("summary_text");
Line 8781: if (part.type !== "summary_text") {
Line 8785: "summary_text",
Line 8809: if (part.type !== "summary_text") {
...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
4120: textItem(0, "first continuation preamble"),
4121: recallCall(1, { query: "second recall" }, "fc_second", "call_second"),
4122: completed("resp_chained_retry_first"),
4123: ]);
4124: const recoveredSecondFollowUp = streamFrom([
4125: created("resp_chained_retry_recovered", "gpt-5.6-terra"),
4126: textItem(0, "chained recovered answer", "msg_chained_retry_recovered"),
4127: completed("resp_chained_retry_recovered"),
4128: ]);
4129: const inputs: string[] = [];
4130: let followUps = 0;
4131: const client = streamResponsesRecallAware(
4132: streamFrom([
4133: created("resp_chained_retry_principal", "gpt-5.6-terra"),
4134: recallCall(0, { query: "first recall" }, "fc_first", "call_first"),
4135: completed("resp_chained_retry_principal"),
4136: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
4660: sseEvent("response.content_part.added", {
4661: output_index: 0,
4662: item_id: "msg_part_initial_changed",
4663: content_index: 0,
4664: part: { type: "output_text", text: "secret" },
4665: }),
4666: sseEvent("response.output_text.done", {
4667: output_index: 0,
4668: item_id: "msg_part_initial_changed",
4669: content_index: 0,
4670: text: "safe",
4671: }),
4672: sseEvent("response.content_part.done", {
4673: output_index: 0,
4674: item_id: "msg_part_initial_changed",
4675: content_index: 0,
4676: part: { type: "output_text", text: "safe" },
4677: }),
4678: sseEvent("response.output_item.done", {
4679: output_index: 0,
4680: item: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/vitest.config.ts</path>
<type>file</type>
<content>
1: import { defineConfig } from "vitest/config";
2: import path from "node:path";
3:
4: export default defineConfig({
5: // Alias @loreai/core and @loreai/gateway for test imports.
6: // MUST be at the top level of the vite config — putting this under
7: // `test.resolve.alias` does NOT work (vite's resolver is a top-level
8: // option, not a test.* option). The previous placement silently
9: // resolved to the stale dist build, masking real test failures.
10: resolve: {
11: alias: {
12: "@loreai/core": path.resolve(__dirname, "packages/core/src"),
13: "@loreai/gateway": path.resolve(__dirname, "packages/gateway/src"),
14: },
15: },
16: test: {
17: // Run all packages' tests
18: include: [
19: "packages/core/test/**/*.test.ts",
20: // Fast, pure unit tests for the eval suite's own logic (scorers,
21: // analysis). ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/core/test/setup.ts</path>
<type>file</type>
<content>
1: import { mkdtempSync, rmSync } from "node:fs";
2: import { join } from "node:path";
3: import { tmpdir } from "node:os";
4: import { afterAll, afterEach } from "vitest";
5: import { close, invalidateProjectIdCache } from "../src/db";
6: import { silenceStderr } from "../src/log";
7:
8: // Create an isolated temporary database for the entire test run.
9: // This prevents test fixtures from leaking into the live lore DB
10: // at ~/.local/share/lore/lore.db.
11: const tmp = mkdtempSync(join(tmpdir(), "lore-test-"));
12: process.env.LORE_DB_PATH = join(tmp, "test.db");
13:
14: // ---------------------------------------------------------------------------
15: // Block live network to models.dev during tests.
16: //
17: // `fetchModelData()` (gateway/src/worker-model.ts) hits
18: // https://models.dev/api.json to pull pricing/limits, and the gateway
19: // pre-warms it on ...
<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: ...
Commit ID: 1ff66d14757b98d3ec7bdb8012104d1f10b292b8
Change ID: uyznyvwtuxrkvnppulnwlpryssrywsrt
Author : Burak Yigit Kaya <ben@byk.im> (2026-09-12 18:34:41)
Committer: Burak Yigit Kaya <ben@byk.im> (2026-09-16 16:44:49)
fix(responses): validate Codex reasoning summaries
packages/gateway/src/pipeline.ts | 185 +++--
...est/openai-responses-recall-aware-stream.test.ts | 739 +++++++++++++++++++++-
2 files changed, 868 insertions(+), 56 deletions(-)
--- head delta paths ---
packages/gateway/src/pipeline.ts
packages/gateway/test/openai-responses-recall-aware-stream.test.ts
--- base ancestor count ---
2cbf40060c67df229731cf1b9e34d5bf22ec2145
RUN v4.1.8 /home/byk/Code/opencode-lore-codex-reasoning
Test Files 1 passed (1)
Tests 229 passed (229)
Start at 17:09:08
Duration 12.48s (transform 5.86s, setup 865ms, import 9.67s, tests 1.59s, environment 0ms)
Found 1 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts: Line 9983: function buildOutputItems(
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9910: "response.content_part.done",
9911: JSON.stringify({
9912: type: "response.content_part.done",
9913: item_id: itemId,
9914: output_index: outputIndex,
9915: content_index: 0,
9916: part: { type: "output_text", text, annotations: [] },
9917: }),
9918: ) +
9919: formatResponsesEvent(
9920: "response.output_item.done",
9921: JSON.stringify({
9922: type: "response.output_item.done",
9923: output_index: outputIndex,
9924: item: {
9925: type: "message",
9926: id: itemId,
9927: role: "assistant",
9928: status: "completed",
9929: content: [{ type: "output_text", text, annotations: [] }],
9930: },
9931: }),
9932: )
9933: );
9934: }
9935:
9936: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9630: const assertReferenceLifecyclesComplete = (
9631: references: ReadonlyMap<number, ReferenceLifecycle>,
9632: ): void => {
9633: for (const [outputIndex, reference] of references) {
9634: if (!reference.done) {
9635: throw new Error(
9636: `Responses stream ended before item_reference completion for index ${outputIndex}`,
9637: );
9638: }
9639: }
9640: };
9641: const assertRecallItemsCompleted = (
9642: acc: ResponsesAccState,
9643: recallIndices: readonly number[],
9644: ): void => {
9645: for (const outputIndex of recallIndices) {
9646: const status = acc.rawItems.get(outputIndex)?.status;
9647: if (status !== undefined && status !== "completed") {
9648: throw new Error(
9649: `recall function call did not complete for index ${outputIndex}`,
9650: ...
Found 1 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/anthropic.ts: Line 58: export const DEFAULT_MAX_SSE_FRAMES = 100_000;
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. youvttksqllkxurqlpxypvrnzpsvxvoq d236533a8d57df57ea780c8729978b7d15c6ea85 clean parents=b9feb17a1feb58a72a080cca0e493130427c506f rtwyxzrrqnqspzypxtymnolzwmpnnumv b9feb17a1feb58a72a080cca0e493130427c506f clean parents=1ff66d14757b98d3ec7bdb8012104d1f10b292b8 pxrvwsvvkmpoxnsqmrkwrnlqvvkoltwz 2cbf40060c67df229731cf1b9e34d5bf22ec2145 clean parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 --- base-is-ancestor --- 2cbf40060c67df229731cf1b9e34d5bf22ec2145 --- changed paths --- packages/gateway/src/pipeline.ts packages/gateway/test/openai-responses-recall-aware-stream.test.ts --- conflict revisions --- --- ...
Omitted terminal items bypass reasoning-content lifecycle validation.
pipeline.ts:9418-9427 reconstructs and validates omitted summaries only. Codex then accepts missing output_item.done at pipeline.ts:9234-9258. Therefore, when the terminal omits a reasoning item:
reasoning_text remains absent from rawOutputItems and onComplete state;The content checks at pipeline.ts:9045-9090 run only when output_item.done exists. The existing content test at openai-responses-recall-aware-stream.test.ts:5031-5083 always supplies that event. Add principal and continuation regressions for completed and unfinished reasoning content when the terminal omits the item.
High-cardinality work remains quadratic on adjacent supported paths.
pipeline.ts:9600-9602 scans every raw item for each unique item_reference, although outputIdentities already indexes both IDs and call IDs.pipeline.ts:11229-11273 compares every continuation item against every principal/earlier-continuation item twice during merging.The test at openai-responses-recall-aware-stream.test.ts:2542-2624 covers only a no-recall stream of ordinary messages. It does not cover references or chained continuations. Under the 100,000-frame production ceiling, these paths can still perform quadratic work. Add linear-work regressions for both paths and mutation-prove them.
rtwyxzrrqnqspzypxtymnolzwmpnnumv, commit b9feb17a1feb58a72a080cca0e493130427c506f.2cbf40060c67df229731cf1b9e34d5bf22ec2145 is an ancestor.packages/gateway/src/pipeline.tspackages/gateway/test/openai-responses-recall-aware-stream.test.ts